blob: a4d7914d9eb6d9bcd507798cb2a72b7cd26bd39c (
plain) (
blame)
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
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
// RUN: cp %s %t
// RUN: not %clang_cc1 -x c++ -fixit %t -DFIXING
// RUN: %clang_cc1 -x c++ %t -DFIXING
template<typename T> void f(T) { }
template<typename T> void g(T) { }
template<typename T> struct x { };
template<typename T> struct y { }; // expected-note {{declared here}}
namespace good {
template void f<int>(int);
template void g(int);
template struct x<int>;
}
namespace unsupported {
#ifndef FIXING
template struct y; // expected-error {{elaborated type refers to a template}}
#endif
}
template<typename T> void f0(T) { }
template<typename T> void g0(T) { }
template<typename T> struct x0 { }; // expected-note {{explicitly specialized declaration is here}}
template<typename T> struct y0 { };
// Should recover as if definition
namespace noargs_body {
#ifndef FIXING
template void g0(int) { } // expected-error {{function cannot be defined in an explicit instantiation; if this declaration is meant to be a function definition, remove the 'template' keyword}}
#endif
template struct y0 { }; // expected-error {{class cannot be defined in an explicit instantiation; if this declaration is meant to be a class definition, remove the 'template' keyword}}
}
// Explicit specializations expected in global scope
namespace exp_spec {
#ifndef FIXING
template<> void f0<int>(int) { } // expected-error {{no function template matches function template specialization 'f0'}}
template<> struct x0<int> { }; // expected-error {{class template specialization of 'x0' must originally be declared in the global scope}}
#endif
}
template<typename T> void f1(T) { }
template<typename T> struct x1 { }; // expected-note {{explicitly specialized declaration is here}}
// Should recover as if specializations,
// thus also complain about not being in global scope.
namespace args_bad {
#ifndef FIXING
template void f1<int>(int) { } // expected-error {{explicit template instantiation cannot have a definition; if this definition is meant to be an explicit specialization, add '<>' after the 'template' keyword}} \
expected-error {{no function template matches function template specialization 'f1'}}
template struct x1<int> { }; // expected-error {{explicit template instantiation cannot have a definition; if this definition is meant to be an explicit specialization, add '<>' after the 'template' keyword}} \
expected-error {{class template specialization of 'x1' must originally be declared in the global scope}}
#endif
}
template<typename T> void f2(T) { }
template<typename T> struct x2 { };
// Should recover as if specializations
template void f2<int>(int) { } // expected-error {{explicit template instantiation cannot have a definition; if this definition is meant to be an explicit specialization, add '<>' after the 'template' keyword}}
template struct x2<int> { }; // expected-error {{explicit template instantiation cannot have a definition; if this definition is meant to be an explicit specialization, add '<>' after the 'template' keyword}}
|
