Lines Matching full:class

3 // C++20 [temp.class.spec] 13.7.5/10
14 // class for tests
15 class TestClass {
17   class PublicClass {};
18   template <class T> class TemplatePublicClass {};
34   class ProtectedClass {};
35   template <class T> class TemplateProtectedClass {};
56   class PrivateClass {};
58   template <class T> class TemplatePrivateClass {};
78 template <typename T> class IT1 {};
79 template <typename T1, typename T2> class IT2 {};
80 template <int X> class IT3 {};
81 template <void (TestClass::*)()> class IT4 {};
82 template <void (*)()> class IT5 {};
83 template <typename T> class IT6 {
84   template <typename NT> class NIT1 {};
86 template <typename T1, typename T2> class IT7 {};
87 template <void (TestClass::*)(), int X> class IT8 {};
88 template <typename T, void (*)()> class IT9 {};
93 template class IT1<TestClass::PublicClass>;
95 template class IT1<TestClass::AliasPublicClass>;
97 template class IT3<TestClass::publicStaticInt>;
99 template class IT4<&TestClass::publicFuncOverloaded>;
100 template class IT5<&TestClass::publicStaticFunc>;
101 template class IT5<&TestClass::publicStaticFuncOverloaded>;
102 template class IT5<&globalFunction>;
103 template class IT6<TestClass::PublicClass>::template NIT1<TestClass::PublicClass>;
104 template class IT7<TestClass::AliasPublicClass, TestClass::PublicClass>;
106 template class IT8<&TestClass::publicFunc, TestClass::publicStaticInt>;
107 template class IT8<&TestClass::publicFuncOverloaded, TestClass::publicStaticInt>;
108 template class IT9<TestClass::PublicClass, &TestClass::publicStaticFunc>;
109 template class IT9<TestClass::PublicClass, &TestClass::publicStaticFuncOverloaded>;
110 template class IT9<TestClass::PublicClass, &globalFunction>;
113 template class IT1<TestClass::ProtectedClass>;
115 template class IT1<TestClass::AliasProtectedClass>;
117 template class IT3<TestClass::protectedStaticInt>;
119 template class IT4<&TestClass::protectedFuncOverloaded>;
120 template class IT5<&TestClass::protectedStaticFunc>;
121 template class IT5<&TestClass::protectedStaticFuncOverloaded>;
122 template class IT6<TestClass::ProtectedClass>::template NIT1<TestClass::ProtectedClass>;
123 template class IT7<TestClass::AliasProtectedClass, TestClass::ProtectedClass>;
125 template class IT8<&TestClass::protectedFunc, TestClass::protectedStaticInt>;
126 template class IT8<&TestClass::protectedFuncOverloaded, TestClass::protectedStaticInt>;
127 template class IT9<TestClass::ProtectedClass, &TestClass::protectedStaticFunc>;
128 template class IT9<TestClass::ProtectedClass, &TestClass::protectedStaticFuncOverloaded>;
129 template class IT9<TestClass::ProtectedClass, &globalFunction>;
132 template class IT1<TestClass::PrivateClass>;
134 template class IT1<TestClass::AliasPrivateClass>;
136 template class IT3<TestClass::privateStaticInt>;
138 template class IT4<&TestClass::privateFuncOverloaded>;
139 template class IT5<&TestClass::privateStaticFunc>;
140 template class IT5<&TestClass::privateStaticFuncOverloaded>;
141 template class IT6<TestClass::PrivateClass>::template NIT1<TestClass::PrivateClass>;
142 template class IT7<TestClass::AliasPrivateClass, TestClass::PrivateClass>;
144 template class IT8<&TestClass::privateFunc, TestClass::privateStaticInt>;
145 template class IT8<&TestClass::privateFuncOverloaded, TestClass::privateStaticInt>;
146 template class IT9<TestClass::PrivateClass, &TestClass::privateStaticFunc>;
147 template class IT9<TestClass::PrivateClass, &TestClass::privateStaticFuncOverloaded>;
148 template class IT9<TestClass::PrivateClass, &globalFunction>;
153 template <typename T> class CT1 {};
154 template <typename T1, typename T2> class CT2 {};
155 template <int X> class CT3 {};
156 template <void (TestClass::*)()> class CT4 {};
157 template <void (*)()> class CT5 {};
158 template <typename T> class CT6 {
159   template <typename NT> class NCT1 {};
160   template <typename NT> class NCT2; // forward declaration
166 template <> class CT1<TestClass::PublicClass>;
167 template <typename T> class CT1<TestClass::TemplatePublicClass<T>>; // not full but let it be here
169 template <> class CT1<TestClass::AliasPublicClass>;
171 template <> class CT3<TestClass::publicStaticInt>;
173 template <> class CT4<&TestClass::publicFuncOverloaded>;
175 template <> class CT5<&TestClass::publicStaticFuncOverloaded>;
176 template <> class CT5<&globalFunction>;
177 template <> template <> class CT6<TestClass::PublicClass>::NCT1<TestClass::PublicClass>;
179 template <> class CT1<TestClass::PublicClass> final {};
180 template <typename T> class CT1<TestClass::TemplatePublicClass<T>> {};
181 template <> class CT1<TestClass::TemplatePublicClass<int>> final {};
182 template <> class CT1<TestClass::AliasPublicClass> {};
183 template <> class CT2<TestClass::PublicClass, TestClass::PublicClass> final {};
184 template <> class CT3<TestClass::publicStaticInt> {};
185 template <> class CT4<&TestClass::publicFunc> final {};
186 template <> class CT4<&TestClass::publicFuncOverloaded> {};
187 template <> class CT5<&TestClass::publicStaticFunc> final {};
188 template <> class CT5<&TestClass::publicStaticFuncOverloaded> {};
189 template <> class CT5<&globalFunction> final {};
190 template <> template <> class CT6<TestClass::PublicClass>::NCT1<TestClass::PublicClass> {};
191 template <> template <typename NT> class CT6<TestClass::PublicClass>::NCT2 final {}; // declaration
194 template <> class CT1<TestClass::ProtectedClass>;
195 template <typename T> class CT1<TestClass::TemplateProtectedClass<T>>; // not full but let it be he…
196 template <> class CT1<TestClass::TemplateProtectedClass<int>>;
198 template <> class CT2<TestClass::ProtectedClass, TestClass::ProtectedClass>;
200 template <> class CT4<&TestClass::protectedFunc>;
202 template <> class CT5<&TestClass::protectedStaticFunc>;
203 template <> class CT5<&TestClass::protectedStaticFuncOverloaded>;
204 template <> template <> class CT6<TestClass::ProtectedClass>::NCT1<TestClass::ProtectedClass>;
206 template <> class CT1<TestClass::ProtectedClass> {};
207 template <typename T> class CT1<TestClass::TemplateProtectedClass<T>> final {}; // not full but let…
208 template <> class CT1<TestClass::TemplateProtectedClass<int>> {};
209 template <> class CT1<TestClass::AliasProtectedClass> final {};
210 template <> class CT2<TestClass::ProtectedClass, TestClass::ProtectedClass> {};
211 template <> class CT3<TestClass::protectedStaticInt> final {};
212 template <> class CT4<&TestClass::protectedFunc> {};
213 template <> class CT4<&TestClass::protectedFuncOverloaded> final {};
214 template <> class CT5<&TestClass::protectedStaticFunc> {};
215 template <> class CT5<&TestClass::protectedStaticFuncOverloaded> final {};
216 template <> template <> class CT6<TestClass::ProtectedClass>::NCT1<TestClass::ProtectedClass> {};
217 template <> template <typename NT> class CT6<TestClass::ProtectedClass>::NCT2 final {}; // declarat…
220 template <> class CT1<TestClass::PrivateClass>;
221 template <typename T> class CT1<TestClass::TemplatePrivateClass<T>>; // not full but let it be here
223 template <> class CT1<TestClass::AliasPrivateClass>;
225 template <> class CT3<TestClass::privateStaticInt>;
227 template <> class CT4<&TestClass::privateFuncOverloaded>;
228 template <> class CT5<&TestClass::privateStaticFunc>;
229 template <> class CT5<&TestClass::privateStaticFuncOverloaded>;
230 template <> template <> class CT6<TestClass::PrivateClass>::NCT1<TestClass::PrivateClass>;
232 template <> class CT1<TestClass::PrivateClass> final {};
233 template <typename T> class CT1<TestClass::TemplatePrivateClass<T>> {}; // not full but let it be h…
234 template <> class CT1<TestClass::TemplatePrivateClass<int>> final {};
235 template <> class CT1<TestClass::AliasPrivateClass> {};
236 template <> class CT2<TestClass::PrivateClass, TestClass::PrivateClass> final {};
237 template <> class CT3<TestClass::privateStaticInt> {};
238 template <> class CT4<&TestClass::privateFunc> final {};     // PR37424
239 template <> class CT4<&TestClass::privateFuncOverloaded> {}; // PR37424
240 template <> class CT5<&TestClass::privateStaticFunc> final {};
241 template <> class CT5<&TestClass::privateStaticFuncOverloaded> {};
242 template <> template <> class CT6<TestClass::PrivateClass>::NCT1<TestClass::PrivateClass> final {};
243 template <> template <typename NT> class CT6<TestClass::PrivateClass>::NCT2 {}; // declaration
248 class P1 {};
249 template <typename T> class PCT1 {};
250 template <typename T1, typename T2> class PCT2 {};
251 template <int X> class PCT3 {};
252 template <void (TestClass::*)()> class PCT4 {};
253 template <void (*)()> class PCT5 {};
254 template <typename T> class PCT6 {
256   template <typename NT> class NPCT1 {};
258   template <typename NT> class NPCT2; // forward declaration
264 template <> class PCT1<TestClass::PublicClass> : P1 {};
265 template <typename T> class PCT1<TestClass::TemplatePublicClass<T>> : PCT2<TestClass::PublicClass, …
267 template <> class PCT1<TestClass::AliasProtectedClass> : PCT2<TestClass::PublicClass, int> {};
269 template <> class PCT3<TestClass::protectedStaticInt> : PCT4<&TestClass::publicFunc> {};
271 template <> class PCT4<&TestClass::publicFuncOverloaded> : PCT5<&TestClass::publicStaticFuncOverloa…
272 template <> class PCT5<&TestClass::protectedStaticFunc> : PCT5<&TestClass::publicStaticFuncOverload…
274 template <> class PCT5<&TestClass::protectedStaticFuncOverloaded> : PCT6<TestClass::PublicClass>::N…
277 template <> class PCT5<&globalFunction> : PCT6<TestClass::ProtectedClass>::NPCT1<int> {};
278 template <> template <typename NT> class PCT6<TestClass::PublicClass>::NPCT2 : P1 {}; // declaration
279 template <> template <> class PCT6<TestClass::PublicClass>::NPCT1<TestClass::ProtectedClass> : PCT6…
282 template <> class PCT1<TestClass::PrivateClass> : P1 {};
285 template <typename T> class PCT1<TestClass::TemplatePrivateClass<T>> : PCT2<TestClass::PrivateClass…
287 template <> class PCT1<TestClass::TemplatePrivateClass<int>> : PCT1<TestClass::AliasProtectedClass>…
290 template <> class PCT1<TestClass::AliasPrivateClass> : PCT2<TestClass::ProtectedClass, TestClass::P…
292 template <> class PCT2<TestClass::PrivateClass, TestClass::PrivateClass> : PCT3<TestClass::protecte…
294 template <> class PCT3<TestClass::privateStaticInt> : PCT4<&TestClass::protectedFunc> {};
296 template <> class PCT4<&TestClass::privateFunc> : PCT5<&TestClass::protectedStaticFunc> {};
298 template <> class PCT4<&TestClass::privateFuncOverloaded> : PCT5<&TestClass::protectedStaticFuncOve…
299 template <> class PCT5<&TestClass::privateStaticFunc> : P1 {};
302 template <> template <> class PCT6<TestClass::PrivateClass>::NPCT1<TestClass::PrivateClass> : PCT6<…
304 template <> class PCT5<&TestClass::privateStaticFuncOverloaded> : PCT6<TestClass::PrivateClass>::NP…
305 template <> template <typename NT> class PCT6<TestClass::PrivateClass>::NPCT2 : P1 {}; // declarati…
310 template <typename T1, typename T2> class CTT1 {};
311 template <typename T1, typename T2, typename T3> class CTT2 {};
312 template <typename T, int X> class CTT3 {};
313 template <typename T, void (TestClass::*)()> class CTT4 {};
314 template <typename T, void (*)()> class CTT5 {};
315 template <typename T1, typename T2> class CTT6 {
316   template <typename NT> class NCT1 {};
317   template <typename NT> class NCT2; // forward declaration
318   template <typename NT1, typename NT2> class NCT3 {};
319   template <typename NT1, typename NT2> class NCT4; // forward declaration
325 template <typename T> class CTT1<T, TestClass::PublicClass> final {};
326 template <typename T> class CTT1<T, TestClass::TemplatePublicClass<T>> {};
328 template <typename T> class CTT1<T, TestClass::AliasPublicClass> {};
331 template <typename T> class CTT2<TestClass::PublicClass, TestClass::PublicClass, T> final {};
332 template <typename T> class CTT3<T, TestClass::publicStaticInt> {};
333 template <typename T> class CTT4<T, &TestClass::publicFunc> final {};
334 template <typename T> class CTT4<T, &TestClass::publicFuncOverloaded> {};
335 template <typename T> class CTT5<T, &TestClass::publicStaticFunc> final {};
336 template <typename T> class CTT5<T, &TestClass::publicStaticFuncOverloaded> {};
337 template <typename T> class CTT5<T, &globalFunction> final {};
339 template <typename T1> template <typename T2> class CTT6<T1, TestClass::PublicClass>::template NCT1…
340 template <typename T1, typename T2> template <typename T3> class CTT6<T1, T2>::NCT1<T3 *> final {};
341 template <typename T1, typename T2> template <typename T3> class CTT6<T1, T2>::NCT2 {}; // declarat…
342 template <typename T1, typename T2> template <typename T3> class CTT6<T1, T2>::NCT2<T3 *> final {};
343 template <typename T1, typename T2> template <typename T3> class CTT6<T1, T2>::NCT3<T3, TestClass::…
345 template <typename T1> template <typename T2> class CTT6<T1, TestClass::PublicClass>::template NCT3…
346 template <typename T1, typename T2> template <typename T3, typename T4> class CTT6<T1, T2>::NCT4 {}…
347 template <typename T1, typename T2> template <typename T3> class CTT6<T1, T2>::NCT4<T3, TestClass::…
348 template <typename T> class CTT6<TestClass::PublicClass, T> {
349   template <typename T1, typename T2> class NCT3 {};
350   template <typename T1, typename T2> class NCT4;
352 template <typename T1> template <typename T2> class CTT6<TestClass::PublicClass, T1>::NCT3<T2, Test…
353 template <typename T1> template <typename, typename> class CTT6<TestClass::PublicClass, T1>::NCT4 f…
354 template <typename T1> template <typename T2> class CTT6<TestClass::PublicClass, T1>::NCT4<T2, Test…
358 template <typename T> class CTT1<T, TestClass::ProtectedClass> {};
359 template <typename T> class CTT1<T, TestClass::TemplateProtectedClass<T>> final {};
361 template <typename T> class CTT1<T, TestClass::AliasProtectedClass> final {};
363 template <typename T> class CTT2<TestClass::ProtectedClass, T, TestClass::ProtectedClass> final {};
365 template <typename T> class CTT3<T, TestClass::protectedStaticInt> final {};
366 template <typename T> class CTT4<T, &TestClass::protectedFunc> {};
367 template <typename T> class CTT4<T, &TestClass::protectedFuncOverloaded> final {};
368 template <typename T> class CTT5<T, &TestClass::protectedStaticFunc> {};
369 template <typename T> class CTT5<T, &TestClass::protectedStaticFuncOverloaded> final {};
371 template <typename T1> template <typename T2> class CTT6<T1, TestClass::ProtectedClass>::template N…
372 template <typename T1, typename T2> template <typename T3> class CTT6<T1, T2>::NCT3<T3, TestClass::…
374 template <typename T1> template <typename T2> class CTT6<T1, TestClass::ProtectedClass>::template N…
375 template <typename T1, typename T2> template <typename T3> class CTT6<T1, T2>::NCT4<T3, TestClass::…
376 template <typename T> class CTT6<TestClass::ProtectedClass, T> {
377   template <typename T1, typename T2> class NCT3 {};
378   template <typename T1, typename T2> class NCT4;
380 template <typename T1> template <typename T2> class CTT6<TestClass::ProtectedClass, T1>::NCT3<T2, T…
381 template <typename T1> template <typename, typename> class CTT6<TestClass::ProtectedClass, T1>::NCT…
382 template <typename T1> template <typename T2> class CTT6<TestClass::ProtectedClass, T1>::NCT4<T2, T…
386 template <typename T> class CTT1<T, TestClass::PrivateClass> final {};
387 template <typename T> class CTT1<T, TestClass::TemplatePrivateClass<T>> {};
389 template <typename T> class CTT1<T, TestClass::AliasPrivateClass> {};
391 template <typename T> class CTT2<TestClass::PrivateClass, T, TestClass::PrivateClass> {};
393 template <typename T> class CTT3<T, TestClass::privateStaticInt> {};
394 template <typename T> class CTT4<T, &TestClass::privateFunc> final {};
395 template <typename T> class CTT4<T, &TestClass::privateFuncOverloaded> {};
396 template <typename T> class CTT5<T, &TestClass::privateStaticFunc> final {};
397 template <typename T> class CTT5<T, &TestClass::privateStaticFuncOverloaded> {};
399 template <typename T1> template <typename T2> class CTT6<T1, TestClass::PrivateClass>::template NCT…
400 template <typename T1, typename T2> template <typename T3> class CTT6<T1, T2>::NCT3<T3, TestClass::…
402 template <typename T1> template <typename T2> class CTT6<T1, TestClass::PrivateClass>::template NCT…
403 template <typename T1, typename T2> template <typename T3> class CTT6<T1, T2>::NCT4<T3, TestClass::…
404 template <typename T> class CTT6<TestClass::PrivateClass, T> {
405   template <typename T1, typename T2> class NCT3 {};
406   template <typename T1, typename T2> class NCT4;
408 template <typename T1> template <typename T2> class CTT6<TestClass::PrivateClass, T1>::NCT3<T2, Tes…
409 template <typename T1> template <typename, typename> class CTT6<TestClass::PrivateClass, T1>::NCT4 …
410 template <typename T1> template <typename T2> class CTT6<TestClass::PrivateClass, T1>::NCT4<T2, Tes…
415 template <typename T1, typename T2> class PCTT1 {};
416 template <typename T1, typename T2, typename T3> class PCTT2 {};
417 template <typename T, int X> class PCTT3 {};
418 template <typename T, void (TestClass::*)()> class PCTT4 {};
419 template <typename T, void (*)()> class PCTT5 {};
420 template <typename T1, typename T2> class PCTT6 {
421   template <typename NT> class NCT1 {};
422   template <typename NT> class NCT2; // forward declaration
423   template <typename NT1, typename NT2> class NCT3 {};
424   template <typename NT1, typename NT2> class NCT4; // forward declaration
430 template <typename T> class PCTT1<T, TestClass::PublicClass> : P1 {};
432 template <typename T> class PCTT1<T, TestClass::TemplatePublicClass<int>> : PCTT1<T, TestClass::Ali…
434 template <typename T> class PCTT1<T, TestClass::TemplatePublicClass<TestClass::TemplateProtectedCla…
436 template <typename T> class PCTT2<T, TestClass::ProtectedClass, TestClass::PublicClass> final : PCT…
437 template <typename T> class PCTT3<T, TestClass::protectedStaticInt> : PCTT4<T, &TestClass::publicFu…
439 template <typename T> class PCTT4<T, &TestClass::publicFuncOverloaded> : PCTT5<T, &TestClass::publi…
440 template <typename T> class PCTT5<T, &TestClass::protectedStaticFunc> final : PCTT5<T, &TestClass::…
441 template <typename T> class PCTT5<T, &TestClass::protectedStaticFuncOverloaded> : PCTT6<T, TestClas…
443 template <typename T> class PCTT5<T, &globalFunction> : PCTT6<T, TestClass::ProtectedClass>::templa…
445 template <typename T1, typename T2> template <typename T3> class PCTT6<T1, T2>::NCT2 final : PCTT4<…
446 template <typename T1, typename T2> template <typename T3> class PCTT6<T1, T2>::NCT2<T3 *> : P1 {};
449 template <typename T> template <typename NT> class PCTT6<T, TestClass::ProtectedClass>::template NC…
452 template <typename T> class PCTT1<T, TestClass::PrivateClass> : P1 {};
457 template <typename T> class PCTT1<T, TestClass::TemplatePrivateClass<int>> : PCTT1<T, TestClass::Al…
462 template <typename T> class PCTT2<T, TestClass::PrivateClass, TestClass::TemplatePrivateClass<T>> :…
464 template <typename T> class PCTT3<T, TestClass::privateStaticInt> final : PCTT4<T, &TestClass::prot…
468 template <typename T> class PCTT4<T, &TestClass::privateFuncOverloaded> final : PCTT5<T, &TestClass…
469 template <typename T> class PCTT5<T, &TestClass::privateStaticFunc> : P1 {};
472 template <typename T> class PCTT6<T, TestClass::PrivateClass>::template PCTT1<TestClass::PrivateCla…
474 template <typename T> class PCTT5<T, &TestClass::privateStaticFuncOverloaded> final : PCTT6<T, T>::…
475 template <typename T> class PCTT6<TestClass::PrivateClass, T> {
476   template <typename T1, typename T2> class NCT3 final {};
477   template <typename T1, typename T2> class NCT4;
479 template <typename T1> template <typename, typename> class PCTT6<TestClass::PrivateClass, T1>::NCT4…