1 // RUN: %clang_cc1 -fsyntax-only -verify %s
2
3 class X{
4 public:
5 enum E {Enumerator}; // expected-note 2{{declared here}}
6 int f();
7 static int mem;
8 static float g();
9 };
10
test(X * xp,X x)11 void test(X* xp, X x) {
12 int i1 = x.f();
13 int i2 = xp->f();
14 x.E; // expected-error{{cannot refer to type member 'E' in 'X' with '.'}}
15 xp->E; // expected-error{{cannot refer to type member 'E' in 'X' with '->'}}
16 int i3 = x.Enumerator;
17 int i4 = xp->Enumerator;
18 x.mem = 1;
19 xp->mem = 2;
20 float f1 = x.g();
21 float f2 = xp->g();
22 }
23
24 struct A {
25 int f0;
26 };
27 struct B {
28 A *f0();
29 };
f0(B * b)30 int f0(B *b) {
31 return b->f0->f0; // expected-error{{did you mean to call it with no arguments}}
32 }
33
34 int i;
35
36 namespace C {
37 int i;
38 }
39
test2(X * xp)40 void test2(X *xp) {
41 xp->::i = 7; // expected-error{{qualified member access refers to a member in the global namespace}}
42 xp->C::i = 7; // expected-error{{qualified member access refers to a member in namespace 'C'}}
43 }
44
45
46 namespace test3 {
47 struct NamespaceDecl;
48
49 struct NamedDecl {
50 void *getIdentifier() const;
51 };
52
53 struct NamespaceDecl : NamedDecl {
isAnonymousNamespacetest3::NamespaceDecl54 bool isAnonymousNamespace() const {
55 return !getIdentifier();
56 }
57 };
58 }
59
60 namespace test4 {
61 class X {
62 protected:
63 template<typename T> void f(T);
64 };
65
66 class Y : public X {
67 public:
68 using X::f;
69 };
70
test_f(Y y)71 void test_f(Y y) {
72 y.f(17);
73 }
74 }
75
76 namespace test5 {
77 struct A {
78 template <class T> void foo();
79 };
80
test0(int x)81 void test0(int x) {
82 x.A::foo<int>(); // expected-error {{'int' is not a structure or union}}
83 }
84
test1(A * x)85 void test1(A *x) {
86 x.A::foo<int>(); // expected-error {{'test5::A *' is a pointer}}
87 }
88
test2(A & x)89 void test2(A &x) {
90 x->A::foo<int>(); // expected-error {{'test5::A' is not a pointer}}
91 }
92 }
93
94 namespace PR7508 {
95 struct A {
96 struct CleanupScope {};
97 void PopCleanupBlock(); // expected-note{{'PopCleanupBlock' declared here}}
98 };
99
foo(A & a)100 void foo(A &a) {
101 a.PopCleanupScope(); // expected-error{{no member named 'PopCleanupScope' in 'PR7508::A'; did you mean 'PopCleanupBlock'?}}
102 }
103 }
104
105 namespace rdar8231724 {
106 namespace N {
107 template<typename T> struct X1;
108 int i;
109 }
110
111 struct X { };
112 struct Y : X { };
113
f(Y * y)114 void f(Y *y) {
115 y->N::X1<int>; // expected-error{{'rdar8231724::N::X1' is not a member of class 'rdar8231724::Y'}}
116 }
117 }
118
119 namespace PR9025 {
120 struct S { int x; };
121 S fun(); // expected-note{{possible target for call}}
122 int fun(int i); // expected-note{{possible target for call}}
g()123 int g() {
124 return fun.x; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}}
125 }
126
127 S fun2(); // expected-note{{possible target for call}}
128 S fun2(int i); // expected-note{{possible target for call}}
g2()129 int g2() {
130 return fun2.x; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}}
131 }
132
133 S fun3(int i=0); // expected-note{{possible target for call}}
134 int fun3(int i, int j); // expected-note{{possible target for call}}
g3()135 int g3() {
136 return fun3.x; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}}
137 }
138
139 template <typename T> S fun4(); // expected-note{{possible target for call}}
g4()140 int g4() {
141 return fun4.x; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it?}}
142 }
143
144 S fun5(int i); // expected-note{{possible target for call}}
145 S fun5(float f); // expected-note{{possible target for call}}
g5()146 int g5() {
147 return fun5.x; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it?}}
148 }
149 }
150
151 namespace FuncInMemberExpr {
152 struct Vec { int size(); };
153 Vec fun1();
test1()154 int test1() { return fun1.size(); } // expected-error {{base of member reference is a function; perhaps you meant to call it with no arguments}}
155 Vec *fun2();
test2()156 int test2() { return fun2->size(); } // expected-error {{base of member reference is a function; perhaps you meant to call it with no arguments}}
157 Vec fun3(int x = 0);
test3()158 int test3() { return fun3.size(); } // expected-error {{base of member reference is a function; perhaps you meant to call it with no arguments}}
159 }
160