374 lines · cpp
1// RUN: %clang_cc1 -fsyntax-only -verify %s2 3namespace A {4 class X { }; // expected-note{{candidate found by name lookup is 'A::X'}}5 // expected-note@-1{{candidate found by name lookup is 'A::X'}}6}7namespace B {8 void X(int); // expected-note{{candidate found by name lookup is 'B::X'}}9 // expected-note@-1{{candidate found by name lookup is 'B::X'}}10}11 12// Using directive doesn't cause A::X to be hidden, so X is ambiguous.13namespace Test1a {14 using namespace A;15 using namespace B;16 17 void f() {18 X(1); // expected-error{{reference to 'X' is ambiguous}}19 }20}21 22namespace Test1b {23 using namespace B;24 using namespace A;25 26 void f() {27 X(1); // expected-error{{reference to 'X' is ambiguous}}28 }29}30 31// The behaviour here should be the same as using namespaces A and B directly32namespace Test2a {33 namespace C {34 using A::X; // expected-note{{candidate found by name lookup is 'Test2a::C::X'}}35 }36 namespace D {37 using B::X; // expected-note{{candidate found by name lookup is 'Test2a::D::X'}}38 }39 using namespace C;40 using namespace D;41 42 void f() {43 X(1); // expected-error{{reference to 'X' is ambiguous}}44 }45}46 47namespace Test2b {48 namespace C {49 using A::X; // expected-note{{candidate found by name lookup is 'Test2b::C::X'}}50 }51 namespace D {52 using B::X; // expected-note{{candidate found by name lookup is 'Test2b::D::X'}}53 }54 using namespace D;55 using namespace C;56 57 void f() {58 X(1); // expected-error{{reference to 'X' is ambiguous}}59 }60}61 62// Defining a function X inside C should hide using A::X in C but not D, so the result is ambiguous.63namespace Test3a {64 namespace C {65 using A::X;66 void X(int); // expected-note{{candidate found by name lookup is 'Test3a::C::X'}}67 }68 namespace D {69 using A::X; // expected-note{{candidate found by name lookup is 'Test3a::D::X'}}70 }71 using namespace C;72 using namespace D;73 void f() {74 X(1); // expected-error{{reference to 'X' is ambiguous}}75 }76}77 78namespace Test3b {79 namespace C {80 using A::X;81 void X(int); // expected-note{{candidate found by name lookup is 'Test3b::C::X'}}82 }83 namespace D {84 using A::X; // expected-note{{candidate found by name lookup is 'Test3b::D::X'}}85 }86 using namespace D;87 using namespace C;88 void f() {89 X(1); // expected-error{{reference to 'X' is ambiguous}}90 }91}92 93namespace Test3c {94 namespace C {95 void X(int); // expected-note{{candidate found by name lookup is 'Test3c::C::X'}}96 using A::X;97 }98 namespace D {99 using A::X; // expected-note{{candidate found by name lookup is 'Test3c::D::X'}}100 }101 using namespace C;102 using namespace D;103 void f() {104 X(1); // expected-error{{reference to 'X' is ambiguous}}105 }106}107 108namespace Test3d {109 namespace C {110 void X(int); // expected-note{{candidate found by name lookup is 'Test3d::C::X'}}111 using A::X;112 }113 namespace D {114 using A::X; // expected-note{{candidate found by name lookup is 'Test3d::D::X'}}115 }116 using namespace D;117 using namespace C;118 void f() {119 X(1); // expected-error{{reference to 'X' is ambiguous}}120 }121}122 123// A::X hidden in both C and D by overloaded function, so the result is not ambiguous.124namespace Test4a {125 namespace C {126 using A::X;127 void X(int);128 }129 namespace D {130 using A::X;131 void X(int, int);132 }133 using namespace C;134 using namespace D;135 void f() {136 X(1);137 }138}139 140namespace Test4b {141 namespace C {142 using A::X;143 void X(int);144 }145 namespace D {146 using A::X;147 void X(int, int);148 }149 using namespace D;150 using namespace C;151 void f() {152 X(1);153 }154}155 156namespace Test4c {157 namespace C {158 void X(int);159 using A::X;160 }161 namespace D {162 void X(int, int);163 using A::X;164 }165 using namespace C;166 using namespace D;167 void f() {168 X(1);169 }170}171 172namespace Test4d {173 namespace C {174 void X(int);175 using A::X;176 }177 namespace D {178 void X(int, int);179 using A::X;180 }181 using namespace D;182 using namespace C;183 void f() {184 X(1);185 }186}187 188// B::X hides class X in C, so the the result is not ambiguous189namespace Test5a {190 namespace C {191 using B::X;192 class X { };193 }194 namespace D {195 using B::X;196 }197 using namespace C;198 using namespace D;199 void f() {200 X(1);201 }202}203 204namespace Test5b {205 namespace C {206 using B::X;207 class X { };208 }209 namespace D {210 using B::X;211 }212 using namespace D;213 using namespace C;214 void f() {215 X(1);216 }217}218 219namespace Test5c {220 namespace C {221 class X { };222 using B::X;223 }224 namespace D {225 using B::X;226 }227 using namespace C;228 using namespace D;229 void f() {230 X(1);231 }232}233 234namespace Test5d {235 namespace C {236 class X { };237 using B::X;238 }239 namespace D {240 using B::X;241 }242 using namespace D;243 using namespace C;244 void f() {245 X(1);246 }247}248 249// B::X hides class X declared in both C and D, so the result is not ambiguous.250namespace Test6a {251 namespace C {252 class X { };253 using B::X;254 }255 namespace D {256 class X { };257 using B::X;258 }259 using namespace C;260 using namespace D;261 void f() {262 X(1);263 }264}265 266namespace Test6b {267 namespace C {268 class X { };269 using B::X;270 }271 namespace D {272 class X { };273 using B::X;274 }275 using namespace D;276 using namespace C;277 void f() {278 X(1);279 }280}281 282namespace Test6c {283 namespace C {284 using B::X;285 class X { };286 }287 namespace D {288 using B::X;289 class X { };290 }291 using namespace C;292 using namespace D;293 void f() {294 X(1);295 }296}297 298namespace Test6d {299 namespace C {300 using B::X;301 class X { };302 }303 namespace D {304 using B::X;305 class X { };306 }307 using namespace D;308 using namespace C;309 void f() {310 X(1);311 }312}313 314// function X inside C should hide class X in C but not D.315namespace Test7a {316 namespace C {317 class X;318 void X(int); // expected-note{{candidate found by name lookup is 'Test7a::C::X'}}319 }320 namespace D {321 class X; // expected-note{{candidate found by name lookup is 'Test7a::D::X'}}322 }323 using namespace C;324 using namespace D;325 void f() {326 X(1); // expected-error{{reference to 'X' is ambiguous}}327 }328}329 330namespace Test7b {331 namespace C {332 class X;333 void X(int); // expected-note{{candidate found by name lookup is 'Test7b::C::X'}}334 }335 namespace D {336 class X; // expected-note{{candidate found by name lookup is 'Test7b::D::X'}}337 }338 using namespace D;339 using namespace C;340 void f() {341 X(1); // expected-error{{reference to 'X' is ambiguous}}342 }343}344 345namespace Test7c {346 namespace C {347 void X(int); // expected-note{{candidate found by name lookup is 'Test7c::C::X'}}348 class X;349 }350 namespace D {351 class X; // expected-note{{candidate found by name lookup is 'Test7c::D::X'}}352 }353 using namespace C;354 using namespace D;355 void f() {356 X(1); // expected-error{{reference to 'X' is ambiguous}}357 }358}359 360namespace Test7d {361 namespace C {362 void X(int); // expected-note{{candidate found by name lookup is 'Test7d::C::X'}}363 class X;364 }365 namespace D {366 class X; // expected-note{{candidate found by name lookup is 'Test7d::D::X'}}367 }368 using namespace D;369 using namespace C;370 void f() {371 X(1); // expected-error{{reference to 'X' is ambiguous}}372 }373}374