1 // RUN: %clang_cc1 -fsyntax-only -verify %s 2 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s 3 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s 4 5 class X{ 6 public: 7 enum E {Enumerator}; // expected-note 2{{declared here}} 8 int f(); 9 static int mem; 10 static float g(); 11 }; 12 13 void test(X* xp, X x) { 14 int i1 = x.f(); 15 int i2 = xp->f(); 16 x.E; // expected-error{{cannot refer to type member 'E' in 'X' with '.'}} 17 xp->E; // expected-error{{cannot refer to type member 'E' in 'X' with '->'}} 18 int i3 = x.Enumerator; 19 int i4 = xp->Enumerator; 20 x.mem = 1; 21 xp->mem = 2; 22 float f1 = x.g(); 23 float f2 = xp->g(); 24 } 25 26 struct A { 27 int f0; 28 }; 29 struct B { 30 A *f0(); 31 }; 32 int f0(B *b) { 33 return b->f0->f0; // expected-error{{did you mean to call it with no arguments}} 34 } 35 36 int i; 37 38 namespace C { 39 int i; 40 } 41 42 void test2(X *xp) { 43 xp->::i = 7; // expected-error{{qualified member access refers to a member in the global namespace}} 44 xp->C::i = 7; // expected-error{{qualified member access refers to a member in namespace 'C'}} 45 } 46 47 48 namespace test3 { 49 struct NamespaceDecl; 50 51 struct NamedDecl { 52 void *getIdentifier() const; 53 }; 54 55 struct NamespaceDecl : NamedDecl { 56 bool isAnonymousNamespace() const { 57 return !getIdentifier(); 58 } 59 }; 60 } 61 62 namespace test4 { 63 class X { 64 protected: 65 template<typename T> void f(T); 66 }; 67 68 class Y : public X { 69 public: 70 using X::f; 71 }; 72 73 void test_f(Y y) { 74 y.f(17); 75 } 76 } 77 78 namespace test5 { 79 struct A { 80 template <class T> void foo(); 81 }; 82 83 void test0(int x) { 84 x.A::foo<int>(); // expected-error {{'int' is not a structure or union}} 85 } 86 87 void test1(A *x) { 88 x.A::foo<int>(); // expected-error {{'test5::A *' is a pointer}} 89 } 90 91 void test2(A &x) { 92 x->A::foo<int>(); // expected-error {{'test5::A' is not a pointer; did you mean to use '.'?}} 93 } 94 } 95 96 namespace PR7508 { 97 struct A { 98 struct CleanupScope {}; 99 void PopCleanupBlock(); // expected-note{{'PopCleanupBlock' declared here}} 100 }; 101 102 void foo(A &a) { 103 a.PopCleanupScope(); // expected-error{{no member named 'PopCleanupScope' in 'PR7508::A'; did you mean 'PopCleanupBlock'?}} 104 } 105 } 106 107 namespace rdar8231724 { 108 namespace N { 109 template<typename T> struct X1; 110 int i; 111 } 112 113 struct X { }; 114 struct Y : X { }; 115 116 template<typename T> struct Z { int n; }; 117 118 void f(Y *y) { 119 y->N::X1<int>; // expected-error{{'rdar8231724::N::X1' is not a member of class 'rdar8231724::Y'}} 120 y->Z<int>::n; // expected-error{{'rdar8231724::Z<int>::n' is not a member of class 'rdar8231724::Y'}} 121 y->template Z<int>::n; // expected-error{{'rdar8231724::Z<int>::n' is not a member of class 'rdar8231724::Y'}} 122 #if __cplusplus <= 199711L // C++03 or earlier modes 123 // expected-warning@-2{{'template' keyword outside of a template}} 124 #endif 125 } 126 } 127 128 namespace PR9025 { 129 struct S { int x; }; 130 S fun(); // expected-note{{possible target for call}} 131 int fun(int i); // expected-note{{possible target for call}} 132 int g() { 133 return fun.x; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}} 134 } 135 136 S fun2(); // expected-note{{possible target for call}} 137 S fun2(int i); // expected-note{{possible target for call}} 138 int g2() { 139 return fun2.x; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}} 140 } 141 142 S fun3(int i=0); // expected-note{{possible target for call}} 143 int fun3(int i, int j); // expected-note{{possible target for call}} 144 int g3() { 145 return fun3.x; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}} 146 } 147 148 template <typename T> S fun4(); // expected-note{{possible target for call}} 149 int g4() { 150 return fun4.x; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it?}} 151 } 152 153 S fun5(int i); // expected-note{{possible target for call}} 154 S fun5(float f); // expected-note{{possible target for call}} 155 int g5() { 156 return fun5.x; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it?}} 157 } 158 } 159 160 namespace FuncInMemberExpr { 161 struct Vec { int size(); }; 162 Vec fun1(); 163 int test1() { return fun1.size(); } // expected-error {{base of member reference is a function; perhaps you meant to call it with no arguments}} 164 Vec *fun2(); 165 int test2() { return fun2->size(); } // expected-error {{base of member reference is a function; perhaps you meant to call it with no arguments}} 166 Vec fun3(int x = 0); 167 int test3() { return fun3.size(); } // expected-error {{base of member reference is a function; perhaps you meant to call it with no arguments}} 168 } 169 170 namespace DotForSemiTypo { 171 void f(int i) { 172 // If the programmer typo'd '.' for ';', make sure we point at the '.' rather 173 // than the "field name" (whatever the first token on the next line happens to 174 // be). 175 int j = i. // expected-error {{member reference base type 'int' is not a structure or union}} 176 j = 0; 177 } 178 } 179 180 namespace PR15045 { 181 class Cl0 { 182 public: 183 int a; 184 }; 185 186 int f() { 187 Cl0 c; 188 return c->a; // expected-error {{member reference type 'PR15045::Cl0' is not a pointer; did you mean to use '.'?}} 189 } 190 191 struct bar { 192 void func(); // expected-note {{'func' declared here}} 193 }; 194 195 struct foo { 196 bar operator->(); // expected-note 2 {{'->' applied to return value of the operator->() declared here}} 197 }; 198 199 template <class T> void call_func(T t) { 200 t->func(); // expected-error-re 2 {{member reference type 'PR15045::bar' is not a pointer{{$}}}} \ 201 // expected-note {{did you mean to use '.' instead?}} 202 } 203 204 void test_arrow_on_non_pointer_records() { 205 bar e; 206 foo f; 207 208 // Show that recovery has happened by also triggering typo correction 209 e->Func(); // expected-error {{member reference type 'PR15045::bar' is not a pointer; did you mean to use '.'?}} \ 210 // expected-error {{no member named 'Func' in 'PR15045::bar'; did you mean 'func'?}} 211 212 // Make sure a fixit isn't given in the case that the '->' isn't actually 213 // the problem (the problem is with the return value of an operator->). 214 f->func(); // expected-error-re {{member reference type 'PR15045::bar' is not a pointer{{$}}}} 215 216 call_func(e); // expected-note {{in instantiation of function template specialization 'PR15045::call_func<PR15045::bar>' requested here}} 217 218 call_func(f); // expected-note {{in instantiation of function template specialization 'PR15045::call_func<PR15045::foo>' requested here}} 219 } 220 } 221 222 namespace pr16676 { 223 struct S { int i; }; 224 struct T { S* get_s(); }; 225 int f(S* s) { 226 T t; 227 return t.get_s // expected-error {{reference to non-static member function must be called; did you mean to call it with no arguments?}} 228 .i; // expected-error {{member reference type 'pr16676::S *' is a pointer; did you mean to use '->'}} 229 } 230 } 231
