1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
|
// RUN: %clang_cc1 -fsyntax-only -verify -fexceptions -fcxx-exceptions %s
// RUN: %clang_cc1 -fsyntax-only -verify -fexceptions -fcxx-exceptions -std=c++11 %s
template void *; // expected-error{{expected unqualified-id}}
template typedef void f0; // expected-error{{explicit instantiation of typedef}}
int v0; // expected-note{{refers here}}
template int v0; // expected-error{{does not refer}}
template<typename T>
struct X0 {
static T value;
T f0(T x) {
return x + 1; // expected-error{{invalid operands}}
}
T *f0(T *, T *) { return T(); } // expected-warning 0-1 {{expression which evaluates to zero treated as a null pointer constant of type 'int *'}} expected-error 0-1 {{cannot initialize return object of type 'int *' with an rvalue of type 'int'}}
template <typename U> T f0(T, U) { return T(); } // expected-note-re {{candidate template ignored: could not match 'int (int, U){{( __attribute__\(\(thiscall\)\))?}}' against 'int (int){{( __attribute__\(\(thiscall\)\))?}} const'}} \
// expected-note {{candidate template ignored: could not match 'int' against 'int *'}}
};
template<typename T>
T X0<T>::value; // expected-error{{no matching constructor}}
template int X0<int>::value;
struct NotDefaultConstructible { // expected-note{{candidate constructor (the implicit copy constructor)}} expected-note 0-1 {{candidate constructor (the implicit move constructor)}}
NotDefaultConstructible(int); // expected-note{{candidate constructor}}
};
template NotDefaultConstructible X0<NotDefaultConstructible>::value; // expected-note{{instantiation}}
template int X0<int>::f0(int);
template int* X0<int>::f0(int*, int*); // expected-note{{in instantiation of member function 'X0<int>::f0' requested here}}
template int X0<int>::f0(int, float);
template int X0<int>::f0(int) const; // expected-error{{does not refer}}
template int* X0<int>::f0(int*, float*); // expected-error{{does not refer}}
struct X1 { };
typedef int X1::*MemPtr;
template MemPtr X0<MemPtr>::f0(MemPtr); // expected-note{{requested here}}
struct X2 {
int f0(int); // expected-note{{refers here}}
template<typename T> T f1(T) { return T(); }
template<typename T> T* f1(T*) { return 0; }
template<typename T, typename U> void f2(T, U*) { } // expected-note{{candidate}}
template<typename T, typename U> void f2(T*, U) { } // expected-note{{candidate}}
};
template int X2::f0(int); // expected-error{{not an instantiation}}
template int *X2::f1(int *); // okay
template void X2::f2(int *, int *); // expected-error{{ambiguous}}
template <typename T>
void print_type() {} // expected-note {{candidate template ignored: could not match 'void ()' against 'void (float *)'}}
template void print_type<int>();
template void print_type<float>();
template <typename T>
void print_type(T *) {} // expected-note {{candidate template ignored: could not match 'void (int *)' against 'void (float *)'}}
template void print_type(int*);
template void print_type<int>(float*); // expected-error{{does not refer}}
void print_type(double*);
template void print_type<double>(double*);
// PR5069
template<int I> void foo0 (int (&)[I + 1]) { }
template void foo0<2> (int (&)[3]);
namespace explicit_instantiation_after_implicit_instantiation {
template <int I> struct X0 { static int x; };
template <int I> int X0<I>::x;
void test1() { (void)&X0<1>::x; }
template struct X0<1>;
}
template<typename> struct X3 { };
inline template struct X3<int>; // expected-warning{{ignoring 'inline' keyword on explicit template instantiation}}
static template struct X3<float>; // expected-warning{{ignoring 'static' keyword on explicit template instantiation}}
namespace PR7622 {
template<typename,typename=int>
struct basic_streambuf;
template<typename,typename>
struct basic_streambuf{friend bob<>()}; // expected-error{{no template named 'bob'}} \
// expected-error{{expected member name or ';' after declaration specifiers}}
template struct basic_streambuf<int>;
}
// Test that we do not crash.
class TC1 {
class TC2 {
template
void foo() { } // expected-error{{expected '<' after 'template'}}
};
};
namespace PR8020 {
template <typename T> struct X { X() {} };
template<> struct X<int> { X(); };
template X<int>::X() {} // expected-error{{function cannot be defined in an explicit instantiation}}
}
namespace PR10086 {
template void foobar(int i) {} // expected-error{{function cannot be defined in an explicit instantiation}}
int func() {
foobar(5);
}
}
namespace undefined_static_data_member {
template<typename T> struct A {
static int a; // expected-note {{here}}
template<typename U> static int b; // expected-note {{here}} expected-warning 0+ {{extension}}
};
struct B {
template<typename U> static int c; // expected-note {{here}} expected-warning 0+ {{extension}}
};
template int A<int>::a; // expected-error {{explicit instantiation of undefined static data member 'a' of class template 'undefined_static_data_member::A<int>'}}
template int A<int>::b<int>; // expected-error {{explicit instantiation of undefined variable template 'undefined_static_data_member::A<int>::b<int>'}}
template int B::c<int>; // expected-error {{explicit instantiation of undefined variable template 'undefined_static_data_member::B::c<int>'}}
template<typename T> struct C {
static int a;
template<typename U> static int b; // expected-warning 0+ {{extension}}
};
struct D {
template<typename U> static int c; // expected-warning 0+ {{extension}}
};
template<typename T> int C<T>::a;
template<typename T> template<typename U> int C<T>::b; // expected-warning 0+ {{extension}}
template<typename U> int D::c; // expected-warning 0+ {{extension}}
template int C<int>::a;
template int C<int>::b<int>;
template int D::c<int>;
}
// expected-note@+1 3-4 {{explicit instantiation refers here}}
template <class T> void Foo(T i) throw(T) { throw i; }
// expected-error@+1 {{exception specification in explicit instantiation does not match instantiated one}}
template void Foo(int a) throw(char);
// expected-error@+1 {{exception specification in explicit instantiation does not match instantiated one}}
template void Foo(double a) throw();
// expected-error@+1 1 {{exception specification in explicit instantiation does not match instantiated one}}
template void Foo(long a) throw(long, char);
template void Foo(float a);
#if __cplusplus >= 201103L
// expected-error@+1 0-1 {{exception specification in explicit instantiation does not match instantiated one}}
template void Foo(double a) noexcept;
#endif
#if __cplusplus >= 201103L
namespace PR21942 {
template <int>
struct A {
virtual void foo() final;
};
template <>
void A<0>::foo() {} // expected-note{{overridden virtual function is here}}
struct B : A<0> {
virtual void foo() override; // expected-error{{declaration of 'foo' overrides a 'final' function}}
};
}
template<typename T> struct LambdaInDefaultMemberInitInExplicitInstantiation {
int a = [this] { return a; }();
};
template struct LambdaInDefaultMemberInitInExplicitInstantiation<int>;
LambdaInDefaultMemberInitInExplicitInstantiation<float> x;
#endif
|
