1 // RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
2 // RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
3 // RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
4 // RUN: %clang_cc1 -std=c++1z %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
5 
6 namespace std { struct type_info; }
7 
8 namespace dr1902 { // dr1902: 3.7
9   struct A {};
10   struct B {
11     B(A);
12 #if __cplusplus >= 201103L
13         // expected-note@-2 {{candidate}}
14 #endif
15 
16     B() = delete;
17 #if __cplusplus < 201103L
18         // expected-error@-2 {{extension}}
19 #endif
20 
21     B(const B&) // expected-note {{deleted here}}
22 #if __cplusplus >= 201103L
23         // expected-note@-2 {{candidate}}
24 #else
25         // expected-error@+2 {{extension}}
26 #endif
27         = delete;
28 
29     operator A();
30   };
31 
32   extern B b1;
33   B b2(b1); // expected-error {{call to deleted}}
34 
35 #if __cplusplus >= 201103L
36   // This is ambiguous, even though calling the B(const B&) constructor would
37   // both directly and indirectly call a deleted function.
38   B b({}); // expected-error {{ambiguous}}
39 #endif
40 }
41 
42 namespace dr1903 {
43   namespace A {
44     struct a {};
45     int a;
46     namespace B {
47       int b;
48     }
49     using namespace B;
50     namespace {
51       int c;
52     }
53     namespace D {
54       int d;
55     }
56     using D::d;
57   }
58   namespace X {
59     using A::a;
60     using A::b;
61     using A::c;
62     using A::d;
63     struct a *p;
64   }
65 }
66 
67 namespace dr1909 { // dr1909: yes
68   struct A {
69     template<typename T> struct A {}; // expected-error {{member 'A' has the same name as its class}}
70   };
71   struct B {
Bdr1909::B72     template<typename T> void B() {} // expected-error {{constructor cannot have a return type}}
73   };
74   struct C {
75     template<typename T> static int C; // expected-error {{member 'C' has the same name as its class}} expected-error 0-1{{extension}}
76   };
77   struct D {
78     template<typename T> using D = int; // expected-error {{member 'D' has the same name as its class}} expected-error 0-1{{extension}}
79   };
80 }
81 
82 namespace dr1940 { // dr1940: yes
83 #if __cplusplus >= 201103L
84 static union {
85   static_assert(true, "");  // ok
86   static_assert(false, ""); // expected-error {{static_assert failed}}
87 };
88 #endif
89 }
90 
91 namespace dr1941 { // dr1941: 3.9
92 #if __cplusplus >= 201402L
93 template<typename X>
94 struct base {
95   template<typename T>
96   base(T a, T b, decltype(void(*T()), 0) = 0) {
97     while (a != b) (void)*a++;
98   }
99 
100   template<typename T>
101   base(T a, X x, decltype(void(T(0) * 1), 0) = 0) {
102     for (T n = 0; n != a; ++n) (void)X(x);
103   }
104 };
105 
106 struct derived : base<int> {
107   using base::base;
108 };
109 
110 struct iter {
111   iter operator++(int);
112   int operator*();
113   friend bool operator!=(iter, iter);
114 } it, end;
115 
116 derived d1(it, end);
117 derived d2(42, 9);
118 #endif
119 }
120 
121 namespace dr1947 { // dr1947: yes
122 #if __cplusplus >= 201402L
123 unsigned o = 0'01;  // ok
124 unsigned b = 0b'01; // expected-error {{invalid digit 'b' in octal constant}}
125 unsigned x = 0x'01; // expected-error {{invalid suffix 'x'01' on integer constant}}
126 #endif
127 }
128 
129 #if __cplusplus >= 201103L
130 // dr1948: yes
131 // FIXME: This diagnostic could be improved.
132 void *operator new(__SIZE_TYPE__) noexcept { return nullptr; } // expected-error{{exception specification in declaration does not match previous declaration}}
133 #endif
134 
135 namespace dr1959 { // dr1959: 3.9
136 #if __cplusplus >= 201103L
137   struct b;
138   struct c;
139   struct a {
140     a() = default;
141     a(const a &) = delete; // expected-note 2{{deleted}}
142     a(const b &) = delete; // not inherited
143     a(c &&) = delete; // expected-note {{deleted}}
144     template<typename T> a(T) = delete;
145   };
146 
147   struct b : a { // expected-note {{copy constructor of 'b' is implicitly deleted because base class 'dr1959::a' has a deleted copy constructor}}
148     using a::a;
149   };
150 
151   a x;
152   b y = x; // expected-error {{deleted}}
153   b z = z; // expected-error {{deleted}}
154 
155   // FIXME: It's not really clear that this matches the intent, but it's
156   // consistent with the behavior for assignment operators.
157   struct c : a {
158     using a::a;
159     c(const c &);
160   };
161   c q(static_cast<c&&>(q)); // expected-error {{call to deleted}}
162 #endif
163 }
164 
165 namespace dr1968 { // dr1968: yes
166 #if __cplusplus >= 201103L
167   static_assert(&typeid(int) == &typeid(int), ""); // expected-error{{not an integral constant expression}}
168 #endif
169 }
170 
171 namespace dr1991 { // dr1991: 3.9
172 #if __cplusplus >= 201103L
173   struct A {
174     A(int, int) = delete;
175   };
176 
177   struct B : A {
178     using A::A;
179     B(int, int, int = 0);
180   };
181 
182   // FIXME: As a resolution to an open DR against P0136R1, we treat derived
183   // class constructors as better than base class constructors in the presence
184   // of ambiguity.
185   B b(0, 0); // ok, calls B constructor
186 #endif
187 }
188 
189 // dr1994: dup 529
190