1// RUN: %clang_cc1 -fsyntax-only -verify %s 2namespace Ns { 3 int f(); // expected-note{{previous declaration is here}} 4 5 enum E { 6 Enumerator 7 }; 8} 9namespace Ns { 10 double f(); // expected-error{{functions that differ only in their return type cannot be overloaded}} 11 12 int x = Enumerator; 13} 14 15namespace Ns2 { 16 float f(); 17} 18 19int y = Ns::Enumerator; 20 21namespace Ns2 { 22 float f(int); // expected-note{{previous declaration is here}} 23} 24 25namespace Ns2 { 26 double f(int); // expected-error{{functions that differ only in their return type cannot be overloaded}} 27} 28 29namespace N { 30 int& f1(); 31} 32 33namespace 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 47void N::f1::foo(int i) { 48 f1::member = i; 49 f1::type &ir = i; 50} 51 52namespace 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 64int i1 = N::f1::member; 65typedef struct N::f1 type1; 66int i2 = N::f2::member; 67typedef struct N::f2 type2; 68 69void 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 76typedef int f2_type; 77namespace 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 86namespace a { 87 namespace a { // A1 88 namespace a { // A2 89 int i; 90 } 91 } 92} 93 94void test_a() { 95 a::a::i = 3; // expected-error{{no member named 'i'}} 96 a::a::a::i = 4; 97} 98 99struct Undef { // expected-note{{definition of 'Undef' is not complete until the closing '}'}} 100 typedef int type; 101 102 Undef::type member; 103 104 static int size = sizeof(Undef); // expected-error{{invalid application of 'sizeof' to an incomplete type 'Undef'}} 105 106 int f(); 107}; 108 109int Undef::f() { 110 return sizeof(Undef); 111} 112 113// PR clang/5667 114namespace test1 { 115 template <typename T> struct is_class { 116 enum { value = 0 }; 117 }; 118 119 template <typename T> class ClassChecker { 120 bool isClass() { 121 return is_class<T>::value; 122 } 123 }; 124 125 template class ClassChecker<int>; 126} 127 128namespace PR6830 { 129 namespace foo { 130 131 class X { 132 public: 133 X() {} 134 }; 135 136 } // namespace foo 137 138 class Z { 139 public: 140 explicit Z(const foo::X& x) {} 141 142 void Work() {} 143 }; 144 145 void Test() { 146 Z(foo::X()).Work(); 147 } 148} 149 150namespace pr12339 { 151 extern "C" void i; 152 pr12339::FOO // expected-error{{no type named 'FOO' in namespace 'pr12339'}} 153} // expected-error{{expected unqualified-id}} 154