1 // RUN: %clang_cc1 -fsyntax-only -verify %s
2
3 namespace N {
4 struct X { };
5
6 X operator+(X, X);
7
8 void f(X); // expected-note 2 {{'N::f' declared here}}
9 void g(X); // expected-note{{candidate function}}
10
test_multiadd(X x)11 void test_multiadd(X x) {
12 (void)(x + x);
13 }
14 }
15
16 namespace M {
17 struct Y : N::X { };
18 }
19
20 void f();
21
test_operator_adl(N::X x,M::Y y)22 void test_operator_adl(N::X x, M::Y y) {
23 (void)(x + x);
24 (void)(y + y);
25 }
26
test_func_adl(N::X x,M::Y y)27 void test_func_adl(N::X x, M::Y y) {
28 f(x);
29 f(y);
30 (f)(x); // expected-error{{too many arguments to function call, expected 0, have 1; did you mean 'N::f'?}}
31 ::f(x); // expected-error{{too many arguments to function call, expected 0, have 1; did you mean 'N::f'?}}
32 }
33
34 namespace N {
test_multiadd2(X x)35 void test_multiadd2(X x) {
36 (void)(x + x);
37 }
38 }
39
40
test_func_adl_only(N::X x)41 void test_func_adl_only(N::X x) {
42 g(x);
43 }
44
45 namespace M {
46 int g(N::X); // expected-note{{candidate function}}
47
test(N::X x)48 void test(N::X x) {
49 g(x); // expected-error{{call to 'g' is ambiguous}}
50 int i = (g)(x);
51
52 int g(N::X);
53 g(x); // okay; calls locally-declared function, no ADL
54 }
55 }
56
57
test_operator_name_adl(N::X x)58 void test_operator_name_adl(N::X x) {
59 (void)operator+(x, x);
60 }
61
62 struct Z { };
63 int& f(Z);
64
65 namespace O {
66 char &f();
test_global_scope_adl(Z z)67 void test_global_scope_adl(Z z) {
68 {
69 int& ir = f(z);
70 }
71 }
72 }
73
74 extern "C" {
75 struct L { int x; };
76 }
77
78 void h(L); // expected-note{{candidate function}}
79
80 namespace P {
81 void h(L); // expected-note{{candidate function}}
test_transparent_context_adl(L l)82 void test_transparent_context_adl(L l) {
83 {
84 h(l); // expected-error {{call to 'h' is ambiguous}}
85 }
86 }
87 }
88
89 namespace test5 {
90 namespace NS {
91 struct A;
92 void foo(void (*)(A&));
93 }
94 void bar(NS::A& a);
95
test()96 void test() {
97 foo(&bar);
98 }
99 }
100
101 // PR6762: __builtin_va_list should be invisible to ADL on all platforms.
102 void test6_function(__builtin_va_list &argv);
103 namespace test6 {
104 void test6_function(__builtin_va_list &argv);
105
test()106 void test() {
107 __builtin_va_list args;
108 test6_function(args);
109 }
110 }
111
112 // PR13682: we might need to instantiate class temploids.
113 namespace test7 {
114 namespace inner {
115 class A {};
116 void test7_function(A &);
117 }
118 template <class T> class B : public inner::A {};
119
test(B<int> & ref)120 void test(B<int> &ref) {
121 test7_function(ref);
122 }
123 }
124
125 // Like test7, but ensure we don't complain if the type is properly
126 // incomplete.
127 namespace test8 {
128 template <class T> class B;
129 void test8_function(B<int> &);
130
test(B<int> & ref)131 void test(B<int> &ref) {
132 test8_function(ref);
133 }
134 }
135