blob: 895eacc87edd78176f34fd45210103d2b1f7efd4 (
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
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
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
template<typename T, typename U>
struct X0 : T::template apply<U> {
X0(U u) : T::template apply<U>(u) { }
};
template<typename T, typename U>
struct X1 : T::apply<U> { }; // expected-error{{use 'template' keyword to treat 'apply' as a dependent template name}}
template<typename T>
struct X2 : vector<T> { }; // expected-error{{unknown template name 'vector'}}
namespace PR6031 {
template<typename T>
struct A;
template <class X>
struct C { };
template <class TT>
struct II {
typedef typename A<TT>::type type;
};
template <class TT>
struct FI : II<TT>
{
C<typename FI::type> a;
};
template <class TT>
struct FI2
{
C<typename FI2::type> a; // expected-error{{no type named 'type' in 'FI2<TT>'}} \
// expected-error{{C++ requires a type specifier for all declarations}}
};
template<typename T>
struct Base {
class Nested { };
template<typename U> struct MemberTemplate { };
int a;
};
template<typename T>
struct HasDepBase : Base<T> {
int foo() {
class HasDepBase::Nested nested;
typedef typename HasDepBase::template MemberTemplate<T>::type type;
return HasDepBase::a;
}
};
template<typename T>
struct NoDepBase {
int foo() {
class NoDepBase::Nested nested; // expected-error{{no class named 'Nested' in 'NoDepBase<T>'}}
typedef typename NoDepBase::template MemberTemplate<T>::type type; // expected-error{{'MemberTemplate' following the 'template' keyword does not refer to a template}} \
// FIXME: expected-error{{unqualified-id}}
return NoDepBase::a; // expected-error{{no member named 'a' in 'NoDepBase<T>'}}
}
};
}
namespace Ambig {
template<typename T>
struct Base1 {
typedef int type; // expected-note{{member found by ambiguous name lookup}}
};
struct Base2 {
typedef float type; // expected-note{{member found by ambiguous name lookup}}
};
template<typename T>
struct Derived : Base1<T>, Base2 {
typedef typename Derived::type type; // expected-error{{member 'type' found in multiple base classes of different types}}
type *foo(float *fp) { return fp; }
};
Derived<int> di; // expected-note{{instantiation of}}
}
namespace PR6081 {
template<typename T>
struct A { };
template<typename T>
class B : public A<T>
{
public:
template< class X >
void f0(const X & k)
{
this->template f1<int>()(k);
}
};
template<typename T>
class C
{
public:
template< class X >
void f0(const X & k)
{
this->template f1<int>()(k); // expected-error{{'f1' following the 'template' keyword does not refer to a template}} \
// FIXME: expected-error{{unqualified-id}} \
// expected-error{{function-style cast or type construction}} \
// expected-error{{expected expression}}
}
};
}
namespace PR6413 {
template <typename T> class Base_A { };
class Base_B { };
template <typename T>
class Derived
: public virtual Base_A<T>
, public virtual Base_B
{ };
}
namespace PR5812 {
template <class T> struct Base {
Base* p;
};
template <class T> struct Derived: public Base<T> {
typename Derived::Base* p; // meaning Derived::Base<T>
};
Derived<int> di;
}
|
