1// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
2// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
3// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
4// RUN: %clang_cc1 -triple %itanium_abi_triple -std=c++1z %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
5
6namespace dr300 { // dr300: yes
7  template<typename R, typename A> void f(R (&)(A)) {}
8  int g(int);
9  void h() { f(g); }
10}
11
12namespace dr301 { // dr301: yes
13  // see also dr38
14  struct S;
15  template<typename T> void operator+(T, T);
16  void operator-(S, S);
17
18  void f() {
19    bool a = (void(*)(S, S))operator+<S> <
20             (void(*)(S, S))operator+<S>;
21    bool b = (void(*)(S, S))operator- <
22             (void(*)(S, S))operator-;
23    bool c = (void(*)(S, S))operator+ <
24             (void(*)(S, S))operator-; // expected-error {{expected '>'}}
25  }
26
27  template<typename T> void f() {
28    typename T::template operator+<int> a; // expected-error {{typename specifier refers to a non-type template}} expected-error +{{}}
29    // FIXME: This shouldn't say (null).
30    class T::template operator+<int> b; // expected-error {{identifier followed by '<' indicates a class template specialization but (null) refers to a function template}}
31    enum T::template operator+<int> c; // expected-error {{expected identifier}} expected-error {{does not declare anything}}
32    enum T::template operator+<int>::E d; // expected-error {{qualified name refers into a specialization of function template 'T::template operator +'}} expected-error {{forward reference}}
33    enum T::template X<int>::E e;
34    T::template operator+<int>::foobar(); // expected-error {{qualified name refers into a specialization of function template 'T::template operator +'}}
35    T::template operator+<int>(0); // ok
36  }
37
38  template<typename T> class operator&<T*> {}; // expected-error +{{}}
39  template<typename T> class T::operator& {}; // expected-error +{{}}
40  template<typename T> class S::operator&<T*> {}; // expected-error +{{}}
41}
42
43namespace dr302 { // dr302: yes
44  struct A { A(); ~A(); };
45#if __cplusplus < 201103L
46  struct B { // expected-error {{implicit default constructor for 'dr302::B' must explicitly initialize the const member 'n'}}
47    const int n; // expected-note {{declared here}}
48    A a;
49  } b = B(); // expected-note {{first required here}}
50  // Trivial default constructor C::C() is not called here.
51  struct C {
52    const int n;
53  } c = C();
54#else
55  struct B {
56    const int n; // expected-note {{deleted because field 'n' of const-qualified type 'const int' would not be initialized}}
57    A a;
58  } b = B(); // expected-error {{call to implicitly-deleted default constructor}}
59  // C::C() is called here, because even though it's trivial, it's deleted.
60  struct C {
61    const int n; // expected-note {{deleted because field 'n' of const-qualified type 'const int' would not be initialized}}
62  } c = C(); // expected-error {{call to implicitly-deleted default constructor}}
63  struct D {
64    const int n = 0;
65  } d = D();
66#endif
67}
68
69// dr303: na
70
71namespace dr304 { // dr304: yes
72  typedef int &a;
73  int n = a(); // expected-error {{requires an initializer}}
74
75  struct S { int &b; };
76  int m = S().b;
77#if __cplusplus < 201103L
78  // expected-error@-3 {{requires an initializer}}
79  // expected-note@-3 {{in value-initialization}}
80#else
81  // expected-error@-5 {{deleted}}
82  // expected-note@-7 {{reference}}
83#endif
84}
85
86namespace dr305 { // dr305: no
87  struct A {
88    typedef A C;
89  };
90  void f(A *a) {
91    struct A {};
92    a->~A();
93    a->~C();
94  }
95  typedef A B;
96  void g(B *b) {
97    b->~B();
98    b->~C();
99  }
100  void h(B *b) {
101    struct B {}; // expected-note {{declared here}}
102    b->~B(); // expected-error {{does not match}}
103  }
104
105  template<typename T> struct X {};
106  void i(X<int>* x) {
107    struct X {};
108    x->~X<int>();
109    x->~X();
110    x->~X<char>(); // expected-error {{no member named}}
111  }
112
113#if __cplusplus >= 201103L
114  struct Y {
115    template<typename T> using T1 = Y;
116  };
117  template<typename T> using T2 = Y;
118  void j(Y *y) {
119    y->~T1<int>();
120    y->~T2<int>();
121  }
122  struct Z {
123    template<typename T> using T2 = T;
124  };
125  void k(Z *z) {
126    // FIXME: This diagnostic is terrible.
127    z->~T1<int>(); // expected-error {{'T1' following the 'template' keyword does not refer to a template}} expected-error +{{}}
128    z->~T2<int>(); // expected-error {{no member named '~int'}}
129    z->~T2<Z>();
130  }
131
132  // FIXME: This is valid.
133  namespace Q {
134    template<typename A> struct R {};
135  }
136  template<typename A> using R = Q::R<int>;
137  void qr(Q::R<int> x) { x.~R<char>(); } // expected-error {{no member named}}
138#endif
139}
140
141namespace dr306 { // dr306: no
142  // FIXME: dup 39
143  // FIXME: This should be accepted.
144  struct A { struct B {}; }; // expected-note 2{{member}}
145  struct C { typedef A::B B; }; // expected-note {{member}}
146  struct D : A, A::B, C {};
147  D::B b; // expected-error {{found in multiple base classes of different types}}
148}
149
150// dr307: na
151
152namespace dr308 { // dr308: yes
153  // This is mostly an ABI library issue.
154  struct A {};
155  struct B : A {};
156  struct C : A {};
157  struct D : B, C {};
158  void f() {
159    try {
160      throw D();
161    } catch (const A&) { // expected-note {{for type 'const dr308::A &'}}
162      // unreachable
163    } catch (const B&) { // expected-warning {{exception of type 'const dr308::B &' will be caught by earlier handler}}
164      // get here instead
165    }
166  }
167}
168
169// dr309: dup 485
170
171namespace dr311 { // dr311: yes
172  namespace X { namespace Y {} }
173  namespace X::Y {}
174#if __cplusplus <= 201402L
175  // expected-error@-2 {{define each namespace separately}}
176#endif
177  namespace X {
178    namespace X::Y {}
179#if __cplusplus <= 201402L
180  // expected-error@-2 {{define each namespace separately}}
181#endif
182  }
183  // FIXME: The diagnostics here are not very good.
184  namespace ::dr311::X {} // expected-error 2+{{}} // expected-warning {{extra qual}}
185}
186
187// dr312: dup 616
188
189namespace dr313 { // dr313: dup 299 c++11
190  struct A { operator int() const; };
191  int *p = new int[A()];
192#if __cplusplus < 201103L
193  // FIXME: should this be available in c++98 mode? expected-error@-2 {{extension}}
194#endif
195}
196
197namespace dr314 { // FIXME 314: dup 1710
198  template<typename T> struct A {
199    template<typename U> struct B {};
200  };
201  template<typename T> struct C : public A<T>::template B<T> {
202    C() : A<T>::template B<T>() {}
203  };
204}
205
206// dr315: na
207// dr316: sup 1004
208
209namespace dr317 { // dr317: 3.5
210  void f() {} // expected-note {{previous}}
211  inline void f(); // expected-error {{inline declaration of 'f' follows non-inline definition}}
212
213  int g();
214  int n = g();
215  inline int g() { return 0; }
216
217  int h();
218  int m = h();
219  int h() { return 0; } // expected-note {{previous}}
220  inline int h(); // expected-error {{inline declaration of 'h' follows non-inline definition}}
221}
222
223namespace dr318 { // dr318: sup 1310
224  struct A {};
225  struct A::A a;
226}
227
228namespace dr319 { // dr319: no
229  // FIXME: dup dr389
230  // FIXME: We don't have a diagnostic for a name with linkage
231  //        having a type without linkage.
232  typedef struct {
233    int i;
234  } *ps;
235  extern "C" void f(ps);
236  void g(ps); // FIXME: ill-formed, type 'ps' has no linkage
237
238  static enum { e } a1;
239  enum { e2 } a2; // FIXME: ill-formed, enum type has no linkage
240
241  enum { n1 = 1u };
242  typedef int (*pa)[n1];
243  pa parr; // ok, type has linkage despite using 'n1'
244
245  template<typename> struct X {};
246
247  void f() {
248    struct A { int n; };
249    extern A a; // FIXME: ill-formed
250    X<A> xa;
251
252    typedef A B;
253    extern B b; // FIXME: ill-formed
254    X<B> xb;
255
256    const int n = 1;
257    typedef int (*C)[n];
258    extern C c; // ok
259    X<C> xc;
260  }
261#if __cplusplus < 201103L
262  // expected-error@-12 {{uses local type 'A'}}
263  // expected-error@-9 {{uses local type 'A'}}
264#endif
265}
266
267namespace dr320 { // dr320: yes
268#if __cplusplus >= 201103L
269  struct X {
270    constexpr X() {}
271    constexpr X(const X &x) : copies(x.copies + 1) {}
272    unsigned copies = 0;
273  };
274  constexpr X f(X x) { return x; }
275  constexpr unsigned g(X x) { return x.copies; }
276  static_assert(f(X()).copies == g(X()) + 1, "expected one extra copy for return value");
277#endif
278}
279
280namespace dr321 { // dr321: dup 557
281  namespace N {
282    template<int> struct A {
283      template<int> struct B;
284    };
285    template<> template<> struct A<0>::B<0>;
286    void f(A<0>::B<0>);
287  }
288  template<> template<> struct N::A<0>::B<0> {};
289
290  template<typename T> void g(T t) { f(t); }
291  template void g(N::A<0>::B<0>);
292
293  namespace N {
294    template<typename> struct I { friend bool operator==(const I&, const I&); };
295  }
296  N::I<int> i, j;
297  bool x = i == j;
298}
299
300namespace dr322 { // dr322: yes
301  struct A {
302    template<typename T> operator T&();
303  } a;
304  int &r = static_cast<int&>(a);
305  int &s = a;
306}
307
308// dr323: no
309
310namespace dr324 { // dr324: yes
311  struct S { int n : 1; } s; // expected-note 3{{bit-field is declared here}}
312  int &a = s.n; // expected-error {{non-const reference cannot bind to bit-field}}
313  int *b = &s.n; // expected-error {{address of bit-field}}
314  int &c = (s.n = 0); // expected-error {{non-const reference cannot bind to bit-field}}
315  int *d = &(s.n = 0); // expected-error {{address of bit-field}}
316  int &e = true ? s.n : s.n; // expected-error {{non-const reference cannot bind to bit-field}}
317  int *f = &(true ? s.n : s.n); // expected-error {{address of bit-field}}
318  int &g = (void(), s.n); // expected-error {{non-const reference cannot bind to bit-field}}
319  int *h = &(void(), s.n); // expected-error {{address of bit-field}}
320  int *i = &++s.n; // expected-error {{address of bit-field}}
321}
322
323namespace dr326 { // dr326: yes
324  struct S {};
325  int test[__is_trivially_constructible(S, const S&) ? 1 : -1];
326}
327
328namespace dr327 { // dr327: dup 538
329  struct A;
330  class A {};
331
332  class B;
333  struct B {};
334}
335
336namespace dr328 { // dr328: yes
337  struct A; // expected-note 3{{forward declaration}}
338  struct B { A a; }; // expected-error {{incomplete}}
339  template<typename> struct C { A a; }; // expected-error {{incomplete}}
340  A *p = new A[0]; // expected-error {{incomplete}}
341}
342
343namespace dr329 { // dr329: 3.5
344  struct B {};
345  template<typename T> struct A : B {
346    friend void f(A a) { g(a); }
347    friend void h(A a) { g(a); } // expected-error {{undeclared}}
348    friend void i(B b) {} // expected-error {{redefinition}} expected-note {{previous}}
349  };
350  A<int> a;
351  A<char> b; // expected-note {{instantiation}}
352
353  void test() {
354    h(a); // expected-note {{instantiation}}
355  }
356}
357
358namespace dr331 { // dr331: yes
359  struct A {
360    A(volatile A&); // expected-note {{candidate}}
361  } const a, b(a); // expected-error {{no matching constructor}}
362}
363
364namespace dr332 { // dr332: dup 577
365  void f(volatile void); // expected-error {{'void' as parameter must not have type qualifiers}}
366  void g(const void); // expected-error {{'void' as parameter must not have type qualifiers}}
367  void h(int n, volatile void); // expected-error {{'void' must be the first and only parameter}}
368}
369
370namespace dr333 { // dr333: yes
371  int n = 0;
372  int f(int(n));
373  int g((int(n)));
374  int h = f(g);
375}
376
377namespace dr334 { // dr334: yes
378  template<typename T> void f() {
379    T x;
380    f((x, 123));
381  }
382  struct S {
383    friend S operator,(S, int);
384    friend void f(S);
385  };
386  template void f<S>();
387}
388
389// dr335: no
390
391namespace dr336 { // dr336: yes
392  namespace Pre {
393    template<class T1> class A {
394      template<class T2> class B {
395        template<class T3> void mf1(T3);
396        void mf2();
397      };
398    };
399    template<> template<class X> class A<int>::B {};
400    template<> template<> template<class T> void A<int>::B<double>::mf1(T t) {} // expected-error {{does not match}}
401    template<class Y> template<> void A<Y>::B<double>::mf2() {} // expected-error {{does not refer into a class}}
402  }
403  namespace Post {
404    template<class T1> class A {
405      template<class T2> class B {
406        template<class T3> void mf1(T3);
407        void mf2();
408      };
409    };
410    template<> template<class X> class A<int>::B {
411      template<class T> void mf1(T);
412    };
413    template<> template<> template<class T> void A<int>::B<double>::mf1(T t) {}
414    // FIXME: This diagnostic isn't very good.
415    template<class Y> template<> void A<Y>::B<double>::mf2() {} // expected-error {{does not refer into a class}}
416  }
417}
418
419namespace dr337 { // dr337: yes
420  template<typename T> void f(T (*)[1]);
421  template<typename T> int &f(...);
422
423  struct A { virtual ~A() = 0; };
424  int &r = f<A>(0);
425
426  // FIXME: The language rules here are completely broken. We cannot determine
427  // whether an incomplete type is abstract. See DR1640, which will probably
428  // supersede this one and remove this rule.
429  struct B;
430  int &s = f<B>(0); // expected-error {{of type 'void'}}
431  struct B { virtual ~B() = 0; };
432}
433
434namespace dr339 { // dr339: yes
435  template <int I> struct A { static const int value = I; };
436
437  char xxx(int);
438  char (&xxx(float))[2];
439
440  template<class T> A<sizeof(xxx((T)0))> f(T) {} // expected-note {{candidate}}
441
442  void test() {
443    A<1> a = f(0);
444    A<2> b = f(0.0f);
445    A<3> c = f("foo"); // expected-error {{no matching function}}
446  }
447
448
449  char f(int);
450  int f(...);
451
452  template <class T> struct conv_int {
453    static const bool value = sizeof(f(T())) == 1;
454  };
455
456  template <class T> bool conv_int2(A<sizeof(f(T()))> p);
457
458  template<typename T> A<sizeof(f(T()))> make_A();
459
460  int a[conv_int<char>::value ? 1 : -1];
461  bool b = conv_int2<char>(A<1>());
462  A<1> c = make_A<char>();
463}
464
465namespace dr340 { // dr340: yes
466  struct A { A(int); };
467  struct B { B(A, A, int); };
468  int x, y;
469  B b(A(x), A(y), 3);
470}
471
472namespace dr341 { // dr341: sup 1708
473  namespace A {
474    int n;
475    extern "C" int &dr341_a = n; // expected-note {{previous}} expected-note {{declared with C language linkage here}}
476  }
477  namespace B {
478    extern "C" int &dr341_a = dr341_a; // expected-error {{redefinition}}
479  }
480  extern "C" void dr341_b(); // expected-note {{declared with C language linkage here}}
481}
482int dr341_a; // expected-error {{declaration of 'dr341_a' in global scope conflicts with declaration with C language linkage}}
483int dr341_b; // expected-error {{declaration of 'dr341_b' in global scope conflicts with declaration with C language linkage}}
484int dr341_c; // expected-note {{declared in global scope here}}
485int dr341_d; // expected-note {{declared in global scope here}}
486namespace dr341 {
487  extern "C" int dr341_c; // expected-error {{declaration of 'dr341_c' with C language linkage conflicts with declaration in global scope}}
488  extern "C" void dr341_d(); // expected-error {{declaration of 'dr341_d' with C language linkage conflicts with declaration in global scope}}
489
490  namespace A { extern "C" int dr341_e; } // expected-note {{previous}}
491  namespace B { extern "C" void dr341_e(); } // expected-error {{redefinition of 'dr341_e' as different kind of symbol}}
492}
493
494// dr342: na
495
496namespace dr343 { // FIXME 343: no
497  // FIXME: dup 1710
498  template<typename T> struct A {
499    template<typename U> struct B {};
500  };
501  // FIXME: In these contexts, the 'template' keyword is optional.
502  template<typename T> struct C : public A<T>::B<T> { // expected-error {{use 'template'}}
503    C() : A<T>::B<T>() {} // expected-error {{use 'template'}}
504  };
505}
506
507namespace dr344 { // dr344: dup 1435
508  struct A { inline virtual ~A(); };
509  struct B { friend A::~A(); };
510}
511
512namespace dr345 { // dr345: yes
513  struct A {
514    struct X {};
515    int X; // expected-note {{here}}
516  };
517  struct B {
518    struct X {};
519  };
520  template <class T> void f(T t) { typename T::X x; } // expected-error {{refers to non-type member 'X'}}
521  void f(A a, B b) {
522    f(b);
523    f(a); // expected-note {{instantiation}}
524  }
525}
526
527// dr346: na
528
529namespace dr347 { // dr347: yes
530  struct base {
531    struct nested;
532    static int n;
533    static void f();
534    void g();
535  };
536
537  struct derived : base {};
538
539  struct derived::nested {}; // expected-error {{no struct named 'nested'}}
540  int derived::n; // expected-error {{no member named 'n'}}
541  void derived::f() {} // expected-error {{does not match any}}
542  void derived::g() {} // expected-error {{does not match any}}
543}
544
545// dr348: na
546
547namespace dr349 { // dr349: no
548  struct A {
549    template <class T> operator T ***() {
550      int ***p = 0;
551      return p; // expected-error {{cannot initialize return object of type 'const int ***' with an lvalue of type 'int ***'}}
552    }
553  };
554
555  // FIXME: This is valid.
556  A a;
557  const int *const *const *p1 = a; // expected-note {{in instantiation of}}
558
559  struct B {
560    template <class T> operator T ***() {
561      const int ***p = 0;
562      return p;
563    }
564  };
565
566  // FIXME: This is invalid.
567  B b;
568  const int *const *const *p2 = b;
569}
570
571// dr351: na
572
573namespace dr352 { // dr352: yes
574  namespace example1 {
575    namespace A {
576      enum E {};
577      template<typename R, typename A> void foo(E, R (*)(A)); // expected-note 2{{couldn't infer template argument 'R'}}
578    }
579
580    template<typename T> void arg(T);
581    template<typename T> int arg(T) = delete; // expected-note {{here}} expected-error 0-1{{extension}}
582
583    void f(A::E e) {
584      foo(e, &arg); // expected-error {{no matching function}}
585
586      using A::foo;
587      foo<int, int>(e, &arg); // expected-error {{deleted}}
588    }
589
590    int arg(int);
591
592    void g(A::E e) {
593      foo(e, &arg); // expected-error {{no matching function}}
594
595      using A::foo;
596      foo<int, int>(e, &arg); // ok, uses non-template
597    }
598  }
599
600  namespace contexts {
601    template<int I> void f1(int (&)[I]);
602    template<int I> void f2(int (&)[I+1]); // expected-note {{couldn't infer}}
603    template<int I> void f3(int (&)[I+1], int (&)[I]);
604    void f() {
605      int a[4];
606      int b[3];
607      f1(a);
608      f2(a); // expected-error {{no matching function}}
609      f3(a, b);
610    }
611
612    template<int I> struct S {};
613    template<int I> void g1(S<I>);
614    template<int I> void g2(S<I+1>); // expected-note {{couldn't infer}}
615    template<int I> void g3(S<I+1>, S<I>);
616    void g() {
617      S<4> a;
618      S<3> b;
619      g1(a);
620      g2(a); // expected-error {{no matching function}}
621      g3(a, b);
622    }
623
624    template<typename T> void h1(T = 0); // expected-note {{couldn't infer}}
625    template<typename T> void h2(T, T = 0);
626    void h() {
627      h1(); // expected-error {{no matching function}}
628      h1(0);
629      h1<int>();
630      h2(0);
631    }
632
633    template<typename T> int tmpl(T);
634    template<typename R, typename A> void i1(R (*)(A)); // expected-note 3{{couldn't infer}}
635    template<typename R, typename A> void i2(R, A, R (*)(A)); // expected-note {{not viable}}
636    void i() {
637      extern int single(int);
638      i1(single);
639      i2(0, 0, single);
640
641      extern int ambig(float), ambig(int);
642      i1(ambig); // expected-error {{no matching function}}
643      i2(0, 0, ambig);
644
645      extern void no_match(float), no_match(int);
646      i1(no_match); // expected-error {{no matching function}}
647      i2(0, 0, no_match); // expected-error {{no matching function}}
648
649      i1(tmpl); // expected-error {{no matching function}}
650      i2(0, 0, tmpl);
651    }
652  }
653
654  template<typename T> struct is_int;
655  template<> struct is_int<int> {};
656
657  namespace example2 {
658    template<typename T> int f(T (*p)(T)) { is_int<T>(); }
659    int g(int);
660    int g(char);
661    int i = f(g);
662  }
663
664  namespace example3 {
665    template<typename T> int f(T, T (*p)(T)) { is_int<T>(); }
666    int g(int);
667    char g(char);
668    int i = f(1, g);
669  }
670
671  namespace example4 {
672    template <class T> int f(T, T (*p)(T)) { is_int<T>(); }
673    char g(char);
674    template <class T> T g(T);
675    int i = f(1, g);
676  }
677
678  namespace example5 {
679    template<int I> class A {};
680    template<int I> void g(A<I+1>); // expected-note {{couldn't infer}}
681    template<int I> void f(A<I>, A<I+1>);
682    void h(A<1> a1, A<2> a2) {
683      g(a1); // expected-error {{no matching function}}
684      g<0>(a1);
685      f(a1, a2);
686    }
687  }
688}
689
690// dr353 needs an IRGen test.
691
692namespace dr354 { // dr354: yes c++11
693  // FIXME: Should we allow this in C++98 too?
694  struct S {};
695
696  template<int*> struct ptr {}; // expected-note 0-4{{here}}
697  ptr<0> p0;
698  ptr<(int*)0> p1;
699  ptr<(float*)0> p2;
700  ptr<(int S::*)0> p3;
701#if __cplusplus < 201103L
702  // expected-error@-5 {{does not refer to any decl}}
703  // expected-error@-5 {{does not refer to any decl}}
704  // expected-error@-5 {{does not refer to any decl}}
705  // expected-error@-5 {{does not refer to any decl}}
706#elif __cplusplus <= 201402L
707  // expected-error@-10 {{must be cast}}
708  // ok
709  // expected-error@-10 {{does not match}}
710  // expected-error@-10 {{does not match}}
711#else
712  // expected-error@-15 {{conversion from 'int' to 'int *' is not allowed}}
713  // ok
714  // expected-error@-15 {{'float *' is not implicitly convertible to 'int *'}}
715  // expected-error@-15 {{'int dr354::S::*' is not implicitly convertible to 'int *'}}
716#endif
717
718  template<int*> int both();
719  template<int> int both();
720  int b0 = both<0>();
721  int b1 = both<(int*)0>();
722#if __cplusplus < 201103L
723  // expected-error@-2 {{no matching function}}
724  // expected-note@-6 {{candidate}}
725  // expected-note@-6 {{candidate}}
726#endif
727
728  template<int S::*> struct ptr_mem {}; // expected-note 0-4{{here}}
729  ptr_mem<0> m0;
730  ptr_mem<(int S::*)0> m1;
731  ptr_mem<(float S::*)0> m2;
732  ptr_mem<(int *)0> m3;
733#if __cplusplus < 201103L
734  // expected-error@-5 {{cannot be converted}}
735  // expected-error@-5 {{is not a pointer to member constant}}
736  // expected-error@-5 {{cannot be converted}}
737  // expected-error@-5 {{cannot be converted}}
738#elif __cplusplus <= 201402L
739  // expected-error@-10 {{must be cast}}
740  // ok
741  // expected-error@-10 {{does not match}}
742  // expected-error@-10 {{does not match}}
743#else
744  // expected-error@-15 {{conversion from 'int' to 'int dr354::S::*' is not allowed}}
745  // ok
746  // expected-error@-15 {{'float dr354::S::*' is not implicitly convertible to 'int dr354::S::*'}}
747  // expected-error@-15 {{'int *' is not implicitly convertible to 'int dr354::S::*'}}
748#endif
749}
750
751struct dr355_S; // dr355: yes
752struct ::dr355_S {}; // expected-warning {{extra qualification}}
753namespace dr355 { struct ::dr355_S s; }
754
755// dr356: na
756
757namespace dr357 { // dr357: yes
758  template<typename T> struct A {
759    void f() const; // expected-note {{const qualified}}
760  };
761  template<typename T> void A<T>::f() {} // expected-error {{does not match}}
762
763  struct B {
764    template<typename T> void f();
765  };
766  template<typename T> void B::f() const {} // expected-error {{does not match}}
767}
768
769namespace dr358 { // dr358: yes
770  extern "C" void dr358_f();
771  namespace N {
772    int var;
773    extern "C" void dr358_f() { var = 10; }
774  }
775}
776
777namespace dr359 { // dr359: yes
778  // Note, the example in the DR is wrong; it doesn't contain an anonymous
779  // union.
780  struct E {
781    union {
782      struct {
783        int x;
784      } s;
785    } v;
786
787    union {
788      struct { // expected-error {{extension}}
789        int x;
790      } s;
791
792      struct S { // expected-error {{types cannot be declared in an anonymous union}}
793        int x;
794      } t;
795
796      union { // expected-error {{extension}}
797        int u;
798      };
799    };
800  };
801}
802
803// dr362: na
804// dr363: na
805
806namespace dr364 { // dr364: yes
807  struct S {
808    static void f(int);
809    void f(char);
810  };
811
812  void g() {
813    S::f('a'); // expected-error {{call to non-static}}
814    S::f(0);
815  }
816}
817
818#if "foo" // expected-error {{invalid token}} dr366: yes
819#endif
820
821namespace dr367 { // dr367: yes
822  // FIXME: These diagnostics are terrible. Don't diagnose an ill-formed global
823  // array as being a VLA!
824  int a[true ? throw 0 : 4]; // expected-error 2{{variable length array}}
825  int b[true ? 4 : throw 0];
826  int c[true ? *new int : 4]; // expected-error 2{{variable length array}}
827  int d[true ? 4 : *new int];
828#if __cplusplus < 201103L
829  // expected-error@-4 {{variable length array}} expected-error@-4 {{constant expression}}
830  // expected-error@-3 {{variable length array}} expected-error@-3 {{constant expression}}
831#endif
832}
833
834namespace dr368 { // dr368: yes
835  template<typename T, T> struct S {}; // expected-note {{here}}
836  template<typename T> int f(S<T, T()> *); // expected-error {{function type}}
837  //template<typename T> int g(S<T, (T())> *); // FIXME: crashes clang
838  template<typename T> int g(S<T, true ? T() : T()> *); // expected-note {{cannot have type 'dr368::X'}}
839  struct X {};
840  int n = g<X>(0); // expected-error {{no matching}}
841}
842
843// dr370: na
844
845namespace dr372 { // dr372: no
846  namespace example1 {
847    template<typename T> struct X {
848    protected:
849      typedef T Type; // expected-note 2{{protected}}
850    };
851    template<typename T> struct Y {};
852
853    // FIXME: These two are valid; deriving from T1<T> gives Z1 access to
854    // the protected member T1<T>::Type.
855    template<typename T,
856             template<typename> class T1,
857             template<typename> class T2> struct Z1 :
858      T1<T>,
859      T2<typename T1<T>::Type> {}; // expected-error {{protected}}
860
861    template<typename T,
862             template<typename> class T1,
863             template<typename> class T2> struct Z2 :
864      T2<typename T1<T>::Type>, // expected-error {{protected}}
865      T1<T> {};
866
867    Z1<int, X, Y> z1; // expected-note {{instantiation of}}
868    Z2<int, X, Y> z2; // expected-note {{instantiation of}}
869  }
870
871  namespace example2 {
872    struct X {
873    private:
874      typedef int Type; // expected-note {{private}}
875    };
876    template<typename T> struct A {
877      typename T::Type t; // expected-error {{private}}
878    };
879    A<X> ax; // expected-note {{instantiation of}}
880  }
881
882  namespace example3 {
883    struct A {
884    protected:
885      typedef int N; // expected-note 2{{protected}}
886    };
887
888    template<typename T> struct B {};
889    template<typename U> struct C : U, B<typename U::N> {}; // expected-error {{protected}}
890    template<typename U> struct D : B<typename U::N>, U {}; // expected-error {{protected}}
891
892    C<A> x; // expected-note {{instantiation of}}
893    D<A> y; // expected-note {{instantiation of}}
894  }
895
896  namespace example4 {
897    class A {
898      class B {};
899      friend class X;
900    };
901
902    struct X : A::B {
903      A::B mx;
904      class Y {
905        A::B my;
906      };
907    };
908  }
909}
910
911namespace dr373 { // dr373: no
912  // FIXME: This is valid.
913  namespace X { int dr373; } // expected-note 2{{here}}
914  struct dr373 { // expected-note {{here}}
915    void f() {
916      using namespace dr373::X; // expected-error {{no namespace named 'X' in 'dr373::dr373'}}
917      int k = dr373; // expected-error {{does not refer to a value}}
918
919      namespace Y = dr373::X; // expected-error {{no namespace named 'X' in 'dr373::dr373'}}
920      k = Y::dr373;
921    }
922  };
923}
924
925namespace dr374 { // dr374: yes c++11
926  namespace N {
927    template<typename T> void f();
928    template<typename T> struct A { void f(); };
929  }
930  template<> void N::f<char>() {}
931  template<> void N::A<char>::f() {}
932  template<> struct N::A<int> {};
933#if __cplusplus < 201103L
934  // expected-error@-4 {{extension}} expected-note@-7 {{here}}
935  // expected-error@-4 {{extension}} expected-note@-7 {{here}}
936  // expected-error@-4 {{extension}} expected-note@-8 {{here}}
937#endif
938}
939
940// dr375: dup 345
941// dr376: na
942
943namespace dr377 { // dr377: yes
944  enum E { // expected-error {{enumeration values exceed range of largest integer}}
945    a = -__LONG_LONG_MAX__ - 1, // expected-error 0-1{{extension}}
946    b = 2 * (unsigned long long)__LONG_LONG_MAX__ // expected-error 0-2{{extension}}
947  };
948}
949
950// dr378: dup 276
951// dr379: na
952
953namespace dr381 { // dr381: yes
954  struct A {
955    int a;
956  };
957  struct B : virtual A {};
958  struct C : B {};
959  struct D : B {};
960  struct E : public C, public D {};
961  struct F : public A {};
962  void f() {
963    E e;
964    e.B::a = 0; // expected-error {{ambiguous conversion}}
965    F f;
966    f.A::a = 1;
967  }
968}
969
970namespace dr382 { // dr382: yes c++11
971  // FIXME: Should we allow this in C++98 mode?
972  struct A { typedef int T; };
973  typename A::T t;
974  typename dr382::A a;
975#if __cplusplus < 201103L
976  // expected-error@-3 {{occurs outside of a template}}
977  // expected-error@-3 {{occurs outside of a template}}
978#endif
979  typename A b; // expected-error {{expected a qualified name}}
980}
981
982namespace dr383 { // dr383: yes
983  struct A { A &operator=(const A&); };
984  struct B { ~B(); };
985  union C { C &operator=(const C&); };
986  union D { ~D(); };
987  int check[(__is_pod(A) || __is_pod(B) || __is_pod(C) || __is_pod(D)) ? -1 : 1];
988}
989
990namespace dr384 { // dr384: yes
991  namespace N1 {
992    template<typename T> struct Base {};
993    template<typename T> struct X {
994      struct Y : public Base<T> {
995        Y operator+(int) const;
996      };
997      Y f(unsigned i) { return Y() + i; }
998    };
999  }
1000
1001  namespace N2 {
1002    struct Z {};
1003    template<typename T> int *operator+(T, unsigned);
1004  }
1005
1006  int main() {
1007    N1::X<N2::Z> v;
1008    v.f(0);
1009  }
1010}
1011
1012namespace dr385 { // dr385: yes
1013  struct A { protected: void f(); };
1014  struct B : A { using A::f; };
1015  struct C : A { void g(B b) { b.f(); } };
1016  void h(B b) { b.f(); }
1017
1018  struct D { int n; }; // expected-note {{member}}
1019  struct E : protected D {}; // expected-note 2{{protected}}
1020  struct F : E { friend int i(E); };
1021  int i(E e) { return e.n; } // expected-error {{protected base}} expected-error {{protected member}}
1022}
1023
1024namespace dr387 { // dr387: yes
1025  namespace old {
1026    template<typename T> class number {
1027      number(int); // expected-note 2{{here}}
1028      friend number gcd(number &x, number &y) {}
1029    };
1030
1031    void g() {
1032      number<double> a(3), b(4); // expected-error 2{{private}}
1033      a = gcd(a, b);
1034      b = gcd(3, 4); // expected-error {{undeclared}}
1035    }
1036  }
1037
1038  namespace newer {
1039    template <typename T> class number {
1040    public:
1041      number(int);
1042      friend number gcd(number x, number y) { return 0; }
1043    };
1044
1045    void g() {
1046      number<double> a(3), b(4);
1047      a = gcd(a, b);
1048      b = gcd(3, 4); // expected-error {{undeclared}}
1049    }
1050  }
1051}
1052
1053// FIXME: dr388 needs codegen test
1054
1055namespace dr389 { // dr389: no
1056  struct S {
1057    typedef struct {} A;
1058    typedef enum {} B;
1059    typedef struct {} const C; // expected-note 0-2{{here}}
1060    typedef enum {} const D; // expected-note 0-1{{here}}
1061  };
1062  template<typename> struct T {};
1063
1064  struct WithLinkage1 {};
1065  enum WithLinkage2 {};
1066  typedef struct {} *WithLinkage3a, WithLinkage3b;
1067  typedef enum {} WithLinkage4a, *WithLinkage4b;
1068  typedef S::A WithLinkage5;
1069  typedef const S::B WithLinkage6;
1070  typedef int WithLinkage7;
1071  typedef void (*WithLinkage8)(WithLinkage2 WithLinkage1::*, WithLinkage5 *);
1072  typedef T<WithLinkage5> WithLinkage9;
1073
1074  typedef struct {} *WithoutLinkage1; // expected-note 0-1{{here}}
1075  typedef enum {} const WithoutLinkage2; // expected-note 0-1{{here}}
1076  // These two types don't have linkage even though they are externally visible
1077  // and the ODR requires them to be merged across TUs.
1078  typedef S::C WithoutLinkage3;
1079  typedef S::D WithoutLinkage4;
1080  typedef void (*WithoutLinkage5)(int (WithoutLinkage3::*)(char));
1081
1082#if __cplusplus >= 201103L
1083  // This has linkage even though its template argument does not.
1084  // FIXME: This is probably a defect.
1085  typedef T<WithoutLinkage1> WithLinkage10;
1086#else
1087  typedef int WithLinkage10; // dummy
1088
1089  typedef T<WithLinkage1> GoodArg1;
1090  typedef T<WithLinkage2> GoodArg2;
1091  typedef T<WithLinkage3a> GoodArg3a;
1092  typedef T<WithLinkage3b> GoodArg3b;
1093  typedef T<WithLinkage4a> GoodArg4a;
1094  typedef T<WithLinkage4b> GoodArg4b;
1095  typedef T<WithLinkage5> GoodArg5;
1096  typedef T<WithLinkage6> GoodArg6;
1097  typedef T<WithLinkage7> GoodArg7;
1098  typedef T<WithLinkage8> GoodArg8;
1099  typedef T<WithLinkage9> GoodArg9;
1100
1101  typedef T<WithoutLinkage1> BadArg1; // expected-error{{template argument uses}}
1102  typedef T<WithoutLinkage2> BadArg2; // expected-error{{template argument uses}}
1103  typedef T<WithoutLinkage3> BadArg3; // expected-error{{template argument uses}}
1104  typedef T<WithoutLinkage4> BadArg4; // expected-error{{template argument uses}}
1105  typedef T<WithoutLinkage5> BadArg5; // expected-error{{template argument uses}}
1106#endif
1107
1108  extern WithLinkage1 withLinkage1;
1109  extern WithLinkage2 withLinkage2;
1110  extern WithLinkage3a withLinkage3a;
1111  extern WithLinkage3b withLinkage3b;
1112  extern WithLinkage4a withLinkage4a;
1113  extern WithLinkage4b withLinkage4b;
1114  extern WithLinkage5 withLinkage5;
1115  extern WithLinkage6 withLinkage6;
1116  extern WithLinkage7 withLinkage7;
1117  extern WithLinkage8 withLinkage8;
1118  extern WithLinkage9 withLinkage9;
1119  extern WithLinkage10 withLinkage10;
1120
1121  // FIXME: These are all ill-formed.
1122  extern WithoutLinkage1 withoutLinkage1;
1123  extern WithoutLinkage2 withoutLinkage2;
1124  extern WithoutLinkage3 withoutLinkage3;
1125  extern WithoutLinkage4 withoutLinkage4;
1126  extern WithoutLinkage5 withoutLinkage5;
1127
1128  // OK, extern "C".
1129  extern "C" {
1130    extern WithoutLinkage1 dr389_withoutLinkage1;
1131    extern WithoutLinkage2 dr389_withoutLinkage2;
1132    extern WithoutLinkage3 dr389_withoutLinkage3;
1133    extern WithoutLinkage4 dr389_withoutLinkage4;
1134    extern WithoutLinkage5 dr389_withoutLinkage5;
1135  }
1136
1137  // OK, defined.
1138  WithoutLinkage1 withoutLinkageDef1;
1139  WithoutLinkage2 withoutLinkageDef2 = WithoutLinkage2();
1140  WithoutLinkage3 withoutLinkageDef3 = {};
1141  WithoutLinkage4 withoutLinkageDef4 = WithoutLinkage4();
1142  WithoutLinkage5 withoutLinkageDef5;
1143
1144  void use(const void *);
1145  void use_all() {
1146    use(&withLinkage1); use(&withLinkage2); use(&withLinkage3a); use(&withLinkage3b);
1147    use(&withLinkage4a); use(&withLinkage4b); use(&withLinkage5); use(&withLinkage6);
1148    use(&withLinkage7); use(&withLinkage8); use(&withLinkage9); use(&withLinkage10);
1149
1150    use(&withoutLinkage1); use(&withoutLinkage2); use(&withoutLinkage3);
1151    use(&withoutLinkage4); use(&withoutLinkage5);
1152
1153    use(&dr389_withoutLinkage1); use(&dr389_withoutLinkage2);
1154    use(&dr389_withoutLinkage3); use(&dr389_withoutLinkage4);
1155    use(&dr389_withoutLinkage5);
1156
1157    use(&withoutLinkageDef1); use(&withoutLinkageDef2); use(&withoutLinkageDef3);
1158    use(&withoutLinkageDef4); use(&withoutLinkageDef5);
1159  }
1160
1161  void local() {
1162    // FIXME: This is ill-formed.
1163    extern WithoutLinkage1 withoutLinkageLocal;
1164  }
1165}
1166
1167namespace dr390 { // dr390: yes
1168  template<typename T>
1169  struct A {
1170    A() { f(); } // expected-warning {{call to pure virt}}
1171    virtual void f() = 0; // expected-note {{here}}
1172    virtual ~A() = 0;
1173  };
1174  template<typename T> A<T>::~A() { T::error; } // expected-error {{cannot be used prior to}}
1175  template<typename T> void A<T>::f() { T::error; } // ok, not odr-used
1176  struct B : A<int> { // expected-note 2{{in instantiation of}}
1177    void f() {}
1178  } b;
1179}
1180
1181namespace dr391 { // dr391: yes c++11
1182  // FIXME: Should this apply to C++98 too?
1183  class A { A(const A&); }; // expected-note 0-1{{here}}
1184  A fa();
1185  const A &a = fa();
1186#if __cplusplus < 201103L
1187  // expected-error@-2 {{C++98 requires an accessible copy constructor}}
1188#endif
1189
1190  struct B { B(const B&) = delete; }; // expected-error 0-1{{extension}} expected-note 0-1{{here}}
1191  B fb();
1192  const B &b = fb();
1193#if __cplusplus < 201103L
1194  // expected-error@-2 {{deleted}}
1195#endif
1196
1197  template<typename T>
1198  struct C {
1199    C(const C&) { T::error; }
1200  };
1201  C<int> fc();
1202  const C<int> &c = fc();
1203}
1204
1205// dr392 FIXME write codegen test
1206// dr394: na
1207
1208namespace dr395 { // dr395: yes
1209  struct S {
1210    template <typename T, int N>(&operator T())[N]; // expected-error {{cannot specify any part of a return type}}
1211    template <typename T, int N> operator(T (&)[N])(); // expected-error {{expected ')'}} expected-note {{to match this '('}} expected-error +{{}}
1212    template <typename T> operator T *() const { return 0; }
1213    template <typename T, typename U> operator T U::*() const { return 0; }
1214    template <typename T, typename U> operator T (U::*)()() const { return 0; } // expected-error +{{}}
1215  };
1216
1217  struct null1_t {
1218    template <class T, class U> struct ptr_mem_fun_t {
1219      typedef T (U::*type)();
1220    };
1221
1222    template <class T, class U>
1223    operator typename ptr_mem_fun_t<T, U>::type() const { // expected-note {{couldn't infer}}
1224      return 0;
1225    }
1226  } null1;
1227  int (S::*p)() = null1; // expected-error {{no viable conversion}}
1228
1229  template <typename T> using id = T; // expected-error 0-1{{extension}}
1230
1231  struct T {
1232    template <typename T, int N> operator id<T[N]> &();
1233    template <typename T, typename U> operator id<T (U::*)()>() const;
1234  };
1235
1236  struct null2_t {
1237    template<class T, class U> using ptr_mem_fun_t = T (U::*)(); // expected-error 0-1{{extension}}
1238    template<class T, class U> operator ptr_mem_fun_t<T, U>() const { return 0; };
1239  } null2;
1240  int (S::*q)() = null2;
1241}
1242
1243namespace dr396 { // dr396: yes
1244  void f() {
1245    auto int a(); // expected-error {{storage class on function}}
1246    int (i); // expected-note {{previous}}
1247    auto int (i); // expected-error {{redefinition}}
1248#if __cplusplus >= 201103L
1249  // expected-error@-4 {{'auto' storage class}} expected-error@-2 {{'auto' storage class}}
1250#endif
1251  }
1252}
1253
1254// dr397: sup 1823
1255
1256namespace dr398 { // dr398: yes
1257  namespace example1 {
1258    struct S {
1259      static int const I = 42;
1260    };
1261    template <int N> struct X {};
1262    template <typename T> void f(X<T::I> *) {}
1263    template <typename T> void f(X<T::J> *) {}
1264    void foo() { f<S>(0); }
1265  }
1266
1267  namespace example2 {
1268    template <int I> struct X {};
1269    template <template <class T> class> struct Z {};
1270    template <class T> void f(typename T::Y *) {} // expected-note 2{{substitution failure}}
1271    template <class T> void g(X<T::N> *) {} // expected-note {{substitution failure}}
1272    template <class T> void h(Z<T::template TT> *) {} // expected-note {{substitution failure}}
1273    struct A {};
1274    struct B {
1275      int Y;
1276    };
1277    struct C {
1278      typedef int N;
1279    };
1280    struct D {
1281      typedef int TT;
1282    };
1283
1284    void test() {
1285      f<A>(0); // expected-error {{no matching function}}
1286      f<B>(0); // expected-error {{no matching function}}
1287      g<C>(0); // expected-error {{no matching function}}
1288      h<D>(0); // expected-error {{no matching function}}
1289    }
1290  }
1291}
1292