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
|
// RUN: %clang_cc1 -fsyntax-only -std=c++17 -verify %s -fcxx-exceptions
template<typename T>
struct X0 {
typedef T* type;
void f0(T);
void f1(type);
};
template<> void X0<char>::f0(char);
template<> void X0<char>::f1(type);
namespace PR6161 {
template<typename _CharT>
class numpunct : public locale::facet // expected-error{{use of undeclared identifier 'locale'}} \
// expected-error{{expected class name}}
{
static locale::id id; // expected-error{{use of undeclared identifier}}
};
numpunct<char>::~numpunct();
}
namespace PR12331 {
template<typename T> struct S {
struct U { static const int n = 5; };
enum E { e = U::n }; // expected-note {{implicit instantiation first required here}}
int arr[e];
};
template<> struct S<int>::U { static const int n = sizeof(int); }; // expected-error {{explicit specialization of 'U' after instantiation}}
}
namespace PR18246 {
template<typename T>
class Baz {
public:
template<int N> void bar();
};
template<typename T>
template<int N>
void Baz<T>::bar() {
}
template<typename T>
void Baz<T>::bar<0>() { // expected-error {{cannot specialize a member of an unspecialized template}}
}
}
namespace PR19340 {
template<typename T> struct Helper {
template<int N> static void func(const T *m) {}
};
template<typename T> void Helper<T>::func<2>() {} // expected-error {{cannot specialize a member}}
}
namespace SpecLoc {
template <typename T> struct A {
static int n; // expected-note {{previous}}
static void f(); // expected-note {{previous}}
};
template<> float A<int>::n; // expected-error {{different type}}
template<> void A<int>::f() throw(); // expected-error {{does not match}}
}
namespace PR41607 {
template<int N> struct Outer {
template<typename...> struct Inner;
template<> struct Inner<> {
static constexpr int f() { return N; }
};
template<typename...> static int a;
template<> constexpr int a<> = N;
template<typename...> static inline int b;
template<> inline constexpr int b<> = N;
template<typename...> static constexpr int f();
template<> constexpr int f() {
return N;
}
};
static_assert(Outer<123>::Inner<>::f() == 123, "");
static_assert(Outer<123>::Inner<>::f() != 125, "");
static_assert(Outer<123>::a<> == 123, "");
static_assert(Outer<123>::a<> != 125, "");
static_assert(Outer<123>::b<> == 123, "");
static_assert(Outer<123>::b<> != 125, "");
static_assert(Outer<123>::f<>() == 123, "");
static_assert(Outer<123>::f<>() != 125, "");
}
|
