1 // RUN: %clang_cc1 -fsyntax-only -verify %s 2 3 // (this actually occurs before paragraph 1) 4 namespace test0 { 5 namespace A {} 6 class B { 7 using namespace A; // expected-error {{'using namespace' is not allowed in classes}} 8 }; 9 } 10 11 12 struct opaque0 {}; 13 struct opaque1 {}; 14 15 // Test that names appear as if in deepest common ancestor. 16 namespace test1 { 17 namespace A { 18 namespace B { 19 opaque0 foo(); // expected-note {{candidate}} 20 } 21 } 22 23 namespace C { 24 opaque1 foo(); // expected-note {{candidate}} 25 test()26 opaque1 test() { 27 using namespace A::B; 28 return foo(); // C::foo 29 } 30 } 31 test()32 opaque1 test() { 33 using namespace A::B; 34 using namespace C; 35 return foo(); // expected-error {{call to 'foo' is ambiguous}} 36 } 37 } 38 39 // Same thing, but with the directives in namespaces. 40 namespace test2 { 41 namespace A { 42 namespace B { 43 opaque0 foo(); // expected-note {{candidate}} 44 } 45 } 46 47 namespace C { 48 opaque1 foo(); // expected-note {{candidate}} 49 50 namespace test { 51 using namespace A::B; 52 test()53 opaque1 test() { 54 return foo(); // C::foo 55 } 56 } 57 } 58 59 namespace test { 60 using namespace A::B; 61 using namespace C; 62 test()63 opaque1 test() { 64 return foo(); // expected-error {{call to 'foo' is ambiguous}} 65 } 66 } 67 } 68 69 // Transitivity. 70 namespace test3 { 71 namespace A { 72 namespace B { 73 opaque0 foo(); 74 } 75 } 76 namespace C { 77 using namespace A; 78 } 79 test0()80 opaque0 test0() { 81 using namespace C; 82 using namespace B; 83 return foo(); 84 } 85 86 namespace D { 87 using namespace C; 88 } 89 namespace A { 90 opaque1 foo(); 91 } 92 test1()93 opaque1 test1() { 94 using namespace D; 95 return foo(); 96 } 97 } 98 99 // Transitivity acts like synthetic using directives. 100 namespace test4 { 101 namespace A { 102 namespace B { 103 opaque0 foo(); // expected-note {{candidate}} 104 } 105 } 106 107 namespace C { 108 using namespace A::B; 109 } 110 111 opaque1 foo(); // expected-note {{candidate}} 112 113 namespace A { 114 namespace D { 115 using namespace C; 116 } 117 test()118 opaque0 test() { 119 using namespace D; 120 return foo(); 121 } 122 } 123 test()124 opaque0 test() { 125 using namespace A::D; 126 return foo(); // expected-error {{call to 'foo' is ambiguous}} 127 } 128 } 129 130 // Bug: using directives should be followed when parsing default 131 // arguments in scoped declarations. 132 class test5 { 133 int inc(int x); 134 }; 135 namespace Test5 { 136 int default_x = 0; 137 } 138 using namespace Test5; inc(int x=default_x)139int test5::inc(int x = default_x) { 140 return x+1; 141 } 142