blob: 515bcd43b2c04401e28d1f7310f27bd8c9a72026 (
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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
class X{
public:
enum E {Enumerator}; // expected-note 2{{declared here}}
int f();
static int mem;
static float g();
};
void test(X* xp, X x) {
int i1 = x.f();
int i2 = xp->f();
x.E; // expected-error{{cannot refer to type member 'E' in 'X' with '.'}}
xp->E; // expected-error{{cannot refer to type member 'E' in 'X' with '->'}}
int i3 = x.Enumerator;
int i4 = xp->Enumerator;
x.mem = 1;
xp->mem = 2;
float f1 = x.g();
float f2 = xp->g();
}
struct A {
int f0;
};
struct B {
A *f0();
};
int f0(B *b) {
return b->f0->f0; // expected-error{{did you mean to call it with no arguments}}
}
int i;
namespace C {
int i;
}
void test2(X *xp) {
xp->::i = 7; // expected-error{{qualified member access refers to a member in the global namespace}}
xp->C::i = 7; // expected-error{{qualified member access refers to a member in namespace 'C'}}
}
namespace test3 {
struct NamespaceDecl;
struct NamedDecl {
void *getIdentifier() const;
};
struct NamespaceDecl : NamedDecl {
bool isAnonymousNamespace() const {
return !getIdentifier();
}
};
}
namespace test4 {
class X {
protected:
template<typename T> void f(T);
};
class Y : public X {
public:
using X::f;
};
void test_f(Y y) {
y.f(17);
}
}
namespace test5 {
struct A {
template <class T> void foo();
};
void test0(int x) {
x.A::foo<int>(); // expected-error {{'int' is not a structure or union}}
}
void test1(A *x) {
x.A::foo<int>(); // expected-error {{'test5::A *' is a pointer}}
}
void test2(A &x) {
x->A::foo<int>(); // expected-error {{'test5::A' is not a pointer}}
}
}
namespace PR7508 {
struct A {
struct CleanupScope {};
void PopCleanupBlock(); // expected-note{{'PopCleanupBlock' declared here}}
};
void foo(A &a) {
a.PopCleanupScope(); // expected-error{{no member named 'PopCleanupScope' in 'PR7508::A'; did you mean 'PopCleanupBlock'?}}
}
}
namespace rdar8231724 {
namespace N {
template<typename T> struct X1;
int i;
}
struct X { };
struct Y : X { };
template<typename T> struct Z { int n; };
void f(Y *y) {
y->N::X1<int>; // expected-error{{'rdar8231724::N::X1' is not a member of class 'rdar8231724::Y'}}
y->Z<int>::n; // expected-error{{'rdar8231724::Z<int>::n' is not a member of class 'rdar8231724::Y'}}
y->template Z<int>::n; // expected-error{{'rdar8231724::Z<int>::n' is not a member of class 'rdar8231724::Y'}} \
// expected-warning{{'template' keyword outside of a template}}
}
}
namespace PR9025 {
struct S { int x; };
S fun(); // expected-note{{possible target for call}}
int fun(int i); // expected-note{{possible target for call}}
int g() {
return fun.x; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}}
}
S fun2(); // expected-note{{possible target for call}}
S fun2(int i); // expected-note{{possible target for call}}
int g2() {
return fun2.x; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}}
}
S fun3(int i=0); // expected-note{{possible target for call}}
int fun3(int i, int j); // expected-note{{possible target for call}}
int g3() {
return fun3.x; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}}
}
template <typename T> S fun4(); // expected-note{{possible target for call}}
int g4() {
return fun4.x; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it?}}
}
S fun5(int i); // expected-note{{possible target for call}}
S fun5(float f); // expected-note{{possible target for call}}
int g5() {
return fun5.x; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it?}}
}
}
namespace FuncInMemberExpr {
struct Vec { int size(); };
Vec fun1();
int test1() { return fun1.size(); } // expected-error {{base of member reference is a function; perhaps you meant to call it with no arguments}}
Vec *fun2();
int test2() { return fun2->size(); } // expected-error {{base of member reference is a function; perhaps you meant to call it with no arguments}}
Vec fun3(int x = 0);
int test3() { return fun3.size(); } // expected-error {{base of member reference is a function; perhaps you meant to call it with no arguments}}
}
namespace DotForSemiTypo {
void f(int i) {
// If the programmer typo'd '.' for ';', make sure we point at the '.' rather
// than the "field name" (whatever the first token on the next line happens to
// be).
int j = i. // expected-error {{member reference base type 'int' is not a structure or union}}
j = 0;
}
}
|
