Home | History | Annotate | Download | only in SemaCXX
      1 // RUN: %clang_cc1 -fsyntax-only -std=c++98 -verify -fblocks %s
      2 namespace A {
      3   struct C {
      4     static int cx;
      5 
      6     static int cx2;
      7 
      8     static int Ag1();
      9     static int Ag2();
     10   };
     11   int ax; // expected-note {{'ax' declared here}}
     12   void Af();
     13 }
     14 
     15 A:: ; // expected-error {{expected unqualified-id}}
     16 ::A::ax::undef ex3; // expected-error {{'ax' is not a class, namespace, or scoped enumeration}}
     17 A::undef1::undef2 ex4; // expected-error {{no member named 'undef1'}}
     18 
     19 int A::C::Ag1() { return 0; }
     20 
     21 static int A::C::Ag2() { return 0; } // expected-error{{'static' can}}
     22 
     23 int A::C::cx = 17;
     24 
     25 
     26 static int A::C::cx2 = 17; // expected-error{{'static' can}}
     27 
     28 class C2 {
     29   void m(); // expected-note{{member declaration does not match because it is not const qualified}}
     30 
     31   void f(const int& parm); // expected-note{{type of 1st parameter of member declaration does not match definition ('const int &' vs 'int')}}
     32   void f(int) const; // expected-note{{member declaration does not match because it is const qualified}}
     33   void f(float);
     34 
     35   int x;
     36 };
     37 
     38 void C2::m() const { } // expected-error{{out-of-line definition of 'm' does not match any declaration in 'C2'}}
     39 
     40 void C2::f(int) { } // expected-error{{out-of-line definition of 'f' does not match any declaration in 'C2'}}
     41 
     42 void C2::m() {
     43   x = 0;
     44 }
     45 
     46 namespace B {
     47   void ::A::Af() {} // expected-error {{cannot define or redeclare 'Af' here because namespace 'B' does not enclose namespace 'A'}}
     48 }
     49 
     50 void f1() {
     51   void A::Af(); // expected-error {{definition or redeclaration of 'Af' not allowed inside a function}}
     52   void (^x)() = ^{ void A::Af(); }; // expected-error {{definition or redeclaration of 'Af' not allowed inside a block}}
     53 }
     54 
     55 void f2() {
     56   A:: ; // expected-error {{expected unqualified-id}}
     57   A::C::undef = 0; // expected-error {{no member named 'undef'}}
     58   ::A::C::cx = 0;
     59   int x = ::A::ax = A::C::cx;
     60   x = sizeof(A::C);
     61   x = sizeof(::A::C::cx);
     62 }
     63 
     64 A::C c1;
     65 struct A::C c2;
     66 struct S : public A::C {};
     67 struct A::undef; // expected-error {{no struct named 'undef' in namespace 'A'}}
     68 
     69 namespace A2 {
     70   typedef int INT;
     71   struct RC;
     72   struct CC {
     73     struct NC;
     74   };
     75 }
     76 
     77 struct A2::RC {
     78   INT x;
     79 };
     80 
     81 struct A2::CC::NC {
     82   void m() {}
     83 };
     84 
     85 void f3() {
     86   N::x = 0; // expected-error {{use of undeclared identifier 'N'}}
     87   // FIXME: Consider including the kind of entity that 'N' is ("variable 'N'
     88   // declared here", "template 'X' declared here", etc) to help explain what it
     89   // is if it's 'not a class, namespace, or scoped enumeration'.
     90   int N; // expected-note {{'N' declared here}}
     91   N::x = 0; // expected-error {{'N' is not a class, namespace, or scoped enumeration}}
     92   { int A;           A::ax = 0; }
     93   { typedef int A;   A::ax = 0; } // expected-error{{'A' (aka 'int') is not a class, namespace, or scoped enumeration}}
     94   { typedef A::C A;  A::ax = 0; } // expected-error {{no member named 'ax'}}
     95   { typedef A::C A;  A::cx = 0; }
     96 }
     97 
     98 // make sure the following doesn't hit any asserts
     99 void f4(undef::C); // expected-error {{use of undeclared identifier 'undef'}}
    100 
    101 typedef void C2::f5(int); // expected-error{{typedef declarator cannot be qualified}}
    102 
    103 void f6(int A2::RC::x); // expected-error{{parameter declarator cannot be qualified}}
    104 
    105 int A2::RC::x; // expected-error{{non-static data member defined out-of-line}}
    106 
    107 void A2::CC::NC::m(); // expected-error{{out-of-line declaration of a member must be a definition}}
    108 
    109 
    110 namespace E {
    111   int X = 5;
    112 
    113   namespace Nested {
    114     enum E {
    115       X = 0
    116     };
    117 
    118     void f() {
    119       return E::X; // expected-error{{'E::Nested::E' is not a class, namespace, or scoped enumeration}}
    120     }
    121   }
    122 }
    123 
    124 
    125 class Operators {
    126   Operators operator+(const Operators&) const; // expected-note{{member declaration does not match because it is const qualified}}
    127   operator bool();
    128 };
    129 
    130 Operators Operators::operator+(const Operators&) { // expected-error{{out-of-line definition of 'operator+' does not match any declaration in 'Operators'}}
    131   Operators ops;
    132   return ops;
    133 }
    134 
    135 Operators Operators::operator+(const Operators&) const {
    136   Operators ops;
    137   return ops;
    138 }
    139 
    140 Operators::operator bool() {
    141   return true;
    142 }
    143 
    144 namespace A {
    145   void g(int&); // expected-note{{type of 1st parameter of member declaration does not match definition ('int &' vs 'const int &')}}
    146 }
    147 
    148 void A::f() {} // expected-error-re{{out-of-line definition of 'f' does not match any declaration in namespace 'A'{{$}}}}
    149 
    150 void A::g(const int&) { } // expected-error{{out-of-line definition of 'g' does not match any declaration in namespace 'A'}}
    151 
    152 struct Struct { };
    153 
    154 void Struct::f() { } // expected-error{{out-of-line definition of 'f' does not match any declaration in 'Struct'}}
    155 
    156 void global_func(int);
    157 void global_func2(int);
    158 
    159 namespace N {
    160   void ::global_func(int) { } // expected-error{{definition or redeclaration of 'global_func' cannot name the global scope}}
    161 
    162   void f();
    163   // FIXME: if we move this to a separate definition of N, things break!
    164 }
    165 void ::global_func2(int) { } // expected-warning{{extra qualification on member 'global_func2'}}
    166 
    167 void N::f() { } // okay
    168 
    169 struct Y;  // expected-note{{forward declaration of 'Y'}}
    170 Y::foo y; // expected-error{{incomplete type 'Y' named in nested name specifier}}
    171 
    172 X::X() : a(5) { } // expected-error{{use of undeclared identifier 'X'}}
    173 
    174 struct foo_S {
    175   static bool value;
    176 };
    177 bool (foo_S::value);
    178 
    179 
    180 namespace somens {
    181   struct a { }; // expected-note{{candidate constructor (the implicit copy constructor)}}
    182 }
    183 
    184 template <typename T>
    185 class foo {
    186 };
    187 
    188 
    189 // PR4452 / PR4451
    190 foo<somens:a> a2;  // expected-error {{unexpected ':' in nested name specifier}}
    191 
    192 somens::a a3 = a2; // expected-error {{no viable conversion}}
    193 
    194 // typedefs and using declarations.
    195 namespace test1 {
    196   namespace ns {
    197     class Counter { public: static int count; };
    198     typedef Counter counter;
    199   }
    200   using ns::counter;
    201 
    202   class Test {
    203     void test1() {
    204       counter c;
    205       c.count++;
    206       counter::count++;
    207     }
    208   };
    209 }
    210 
    211 // We still need to do lookup in the lexical scope, even if we push a
    212 // non-lexical scope.
    213 namespace test2 {
    214   namespace ns {
    215     extern int *count_ptr;
    216   }
    217   namespace {
    218     int count = 0;
    219   }
    220 
    221   int *ns::count_ptr = &count;
    222 }
    223 
    224 // PR6259, invalid case
    225 namespace test3 {
    226   class A; // expected-note {{forward declaration}}
    227   void foo(const char *path) {
    228     A::execute(path); // expected-error {{incomplete type 'test3::A' named in nested name specifier}}
    229   }
    230 }
    231 
    232 namespace PR7133 {
    233   namespace A {
    234     class Foo;
    235   }
    236 
    237   namespace A {
    238     namespace B {
    239       bool foo(Foo &);
    240     }
    241   }
    242 
    243   bool A::B::foo(Foo &) {
    244     return false;
    245   }
    246 }
    247 
    248 class CLASS {
    249   void CLASS::foo2(); // expected-error {{extra qualification on member 'foo2'}}
    250 };
    251 
    252 namespace PR8159 {
    253   class B { };
    254 
    255   class A {
    256     int A::a; // expected-error{{extra qualification on member 'a'}}
    257     static int A::b; // expected-error{{extra qualification on member 'b'}}
    258     int ::c; // expected-error{{non-friend class member 'c' cannot have a qualified name}}
    259   };
    260 }
    261 
    262 namespace rdar7980179 {
    263   class A { void f0(); }; // expected-note {{previous}}
    264   int A::f0() {} // expected-error {{return type of out-of-line definition of 'rdar7980179::A::f0' differs}}
    265 }
    266 
    267 namespace alias = A;
    268 double *dp = (alias::C*)0; // expected-error{{cannot initialize a variable of type 'double *' with an rvalue of type 'alias::C *'}}
    269 
    270 // http://llvm.org/PR10109
    271 namespace PR10109 {
    272 template<typename T>
    273 struct A {
    274 protected:
    275   struct B;
    276   struct B::C; // expected-error {{requires a template parameter list}} \
    277                // expected-error {{no struct named 'C'}} \
    278     // expected-error{{non-friend class member 'C' cannot have a qualified name}}
    279 };
    280 
    281 template<typename T>
    282 struct A2 {
    283 protected:
    284   struct B;
    285 };
    286 template <typename T>
    287 struct A2<T>::B::C; // expected-error {{no struct named 'C'}}
    288 }
    289 
    290 namespace PR13033 {
    291 namespace NS {
    292  int a; // expected-note {{'NS::a' declared here}}
    293  int longer_b; //expected-note {{'NS::longer_b' declared here}}
    294 }
    295 
    296 // Suggest adding a namespace qualifier to both variable names even though one
    297 // is only a single character long.
    298 int foobar = a + longer_b; // expected-error {{use of undeclared identifier 'a'; did you mean 'NS::a'?}} \
    299                            // expected-error {{use of undeclared identifier 'longer_b'; did you mean 'NS::longer_b'?}}
    300 }
    301 
    302 // <rdar://problem/13853540>
    303 namespace N {
    304   struct X { };
    305   namespace N {
    306     struct Foo {
    307       struct N::X *foo(); // expected-error{{no struct named 'X' in namespace 'N::N'}}
    308     };
    309   }
    310 }
    311 
    312 namespace TypedefNamespace { typedef int F; };
    313 TypedefNamespace::F::NonexistentName BadNNSWithCXXScopeSpec; // expected-error {{'F' (aka 'int') is not a class, namespace, or scoped enumeration}}
    314