1 struct Base1 {
2 int member1;
3 float member2;
4 };
5
6 struct Base2 {
7 int member1;
8 double member3;
9 void memfun1(int);
10 };
11
12 struct Base3 : Base1, Base2 {
13 void memfun1(float);
14 void memfun1(double) const;
15 void memfun2(int);
16 };
17
18 struct Derived : Base3 {
19 template <typename T> Derived(T);
20 Derived(int);
21 int member4;
22 int memfun3(int);
23 };
24
25 class Proxy {
26 public:
27 Derived *operator->() const;
28 };
29
test(const Proxy & p)30 void test(const Proxy &p) {
31 p->
32 }
33
34 struct Test1 {
35 Base1 b;
36
sfuncTest137 static void sfunc() {
38 b. // expected-error {{invalid use of member 'b' in static member function}}
39 }
40 };
41
42 struct Foo {
43 void foo() const;
44 static void foo(bool);
45 };
46
47 struct Bar {
fooBar48 void foo(bool param) {
49 Foo::foo( );// unresolved member expression with an implicit base
50 }
51 };
52
53 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:31:6 %s -o - | FileCheck -check-prefix=CHECK-CC1 --implicit-check-not="Derived : Derived(" %s
54 // CHECK-CC1: Base1 (InBase) : Base1::
55 // CHECK-CC1: member1 (InBase) : [#int#][#Base1::#]member1
56 // CHECK-CC1: member1 (InBase) : [#int#][#Base2::#]member1
57 // CHECK-CC1: member2 (InBase) : [#float#][#Base1::#]member2
58 // CHECK-CC1: member3 (InBase)
59 // CHECK-CC1: member4
60 // CHECK-CC1: memfun1 (InBase) : [#void#][#Base3::#]memfun1(<#float#>)
61 // CHECK-CC1: memfun1 (InBase) : [#void#][#Base3::#]memfun1(<#double#>)[# const#]
62 // CHECK-CC1: memfun1 (Hidden,InBase) : [#void#]Base2::memfun1(<#int#>)
63 // CHECK-CC1: memfun2 (InBase) : [#void#][#Base3::#]memfun2(<#int#>)
64 // CHECK-CC1: memfun3 : [#int#]memfun3(<#int#>)
65
66 // Make sure this doesn't crash
67 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:38:7 %s -verify
68
69 // Make sure this also doesn't crash
70 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:49:14 %s
71
72
73 template<typename T>
74 class BaseTemplate {
75 public:
76 T baseTemplateFunction();
77
78 T baseTemplateField;
79 };
80
81 template<typename T, typename S>
82 class TemplateClass: public Base1 , public BaseTemplate<T> {
83 public:
function()84 T function() { }
85 T field;
86
87 TemplateClass<S, T> &relatedField;
88 BaseTemplate<S> &relatedFunction();
89
90 void overload1(const T &);
91 void overload1(const S &);
92 };
93
94 template<typename T, typename S>
completeDependentMembers(TemplateClass<T,S> & object,TemplateClass<int,S> * object2)95 void completeDependentMembers(TemplateClass<T, S> &object,
96 TemplateClass<int, S> *object2) {
97 object.field;
98 object2->field;
99 // CHECK-CC2: baseTemplateField (InBase) : [#T#][#BaseTemplate<T>::#]baseTemplateField
100 // CHECK-CC2: baseTemplateFunction (InBase) : [#T#][#BaseTemplate<T>::#]baseTemplateFunction()
101 // CHECK-CC2: field : [#T#]field
102 // CHECK-CC2: function : [#T#]function()
103 // CHECK-CC2: member1 (InBase) : [#int#][#Base1::#]member1
104 // CHECK-CC2: member2 (InBase) : [#float#][#Base1::#]member2
105 // CHECK-CC2: overload1 : [#void#]overload1(<#const T &#>)
106 // CHECK-CC2: overload1 : [#void#]overload1(<#const S &#>)
107
108 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:97:10 %s -o - | FileCheck -check-prefix=CHECK-CC2 %s
109 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:98:12 %s -o - | FileCheck -check-prefix=CHECK-CC2 %s
110
111 object.relatedField.relatedFunction().baseTemplateField;
112 // CHECK-DEP-CHAIN: baseTemplateField : [#T#]baseTemplateField
113 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:111:41 %s -o - | FileCheck -check-prefix=CHECK-DEP-CHAIN %s
114 }
115
116
completeDependentSpecializedMembers(TemplateClass<int,double> & object,TemplateClass<int,double> * object2)117 void completeDependentSpecializedMembers(TemplateClass<int, double> &object,
118 TemplateClass<int, double> *object2) {
119 object.field;
120 object2->field;
121 // CHECK-CC3: baseTemplateField (InBase) : [#int#][#BaseTemplate<int>::#]baseTemplateField
122 // CHECK-CC3: baseTemplateFunction (InBase) : [#int#][#BaseTemplate<int>::#]baseTemplateFunction()
123 // CHECK-CC3: field : [#int#]field
124 // CHECK-CC3: function : [#int#]function()
125 // CHECK-CC3: member1 (InBase) : [#int#][#Base1::#]member1
126 // CHECK-CC3: member2 (InBase) : [#float#][#Base1::#]member2
127 // CHECK-CC3: overload1 : [#void#]overload1(<#const int &#>)
128 // CHECK-CC3: overload1 : [#void#]overload1(<#const double &#>)
129
130 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:119:10 %s -o - | FileCheck -check-prefix=CHECK-CC3 %s
131 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:120:12 %s -o - | FileCheck -check-prefix=CHECK-CC3 %s
132 }
133
134 template <typename T>
135 class Template {
136 public:
137 BaseTemplate<int> o1;
138 BaseTemplate<T> o2;
139
function()140 void function() {
141 o1.baseTemplateField;
142 // CHECK-CC4: BaseTemplate : BaseTemplate::
143 // CHECK-CC4: baseTemplateField : [#int#]baseTemplateField
144 // CHECK-CC4: baseTemplateFunction : [#int#]baseTemplateFunction()
145 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:141:8 %s -o - | FileCheck -check-prefix=CHECK-CC4 %s
146 o2.baseTemplateField;
147 // CHECK-CC5: BaseTemplate : BaseTemplate::
148 // CHECK-CC5: baseTemplateField : [#T#]baseTemplateField
149 // CHECK-CC5: baseTemplateFunction : [#T#]baseTemplateFunction()
150 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:146:8 %s -o - | FileCheck -check-prefix=CHECK-CC5 %s
151 this->o1;
152 // CHECK-CC6: [#void#]function()
153 // CHECK-CC6: o1 : [#BaseTemplate<int>#]o1
154 // CHECK-CC6: o2 : [#BaseTemplate<T>#]o2
155 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:151:11 %s -o - | FileCheck -check-prefix=CHECK-CC6 %s
156 }
157
158 static void staticFn(T &obj);
159
160 struct Nested { };
161 };
162
163 template<typename T>
dependentColonColonCompletion()164 void dependentColonColonCompletion() {
165 Template<T>::staticFn();
166 // CHECK-CC7: function : [#void#]function()
167 // CHECK-CC7: Nested : Nested
168 // CHECK-CC7: o1 : [#BaseTemplate<int>#]o1
169 // CHECK-CC7: o2 : [#BaseTemplate<T>#]o2
170 // CHECK-CC7: staticFn : [#void#]staticFn(<#T &obj#>)
171 // CHECK-CC7: Template : Template
172 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:165:16 %s -o - | FileCheck -check-prefix=CHECK-CC7 %s
173 typename Template<T>::Nested m;
174 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:173:25 %s -o - | FileCheck -check-prefix=CHECK-CC7 %s
175 }
176
177 class Proxy2 {
178 public:
179 Derived *operator->() const;
180 int member5;
181 };
182
test2(const Proxy2 & p)183 void test2(const Proxy2 &p) {
184 p->
185 }
186
test3(const Proxy2 & p)187 void test3(const Proxy2 &p) {
188 p.
189 }
190
191 // RUN: %clang_cc1 -fsyntax-only -code-completion-with-fixits -code-completion-at=%s:184:6 %s -o - | FileCheck -check-prefix=CHECK-CC8 --implicit-check-not="Derived : Derived(" %s
192 // CHECK-CC8: Base1 (InBase) : Base1::
193 // CHECK-CC8: member1 (InBase) : [#int#][#Base1::#]member1
194 // CHECK-CC8: member1 (InBase) : [#int#][#Base2::#]member1
195 // CHECK-CC8: member2 (InBase) : [#float#][#Base1::#]member2
196 // CHECK-CC8: member3 (InBase) : [#double#][#Base2::#]member3
197 // CHECK-CC8: member4 : [#int#]member4
198 // CHECK-CC8: member5 : [#int#]member5 (requires fix-it: {184:4-184:6} to ".")
199 // CHECK-CC8: memfun1 (InBase) : [#void#][#Base3::#]memfun1(<#float#>)
200 // CHECK-CC8: memfun1 (InBase) : [#void#][#Base3::#]memfun1(<#double#>)[# const#]
201 // CHECK-CC8: memfun1 (Hidden,InBase) : [#void#]Base2::memfun1(<#int#>)
202 // CHECK-CC8: memfun2 (InBase) : [#void#][#Base3::#]memfun2(<#int#>)
203 // CHECK-CC8: memfun3 : [#int#]memfun3(<#int#>)
204 // CHECK-CC8: operator-> : [#Derived *#]operator->()[# const#] (requires fix-it: {184:4-184:6} to ".")
205
206 // RUN: %clang_cc1 -fsyntax-only -code-completion-with-fixits -code-completion-at=%s:188:6 %s -o - | FileCheck -check-prefix=CHECK-CC9 --implicit-check-not="Derived : Derived(" %s
207 // CHECK-CC9: Base1 (InBase) : Base1::
208 // CHECK-CC9: member1 (InBase) : [#int#][#Base1::#]member1 (requires fix-it: {188:4-188:5} to "->")
209 // CHECK-CC9: member1 (InBase) : [#int#][#Base2::#]member1 (requires fix-it: {188:4-188:5} to "->")
210 // CHECK-CC9: member2 (InBase) : [#float#][#Base1::#]member2 (requires fix-it: {188:4-188:5} to "->")
211 // CHECK-CC9: member3 (InBase) : [#double#][#Base2::#]member3 (requires fix-it: {188:4-188:5} to "->")
212 // CHECK-CC9: member4 : [#int#]member4 (requires fix-it: {188:4-188:5} to "->")
213 // CHECK-CC9: member5 : [#int#]member5
214 // CHECK-CC9: memfun1 (InBase) : [#void#][#Base3::#]memfun1(<#float#>) (requires fix-it: {188:4-188:5} to "->")
215 // CHECK-CC9: memfun1 (InBase) : [#void#][#Base3::#]memfun1(<#double#>)[# const#] (requires fix-it: {188:4-188:5} to "->")
216 // CHECK-CC9: memfun1 (Hidden,InBase) : [#void#]Base2::memfun1(<#int#>) (requires fix-it: {188:4-188:5} to "->")
217 // CHECK-CC9: memfun2 (InBase) : [#void#][#Base3::#]memfun2(<#int#>) (requires fix-it: {188:4-188:5} to "->")
218 // CHECK-CC9: memfun3 : [#int#]memfun3(<#int#>) (requires fix-it: {188:4-188:5} to "->")
219 // CHECK-CC9: operator-> : [#Derived *#]operator->()[# const#]
220
221 // These overload sets differ only by return type and this-qualifiers.
222 // So for any given callsite, only one is available.
223 struct Overloads {
224 double ConstOverload(char);
225 int ConstOverload(char) const;
226
227 int RefOverload(char) &;
228 double RefOverload(char) const&;
229 char RefOverload(char) &&;
230 };
testLValue(Overloads & Ref)231 void testLValue(Overloads& Ref) {
232 Ref.
233 }
testConstLValue(const Overloads & ConstRef)234 void testConstLValue(const Overloads& ConstRef) {
235 ConstRef.
236 }
testRValue()237 void testRValue() {
238 Overloads().
239 }
testXValue(Overloads & X)240 void testXValue(Overloads& X) {
241 static_cast<Overloads&&>(X).
242 }
243
244 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:232:7 %s -o - | FileCheck -check-prefix=CHECK-LVALUE %s \
245 // RUN: --implicit-check-not="[#int#]ConstOverload(" \
246 // RUN: --implicit-check-not="[#double#]RefOverload(" \
247 // RUN: --implicit-check-not="[#char#]RefOverload("
248 // CHECK-LVALUE-DAG: [#double#]ConstOverload(
249 // CHECK-LVALUE-DAG: [#int#]RefOverload(
250
251 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:235:12 %s -o - | FileCheck -check-prefix=CHECK-CONSTLVALUE %s \
252 // RUN: --implicit-check-not="[#double#]ConstOverload(" \
253 // RUN: --implicit-check-not="[#int#]RefOverload(" \
254 // RUN: --implicit-check-not="[#char#]RefOverload("
255 // CHECK-CONSTLVALUE: [#int#]ConstOverload(
256 // CHECK-CONSTLVALUE: [#double#]RefOverload(
257
258 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:238:15 %s -o - | FileCheck -check-prefix=CHECK-PRVALUE %s \
259 // RUN: --implicit-check-not="[#int#]ConstOverload(" \
260 // RUN: --implicit-check-not="[#int#]RefOverload(" \
261 // RUN: --implicit-check-not="[#double#]RefOverload("
262 // CHECK-PRVALUE: [#double#]ConstOverload(
263 // CHECK-PRVALUE: [#char#]RefOverload(
264
265 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:241:31 %s -o - | FileCheck -check-prefix=CHECK-XVALUE %s \
266 // RUN: --implicit-check-not="[#int#]ConstOverload(" \
267 // RUN: --implicit-check-not="[#int#]RefOverload(" \
268 // RUN: --implicit-check-not="[#double#]RefOverload("
269 // CHECK-XVALUE: [#double#]ConstOverload(
270 // CHECK-XVALUE: [#char#]RefOverload(
271
testOverloadOperator()272 void testOverloadOperator() {
273 struct S {
274 char operator=(int) const;
275 int operator=(int);
276 } s;
277 return s.
278 }
279 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:277:12 %s -o - | FileCheck -check-prefix=CHECK-OPER %s \
280 // RUN: --implicit-check-not="[#char#]operator=("
281 // CHECK-OPER: [#int#]operator=(
282
283 struct S { int member; };
284 S overloaded(int);
285 S overloaded(double);
foo()286 void foo() {
287 // No overload matches, but we have recovery-expr with the correct type.
288 overloaded().
289 }
290 // RUN: not %clang_cc1 -fsyntax-only -frecovery-ast -frecovery-ast-type -code-completion-at=%s:288:16 %s -o - | FileCheck -check-prefix=CHECK-RECOVERY %s
291 // CHECK-RECOVERY: [#int#]member
292 template <typename T>
fooDependent(T t)293 void fooDependent(T t) {
294 // Overload not resolved, but we notice all candidates return the same type.
295 overloaded(t).
296 }
297 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:295:17 %s -o - | FileCheck -check-prefix=CHECK-OVERLOAD %s
298 // CHECK-OVERLOAD: [#int#]member
299
300 struct Base4 {
301 Base4 base4();
302 };
303
304 template <typename T>
305 struct Derived2 : Base4 {};
306
307 template <typename T>
testMembersFromBasesInDependentContext()308 void testMembersFromBasesInDependentContext() {
309 Derived2<T> X;
310 (void)X.base4().base4();
311 // RUN: %clang_cc1 -fsyntax-only -code-completion-at=%s:310:19 %s -o - | FileCheck -check-prefix=CHECK-MEMBERS-FROM-BASE-DEPENDENT %s
312 // CHECK-MEMBERS-FROM-BASE-DEPENDENT: [#Base4#]base4
313 }
314