Home | History | Annotate | Download | only in SemaCXX 
      1 // RUN: %clang_cc1 -fsyntax-only -verify %s
      2 namespace Ns {
      3   int f(); // expected-note{{previous declaration is here}}
      4 
      5   enum E {
      6     Enumerator
      7   };
      8 }
      9 namespace Ns {
     10   double f(); // expected-error{{functions that differ only in their return type cannot be overloaded}}
     11 
     12   int x = Enumerator;
     13 }
     14 
     15 namespace Ns2 {
     16   float f();
     17 }
     18 
     19 int y = Ns::Enumerator;
     20 
     21 namespace Ns2 {
     22   float f(int); // expected-note{{previous declaration is here}}
     23 }
     24 
     25 namespace Ns2 {
     26   double f(int); // expected-error{{functions that differ only in their return type cannot be overloaded}}
     27 }
     28 
     29 namespace N {
     30   int& f1();
     31 }
     32 
     33 namespace N {
     34   struct f1 {
     35     static int member;
     36 
     37     typedef int type;
     38 
     39     void foo(type);
     40   };
     41 
     42   void test_f1() {
     43     int &i1 = f1();
     44   }
     45 }
     46 
     47 void N::f1::foo(int i) {
     48   f1::member = i;
     49   f1::type &ir = i;
     50 }
     51 
     52 namespace N {
     53   float& f1(int x) {
     54     N::f1::type& i1 = x;
     55     f1::type& i2 = x;
     56   }
     57 
     58   struct f2 {
     59     static int member;
     60   };
     61   void f2();
     62 }
     63 
     64 int i1 = N::f1::member;
     65 typedef struct N::f1 type1;
     66 int i2 = N::f2::member;
     67 typedef struct N::f2 type2;
     68 
     69 void test_f1(int i) {
     70   int &v1 = N::f1();
     71   float &v2 = N::f1(i);
     72   int v3 = ::i1;
     73   int v4 = N::f1::member;
     74 }
     75 
     76 typedef int f2_type;
     77 namespace a {
     78   typedef int f2_type(int, int);
     79 
     80   void test_f2() {
     81     ::f2_type(1, 2); // expected-error {{excess elements in scalar initializer}}
     82   }
     83 }
     84 
     85 // PR clang/3291
     86 namespace a {
     87   namespace a {   // A1
     88     namespace a { // A2
     89       int i; // expected-note{{'a::a::a::i' declared here}}
     90     }
     91   }
     92 }
     93 
     94 void test_a() {
     95   a::a::i = 3; // expected-error{{no member named 'i' in namespace 'a::a'; did you mean 'a::a::a::i'?}}
     96   a::a::a::i = 4;
     97   a::a::j = 3; // expected-error-re{{no member named 'j' in namespace 'a::a'{{$}}}}
     98 }
     99 
    100 struct Undef { // expected-note{{definition of 'Undef' is not complete until the closing '}'}}
    101   typedef int type;
    102 
    103   Undef::type member;
    104 
    105   static int size = sizeof(Undef); // expected-error{{invalid application of 'sizeof' to an incomplete type 'Undef'}}
    106 
    107   int f();
    108 };
    109 
    110 int Undef::f() {
    111   return sizeof(Undef);
    112 }
    113 
    114 // PR clang/5667
    115 namespace test1 {
    116   template <typename T> struct is_class {
    117     enum { value = 0 };
    118   };
    119 
    120   template <typename T> class ClassChecker {
    121     bool isClass() {
    122       return is_class<T>::value;
    123     }
    124   };
    125 
    126   template class ClassChecker<int>;
    127 }
    128 
    129 namespace PR6830 {
    130   namespace foo {
    131 
    132     class X {
    133     public:
    134       X() {}
    135     };
    136 
    137   }  // namespace foo
    138 
    139   class Z {
    140   public:
    141     explicit Z(const foo::X& x) {}
    142 
    143     void Work() {}
    144   };
    145 
    146   void Test() {
    147     Z(foo::X()).Work();
    148   }
    149 }
    150 
    151 namespace pr12339 {
    152   extern "C" void i; // expected-error{{variable has incomplete type 'void'}}
    153   pr12339::FOO  // expected-error{{no type named 'FOO' in namespace 'pr12339'}}
    154 }  // expected-error{{expected unqualified-id}}
    155