blob: f5fbf7a08c20f58defc3001f7e6bebc442d62004 (
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
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
// [class.mfct.non-static]p3:
// When an id-expression (5.1) that is not part of a class member
// access syntax (5.2.5) and not used to form a pointer to member
// (5.3.1) is used in the body of a non-static member function of
// class X, if name lookup (3.4.1) resolves the name in the
// id-expression to a non-static non-type member of some class C,
// the id-expression is transformed into a class member access
// expression (5.2.5) using (*this) (9.3.2) as the
// postfix-expression to the left of the . operator. [ Note: if C is
// not X or a base class of X, the class member access expression is
// ill-formed. --end note] Similarly during name lookup, when an
// unqualified-id (5.1) used in the definition of a member function
// for class X resolves to a static member, an enumerator or a
// nested type of class X or of a base class of X, the
// unqualified-id is transformed into a qualified-id (5.1) in which
// the nested-name-specifier names the class of the member function.
namespace test0 {
class A {
int data_member;
int instance_method();
static int static_method();
bool test() {
return data_member + instance_method() < static_method();
}
};
}
namespace test1 {
struct Opaque1 {}; struct Opaque2 {}; struct Opaque3 {};
struct A {
void foo(Opaque1); // expected-note {{candidate}}
void foo(Opaque2); // expected-note {{candidate}}
void test();
};
struct B : A {
};
void A::test() {
B::foo(Opaque1());
B::foo(Opaque2());
B::foo(Opaque3()); // expected-error {{no matching member function}}
}
}
namespace test2 {
class Unrelated {
void foo();
};
template <class T> struct B;
template <class T> struct C;
template <class T> struct A {
void foo();
void test0() {
Unrelated::foo(); // expected-error {{call to non-static member function without an object argument}}
}
void test1() {
B<T>::foo();
}
static void test2() {
B<T>::foo(); // expected-error {{call to non-static member function without an object argument}}
}
void test3() {
C<T>::foo(); // expected-error {{no member named 'foo'}}
}
};
template <class T> struct B : A<T> {
};
template <class T> struct C {
};
int test() {
A<int> a;
a.test0(); // no instantiation note here, decl is ill-formed
a.test1();
a.test2(); // expected-note {{in instantiation}}
a.test3(); // expected-note {{in instantiation}}
}
}
|
