|
150
|
1 // RUN: %clang_cc1 -fsyntax-only -verify %s
|
|
|
2
|
|
|
3 // This test concerns the identity of dependent types within the
|
|
|
4 // canonical type system, specifically focusing on the difference
|
|
|
5 // between members of the current instantiation and members of an
|
|
|
6 // unknown specialization. This considers C++ [temp.type], which
|
|
|
7 // specifies type equivalence within a template, and C++0x
|
|
|
8 // [temp.dep.type], which defines what it means to be a member of the
|
|
|
9 // current instantiation.
|
|
|
10
|
|
|
11 template<typename T, typename U>
|
|
|
12 struct X0 {
|
|
|
13 typedef T T_type;
|
|
|
14 typedef U U_type;
|
|
|
15
|
|
|
16 void f0(T&); // expected-note{{previous}}
|
|
|
17 void f0(typename X0::U_type&);
|
|
|
18 void f0(typename X0::T_type&); // expected-error{{redecl}}
|
|
|
19
|
|
|
20 void f1(T&); // expected-note{{previous}}
|
|
|
21 void f1(typename X0::U_type&);
|
|
|
22 void f1(typename X0<T, U>::T_type&); // expected-error{{redecl}}
|
|
|
23
|
|
|
24 void f2(T&); // expected-note{{previous}}
|
|
|
25 void f2(typename X0::U_type&);
|
|
|
26 void f2(typename X0<T_type, U_type>::T_type&); // expected-error{{redecl}}
|
|
|
27
|
|
|
28 void f3(T&); // expected-note{{previous}}
|
|
|
29 void f3(typename X0::U_type&);
|
|
|
30 void f3(typename ::X0<T_type, U_type>::T_type&); // expected-error{{redecl}}
|
|
|
31
|
|
|
32 struct X1 {
|
|
|
33 typedef T my_T_type;
|
|
|
34
|
|
|
35 void g0(T&); // expected-note{{previous}}
|
|
|
36 void g0(typename X0::U_type&);
|
|
|
37 void g0(typename X0::T_type&); // expected-error{{redecl}}
|
|
|
38
|
|
|
39 void g1(T&); // expected-note{{previous}}
|
|
|
40 void g1(typename X0::U_type&);
|
|
|
41 void g1(typename X0<T, U>::T_type&); // expected-error{{redecl}}
|
|
|
42
|
|
|
43 void g2(T&); // expected-note{{previous}}
|
|
|
44 void g2(typename X0::U_type&);
|
|
|
45 void g2(typename X0<T_type, U_type>::T_type&); // expected-error{{redecl}}
|
|
|
46
|
|
|
47 void g3(T&); // expected-note{{previous}}
|
|
|
48 void g3(typename X0::U_type&);
|
|
|
49 void g3(typename ::X0<T_type, U_type>::T_type&); // expected-error{{redecl}}
|
|
|
50
|
|
|
51 void g4(T&); // expected-note{{previous}}
|
|
|
52 void g4(typename X0::U_type&);
|
|
|
53 void g4(typename X1::my_T_type&); // expected-error{{redecl}}
|
|
|
54
|
|
|
55 void g5(T&); // expected-note{{previous}}
|
|
|
56 void g5(typename X0::U_type&);
|
|
|
57 void g5(typename X0::X1::my_T_type&); // expected-error{{redecl}}
|
|
|
58
|
|
|
59 void g6(T&); // expected-note{{previous}}
|
|
|
60 void g6(typename X0::U_type&);
|
|
|
61 void g6(typename X0<T, U>::X1::my_T_type&); // expected-error{{redecl}}
|
|
|
62
|
|
|
63 void g7(T&); // expected-note{{previous}}
|
|
|
64 void g7(typename X0::U_type&);
|
|
|
65 void g7(typename ::X0<typename X1::my_T_type, U_type>::X1::my_T_type&); // expected-error{{redecl}}
|
|
|
66
|
|
|
67 void g8(T&); // expected-note{{previous}}
|
|
|
68 void g8(typename X0<U, T_type>::T_type&);
|
|
|
69 void g8(typename ::X0<typename X0<T_type, U>::X1::my_T_type, U_type>::X1::my_T_type&); // expected-error{{redecl}}
|
|
|
70 };
|
|
|
71 };
|
|
|
72
|
|
|
73
|
|
|
74 template<typename T, typename U>
|
|
|
75 struct X0<T*, U*> {
|
|
|
76 typedef T T_type;
|
|
|
77 typedef U U_type;
|
|
|
78 typedef T* Tptr;
|
|
|
79 typedef U* Uptr;
|
|
|
80
|
|
|
81 void f0(T&); // expected-note{{previous}}
|
|
|
82 void f0(typename X0::U_type&);
|
|
|
83 void f0(typename X0::T_type&); // expected-error{{redecl}}
|
|
|
84
|
|
|
85 void f1(T&); // expected-note{{previous}}
|
|
|
86 void f1(typename X0::U_type&);
|
|
|
87 void f1(typename X0<T*, U*>::T_type&); // expected-error{{redecl}}
|
|
|
88
|
|
|
89 void f2(T&); // expected-note{{previous}}
|
|
|
90 void f2(typename X0::U_type&);
|
|
|
91 void f2(typename X0<T_type*, U_type*>::T_type&); // expected-error{{redecl}}
|
|
|
92
|
|
|
93 void f3(T&); // expected-note{{previous}}
|
|
|
94 void f3(typename X0::U_type&);
|
|
|
95 void f3(typename ::X0<T_type*, U_type*>::T_type&); // expected-error{{redecl}}
|
|
|
96
|
|
|
97 void f4(T&); // expected-note{{previous}}
|
|
|
98 void f4(typename X0::U_type&);
|
|
|
99 void f4(typename ::X0<Tptr, Uptr>::T_type&); // expected-error{{redecl}}
|
|
|
100
|
|
|
101 void f5(X0*); // expected-note{{previous}}
|
|
|
102 void f5(::X0<T, U>*);
|
|
|
103 void f5(::X0<T*, U*>*); // expected-error{{redecl}}
|
|
|
104
|
|
|
105 struct X2 {
|
|
|
106 typedef T my_T_type;
|
|
|
107
|
|
|
108 void g0(T&); // expected-note{{previous}}
|
|
|
109 void g0(typename X0::U_type&);
|
|
|
110 void g0(typename X0::T_type&); // expected-error{{redecl}}
|
|
|
111
|
|
|
112 void g1(T&); // expected-note{{previous}}
|
|
|
113 void g1(typename X0::U_type&);
|
|
|
114 void g1(typename X0<T*, U*>::T_type&); // expected-error{{redecl}}
|
|
|
115
|
|
|
116 void g2(T&); // expected-note{{previous}}
|
|
|
117 void g2(typename X0::U_type&);
|
|
|
118 void g2(typename X0<T_type*, U_type*>::T_type&); // expected-error{{redecl}}
|
|
|
119
|
|
|
120 void g3(T&); // expected-note{{previous}}
|
|
|
121 void g3(typename X0::U_type&);
|
|
|
122 void g3(typename ::X0<T_type*, U_type*>::T_type&); // expected-error{{redecl}}
|
|
|
123
|
|
|
124 void g4(T&); // expected-note{{previous}}
|
|
|
125 void g4(typename X0::U_type&);
|
|
|
126 void g4(typename X2::my_T_type&); // expected-error{{redecl}}
|
|
|
127
|
|
|
128 void g5(T&); // expected-note{{previous}}
|
|
|
129 void g5(typename X0::U_type&);
|
|
|
130 void g5(typename X0::X2::my_T_type&); // expected-error{{redecl}}
|
|
|
131
|
|
|
132 void g6(T&); // expected-note{{previous}}
|
|
|
133 void g6(typename X0::U_type&);
|
|
|
134 void g6(typename X0<T*, U*>::X2::my_T_type&); // expected-error{{redecl}}
|
|
|
135
|
|
|
136 void g7(T&); // expected-note{{previous}}
|
|
|
137 void g7(typename X0::U_type&);
|
|
|
138 void g7(typename ::X0<typename X2::my_T_type*, U_type*>::X2::my_T_type&); // expected-error{{redecl}}
|
|
|
139
|
|
|
140 void g8(T&); // expected-note{{previous}}
|
|
|
141 void g8(typename X0<U, T_type>::T_type&);
|
|
|
142 void g8(typename ::X0<typename X0<T_type*, U*>::X2::my_T_type*, U_type*>::X2::my_T_type&); // expected-error{{redecl}}
|
|
|
143 };
|
|
|
144 };
|
|
|
145
|
|
|
146 template<typename T>
|
|
|
147 struct X1 {
|
|
|
148 static int *a;
|
|
|
149 void f(float *b) {
|
|
|
150 X1<T>::a = b; // expected-error{{incompatible}}
|
|
|
151 X1<T*>::a = b;
|
|
|
152 }
|
|
|
153 };
|
|
|
154
|
|
|
155 namespace ConstantInCurrentInstantiation {
|
|
|
156 template<typename T>
|
|
|
157 struct X {
|
|
|
158 static const int value = 2;
|
|
|
159 static int array[value];
|
|
|
160 };
|
|
|
161
|
|
|
162 template<typename T> const int X<T>::value;
|
|
|
163
|
|
|
164 template<typename T>
|
|
|
165 int X<T>::array[X<T>::value] = { 1, 2 };
|
|
|
166 }
|
|
|
167
|
|
|
168 namespace Expressions {
|
|
|
169 template <bool b>
|
|
|
170 struct Bool {
|
|
|
171 enum anonymous_enum { value = b };
|
|
|
172 };
|
|
|
173 struct True : public Bool<true> {};
|
|
|
174 struct False : public Bool<false> {};
|
|
|
175
|
|
|
176 template <typename T1, typename T2>
|
|
|
177 struct Is_Same : public False {};
|
|
|
178 template <typename T>
|
|
|
179 struct Is_Same<T, T> : public True {};
|
|
|
180
|
|
|
181 template <bool b, typename T = void>
|
|
|
182 struct Enable_If {};
|
|
|
183 template <typename T>
|
|
|
184 struct Enable_If<true, T> {
|
|
|
185 typedef T type;
|
|
|
186 };
|
|
|
187
|
|
|
188 template <typename T>
|
|
|
189 class Class {
|
|
|
190 public:
|
|
|
191 template <typename U>
|
|
|
192 typename Enable_If<Is_Same<U, Class>::value, void>::type
|
|
|
193 foo();
|
|
|
194 };
|
|
|
195
|
|
|
196
|
|
|
197 template <typename T>
|
|
|
198 template <typename U>
|
|
|
199 typename Enable_If<Is_Same<U, Class<T> >::value, void>::type
|
|
|
200 Class<T>::foo() {}
|
|
|
201 }
|
|
|
202
|
|
|
203 namespace PR9255 {
|
|
|
204 template<typename T>
|
|
|
205 class X0 {
|
|
|
206 public:
|
|
|
207 class Inner1;
|
|
|
208
|
|
|
209 class Inner2 {
|
|
|
210 public:
|
|
|
211 void f()
|
|
|
212 {
|
|
|
213 Inner1::f.g();
|
|
|
214 }
|
|
|
215 };
|
|
|
216 };
|
|
|
217 }
|
|
|
218
|
|
|
219 namespace rdar10194295 {
|
|
|
220 template<typename XT>
|
|
|
221 class X {
|
|
|
222 public:
|
|
|
223 enum Enum { Yes, No };
|
|
|
224 template<Enum> void foo();
|
|
|
225 template<Enum> class Inner;
|
|
|
226 };
|
|
|
227
|
|
|
228 template<typename XT>
|
|
|
229 template<typename X<XT>::Enum>
|
|
|
230 void X<XT>::foo()
|
|
|
231 {
|
|
|
232 }
|
|
|
233
|
|
|
234 template<typename XT>
|
|
|
235 template<typename X<XT>::Enum>
|
|
|
236 class X<XT>::Inner { };
|
|
|
237 }
|
|
|
238
|
|
|
239 namespace RebuildDependentScopeDeclRefExpr {
|
|
|
240 template<int> struct N {};
|
|
|
241 template<typename T> struct X {
|
|
|
242 static const int thing = 0;
|
|
|
243 N<thing> data();
|
|
|
244 N<thing> foo();
|
|
|
245 };
|
|
|
246 template<typename T> N<X<T>::thing> X<T>::data() {}
|
|
|
247 // FIXME: We should issue a typo-correction here.
|
|
|
248 template<typename T> N<X<T>::think> X<T>::foo() {} // expected-error {{no member named 'think' in 'X<T>'}}
|
|
|
249 }
|
