blob: bb6427670c3ee733d649e52513a6bd5a188532ba (
about) (
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
138
139
140
141
142
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
namespace PR8965 {
template<typename T>
struct X {
typedef int type;
T field; // expected-note{{in instantiation of member class}}
};
template<typename T>
struct Y {
struct Inner;
typedef typename X<Inner>::type // expected-note{{in instantiation of template class}}
type; // expected-note{{not-yet-instantiated member is declared here}}
struct Inner {
typedef type field; // expected-error{{no member 'type' in 'PR8965::Y<int>'; it has not yet been instantiated}}
};
};
Y<int> y; // expected-note{{in instantiation of template class}}
}
template<typename T>
class X {
public:
struct C { T &foo(); };
struct D {
struct E { T &bar(); }; // expected-error{{cannot form a reference to 'void'}}
struct F; // expected-note{{member is declared here}}
};
};
X<int>::C *c1;
X<float>::C *c2;
X<int>::X *xi; // expected-error{{qualified reference to 'X' is a constructor name rather than a type wherever a constructor can be declared}}
X<float>::X *xf; // expected-error{{qualified reference to 'X' is a constructor name rather than a type wherever a constructor can be declared}}
void test_naming() {
c1 = c2; // expected-error{{assigning to 'X<int>::C *' from incompatible type 'X<float>::C *'}}
xi = xf; // expected-error{{assigning to 'X<int>::X<int> *' from incompatible type 'X<float>::X<float> *'}}
// FIXME: error above doesn't print the type X<int>::X cleanly!
}
void test_instantiation(X<double>::C *x,
X<float>::D::E *e,
X<float>::D::F *f) {
double &dr = x->foo();
float &fr = e->bar();
f->foo(); // expected-error{{implicit instantiation of undefined member 'X<float>::D::F'}}
}
X<void>::C *c3; // okay
X<void>::D::E *e1; // okay
X<void>::D::E e2; // expected-note{{in instantiation of member class 'X<void>::D::E' requested here}}
// Redeclarations.
namespace test1 {
template <typename T> struct Registry {
struct node;
static node *Head;
struct node {
node(int v) { Head = this; }
};
};
void test() {
Registry<int>::node node(0);
}
}
// Redeclarations during explicit instantiations.
namespace test2 {
template <typename T> class A {
class Foo;
class Foo {
int foo();
};
};
template class A<int>;
template <typename T> class B {
class Foo;
class Foo {
public:
typedef int X;
};
typename Foo::X x;
class Foo;
};
template class B<int>;
template <typename T> class C {
class Foo;
class Foo;
};
template <typename T> class C<T>::Foo {
int x;
};
template class C<int>;
}
namespace AliasTagDef {
template<typename T>
struct F {
using S = struct U { // expected-warning {{C++11}}
T g() {
return T();
}
};
};
int m = F<int>::S().g();
int n = F<int>::U().g();
}
namespace rdar10397846 {
template<int I> struct A
{
struct B
{
struct C { C() { int *ptr = I; } }; // expected-error{{cannot initialize a variable of type 'int *' with an rvalue of type 'int'}}
};
};
template<int N> void foo()
{
class A<N>::B::C X; // expected-note{{in instantiation of member function}}
int A<N+1>::B::C::*member = 0;
}
void bar()
{
foo<0>();
foo<1>(); // expected-note{{in instantiation of function template}}
}
}
|
