blob: 981bae7c770bd47a0107ecbc72fca74797036e43 (
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
|
// 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{{perhaps you meant 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();
};
void foo(A &a) {
a.PopCleanupScope(); // expected-error{{no member named 'PopCleanupScope' in 'PR7508::A'}}
}
}
namespace rdar8231724 {
namespace N {
template<typename T> struct X1;
int i;
}
struct X { };
struct Y : X { };
void f(Y *y) {
y->N::X1<int>; // expected-error{{'rdar8231724::N::X1' is not a member of class 'rdar8231724::Y'}}
}
}
namespace PR9025 {
struct S { int x; };
S fun();
int fun(int i);
int g() {
return fun.x; // expected-error{{base of member reference is an overloaded function; perhaps you meant to call it with no arguments?}}
}
S fun2();
S fun2(int i);
int g2() {
return fun2.x; // expected-error{{base of member reference is an overloaded function; perhaps you meant to call it with no arguments?}}
}
S fun3(int i=0);
int fun3(int i, int j);
int g3() {
return fun3.x; // expected-error{{base of member reference is an overloaded function; perhaps you meant to call it with no arguments?}}
}
template <typename T> S fun4();
int g4() {
return fun4.x; // expected-error{{base of member reference is a function; perhaps you meant to call it?}}
}
S fun5(int i); // expected-note{{possibly valid overload here}}
S fun5(float f); // expected-note{{possibly valid overload here}}
int g5() {
return fun5.x; // expected-error{{base of member reference is an overloaded function; perhaps you meant to call it?}}
}
}
|
