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