Home | History | Annotate | Download | only in namespace.udir 
      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 
     26     opaque1 test() {
     27       using namespace A::B;
     28       return foo(); // C::foo
     29     }
     30   }
     31 
     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 
     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 
     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 
     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 
     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 
    118     opaque0 test() {
    119       using namespace D;
    120       return foo();
    121     }
    122   }
    123 
    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;
    139 int test5::inc(int x = default_x) {
    140   return x+1;
    141 }
    142