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
test_naming()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
test_instantiation(X<double>::C * x,X<float>::D::E * e,X<float>::D::F * f)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 {
nodetest1::Registry::node69 node(int v) { Head = this; }
70 };
71 };
test()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 {
Crdar10397846::A::B::C125 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
foo()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
bar()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