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
151
152
153
154
155
156
157
158
159
160
161
162
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
namespace A {
class A {
friend void func(A);
friend A operator+(A,A);
};
}
namespace B {
class B {
static void func(B);
};
B operator+(B,B);
}
namespace D {
class D {};
}
namespace C {
class C {}; // expected-note {{candidate constructor (the implicit copy constructor) not viable: no known conversion from 'B::B' to 'const C::C &' for 1st argument}}
#if __cplusplus >= 201103L // C++11 or later
// expected-note@-2 {{candidate constructor (the implicit move constructor) not viable: no known conversion from 'B::B' to 'C::C &&' for 1st argument}}
#endif
void func(C); // expected-note {{'C::func' declared here}} \
// expected-note {{passing argument to parameter here}}
C operator+(C,C);
D::D operator+(D::D,D::D);
}
namespace D {
using namespace C;
}
namespace Test {
void test() {
func(A::A());
// FIXME: namespace-aware typo correction causes an extra, misleading
// message in this case; some form of backtracking, diagnostic message
// delaying, or argument checking before emitting diagnostics is needed to
// avoid accepting and printing out a typo correction that proves to be
// incorrect once argument-dependent lookup resolution has occurred.
func(B::B()); // expected-error {{use of undeclared identifier 'func'; did you mean 'C::func'?}} \
// expected-error {{no viable conversion from 'B::B' to 'C::C'}}
func(C::C());
A::A() + A::A();
B::B() + B::B();
C::C() + C::C();
D::D() + D::D(); // expected-error {{invalid operands to binary expression ('D::D' and 'D::D')}}
}
}
// PR6716
namespace test1 {
template <class T> class A {
template <class U> friend void foo(A &, U); // expected-note {{not viable: 1st argument ('const A<int>') would lose const qualifier}}
public:
A();
};
void test() {
const A<int> a;
foo(a, 10); // expected-error {{no matching function for call to 'foo'}}
}
}
// Check the rules described in p4:
// When considering an associated namespace, the lookup is the same as the lookup
// performed when the associated namespace is used as a qualifier (6.4.3.2) except that:
// - Any using-directives in the associated namespace are ignored.
namespace test_using_directives {
namespace M { struct S; }
namespace N {
void f(M::S); // expected-note {{declared here}}
}
namespace M {
using namespace N;
struct S {};
}
void test() {
M::S s;
f(s); // expected-error {{use of undeclared}}
M::f(s); // ok
}
}
// - Any namespace-scope friend functions or friend function templates declared in
// associated classes are visible within their respective namespaces even if
// they are not visible during an ordinary lookup
// (Note: For the friend declaration to be visible, the corresponding class must be
// included in the set of associated classes. Merely including the namespace in
// the set of associated namespaces is not enough.)
namespace test_friend1 {
namespace N {
struct S;
struct T {
friend void f(S); // #1
};
struct S { S(); S(T); };
}
void test() {
N::S s;
N::T t;
f(s); // expected-error {{use of undeclared}}
f(t); // ok, #1
}
}
// credit: Arthur O’Dwyer
namespace test_friend2 {
struct A {
struct B {
struct C {};
};
friend void foo(...); // #1
};
struct D {
friend void foo(...); // #2
};
template<class> struct E {
struct F {};
};
template<class> struct G {};
template<class> struct H {};
template<class> struct I {};
struct J { friend void foo(...) {} }; // #3
void test() {
A::B::C c;
foo(c); // #1 is not visible since A is not an associated class
// expected-error@-1 {{use of undeclared}}
E<D>::F f;
foo(f); // #2 is not visible since D is not an associated class
// expected-error@-1 {{use of undeclared}}
G<H<I<J> > > j;
foo(j); // ok, #3.
}
}
// - All names except those of (possibly overloaded) functions and
// function templates are ignored.
namespace test_other_names {
namespace N {
struct S {};
struct Callable { void operator()(S); };
static struct Callable Callable;
}
void test() {
N::S s;
Callable(s); // expected-error {{use of undeclared}}
}
}
|
