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 x.A::foo<int>(); // expected-error {{'int' is not a structure or union}} 83 } 84 85 void test1(A *x) { 86 x.A::foo<int>(); // expected-error {{'test5::A *' is a pointer}} 87 } 88 89 void test2(A &x) { 90 x->A::foo<int>(); // expected-error {{'test5::A' is not a pointer}} \ 91 // expected-note {{did you mean to use '.' instead?}} 92 } 93 } 94 95 namespace PR7508 { 96 struct A { 97 struct CleanupScope {}; 98 void PopCleanupBlock(); // expected-note{{'PopCleanupBlock' declared here}} 99 }; 100 101 void foo(A &a) { 102 a.PopCleanupScope(); // expected-error{{no member named 'PopCleanupScope' in 'PR7508::A'; did you mean 'PopCleanupBlock'?}} 103 } 104 } 105 106 namespace rdar8231724 { 107 namespace N { 108 template<typename T> struct X1; 109 int i; 110 } 111 112 struct X { }; 113 struct Y : X { }; 114 115 template<typename T> struct Z { int n; }; 116 117 void f(Y *y) { 118 y->N::X1<int>; // expected-error{{'rdar8231724::N::X1' is not a member of class 'rdar8231724::Y'}} 119 y->Z<int>::n; // expected-error{{'rdar8231724::Z<int>::n' is not a member of class 'rdar8231724::Y'}} 120 y->template Z<int>::n; // expected-error{{'rdar8231724::Z<int>::n' is not a member of class 'rdar8231724::Y'}} \ 121 // expected-warning{{'template' keyword outside of a template}} 122 } 123 } 124 125 namespace PR9025 { 126 struct S { int x; }; 127 S fun(); // expected-note{{possible target for call}} 128 int fun(int i); // expected-note{{possible target for call}} 129 int g() { 130 return fun.x; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}} 131 } 132 133 S fun2(); // expected-note{{possible target for call}} 134 S fun2(int i); // expected-note{{possible target for call}} 135 int g2() { 136 return fun2.x; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}} 137 } 138 139 S fun3(int i=0); // expected-note{{possible target for call}} 140 int fun3(int i, int j); // expected-note{{possible target for call}} 141 int g3() { 142 return fun3.x; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it with no arguments?}} 143 } 144 145 template <typename T> S fun4(); // expected-note{{possible target for call}} 146 int g4() { 147 return fun4.x; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it?}} 148 } 149 150 S fun5(int i); // expected-note{{possible target for call}} 151 S fun5(float f); // expected-note{{possible target for call}} 152 int g5() { 153 return fun5.x; // expected-error{{reference to overloaded function could not be resolved; did you mean to call it?}} 154 } 155 } 156 157 namespace FuncInMemberExpr { 158 struct Vec { int size(); }; 159 Vec fun1(); 160 int test1() { return fun1.size(); } // expected-error {{base of member reference is a function; perhaps you meant to call it with no arguments}} 161 Vec *fun2(); 162 int test2() { return fun2->size(); } // expected-error {{base of member reference is a function; perhaps you meant to call it with no arguments}} 163 Vec fun3(int x = 0); 164 int test3() { return fun3.size(); } // expected-error {{base of member reference is a function; perhaps you meant to call it with no arguments}} 165 } 166 167 namespace DotForSemiTypo { 168 void f(int i) { 169 // If the programmer typo'd '.' for ';', make sure we point at the '.' rather 170 // than the "field name" (whatever the first token on the next line happens to 171 // be). 172 int j = i. // expected-error {{member reference base type 'int' is not a structure or union}} 173 j = 0; 174 } 175 } 176 177 namespace PR15045 { 178 class Cl0 { 179 public: 180 int a; 181 }; 182 183 int f() { 184 Cl0 c; 185 return c->a; // expected-error {{member reference type 'PR15045::Cl0' is not a pointer}} \ 186 // expected-note {{did you mean to use '.' instead?}} 187 } 188 } 189