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
142
143
144
145
146
147
148
149
150
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
namespace N {
struct X { };
X operator+(X, X);
void f(X); // expected-note 2 {{'N::f' declared here}}
void g(X); // expected-note{{candidate function}}
void test_multiadd(X x) {
(void)(x + x);
}
}
namespace M {
struct Y : N::X { };
}
void f();
void test_operator_adl(N::X x, M::Y y) {
(void)(x + x);
(void)(y + y);
}
void test_func_adl(N::X x, M::Y y) {
f(x);
f(y);
(f)(x); // expected-error{{too many arguments to function call, expected 0, have 1; did you mean 'N::f'?}}
::f(x); // expected-error{{too many arguments to function call, expected 0, have 1; did you mean 'N::f'?}}
}
namespace N {
void test_multiadd2(X x) {
(void)(x + x);
}
}
void test_func_adl_only(N::X x) {
g(x);
}
namespace M {
int g(N::X); // expected-note{{candidate function}}
void test(N::X x) {
g(x); // expected-error{{call to 'g' is ambiguous}}
int i = (g)(x);
int g(N::X);
g(x); // okay; calls locally-declared function, no ADL
}
}
void test_operator_name_adl(N::X x) {
(void)operator+(x, x);
}
struct Z { };
int& f(Z);
namespace O {
char &f();
void test_global_scope_adl(Z z) {
{
int& ir = f(z);
}
}
}
extern "C" {
struct L { int x; };
}
void h(L); // expected-note{{candidate function}}
namespace P {
void h(L); // expected-note{{candidate function}}
void test_transparent_context_adl(L l) {
{
h(l); // expected-error {{call to 'h' is ambiguous}}
}
}
}
namespace test5 {
namespace NS {
struct A;
void foo(void (*)(A&));
}
void bar(NS::A& a);
void test() {
foo(&bar);
}
}
// PR6762: __builtin_va_list should be invisible to ADL on all platforms.
void test6_function(__builtin_va_list &argv);
namespace test6 {
void test6_function(__builtin_va_list &argv);
void test() {
__builtin_va_list args;
test6_function(args);
}
}
// PR13682: we might need to instantiate class temploids.
namespace test7 {
namespace inner {
class A {};
void test7_function(A &);
}
template <class T> class B : public inner::A {};
void test(B<int> &ref) {
test7_function(ref);
}
}
// Like test7, but ensure we don't complain if the type is properly
// incomplete.
namespace test8 {
template <class T> class B;
void test8_function(B<int> &);
void test(B<int> &ref) {
test8_function(ref);
}
}
// [...] Typedef names and using-declarations used to specify the types
// do not contribute to this set.
namespace typedef_names_and_using_declarations {
namespace N { struct S {}; void f(S); }
namespace M { typedef N::S S; void g1(S); } // expected-note {{declared here}}
namespace L { using N::S; void g2(S); } // expected-note {{declared here}}
void test() {
M::S s;
f(s); // ok
g1(s); // expected-error {{use of undeclared}}
g2(s); // expected-error {{use of undeclared}}
}
}
|
