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++1y %s -verify -fexceptions -fcxx-exceptions -pedantic-errors
4
5namespace dr100 { // dr100: yes
6  template<const char *> struct A {}; // expected-note {{declared here}}
7  template<const char (&)[4]> struct B {}; // expected-note {{declared here}}
8  A<"foo"> a; // expected-error {{does not refer to any declaration}}
9  B<"bar"> b; // expected-error {{does not refer to any declaration}}
10}
11
12namespace dr101 { // dr101: yes
13  extern "C" void dr101_f();
14  typedef unsigned size_t;
15  namespace X {
16    extern "C" void dr101_f();
17    typedef unsigned size_t;
18  }
19  using X::dr101_f;
20  using X::size_t;
21}
22
23namespace dr102 { // dr102: yes
24  namespace A {
25    template<typename T> T f(T a, T b) { return a + b; } // expected-error {{neither visible in the template definition nor found by argument-dependent lookup}}
26  }
27  namespace B {
28    struct S {};
29  }
30  B::S operator+(B::S, B::S); // expected-note {{should be declared prior to the call site or in namespace 'dr102::B'}}
31  template B::S A::f(B::S, B::S); // expected-note {{in instantiation of}}
32}
33
34// dr103: na
35// dr104 FIXME: add codegen test
36// dr105: na
37
38namespace dr106 { // dr106: sup 540
39  typedef int &r1;
40  typedef r1 &r1;
41  typedef const r1 r1;
42  typedef const r1 &r1;
43
44  typedef const int &r2;
45  typedef r2 &r2;
46  typedef const r2 r2;
47  typedef const r2 &r2;
48}
49
50namespace dr107 { // dr107: yes
51  struct S {};
52  extern "C" S operator+(S, S) { return S(); }
53}
54
55namespace dr108 { // dr108: yes
56  template<typename T> struct A {
57    struct B { typedef int X; };
58    B::X x; // expected-error {{missing 'typename'}}
59    struct C : B { X x; }; // expected-error {{unknown type name}}
60  };
61  template<> struct A<int>::B { int X; };
62}
63
64namespace dr109 { // dr109: yes
65  struct A { template<typename T> void f(T); };
66  template<typename T> struct B : T {
67    using T::template f; // expected-error {{using declaration can not refer to a template}}
68    void g() { this->f<int>(123); } // expected-error {{use 'template'}}
69  };
70}
71
72namespace dr111 { // dr111: dup 535
73  struct A { A(); A(volatile A&, int = 0); A(A&, const char * = "foo"); };
74  struct B : A { B(); }; // expected-note {{would lose const qualifier}} expected-note {{requires 0 arguments}}
75  const B b1;
76  B b2(b1); // expected-error {{no matching constructor}}
77}
78
79namespace dr112 { // dr112: yes
80  struct T { int n; };
81  typedef T Arr[1];
82
83  const T a1[1] = {};
84  volatile T a2[1] = {};
85  const Arr a3 = {};
86  volatile Arr a4 = {};
87  template<const volatile T*> struct X {};
88  X<a1> x1;
89  X<a2> x2;
90  X<a3> x3;
91  X<a4> x4;
92#if __cplusplus < 201103L
93  // expected-error@-5 {{internal linkage}} expected-note@-10 {{here}}
94  // expected-error@-4 {{internal linkage}} expected-note@-9 {{here}}
95#else
96  // FIXME: Test this somehow.
97#endif
98}
99
100namespace dr113 { // dr113: yes
101  extern void (*p)();
102  void f() {
103    no_such_function(); // expected-error {{undeclared}}
104    p();
105  }
106  void g();
107  void (*p)() = &g;
108}
109
110namespace dr114 { // dr114: yes
111  struct A {
112    virtual void f(int) = 0; // expected-note {{unimplemented}}
113  };
114  struct B : A {
115    template<typename T> void f(T);
116    void g() { f(0); }
117  } b; // expected-error {{abstract}}
118}
119
120namespace dr115 { // dr115: yes
121  template<typename T> int f(T); // expected-note +{{}}
122  template<typename T> int g(T); // expected-note +{{}}
123  template<typename T> int g(T, int); // expected-note +{{}}
124
125  int k1 = f(&f); // expected-error {{no match}}
126  int k2 = f(&f<int>);
127  int k3 = f(&g<int>); // expected-error {{no match}}
128
129  void h() {
130    (void)&f; // expected-error {{address of overloaded function 'f' cannot be cast to type 'void'}}
131    (void)&f<int>;
132    (void)&g<int>; // expected-error {{address of overloaded function 'g' cannot be cast to type 'void'}}
133
134    &f; // expected-error {{reference to overloaded function could not be resolved}}
135    &f<int>; // expected-warning {{unused}}
136    &g<int>; // expected-error {{reference to overloaded function could not be resolved}}
137  }
138
139  struct S {
140    template<typename T> static int f(T);
141    template<typename T> static int g(T);
142    template<typename T> static int g(T, int);
143  } s;
144
145  int k4 = f(&s.f); // expected-error {{non-constant pointer to member}}
146  int k5 = f(&s.f<int>);
147  int k6 = f(&s.g<int>); // expected-error {{non-constant pointer to member}}
148
149  void i() {
150    (void)&s.f; // expected-error {{non-constant pointer to member}}
151    (void)&s.f<int>;
152    (void)&s.g<int>; // expected-error {{non-constant pointer to member}}
153
154    &s.f; // expected-error {{non-constant pointer to member}}
155    &s.f<int>; // expected-warning {{unused}}
156    &s.g<int>; // expected-error {{non-constant pointer to member}}
157  }
158
159  struct T {
160    template<typename T> int f(T);
161    template<typename T> int g(T);
162    template<typename T> int g(T, int);
163  } t;
164
165  int k7 = f(&s.f); // expected-error {{non-constant pointer to member}}
166  int k8 = f(&s.f<int>);
167  int k9 = f(&s.g<int>); // expected-error {{non-constant pointer to member}}
168
169  void j() {
170    (void)&s.f; // expected-error {{non-constant pointer to member}}
171    (void)&s.f<int>;
172    (void)&s.g<int>; // expected-error {{non-constant pointer to member}}
173
174    &s.f; // expected-error {{non-constant pointer to member}}
175    &s.f<int>; // expected-warning {{unused}}
176    &s.g<int>; // expected-error {{non-constant pointer to member}}
177  }
178
179#if __cplusplus >= 201103L
180  // Special case kicks in only if a template argument list is specified.
181  template<typename T=int> void with_default(); // expected-note +{{}}
182  int k10 = f(&with_default); // expected-error {{no matching function}}
183  int k11 = f(&with_default<>);
184  void k() {
185    (void)&with_default; // expected-error {{overloaded function}}
186    (void)&with_default<>;
187    &with_default; // expected-error {{overloaded function}}
188    &with_default<>; // expected-warning {{unused}}
189  }
190#endif
191}
192
193namespace dr116 { // dr116: yes
194  template<int> struct A {};
195  template<int N> void f(A<N>) {} // expected-note {{previous}}
196  template<int M> void f(A<M>) {} // expected-error {{redefinition}}
197  template<typename T> void f(A<sizeof(T)>) {} // expected-note {{previous}}
198  template<typename U> void f(A<sizeof(U)>) {} // expected-error {{redefinition}}
199}
200
201// dr117: na
202// dr118 FIXME: add codegen test
203// dr119: na
204// dr120: na
205
206namespace dr121 { // dr121: yes
207  struct X {
208    template<typename T> struct Y {};
209  };
210  template<typename T> struct Z {
211    X::Y<T> x;
212    T::Y<T> y; // expected-error +{{}}
213  };
214  Z<X> z;
215}
216
217namespace dr122 { // dr122: yes
218  template<typename T> void f();
219  void g() { f<int>(); }
220}
221
222// dr123: na
223// dr124: dup 201
224
225// dr125: yes
226struct dr125_A { struct dr125_B {}; };
227dr125_A::dr125_B dr125_C();
228namespace dr125_B { dr125_A dr125_C(); }
229namespace dr125 {
230  struct X {
231    friend dr125_A::dr125_B (::dr125_C)(); // ok
232    friend dr125_A (::dr125_B::dr125_C)(); // ok
233    friend dr125_A::dr125_B::dr125_C(); // expected-error {{requires a type specifier}}
234  };
235}
236
237namespace dr126 { // dr126: no
238  struct C {};
239  struct D : C {};
240  struct E : private C { friend class A; friend class B; };
241  struct F : protected C {};
242  struct G : C {};
243  struct H : D, G {};
244
245  struct A {
246    virtual void cp() throw(C*);
247    virtual void dp() throw(C*);
248    virtual void ep() throw(C*); // expected-note {{overridden}}
249    virtual void fp() throw(C*); // expected-note {{overridden}}
250    virtual void gp() throw(C*);
251    virtual void hp() throw(C*); // expected-note {{overridden}}
252
253    virtual void cr() throw(C&);
254    virtual void dr() throw(C&);
255    virtual void er() throw(C&); // expected-note {{overridden}}
256    virtual void fr() throw(C&); // expected-note {{overridden}}
257    virtual void gr() throw(C&);
258    virtual void hr() throw(C&); // expected-note {{overridden}}
259
260    virtual void pv() throw(void*); // expected-note {{overridden}}
261
262#if __cplusplus >= 201103L
263    virtual void np() throw(C*); // expected-note {{overridden}}
264    virtual void npm() throw(int C::*); // expected-note {{overridden}}
265    virtual void nr() throw(C&); // expected-note {{overridden}}
266#endif
267
268    virtual void ref1() throw(C *const&);
269    virtual void ref2() throw(C *);
270
271    virtual void v() throw(int);
272    virtual void w() throw(const int);
273    virtual void x() throw(int*);
274    virtual void y() throw(const int*);
275    virtual void z() throw(int); // expected-note {{overridden}}
276  };
277  struct B : A {
278    virtual void cp() throw(C*);
279    virtual void dp() throw(D*);
280    virtual void ep() throw(E*); // expected-error {{more lax}}
281    virtual void fp() throw(F*); // expected-error {{more lax}}
282    virtual void gp() throw(G*);
283    virtual void hp() throw(H*); // expected-error {{more lax}}
284
285    virtual void cr() throw(C&);
286    virtual void dr() throw(D&);
287    virtual void er() throw(E&); // expected-error {{more lax}}
288    virtual void fr() throw(F&); // expected-error {{more lax}}
289    virtual void gr() throw(G&);
290    virtual void hr() throw(H&); // expected-error {{more lax}}
291
292    virtual void pv() throw(C*); // expected-error {{more lax}} FIXME: This is valid.
293
294#if __cplusplus >= 201103L
295    using nullptr_t = decltype(nullptr);
296    virtual void np() throw(nullptr_t*); // expected-error {{more lax}} FIXME: This is valid.
297    virtual void npm() throw(nullptr_t*); // expected-error {{more lax}} FIXME: This is valid.
298    virtual void nr() throw(nullptr_t&); // expected-error {{more lax}} This is not.
299#endif
300
301    virtual void ref1() throw(D *const &);
302    virtual void ref2() throw(D *);
303
304    virtual void v() throw(const int);
305    virtual void w() throw(int);
306    virtual void x() throw(const int*); // FIXME: 'const int*' is not allowed by A::h.
307    virtual void y() throw(int*); // ok
308    virtual void z() throw(long); // expected-error {{more lax}}
309  };
310}
311
312namespace dr127 { // dr127: yes
313  __extension__ typedef __decltype(sizeof(0)) size_t;
314  template<typename T> struct A {
315    A() throw(int);
316    void *operator new(size_t, const char * = 0);
317    void operator delete(void *, const char *) { T::error; } // expected-error 2{{no members}}
318    void operator delete(void *) { T::error; }
319  };
320  A<void> *p = new A<void>; // expected-note {{instantiat}}
321  A<int> *q = new ("") A<int>; // expected-note {{instantiat}}
322}
323
324namespace dr128 { // dr128: yes
325  enum E1 { e1 } x = e1;
326  enum E2 { e2 } y = static_cast<E2>(x), z = static_cast<E2>(e1);
327}
328
329// dr129: dup 616
330// dr130: na
331
332namespace dr131 { // dr131: yes
333  const char *a_with_\u0e8c = "\u0e8c";
334  const char *b_with_\u0e8d = "\u0e8d";
335  const char *c_with_\u0e8e = "\u0e8e";
336#if __cplusplus < 201103L
337  // expected-error@-4 {{expected ';'}} expected-error@-2 {{expected ';'}}
338#endif
339}
340
341namespace dr132 { // dr132: no
342  void f() {
343    extern struct {} x; // ok
344    extern struct S {} y; // FIXME: This is invalid.
345  }
346  static enum { E } e;
347}
348
349// dr133: dup 87
350// dr134: na
351
352namespace dr135 { // dr135: yes
353  struct A {
354    A f(A a) { return a; }
355    friend A g(A a) { return a; }
356    static A h(A a) { return a; }
357  };
358}
359
360namespace dr136 { // dr136: 3.4
361  void f(int, int, int = 0); // expected-note {{previous declaration is here}}
362  void g(int, int, int); // expected-note {{previous declaration is here}}
363  struct A {
364    friend void f(int, int = 0, int); // expected-error {{friend declaration specifying a default argument must be the only declaration}}
365    friend void g(int, int, int = 0); // expected-error {{friend declaration specifying a default argument must be the only declaration}}
366    friend void h(int, int, int = 0); // expected-error {{friend declaration specifying a default argument must be a definition}}
367    friend void i(int, int, int = 0) {} // expected-note {{previous declaration is here}}
368    friend void j(int, int, int = 0) {}
369    operator int();
370  };
371  void i(int, int, int); // expected-error {{friend declaration specifying a default argument must be the only declaration}}
372  void q() {
373    j(A(), A()); // ok, has default argument
374  }
375  extern "C" void k(int, int, int, int); // expected-note {{previous declaration is here}}
376  namespace NSA {
377  struct A {
378    friend void dr136::k(int, int, int, int = 0); // expected-error {{friend declaration specifying a default argument must be the only declaration}} \
379                                                  // expected-note {{previous declaration is here}}
380  };
381  }
382  namespace NSB {
383  struct A {
384    friend void dr136::k(int, int, int = 0, int); // expected-error {{friend declaration specifying a default argument must be the only declaration}}
385  };
386  }
387  struct B {
388    void f(int); // expected-note {{previous declaration is here}}
389  };
390  struct C {
391    friend void B::f(int = 0); // expected-error {{friend declaration specifying a default argument must be the only declaration}}
392  };
393}
394
395namespace dr137 { // dr137: yes
396  extern void *p;
397  extern const void *cp;
398  extern volatile void *vp;
399  extern const volatile void *cvp;
400  int *q = static_cast<int*>(p);
401  int *qc = static_cast<int*>(cp); // expected-error {{casts away qualifiers}}
402  int *qv = static_cast<int*>(vp); // expected-error {{casts away qualifiers}}
403  int *qcv = static_cast<int*>(cvp); // expected-error {{casts away qualifiers}}
404  const int *cq = static_cast<const int*>(p);
405  const int *cqc = static_cast<const int*>(cp);
406  const int *cqv = static_cast<const int*>(vp); // expected-error {{casts away qualifiers}}
407  const int *cqcv = static_cast<const int*>(cvp); // expected-error {{casts away qualifiers}}
408  const volatile int *cvq = static_cast<const volatile int*>(p);
409  const volatile int *cvqc = static_cast<const volatile int*>(cp);
410  const volatile int *cvqv = static_cast<const volatile int*>(vp);
411  const volatile int *cvqcv = static_cast<const volatile int*>(cvp);
412}
413
414namespace dr139 { // dr139: yes
415  namespace example1 {
416    typedef int f; // expected-note {{previous}}
417    struct A {
418      friend void f(A &); // expected-error {{different kind of symbol}}
419    };
420  }
421
422  namespace example2 {
423    typedef int f;
424    namespace N {
425      struct A {
426        friend void f(A &);
427        operator int();
428        void g(A a) { int i = f(a); } // ok, f is typedef not friend function
429      };
430    }
431  }
432}
433
434namespace dr140 { // dr140: yes
435  void f(int *const) {} // expected-note {{previous}}
436  void f(int[3]) {} // expected-error {{redefinition}}
437  void g(const int);
438  void g(int n) { n = 2; }
439}
440
441namespace dr141 { // dr141: yes
442  template<typename T> void f();
443  template<typename T> struct S { int n; };
444  struct A : S<int> {
445    template<typename T> void f();
446    template<typename T> struct S {};
447  } a;
448  struct B : S<int> {} b;
449  void g() {
450    a.f<int>();
451    (void)a.S<int>::n; // expected-error {{no member named 'n'}}
452#if __cplusplus < 201103L
453    // expected-error@-2 {{ambiguous}}
454    // expected-note@-11 {{lookup from the current scope}}
455    // expected-note@-9 {{lookup in the object type}}
456#endif
457    b.f<int>(); // expected-error {{no member}} expected-error +{{}}
458    (void)b.S<int>::n;
459  }
460  template<typename T> struct C {
461    T t;
462    void g() {
463      t.f<int>(); // expected-error {{use 'template'}}
464    }
465    void h() {
466      (void)t.S<int>::n; // ok
467    }
468    void i() {
469      (void)t.S<int>(); // ok!
470    }
471  };
472  void h() { C<B>().h(); } // ok
473  struct X {
474    template<typename T> void S();
475  };
476  void i() { C<X>().i(); } // ok!!
477}
478
479namespace dr142 { // dr142: yes
480  class B { // expected-note +{{here}}
481  public:
482    int mi; // expected-note +{{here}}
483    static int si; // expected-note +{{here}}
484  };
485  class D : private B { // expected-note +{{here}}
486  };
487  class DD : public D {
488    void f();
489  };
490  void DD::f() {
491    mi = 3; // expected-error {{private base class}} expected-error {{private member}}
492    si = 3; // expected-error {{private member}}
493    B b_old; // expected-error {{private member}}
494    dr142::B b;
495    b.mi = 3;
496    b.si = 3;
497    B::si = 3; // expected-error {{private member}}
498    dr142::B::si = 3;
499    B *bp1_old = this; // expected-error {{private member}} expected-error {{private base class}}
500    dr142::B *bp1 = this; // expected-error {{private base class}}
501    B *bp2_old = (B*)this; // expected-error 2{{private member}}
502    dr142::B *bp2 = (dr142::B*)this;
503    bp2->mi = 3;
504  }
505}
506
507namespace dr143 { // dr143: yes
508  namespace A { struct X; }
509  namespace B { void f(A::X); }
510  namespace A {
511    struct X { friend void B::f(X); };
512  }
513  void g(A::X x) {
514    f(x); // expected-error {{undeclared identifier 'f'}}
515  }
516}
517
518namespace dr145 { // dr145: yes
519  void f(bool b) {
520    ++b; // expected-warning {{deprecated}}
521    b++; // expected-warning {{deprecated}}
522  }
523}
524
525namespace dr147 { // dr147: no
526  namespace example1 {
527    template<typename> struct A {
528      template<typename T> A(T);
529    };
530    // FIXME: This appears to be valid, and EDG and G++ accept.
531    template<> template<> A<int>::A<int>(int) {} // expected-error {{out-of-line constructor for 'A' cannot have template arguments}}
532  }
533  namespace example2 {
534    struct A { A(); };
535    struct B : A { B(); };
536    A::A a1; // expected-error {{is a constructor}}
537    B::A a2;
538  }
539  namespace example3 {
540    template<typename> struct A {
541      template<typename T> A(T);
542      static A a;
543    };
544    template<> A<int>::A<int>(A<int>::a); // expected-error {{is a constructor}}
545  }
546}
547
548namespace dr148 { // dr148: yes
549  struct A { int A::*p; };
550  int check1[__is_pod(int(A::*)) ? 1 : -1];
551  int check2[__is_pod(A) ? 1 : -1];
552}
553
554// dr149: na
555