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