blob: 4416f92723adc8d3a28a49cdecc662a0fad7ae09 (
plain)
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
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
// PR5336
template<typename FromCl>
struct isa_impl_cl {
template<class ToCl>
static void isa(const FromCl &Val) { }
};
template<class X, class Y>
void isa(const Y &Val) { return isa_impl_cl<Y>::template isa<X>(Val); }
class Value;
void f0(const Value &Val) { isa<Value>(Val); }
// Implicit template-ids.
template<typename T>
struct X0 {
template<typename U>
void f1();
template<typename U>
void f2(U) {
f1<U>();
}
};
void test_X0_int(X0<int> xi, float f) {
xi.f2(f);
}
// Not template-id expressions, but they almost look like it.
template<typename F>
struct Y {
Y(const F&);
};
template<int I>
struct X {
X(int, int);
void f() {
Y<X<I> >(X<I>(0, 0));
Y<X<I> >(::X<I>(0, 0));
}
};
template struct X<3>;
// 'template' as a disambiguator.
// PR7030
struct Y0 {
template<typename U>
void f1(U);
template<typename U>
static void f2(U);
void f3(int);
static int f4(int);
template<typename U>
static void f4(U);
template<typename U>
void f() {
Y0::template f1<U>(0);
Y0::template f1(0);
this->template f1(0);
Y0::template f2<U>(0);
Y0::template f2(0);
Y0::template f3(0); // expected-error {{'f3' following the 'template' keyword does not refer to a template}}
Y0::template f3(); // expected-error {{'f3' following the 'template' keyword does not refer to a template}}
int x;
x = Y0::f4(0);
x = Y0::f4<int>(0); // expected-error {{assigning to 'int' from incompatible type 'void'}}
x = Y0::template f4(0); // expected-error {{assigning to 'int' from incompatible type 'void'}}
x = this->f4(0);
x = this->f4<int>(0); // expected-error {{assigning to 'int' from incompatible type 'void'}}
x = this->template f4(0); // expected-error {{assigning to 'int' from incompatible type 'void'}}
}
};
struct A {
template<int I>
struct B {
static void b1();
};
};
template<int I>
void f5() {
A::template B<I>::template b1(); // expected-error {{'b1' following the 'template' keyword does not refer to a template}}
}
template void f5<0>(); // expected-note {{in instantiation of function template specialization 'f5<0>' requested here}}
|
