Home | History | Annotate | Download | only in SemaTemplate 
      1 // RUN: %clang_cc1 -fsyntax-only -verify %s
      2 
      3 namespace PR8965 {
      4   template<typename T>
      5   struct X {
      6     typedef int type;
      7 
      8     T field; // expected-note{{in instantiation of member class}}
      9   };
     10 
     11   template<typename T>
     12   struct Y {
     13     struct Inner;
     14 
     15     typedef typename X<Inner>::type // expected-note{{in instantiation of template class}}
     16       type; // expected-note{{not-yet-instantiated member is declared here}}
     17 
     18     struct Inner {
     19       typedef type field; // expected-error{{no member 'type' in 'PR8965::Y<int>'; it has not yet been instantiated}}
     20     };
     21   };
     22 
     23   Y<int> y; // expected-note{{in instantiation of template class}}
     24 }
     25 
     26 template<typename T>
     27 class X {
     28 public:
     29   struct C { T &foo(); };
     30 
     31   struct D {
     32     struct E { T &bar(); }; // expected-error{{cannot form a reference to 'void'}}
     33     struct F; // expected-note{{member is declared here}}
     34   };
     35 };
     36 
     37 X<int>::C *c1;
     38 X<float>::C *c2;
     39 
     40 X<int>::X *xi; // expected-error{{qualified reference to 'X' is a constructor name rather than a type wherever a constructor can be declared}}
     41 X<float>::X *xf; // expected-error{{qualified reference to 'X' is a constructor name rather than a type wherever a constructor can be declared}}
     42 
     43 void test_naming() {
     44   c1 = c2; // expected-error{{assigning to 'X<int>::C *' from incompatible type 'X<float>::C *'}}
     45   xi = xf;  // expected-error{{assigning to 'X<int>::X<int> *' from incompatible type 'X<float>::X<float> *'}}
     46     // FIXME: error above doesn't print the type X<int>::X cleanly!
     47 }
     48 
     49 void test_instantiation(X<double>::C *x,
     50                         X<float>::D::E *e,
     51                         X<float>::D::F *f) {
     52   double &dr = x->foo();
     53   float &fr = e->bar();
     54   f->foo(); // expected-error{{implicit instantiation of undefined member 'X<float>::D::F'}}
     55 
     56 }
     57 
     58 
     59 X<void>::C *c3; // okay
     60 X<void>::D::E *e1; // okay
     61 X<void>::D::E e2; // expected-note{{in instantiation of member class 'X<void>::D::E' requested here}}
     62 
     63 // Redeclarations.
     64 namespace test1 {
     65   template <typename T> struct Registry {
     66     struct node;
     67     static node *Head;
     68     struct node {
     69       node(int v) { Head = this; }
     70     };
     71   };
     72   void test() {
     73     Registry<int>::node node(0);
     74   }
     75 }
     76 
     77 // Redeclarations during explicit instantiations.
     78 namespace test2 {
     79   template <typename T> class A {
     80     class Foo;
     81     class Foo {
     82       int foo();
     83     };
     84   };
     85   template class A<int>;
     86 
     87   template <typename T> class B {
     88     class Foo;
     89     class Foo {
     90     public:
     91       typedef int X;
     92     };
     93     typename Foo::X x;
     94   };
     95   template class B<int>;
     96 
     97   template <typename T> class C {
     98     class Foo;
     99   };
    100   template <typename T> class C<T>::Foo {
    101     int x;
    102   };
    103   template class C<int>;
    104 }
    105 
    106 namespace AliasTagDef {
    107   template<typename T>
    108   struct F {
    109     using S = struct U { // expected-warning {{C++11}}
    110       T g() {
    111         return T();
    112       }
    113     };
    114   };
    115 
    116   int m = F<int>::S().g();
    117   int n = F<int>::U().g();
    118 }
    119 
    120 namespace rdar10397846 {
    121   template<int I> struct A
    122   {
    123     struct B
    124     {
    125       struct C { C() { int *ptr = I; } }; // expected-error{{cannot initialize a variable of type 'int *' with an rvalue of type 'int'}} \
    126                                              expected-warning{{expression which evaluates to zero treated as a null pointer constant of type 'int *'}}
    127     };
    128   };
    129 
    130   template<int N> void foo()
    131   {
    132     class A<N>::B::C X; // expected-note 2 {{in instantiation of member function}}
    133     int A<N+1>::B::C::*member = 0;
    134   }
    135 
    136   void bar()
    137   {
    138     foo<0>(); // expected-note{{in instantiation of function template}}
    139     foo<1>(); // expected-note{{in instantiation of function template}}
    140   }
    141 }
    142