|
150
|
1 // RUN: %clang_cc1 -fsyntax-only -verify -pedantic -Wc++11-compat %s
|
|
|
2 // RUN: %clang_cc1 -fsyntax-only -verify -pedantic -Wc++11-compat -std=c++98 %s
|
|
|
3 // RUN: %clang_cc1 -fsyntax-only -verify -pedantic -std=c++11 %s
|
|
|
4 //
|
|
|
5 // Tests explicit instantiation of templates.
|
|
|
6 template<typename T, typename U = T> class X0 { };
|
|
|
7
|
|
|
8 namespace N {
|
|
|
9 template<typename T, typename U = T> class X1 { };
|
|
|
10 }
|
|
|
11
|
|
|
12 // Check the syntax of explicit instantiations.
|
|
|
13 template class X0<int, float>;
|
|
|
14 template class X0<int>; // expected-note{{previous}}
|
|
|
15
|
|
|
16 template class N::X1<int>;
|
|
|
17 template class ::N::X1<int, float>;
|
|
|
18
|
|
|
19 using namespace N;
|
|
|
20
|
|
|
21 // Check for some bogus syntax that probably means that the user
|
|
|
22 // wanted to write an explicit specialization, but forgot the '<>'
|
|
|
23 // after 'template'.
|
|
|
24 template class X0<double> { }; // expected-error{{explicit specialization}}
|
|
|
25
|
|
|
26 // Check for explicit instantiations that come after other kinds of
|
|
|
27 // instantiations or declarations.
|
|
|
28 template class X0<int, int>; // expected-error{{duplicate}}
|
|
|
29
|
|
|
30 template<> class X0<char> { }; // expected-note{{previous}}
|
|
|
31 template class X0<char>; // expected-warning{{has no effect}}
|
|
|
32
|
|
|
33 void foo(X0<short>) { }
|
|
|
34 template class X0<short>;
|
|
|
35
|
|
|
36 // Check that explicit instantiations actually produce definitions. We
|
|
|
37 // determine whether this happens by placing semantic errors in the
|
|
|
38 // definition of the template we're instantiating.
|
|
|
39 template<typename T> struct X2; // expected-note{{declared here}}
|
|
|
40
|
|
|
41 template struct X2<float>; // expected-error{{undefined template}}
|
|
|
42
|
|
|
43 template<typename T>
|
|
|
44 struct X2 {
|
|
|
45 void f0(T*); // expected-error{{pointer to a reference}}
|
|
|
46 };
|
|
|
47
|
|
|
48 template struct X2<int>; // okay
|
|
|
49 template struct X2<int&>; // expected-note{{in instantiation of}}
|
|
|
50
|
|
|
51 // Check that explicit instantiations instantiate member classes.
|
|
|
52 template<typename T> struct X3 {
|
|
|
53 struct Inner {
|
|
|
54 void f(T*); // expected-error{{pointer to a reference}}
|
|
|
55 };
|
|
|
56 };
|
|
|
57
|
|
|
58 void f1(X3<int&>); // okay, Inner, not instantiated
|
|
|
59
|
|
|
60 template struct X3<int&>; // expected-note{{instantiation}}
|
|
|
61
|
|
|
62 template<typename T> struct X4 {
|
|
|
63 struct Inner {
|
|
|
64 struct VeryInner {
|
|
|
65 void f(T*); // expected-error 2{{pointer to a reference}}
|
|
|
66 };
|
|
|
67 };
|
|
|
68 };
|
|
|
69
|
|
|
70 void f2(X4<int&>); // okay, Inner, not instantiated
|
|
|
71 void f3(X4<int&>::Inner); // okay, Inner::VeryInner, not instantiated
|
|
|
72
|
|
|
73 template struct X4<int&>; // expected-note{{instantiation}}
|
|
|
74 template struct X4<float&>; // expected-note{{instantiation}}
|
|
|
75
|
|
|
76 // Check explicit instantiation of member classes
|
|
|
77 namespace N2 {
|
|
|
78
|
|
|
79 template<typename T>
|
|
|
80 struct X5 {
|
|
|
81 struct Inner1 {
|
|
|
82 void f(T&);
|
|
|
83 };
|
|
|
84
|
|
|
85 struct Inner2 { // expected-note {{here}}
|
|
|
86 struct VeryInner {
|
|
|
87 void g(T*); // expected-error 2{{pointer to a reference}}
|
|
|
88 };
|
|
|
89 };
|
|
|
90 };
|
|
|
91
|
|
|
92 }
|
|
|
93
|
|
|
94 template struct N2::X5<void>::Inner2;
|
|
|
95
|
|
|
96 using namespace N2;
|
|
|
97 template struct X5<int&>::Inner2; // expected-note{{instantiation}}
|
|
|
98
|
|
|
99 void f4(X5<float&>::Inner2);
|
|
|
100 template struct X5<float&>::Inner2; // expected-note{{instantiation}}
|
|
|
101
|
|
|
102 namespace N3 {
|
|
|
103 template struct N2::X5<int>::Inner2;
|
|
|
104 #if __cplusplus <= 199711L
|
|
|
105 // expected-warning@-2 {{explicit instantiation of 'Inner2' not in a namespace enclosing 'N2'}}
|
|
|
106 #else
|
|
|
107 // expected-error@-4 {{explicit instantiation of 'Inner2' not in a namespace enclosing 'N2'}}
|
|
|
108 #endif
|
|
|
109 }
|
|
|
110
|
|
|
111 struct X6 {
|
|
|
112 struct Inner { // expected-note{{here}}
|
|
|
113 void f();
|
|
|
114 };
|
|
|
115 };
|
|
|
116
|
|
|
117 template struct X6::Inner; // expected-error{{non-templated}}
|
|
|
118
|
|
|
119 // PR5559
|
|
|
120 template <typename T>
|
|
|
121 struct Foo;
|
|
|
122
|
|
|
123 template <>
|
|
|
124 struct Foo<int> // expected-note{{header not required for explicitly-specialized}}
|
|
|
125 {
|
|
|
126 template <typename U>
|
|
|
127 struct Bar
|
|
|
128 {};
|
|
|
129 };
|
|
|
130
|
|
|
131 template <> // expected-warning{{extraneous template parameter list}}
|
|
|
132 template <>
|
|
|
133 struct Foo<int>::Bar<void>
|
|
|
134 {};
|
|
|
135
|
|
|
136 namespace N1 {
|
|
|
137
|
|
|
138 template<typename T> struct X7 { }; // expected-note{{here}}
|
|
|
139
|
|
|
140 namespace Inner {
|
|
|
141 template<typename T> struct X8 { };
|
|
|
142 }
|
|
|
143
|
|
|
144 template struct X7<int>;
|
|
|
145 template struct Inner::X8<int>;
|
|
|
146 }
|
|
|
147
|
|
|
148 template<typename T> struct X9 { }; // expected-note{{here}}
|
|
|
149
|
|
|
150 template struct ::N1::Inner::X8<float>;
|
|
|
151
|
|
|
152 namespace N2 {
|
|
|
153 using namespace N1;
|
|
|
154
|
|
|
155 template struct X7<double>;
|
|
|
156 #if __cplusplus <= 199711L
|
|
|
157 // expected-warning@-2 {{explicit instantiation of 'N1::X7' must occur in namespace 'N1'}}
|
|
|
158 #else
|
|
|
159 // expected-error@-4 {{explicit instantiation of 'N1::X7' must occur in namespace 'N1'}}
|
|
|
160 #endif
|
|
|
161
|
|
|
162 template struct X9<float>;
|
|
|
163 #if __cplusplus <= 199711L
|
|
|
164 // expected-warning@-2 {{explicit instantiation of 'X9' must occur at global scope}}
|
|
|
165 #else
|
|
|
166 // expected-error@-4 {{explicit instantiation of 'X9' must occur at global scope}}
|
|
|
167 #endif
|
|
|
168 }
|
