Mercurial > hg > CbC > CbC_llvm

comparison clang/test/SemaTemplate/current-instantiation.cpp @ 150:1d019706d866

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
LLVM10
author anatofuz
date Thu, 13 Feb 2020 15:10:13 +0900
parents
children
comparison
equal deleted inserted replaced
147:c2174574ed3a 150:1d019706d866
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 }