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 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 }; 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 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 { 54 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 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 81 void test0(int x) { 82 } 83 84 void test1(A *x) { 85 } 86 87 void test2(A &x) { 88 x->A::foo<int>(); // expected-error {{'test5::A' is not a pointer; maybe you meant to use '.'?}} 89 } 90 } 91 92 namespace PR7508 { 93 struct A { 94 struct CleanupScope {}; 95 void PopCleanupBlock(); // expected-note{{'PopCleanupBlock' declared here}} 96 }; 97 98 void foo(A &a) { 99 a.PopCleanupScope(); // expected-error{{no member named 'PopCleanupScope' in 'PR7508::A'; did you mean 'PopCleanupBlock'?}} 100 } 101 } 102 103 namespace rdar8231724 { 104 namespace N { 105 template<typename T> struct X1; 106 int i; 107 } 108 109 struct X { }; 110 struct Y : X { }; 111 112 template<typename T> struct Z { int n; }; 113 114 void f(Y *y) { 115 y->N::X1<int>; // expected-error{{'rdar8231724::N::X1' is not a member of class 'rdar8231724::Y'}} 116 y->Z<int>::n; // expected-error{{'rdar8231724::Z<int>::n' is not a member of class 'rdar8231724::Y'}} 117 y->template Z<int>::n; // expected-error{{'rdar8231724::Z<int>::n' is not a member of class 'rdar8231724::Y'}} \ 118 // expected-warning{{'template' keyword outside of a template}} 119 } 120 } 121 122 namespace PR9025 { 123 struct S { int x; }; 124 S fun(); // expected-note{{possible target for call}} 125 int fun(int i); // expected-note{{possible target for call}} 126 int g() { 127 return fun.x; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}} 128 } 129 130 S fun2(); // expected-note{{possible target for call}} 131 S fun2(int i); // expected-note{{possible target for call}} 132 int g2() { 133 return fun2.x; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}} 134 } 135 136 S fun3(int i=0); // expected-note{{possible target for call}} 137 int fun3(int i, int j); // expected-note{{possible target for call}} 138 int g3() { 139 return fun3.x; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}} 140 } 141 142 template <typename T> S fun4(); // expected-note{{possible target for call}} 143 int g4() { 144 return fun4.x; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it?}} 145 } 146 147 S fun5(int i); // expected-note{{possible target for call}} 148 S fun5(float f); // expected-note{{possible target for call}} 149 int g5() { 150 return fun5.x; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it?}} 151 } 152 } 153 154 namespace FuncInMemberExpr { 155 struct Vec { int size(); }; 156 Vec fun1(); 157 int test1() { return fun1.size(); } // expected-error {{base of member reference is a function; perhaps you meant to call it with no arguments}} 158 Vec *fun2(); 159 int test2() { return fun2->size(); } // expected-error {{base of member reference is a function; perhaps you meant to call it with no arguments}} 160 Vec fun3(int x = 0); 161 int test3() { return fun3.size(); } // expected-error {{base of member reference is a function; perhaps you meant to call it with no arguments}} 162 } 163 164 namespace DotForSemiTypo { 165 void f(int i) { 166 // If the programmer typo'd '.' for ';', make sure we point at the '.' rather 167 // than the "field name" (whatever the first token on the next line happens to 168 // be). 169 int j = i. // expected-error {{member reference base type 'int' is not a structure or union}} 170 j = 0; 171 } 172 } 173 174 namespace PR15045 { 175 class Cl0 { 176 public: 177 int a; 178 }; 179 180 int f() { 181 Cl0 c; 182 return c->a; // expected-error {{member reference type 'PR15045::Cl0' is not a pointer; maybe you meant to use '.'?}} 183 } 184 185 struct bar { 186 void func(); // expected-note {{'func' declared here}} 187 }; 188 189 struct foo { 190 bar operator->(); // expected-note 2 {{'->' applied to return value of the operator->() declared here}} 191 }; 192 193 template <class T> void call_func(T t) { 194 t->func(); // expected-error-re 2 {{member reference type 'PR15045::bar' is not a pointer$}} \ 195 // expected-note {{did you mean to use '.' instead?}} 196 } 197 198 void test_arrow_on_non_pointer_records() { 199 bar e; 200 foo f; 201 202 // Show that recovery has happened by also triggering typo correction 203 e->Func(); // expected-error {{member reference type 'PR15045::bar' is not a pointer; maybe you meant to use '.'?}} \ 204 // expected-error {{no member named 'Func' in 'PR15045::bar'; did you mean 'func'?}} 205 206 // Make sure a fixit isn't given in the case that the '->' isn't actually 207 // the problem (the problem is with the return value of an operator->). 208 f->func(); // expected-error-re {{member reference type 'PR15045::bar' is not a pointer$}} 209 210 call_func(e); // expected-note {{in instantiation of function template specialization 'PR15045::call_func<PR15045::bar>' requested here}} 211 212 call_func(f); // expected-note {{in instantiation of function template specialization 'PR15045::call_func<PR15045::foo>' requested here}} 213 } 214 } 215