File: | clang/lib/Sema/SemaExprMember.cpp |
Warning: | line 416, column 44 Called C++ object pointer is null |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | //===--- SemaExprMember.cpp - Semantic Analysis for Expressions -----------===// | |||
2 | // | |||
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |||
4 | // See https://llvm.org/LICENSE.txt for license information. | |||
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |||
6 | // | |||
7 | //===----------------------------------------------------------------------===// | |||
8 | // | |||
9 | // This file implements semantic analysis member access expressions. | |||
10 | // | |||
11 | //===----------------------------------------------------------------------===// | |||
12 | #include "clang/Sema/Overload.h" | |||
13 | #include "clang/AST/ASTLambda.h" | |||
14 | #include "clang/AST/DeclCXX.h" | |||
15 | #include "clang/AST/DeclObjC.h" | |||
16 | #include "clang/AST/DeclTemplate.h" | |||
17 | #include "clang/AST/ExprCXX.h" | |||
18 | #include "clang/AST/ExprObjC.h" | |||
19 | #include "clang/Lex/Preprocessor.h" | |||
20 | #include "clang/Sema/Lookup.h" | |||
21 | #include "clang/Sema/Scope.h" | |||
22 | #include "clang/Sema/ScopeInfo.h" | |||
23 | #include "clang/Sema/SemaInternal.h" | |||
24 | ||||
25 | using namespace clang; | |||
26 | using namespace sema; | |||
27 | ||||
28 | typedef llvm::SmallPtrSet<const CXXRecordDecl*, 4> BaseSet; | |||
29 | ||||
30 | /// Determines if the given class is provably not derived from all of | |||
31 | /// the prospective base classes. | |||
32 | static bool isProvablyNotDerivedFrom(Sema &SemaRef, CXXRecordDecl *Record, | |||
33 | const BaseSet &Bases) { | |||
34 | auto BaseIsNotInSet = [&Bases](const CXXRecordDecl *Base) { | |||
35 | return !Bases.count(Base->getCanonicalDecl()); | |||
36 | }; | |||
37 | return BaseIsNotInSet(Record) && Record->forallBases(BaseIsNotInSet); | |||
38 | } | |||
39 | ||||
40 | enum IMAKind { | |||
41 | /// The reference is definitely not an instance member access. | |||
42 | IMA_Static, | |||
43 | ||||
44 | /// The reference may be an implicit instance member access. | |||
45 | IMA_Mixed, | |||
46 | ||||
47 | /// The reference may be to an instance member, but it might be invalid if | |||
48 | /// so, because the context is not an instance method. | |||
49 | IMA_Mixed_StaticContext, | |||
50 | ||||
51 | /// The reference may be to an instance member, but it is invalid if | |||
52 | /// so, because the context is from an unrelated class. | |||
53 | IMA_Mixed_Unrelated, | |||
54 | ||||
55 | /// The reference is definitely an implicit instance member access. | |||
56 | IMA_Instance, | |||
57 | ||||
58 | /// The reference may be to an unresolved using declaration. | |||
59 | IMA_Unresolved, | |||
60 | ||||
61 | /// The reference is a contextually-permitted abstract member reference. | |||
62 | IMA_Abstract, | |||
63 | ||||
64 | /// The reference may be to an unresolved using declaration and the | |||
65 | /// context is not an instance method. | |||
66 | IMA_Unresolved_StaticContext, | |||
67 | ||||
68 | // The reference refers to a field which is not a member of the containing | |||
69 | // class, which is allowed because we're in C++11 mode and the context is | |||
70 | // unevaluated. | |||
71 | IMA_Field_Uneval_Context, | |||
72 | ||||
73 | /// All possible referrents are instance members and the current | |||
74 | /// context is not an instance method. | |||
75 | IMA_Error_StaticContext, | |||
76 | ||||
77 | /// All possible referrents are instance members of an unrelated | |||
78 | /// class. | |||
79 | IMA_Error_Unrelated | |||
80 | }; | |||
81 | ||||
82 | /// The given lookup names class member(s) and is not being used for | |||
83 | /// an address-of-member expression. Classify the type of access | |||
84 | /// according to whether it's possible that this reference names an | |||
85 | /// instance member. This is best-effort in dependent contexts; it is okay to | |||
86 | /// conservatively answer "yes", in which case some errors will simply | |||
87 | /// not be caught until template-instantiation. | |||
88 | static IMAKind ClassifyImplicitMemberAccess(Sema &SemaRef, | |||
89 | const LookupResult &R) { | |||
90 | assert(!R.empty() && (*R.begin())->isCXXClassMember())((!R.empty() && (*R.begin())->isCXXClassMember()) ? static_cast<void> (0) : __assert_fail ("!R.empty() && (*R.begin())->isCXXClassMember()" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp" , 90, __PRETTY_FUNCTION__)); | |||
91 | ||||
92 | DeclContext *DC = SemaRef.getFunctionLevelDeclContext(); | |||
93 | ||||
94 | bool isStaticContext = SemaRef.CXXThisTypeOverride.isNull() && | |||
95 | (!isa<CXXMethodDecl>(DC) || cast<CXXMethodDecl>(DC)->isStatic()); | |||
96 | ||||
97 | if (R.isUnresolvableResult()) | |||
98 | return isStaticContext ? IMA_Unresolved_StaticContext : IMA_Unresolved; | |||
99 | ||||
100 | // Collect all the declaring classes of instance members we find. | |||
101 | bool hasNonInstance = false; | |||
102 | bool isField = false; | |||
103 | BaseSet Classes; | |||
104 | for (NamedDecl *D : R) { | |||
105 | // Look through any using decls. | |||
106 | D = D->getUnderlyingDecl(); | |||
107 | ||||
108 | if (D->isCXXInstanceMember()) { | |||
109 | isField |= isa<FieldDecl>(D) || isa<MSPropertyDecl>(D) || | |||
110 | isa<IndirectFieldDecl>(D); | |||
111 | ||||
112 | CXXRecordDecl *R = cast<CXXRecordDecl>(D->getDeclContext()); | |||
113 | Classes.insert(R->getCanonicalDecl()); | |||
114 | } else | |||
115 | hasNonInstance = true; | |||
116 | } | |||
117 | ||||
118 | // If we didn't find any instance members, it can't be an implicit | |||
119 | // member reference. | |||
120 | if (Classes.empty()) | |||
121 | return IMA_Static; | |||
122 | ||||
123 | // C++11 [expr.prim.general]p12: | |||
124 | // An id-expression that denotes a non-static data member or non-static | |||
125 | // member function of a class can only be used: | |||
126 | // (...) | |||
127 | // - if that id-expression denotes a non-static data member and it | |||
128 | // appears in an unevaluated operand. | |||
129 | // | |||
130 | // This rule is specific to C++11. However, we also permit this form | |||
131 | // in unevaluated inline assembly operands, like the operand to a SIZE. | |||
132 | IMAKind AbstractInstanceResult = IMA_Static; // happens to be 'false' | |||
133 | assert(!AbstractInstanceResult)((!AbstractInstanceResult) ? static_cast<void> (0) : __assert_fail ("!AbstractInstanceResult", "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp" , 133, __PRETTY_FUNCTION__)); | |||
134 | switch (SemaRef.ExprEvalContexts.back().Context) { | |||
135 | case Sema::ExpressionEvaluationContext::Unevaluated: | |||
136 | case Sema::ExpressionEvaluationContext::UnevaluatedList: | |||
137 | if (isField && SemaRef.getLangOpts().CPlusPlus11) | |||
138 | AbstractInstanceResult = IMA_Field_Uneval_Context; | |||
139 | break; | |||
140 | ||||
141 | case Sema::ExpressionEvaluationContext::UnevaluatedAbstract: | |||
142 | AbstractInstanceResult = IMA_Abstract; | |||
143 | break; | |||
144 | ||||
145 | case Sema::ExpressionEvaluationContext::DiscardedStatement: | |||
146 | case Sema::ExpressionEvaluationContext::ConstantEvaluated: | |||
147 | case Sema::ExpressionEvaluationContext::PotentiallyEvaluated: | |||
148 | case Sema::ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed: | |||
149 | break; | |||
150 | } | |||
151 | ||||
152 | // If the current context is not an instance method, it can't be | |||
153 | // an implicit member reference. | |||
154 | if (isStaticContext) { | |||
155 | if (hasNonInstance) | |||
156 | return IMA_Mixed_StaticContext; | |||
157 | ||||
158 | return AbstractInstanceResult ? AbstractInstanceResult | |||
159 | : IMA_Error_StaticContext; | |||
160 | } | |||
161 | ||||
162 | CXXRecordDecl *contextClass; | |||
163 | if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(DC)) | |||
164 | contextClass = MD->getParent()->getCanonicalDecl(); | |||
165 | else | |||
166 | contextClass = cast<CXXRecordDecl>(DC); | |||
167 | ||||
168 | // [class.mfct.non-static]p3: | |||
169 | // ...is used in the body of a non-static member function of class X, | |||
170 | // if name lookup (3.4.1) resolves the name in the id-expression to a | |||
171 | // non-static non-type member of some class C [...] | |||
172 | // ...if C is not X or a base class of X, the class member access expression | |||
173 | // is ill-formed. | |||
174 | if (R.getNamingClass() && | |||
175 | contextClass->getCanonicalDecl() != | |||
176 | R.getNamingClass()->getCanonicalDecl()) { | |||
177 | // If the naming class is not the current context, this was a qualified | |||
178 | // member name lookup, and it's sufficient to check that we have the naming | |||
179 | // class as a base class. | |||
180 | Classes.clear(); | |||
181 | Classes.insert(R.getNamingClass()->getCanonicalDecl()); | |||
182 | } | |||
183 | ||||
184 | // If we can prove that the current context is unrelated to all the | |||
185 | // declaring classes, it can't be an implicit member reference (in | |||
186 | // which case it's an error if any of those members are selected). | |||
187 | if (isProvablyNotDerivedFrom(SemaRef, contextClass, Classes)) | |||
188 | return hasNonInstance ? IMA_Mixed_Unrelated : | |||
189 | AbstractInstanceResult ? AbstractInstanceResult : | |||
190 | IMA_Error_Unrelated; | |||
191 | ||||
192 | return (hasNonInstance ? IMA_Mixed : IMA_Instance); | |||
193 | } | |||
194 | ||||
195 | /// Diagnose a reference to a field with no object available. | |||
196 | static void diagnoseInstanceReference(Sema &SemaRef, | |||
197 | const CXXScopeSpec &SS, | |||
198 | NamedDecl *Rep, | |||
199 | const DeclarationNameInfo &nameInfo) { | |||
200 | SourceLocation Loc = nameInfo.getLoc(); | |||
201 | SourceRange Range(Loc); | |||
202 | if (SS.isSet()) Range.setBegin(SS.getRange().getBegin()); | |||
203 | ||||
204 | // Look through using shadow decls and aliases. | |||
205 | Rep = Rep->getUnderlyingDecl(); | |||
206 | ||||
207 | DeclContext *FunctionLevelDC = SemaRef.getFunctionLevelDeclContext(); | |||
208 | CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FunctionLevelDC); | |||
209 | CXXRecordDecl *ContextClass = Method ? Method->getParent() : nullptr; | |||
210 | CXXRecordDecl *RepClass = dyn_cast<CXXRecordDecl>(Rep->getDeclContext()); | |||
211 | ||||
212 | bool InStaticMethod = Method && Method->isStatic(); | |||
213 | bool IsField = isa<FieldDecl>(Rep) || isa<IndirectFieldDecl>(Rep); | |||
214 | ||||
215 | if (IsField && InStaticMethod) | |||
216 | // "invalid use of member 'x' in static member function" | |||
217 | SemaRef.Diag(Loc, diag::err_invalid_member_use_in_static_method) | |||
218 | << Range << nameInfo.getName(); | |||
219 | else if (ContextClass && RepClass && SS.isEmpty() && !InStaticMethod && | |||
220 | !RepClass->Equals(ContextClass) && RepClass->Encloses(ContextClass)) | |||
221 | // Unqualified lookup in a non-static member function found a member of an | |||
222 | // enclosing class. | |||
223 | SemaRef.Diag(Loc, diag::err_nested_non_static_member_use) | |||
224 | << IsField << RepClass << nameInfo.getName() << ContextClass << Range; | |||
225 | else if (IsField) | |||
226 | SemaRef.Diag(Loc, diag::err_invalid_non_static_member_use) | |||
227 | << nameInfo.getName() << Range; | |||
228 | else | |||
229 | SemaRef.Diag(Loc, diag::err_member_call_without_object) | |||
230 | << Range; | |||
231 | } | |||
232 | ||||
233 | /// Builds an expression which might be an implicit member expression. | |||
234 | ExprResult | |||
235 | Sema::BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS, | |||
236 | SourceLocation TemplateKWLoc, | |||
237 | LookupResult &R, | |||
238 | const TemplateArgumentListInfo *TemplateArgs, | |||
239 | const Scope *S) { | |||
240 | switch (ClassifyImplicitMemberAccess(*this, R)) { | |||
241 | case IMA_Instance: | |||
242 | return BuildImplicitMemberExpr(SS, TemplateKWLoc, R, TemplateArgs, true, S); | |||
243 | ||||
244 | case IMA_Mixed: | |||
245 | case IMA_Mixed_Unrelated: | |||
246 | case IMA_Unresolved: | |||
247 | return BuildImplicitMemberExpr(SS, TemplateKWLoc, R, TemplateArgs, false, | |||
248 | S); | |||
249 | ||||
250 | case IMA_Field_Uneval_Context: | |||
251 | Diag(R.getNameLoc(), diag::warn_cxx98_compat_non_static_member_use) | |||
252 | << R.getLookupNameInfo().getName(); | |||
253 | LLVM_FALLTHROUGH[[gnu::fallthrough]]; | |||
254 | case IMA_Static: | |||
255 | case IMA_Abstract: | |||
256 | case IMA_Mixed_StaticContext: | |||
257 | case IMA_Unresolved_StaticContext: | |||
258 | if (TemplateArgs || TemplateKWLoc.isValid()) | |||
259 | return BuildTemplateIdExpr(SS, TemplateKWLoc, R, false, TemplateArgs); | |||
260 | return BuildDeclarationNameExpr(SS, R, false); | |||
261 | ||||
262 | case IMA_Error_StaticContext: | |||
263 | case IMA_Error_Unrelated: | |||
264 | diagnoseInstanceReference(*this, SS, R.getRepresentativeDecl(), | |||
265 | R.getLookupNameInfo()); | |||
266 | return ExprError(); | |||
267 | } | |||
268 | ||||
269 | llvm_unreachable("unexpected instance member access kind")::llvm::llvm_unreachable_internal("unexpected instance member access kind" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp" , 269); | |||
270 | } | |||
271 | ||||
272 | /// Determine whether input char is from rgba component set. | |||
273 | static bool | |||
274 | IsRGBA(char c) { | |||
275 | switch (c) { | |||
276 | case 'r': | |||
277 | case 'g': | |||
278 | case 'b': | |||
279 | case 'a': | |||
280 | return true; | |||
281 | default: | |||
282 | return false; | |||
283 | } | |||
284 | } | |||
285 | ||||
286 | // OpenCL v1.1, s6.1.7 | |||
287 | // The component swizzle length must be in accordance with the acceptable | |||
288 | // vector sizes. | |||
289 | static bool IsValidOpenCLComponentSwizzleLength(unsigned len) | |||
290 | { | |||
291 | return (len >= 1 && len <= 4) || len == 8 || len == 16; | |||
292 | } | |||
293 | ||||
294 | /// Check an ext-vector component access expression. | |||
295 | /// | |||
296 | /// VK should be set in advance to the value kind of the base | |||
297 | /// expression. | |||
298 | static QualType | |||
299 | CheckExtVectorComponent(Sema &S, QualType baseType, ExprValueKind &VK, | |||
300 | SourceLocation OpLoc, const IdentifierInfo *CompName, | |||
301 | SourceLocation CompLoc) { | |||
302 | // FIXME: Share logic with ExtVectorElementExpr::containsDuplicateElements, | |||
303 | // see FIXME there. | |||
304 | // | |||
305 | // FIXME: This logic can be greatly simplified by splitting it along | |||
306 | // halving/not halving and reworking the component checking. | |||
307 | const ExtVectorType *vecType = baseType->getAs<ExtVectorType>(); | |||
308 | ||||
309 | // The vector accessor can't exceed the number of elements. | |||
310 | const char *compStr = CompName->getNameStart(); | |||
311 | ||||
312 | // This flag determines whether or not the component is one of the four | |||
313 | // special names that indicate a subset of exactly half the elements are | |||
314 | // to be selected. | |||
315 | bool HalvingSwizzle = false; | |||
316 | ||||
317 | // This flag determines whether or not CompName has an 's' char prefix, | |||
318 | // indicating that it is a string of hex values to be used as vector indices. | |||
319 | bool HexSwizzle = (*compStr == 's' || *compStr == 'S') && compStr[1]; | |||
320 | ||||
321 | bool HasRepeated = false; | |||
322 | bool HasIndex[16] = {}; | |||
323 | ||||
324 | int Idx; | |||
325 | ||||
326 | // Check that we've found one of the special components, or that the component | |||
327 | // names must come from the same set. | |||
328 | if (!strcmp(compStr, "hi") || !strcmp(compStr, "lo") || | |||
329 | !strcmp(compStr, "even") || !strcmp(compStr, "odd")) { | |||
330 | HalvingSwizzle = true; | |||
331 | } else if (!HexSwizzle
| |||
332 | (Idx = vecType->getPointAccessorIdx(*compStr)) != -1) { | |||
333 | bool HasRGBA = IsRGBA(*compStr); | |||
334 | do { | |||
335 | // Ensure that xyzw and rgba components don't intermingle. | |||
336 | if (HasRGBA != IsRGBA(*compStr)) | |||
337 | break; | |||
338 | if (HasIndex[Idx]) HasRepeated = true; | |||
339 | HasIndex[Idx] = true; | |||
340 | compStr++; | |||
341 | } while (*compStr && (Idx = vecType->getPointAccessorIdx(*compStr)) != -1); | |||
342 | ||||
343 | // Emit a warning if an rgba selector is used earlier than OpenCL 2.2 | |||
344 | if (HasRGBA || (*compStr && IsRGBA(*compStr))) { | |||
345 | if (S.getLangOpts().OpenCL && S.getLangOpts().OpenCLVersion < 220) { | |||
346 | const char *DiagBegin = HasRGBA ? CompName->getNameStart() : compStr; | |||
347 | S.Diag(OpLoc, diag::ext_opencl_ext_vector_type_rgba_selector) | |||
348 | << StringRef(DiagBegin, 1) | |||
349 | << S.getLangOpts().OpenCLVersion << SourceRange(CompLoc); | |||
350 | } | |||
351 | } | |||
352 | } else { | |||
353 | if (HexSwizzle
| |||
354 | while ((Idx = vecType->getNumericAccessorIdx(*compStr)) != -1) { | |||
355 | if (HasIndex[Idx]) HasRepeated = true; | |||
356 | HasIndex[Idx] = true; | |||
357 | compStr++; | |||
358 | } | |||
359 | } | |||
360 | ||||
361 | if (!HalvingSwizzle
| |||
362 | // We didn't get to the end of the string. This means the component names | |||
363 | // didn't come from the same set *or* we encountered an illegal name. | |||
364 | S.Diag(OpLoc, diag::err_ext_vector_component_name_illegal) | |||
365 | << StringRef(compStr, 1) << SourceRange(CompLoc); | |||
366 | return QualType(); | |||
367 | } | |||
368 | ||||
369 | // Ensure no component accessor exceeds the width of the vector type it | |||
370 | // operates on. | |||
371 | if (!HalvingSwizzle
| |||
372 | compStr = CompName->getNameStart(); | |||
373 | ||||
374 | if (HexSwizzle
| |||
375 | compStr++; | |||
376 | ||||
377 | while (*compStr) { | |||
378 | if (!vecType->isAccessorWithinNumElements(*compStr++, HexSwizzle)) { | |||
379 | S.Diag(OpLoc, diag::err_ext_vector_component_exceeds_length) | |||
380 | << baseType << SourceRange(CompLoc); | |||
381 | return QualType(); | |||
382 | } | |||
383 | } | |||
384 | } | |||
385 | ||||
386 | // OpenCL mode requires swizzle length to be in accordance with accepted | |||
387 | // sizes. Clang however supports arbitrary lengths for other languages. | |||
388 | if (S.getLangOpts().OpenCL && !HalvingSwizzle) { | |||
389 | unsigned SwizzleLength = CompName->getLength(); | |||
390 | ||||
391 | if (HexSwizzle) | |||
392 | SwizzleLength--; | |||
393 | ||||
394 | if (IsValidOpenCLComponentSwizzleLength(SwizzleLength) == false) { | |||
395 | S.Diag(OpLoc, diag::err_opencl_ext_vector_component_invalid_length) | |||
396 | << SwizzleLength << SourceRange(CompLoc); | |||
397 | return QualType(); | |||
398 | } | |||
399 | } | |||
400 | ||||
401 | // The component accessor looks fine - now we need to compute the actual type. | |||
402 | // The vector type is implied by the component accessor. For example, | |||
403 | // vec4.b is a float, vec4.xy is a vec2, vec4.rgb is a vec3, etc. | |||
404 | // vec4.s0 is a float, vec4.s23 is a vec3, etc. | |||
405 | // vec4.hi, vec4.lo, vec4.e, and vec4.o all return vec2. | |||
406 | unsigned CompSize = HalvingSwizzle
| |||
407 | : CompName->getLength(); | |||
408 | if (HexSwizzle
| |||
409 | CompSize--; | |||
410 | ||||
411 | if (CompSize == 1) | |||
412 | return vecType->getElementType(); | |||
413 | ||||
414 | if (HasRepeated
| |||
415 | ||||
416 | QualType VT = S.Context.getExtVectorType(vecType->getElementType(), CompSize); | |||
| ||||
417 | // Now look up the TypeDefDecl from the vector type. Without this, | |||
418 | // diagostics look bad. We want extended vector types to appear built-in. | |||
419 | for (Sema::ExtVectorDeclsType::iterator | |||
420 | I = S.ExtVectorDecls.begin(S.getExternalSource()), | |||
421 | E = S.ExtVectorDecls.end(); | |||
422 | I != E; ++I) { | |||
423 | if ((*I)->getUnderlyingType() == VT) | |||
424 | return S.Context.getTypedefType(*I); | |||
425 | } | |||
426 | ||||
427 | return VT; // should never get here (a typedef type should always be found). | |||
428 | } | |||
429 | ||||
430 | static Decl *FindGetterSetterNameDeclFromProtocolList(const ObjCProtocolDecl*PDecl, | |||
431 | IdentifierInfo *Member, | |||
432 | const Selector &Sel, | |||
433 | ASTContext &Context) { | |||
434 | if (Member) | |||
435 | if (ObjCPropertyDecl *PD = PDecl->FindPropertyDeclaration( | |||
436 | Member, ObjCPropertyQueryKind::OBJC_PR_query_instance)) | |||
437 | return PD; | |||
438 | if (ObjCMethodDecl *OMD = PDecl->getInstanceMethod(Sel)) | |||
439 | return OMD; | |||
440 | ||||
441 | for (const auto *I : PDecl->protocols()) { | |||
442 | if (Decl *D = FindGetterSetterNameDeclFromProtocolList(I, Member, Sel, | |||
443 | Context)) | |||
444 | return D; | |||
445 | } | |||
446 | return nullptr; | |||
447 | } | |||
448 | ||||
449 | static Decl *FindGetterSetterNameDecl(const ObjCObjectPointerType *QIdTy, | |||
450 | IdentifierInfo *Member, | |||
451 | const Selector &Sel, | |||
452 | ASTContext &Context) { | |||
453 | // Check protocols on qualified interfaces. | |||
454 | Decl *GDecl = nullptr; | |||
455 | for (const auto *I : QIdTy->quals()) { | |||
456 | if (Member) | |||
457 | if (ObjCPropertyDecl *PD = I->FindPropertyDeclaration( | |||
458 | Member, ObjCPropertyQueryKind::OBJC_PR_query_instance)) { | |||
459 | GDecl = PD; | |||
460 | break; | |||
461 | } | |||
462 | // Also must look for a getter or setter name which uses property syntax. | |||
463 | if (ObjCMethodDecl *OMD = I->getInstanceMethod(Sel)) { | |||
464 | GDecl = OMD; | |||
465 | break; | |||
466 | } | |||
467 | } | |||
468 | if (!GDecl) { | |||
469 | for (const auto *I : QIdTy->quals()) { | |||
470 | // Search in the protocol-qualifier list of current protocol. | |||
471 | GDecl = FindGetterSetterNameDeclFromProtocolList(I, Member, Sel, Context); | |||
472 | if (GDecl) | |||
473 | return GDecl; | |||
474 | } | |||
475 | } | |||
476 | return GDecl; | |||
477 | } | |||
478 | ||||
479 | ExprResult | |||
480 | Sema::ActOnDependentMemberExpr(Expr *BaseExpr, QualType BaseType, | |||
481 | bool IsArrow, SourceLocation OpLoc, | |||
482 | const CXXScopeSpec &SS, | |||
483 | SourceLocation TemplateKWLoc, | |||
484 | NamedDecl *FirstQualifierInScope, | |||
485 | const DeclarationNameInfo &NameInfo, | |||
486 | const TemplateArgumentListInfo *TemplateArgs) { | |||
487 | // Even in dependent contexts, try to diagnose base expressions with | |||
488 | // obviously wrong types, e.g.: | |||
489 | // | |||
490 | // T* t; | |||
491 | // t.f; | |||
492 | // | |||
493 | // In Obj-C++, however, the above expression is valid, since it could be | |||
494 | // accessing the 'f' property if T is an Obj-C interface. The extra check | |||
495 | // allows this, while still reporting an error if T is a struct pointer. | |||
496 | if (!IsArrow) { | |||
497 | const PointerType *PT = BaseType->getAs<PointerType>(); | |||
498 | if (PT && (!getLangOpts().ObjC || | |||
499 | PT->getPointeeType()->isRecordType())) { | |||
500 | assert(BaseExpr && "cannot happen with implicit member accesses")((BaseExpr && "cannot happen with implicit member accesses" ) ? static_cast<void> (0) : __assert_fail ("BaseExpr && \"cannot happen with implicit member accesses\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp" , 500, __PRETTY_FUNCTION__)); | |||
501 | Diag(OpLoc, diag::err_typecheck_member_reference_struct_union) | |||
502 | << BaseType << BaseExpr->getSourceRange() << NameInfo.getSourceRange(); | |||
503 | return ExprError(); | |||
504 | } | |||
505 | } | |||
506 | ||||
507 | assert(BaseType->isDependentType() ||((BaseType->isDependentType() || NameInfo.getName().isDependentName () || isDependentScopeSpecifier(SS)) ? static_cast<void> (0) : __assert_fail ("BaseType->isDependentType() || NameInfo.getName().isDependentName() || isDependentScopeSpecifier(SS)" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp" , 509, __PRETTY_FUNCTION__)) | |||
508 | NameInfo.getName().isDependentName() ||((BaseType->isDependentType() || NameInfo.getName().isDependentName () || isDependentScopeSpecifier(SS)) ? static_cast<void> (0) : __assert_fail ("BaseType->isDependentType() || NameInfo.getName().isDependentName() || isDependentScopeSpecifier(SS)" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp" , 509, __PRETTY_FUNCTION__)) | |||
509 | isDependentScopeSpecifier(SS))((BaseType->isDependentType() || NameInfo.getName().isDependentName () || isDependentScopeSpecifier(SS)) ? static_cast<void> (0) : __assert_fail ("BaseType->isDependentType() || NameInfo.getName().isDependentName() || isDependentScopeSpecifier(SS)" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp" , 509, __PRETTY_FUNCTION__)); | |||
510 | ||||
511 | // Get the type being accessed in BaseType. If this is an arrow, the BaseExpr | |||
512 | // must have pointer type, and the accessed type is the pointee. | |||
513 | return CXXDependentScopeMemberExpr::Create( | |||
514 | Context, BaseExpr, BaseType, IsArrow, OpLoc, | |||
515 | SS.getWithLocInContext(Context), TemplateKWLoc, FirstQualifierInScope, | |||
516 | NameInfo, TemplateArgs); | |||
517 | } | |||
518 | ||||
519 | /// We know that the given qualified member reference points only to | |||
520 | /// declarations which do not belong to the static type of the base | |||
521 | /// expression. Diagnose the problem. | |||
522 | static void DiagnoseQualifiedMemberReference(Sema &SemaRef, | |||
523 | Expr *BaseExpr, | |||
524 | QualType BaseType, | |||
525 | const CXXScopeSpec &SS, | |||
526 | NamedDecl *rep, | |||
527 | const DeclarationNameInfo &nameInfo) { | |||
528 | // If this is an implicit member access, use a different set of | |||
529 | // diagnostics. | |||
530 | if (!BaseExpr) | |||
531 | return diagnoseInstanceReference(SemaRef, SS, rep, nameInfo); | |||
532 | ||||
533 | SemaRef.Diag(nameInfo.getLoc(), diag::err_qualified_member_of_unrelated) | |||
534 | << SS.getRange() << rep << BaseType; | |||
535 | } | |||
536 | ||||
537 | // Check whether the declarations we found through a nested-name | |||
538 | // specifier in a member expression are actually members of the base | |||
539 | // type. The restriction here is: | |||
540 | // | |||
541 | // C++ [expr.ref]p2: | |||
542 | // ... In these cases, the id-expression shall name a | |||
543 | // member of the class or of one of its base classes. | |||
544 | // | |||
545 | // So it's perfectly legitimate for the nested-name specifier to name | |||
546 | // an unrelated class, and for us to find an overload set including | |||
547 | // decls from classes which are not superclasses, as long as the decl | |||
548 | // we actually pick through overload resolution is from a superclass. | |||
549 | bool Sema::CheckQualifiedMemberReference(Expr *BaseExpr, | |||
550 | QualType BaseType, | |||
551 | const CXXScopeSpec &SS, | |||
552 | const LookupResult &R) { | |||
553 | CXXRecordDecl *BaseRecord = | |||
554 | cast_or_null<CXXRecordDecl>(computeDeclContext(BaseType)); | |||
555 | if (!BaseRecord) { | |||
556 | // We can't check this yet because the base type is still | |||
557 | // dependent. | |||
558 | assert(BaseType->isDependentType())((BaseType->isDependentType()) ? static_cast<void> ( 0) : __assert_fail ("BaseType->isDependentType()", "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp" , 558, __PRETTY_FUNCTION__)); | |||
559 | return false; | |||
560 | } | |||
561 | ||||
562 | for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) { | |||
563 | // If this is an implicit member reference and we find a | |||
564 | // non-instance member, it's not an error. | |||
565 | if (!BaseExpr && !(*I)->isCXXInstanceMember()) | |||
566 | return false; | |||
567 | ||||
568 | // Note that we use the DC of the decl, not the underlying decl. | |||
569 | DeclContext *DC = (*I)->getDeclContext(); | |||
570 | while (DC->isTransparentContext()) | |||
571 | DC = DC->getParent(); | |||
572 | ||||
573 | if (!DC->isRecord()) | |||
574 | continue; | |||
575 | ||||
576 | CXXRecordDecl *MemberRecord = cast<CXXRecordDecl>(DC)->getCanonicalDecl(); | |||
577 | if (BaseRecord->getCanonicalDecl() == MemberRecord || | |||
578 | !BaseRecord->isProvablyNotDerivedFrom(MemberRecord)) | |||
579 | return false; | |||
580 | } | |||
581 | ||||
582 | DiagnoseQualifiedMemberReference(*this, BaseExpr, BaseType, SS, | |||
583 | R.getRepresentativeDecl(), | |||
584 | R.getLookupNameInfo()); | |||
585 | return true; | |||
586 | } | |||
587 | ||||
588 | namespace { | |||
589 | ||||
590 | // Callback to only accept typo corrections that are either a ValueDecl or a | |||
591 | // FunctionTemplateDecl and are declared in the current record or, for a C++ | |||
592 | // classes, one of its base classes. | |||
593 | class RecordMemberExprValidatorCCC final : public CorrectionCandidateCallback { | |||
594 | public: | |||
595 | explicit RecordMemberExprValidatorCCC(const RecordType *RTy) | |||
596 | : Record(RTy->getDecl()) { | |||
597 | // Don't add bare keywords to the consumer since they will always fail | |||
598 | // validation by virtue of not being associated with any decls. | |||
599 | WantTypeSpecifiers = false; | |||
600 | WantExpressionKeywords = false; | |||
601 | WantCXXNamedCasts = false; | |||
602 | WantFunctionLikeCasts = false; | |||
603 | WantRemainingKeywords = false; | |||
604 | } | |||
605 | ||||
606 | bool ValidateCandidate(const TypoCorrection &candidate) override { | |||
607 | NamedDecl *ND = candidate.getCorrectionDecl(); | |||
608 | // Don't accept candidates that cannot be member functions, constants, | |||
609 | // variables, or templates. | |||
610 | if (!ND || !(isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND))) | |||
611 | return false; | |||
612 | ||||
613 | // Accept candidates that occur in the current record. | |||
614 | if (Record->containsDecl(ND)) | |||
615 | return true; | |||
616 | ||||
617 | if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Record)) { | |||
618 | // Accept candidates that occur in any of the current class' base classes. | |||
619 | for (const auto &BS : RD->bases()) { | |||
620 | if (const RecordType *BSTy = | |||
621 | dyn_cast_or_null<RecordType>(BS.getType().getTypePtrOrNull())) { | |||
622 | if (BSTy->getDecl()->containsDecl(ND)) | |||
623 | return true; | |||
624 | } | |||
625 | } | |||
626 | } | |||
627 | ||||
628 | return false; | |||
629 | } | |||
630 | ||||
631 | std::unique_ptr<CorrectionCandidateCallback> clone() override { | |||
632 | return std::make_unique<RecordMemberExprValidatorCCC>(*this); | |||
633 | } | |||
634 | ||||
635 | private: | |||
636 | const RecordDecl *const Record; | |||
637 | }; | |||
638 | ||||
639 | } | |||
640 | ||||
641 | static bool LookupMemberExprInRecord(Sema &SemaRef, LookupResult &R, | |||
642 | Expr *BaseExpr, | |||
643 | const RecordType *RTy, | |||
644 | SourceLocation OpLoc, bool IsArrow, | |||
645 | CXXScopeSpec &SS, bool HasTemplateArgs, | |||
646 | SourceLocation TemplateKWLoc, | |||
647 | TypoExpr *&TE) { | |||
648 | SourceRange BaseRange = BaseExpr ? BaseExpr->getSourceRange() : SourceRange(); | |||
649 | RecordDecl *RDecl = RTy->getDecl(); | |||
650 | if (!SemaRef.isThisOutsideMemberFunctionBody(QualType(RTy, 0)) && | |||
651 | SemaRef.RequireCompleteType(OpLoc, QualType(RTy, 0), | |||
652 | diag::err_typecheck_incomplete_tag, | |||
653 | BaseRange)) | |||
654 | return true; | |||
655 | ||||
656 | if (HasTemplateArgs || TemplateKWLoc.isValid()) { | |||
657 | // LookupTemplateName doesn't expect these both to exist simultaneously. | |||
658 | QualType ObjectType = SS.isSet() ? QualType() : QualType(RTy, 0); | |||
659 | ||||
660 | bool MOUS; | |||
661 | return SemaRef.LookupTemplateName(R, nullptr, SS, ObjectType, false, MOUS, | |||
662 | TemplateKWLoc); | |||
663 | } | |||
664 | ||||
665 | DeclContext *DC = RDecl; | |||
666 | if (SS.isSet()) { | |||
667 | // If the member name was a qualified-id, look into the | |||
668 | // nested-name-specifier. | |||
669 | DC = SemaRef.computeDeclContext(SS, false); | |||
670 | ||||
671 | if (SemaRef.RequireCompleteDeclContext(SS, DC)) { | |||
672 | SemaRef.Diag(SS.getRange().getEnd(), diag::err_typecheck_incomplete_tag) | |||
673 | << SS.getRange() << DC; | |||
674 | return true; | |||
675 | } | |||
676 | ||||
677 | assert(DC && "Cannot handle non-computable dependent contexts in lookup")((DC && "Cannot handle non-computable dependent contexts in lookup" ) ? static_cast<void> (0) : __assert_fail ("DC && \"Cannot handle non-computable dependent contexts in lookup\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp" , 677, __PRETTY_FUNCTION__)); | |||
678 | ||||
679 | if (!isa<TypeDecl>(DC)) { | |||
680 | SemaRef.Diag(R.getNameLoc(), diag::err_qualified_member_nonclass) | |||
681 | << DC << SS.getRange(); | |||
682 | return true; | |||
683 | } | |||
684 | } | |||
685 | ||||
686 | // The record definition is complete, now look up the member. | |||
687 | SemaRef.LookupQualifiedName(R, DC, SS); | |||
688 | ||||
689 | if (!R.empty()) | |||
690 | return false; | |||
691 | ||||
692 | DeclarationName Typo = R.getLookupName(); | |||
693 | SourceLocation TypoLoc = R.getNameLoc(); | |||
694 | ||||
695 | struct QueryState { | |||
696 | Sema &SemaRef; | |||
697 | DeclarationNameInfo NameInfo; | |||
698 | Sema::LookupNameKind LookupKind; | |||
699 | Sema::RedeclarationKind Redecl; | |||
700 | }; | |||
701 | QueryState Q = {R.getSema(), R.getLookupNameInfo(), R.getLookupKind(), | |||
702 | R.redeclarationKind()}; | |||
703 | RecordMemberExprValidatorCCC CCC(RTy); | |||
704 | TE = SemaRef.CorrectTypoDelayed( | |||
705 | R.getLookupNameInfo(), R.getLookupKind(), nullptr, &SS, CCC, | |||
706 | [=, &SemaRef](const TypoCorrection &TC) { | |||
707 | if (TC) { | |||
708 | assert(!TC.isKeyword() &&((!TC.isKeyword() && "Got a keyword as a correction for a member!" ) ? static_cast<void> (0) : __assert_fail ("!TC.isKeyword() && \"Got a keyword as a correction for a member!\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp" , 709, __PRETTY_FUNCTION__)) | |||
709 | "Got a keyword as a correction for a member!")((!TC.isKeyword() && "Got a keyword as a correction for a member!" ) ? static_cast<void> (0) : __assert_fail ("!TC.isKeyword() && \"Got a keyword as a correction for a member!\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp" , 709, __PRETTY_FUNCTION__)); | |||
710 | bool DroppedSpecifier = | |||
711 | TC.WillReplaceSpecifier() && | |||
712 | Typo.getAsString() == TC.getAsString(SemaRef.getLangOpts()); | |||
713 | SemaRef.diagnoseTypo(TC, SemaRef.PDiag(diag::err_no_member_suggest) | |||
714 | << Typo << DC << DroppedSpecifier | |||
715 | << SS.getRange()); | |||
716 | } else { | |||
717 | SemaRef.Diag(TypoLoc, diag::err_no_member) << Typo << DC << BaseRange; | |||
718 | } | |||
719 | }, | |||
720 | [=](Sema &SemaRef, TypoExpr *TE, TypoCorrection TC) mutable { | |||
721 | LookupResult R(Q.SemaRef, Q.NameInfo, Q.LookupKind, Q.Redecl); | |||
722 | R.clear(); // Ensure there's no decls lingering in the shared state. | |||
723 | R.suppressDiagnostics(); | |||
724 | R.setLookupName(TC.getCorrection()); | |||
725 | for (NamedDecl *ND : TC) | |||
726 | R.addDecl(ND); | |||
727 | R.resolveKind(); | |||
728 | return SemaRef.BuildMemberReferenceExpr( | |||
729 | BaseExpr, BaseExpr->getType(), OpLoc, IsArrow, SS, SourceLocation(), | |||
730 | nullptr, R, nullptr, nullptr); | |||
731 | }, | |||
732 | Sema::CTK_ErrorRecovery, DC); | |||
733 | ||||
734 | return false; | |||
735 | } | |||
736 | ||||
737 | static ExprResult LookupMemberExpr(Sema &S, LookupResult &R, | |||
738 | ExprResult &BaseExpr, bool &IsArrow, | |||
739 | SourceLocation OpLoc, CXXScopeSpec &SS, | |||
740 | Decl *ObjCImpDecl, bool HasTemplateArgs, | |||
741 | SourceLocation TemplateKWLoc); | |||
742 | ||||
743 | ExprResult | |||
744 | Sema::BuildMemberReferenceExpr(Expr *Base, QualType BaseType, | |||
745 | SourceLocation OpLoc, bool IsArrow, | |||
746 | CXXScopeSpec &SS, | |||
747 | SourceLocation TemplateKWLoc, | |||
748 | NamedDecl *FirstQualifierInScope, | |||
749 | const DeclarationNameInfo &NameInfo, | |||
750 | const TemplateArgumentListInfo *TemplateArgs, | |||
751 | const Scope *S, | |||
752 | ActOnMemberAccessExtraArgs *ExtraArgs) { | |||
753 | if (BaseType->isDependentType() || | |||
754 | (SS.isSet() && isDependentScopeSpecifier(SS))) | |||
755 | return ActOnDependentMemberExpr(Base, BaseType, | |||
756 | IsArrow, OpLoc, | |||
757 | SS, TemplateKWLoc, FirstQualifierInScope, | |||
758 | NameInfo, TemplateArgs); | |||
759 | ||||
760 | LookupResult R(*this, NameInfo, LookupMemberName); | |||
761 | ||||
762 | // Implicit member accesses. | |||
763 | if (!Base) { | |||
764 | TypoExpr *TE = nullptr; | |||
765 | QualType RecordTy = BaseType; | |||
766 | if (IsArrow) RecordTy = RecordTy->getAs<PointerType>()->getPointeeType(); | |||
767 | if (LookupMemberExprInRecord( | |||
768 | *this, R, nullptr, RecordTy->getAs<RecordType>(), OpLoc, IsArrow, | |||
769 | SS, TemplateArgs != nullptr, TemplateKWLoc, TE)) | |||
770 | return ExprError(); | |||
771 | if (TE) | |||
772 | return TE; | |||
773 | ||||
774 | // Explicit member accesses. | |||
775 | } else { | |||
776 | ExprResult BaseResult = Base; | |||
777 | ExprResult Result = | |||
778 | LookupMemberExpr(*this, R, BaseResult, IsArrow, OpLoc, SS, | |||
779 | ExtraArgs ? ExtraArgs->ObjCImpDecl : nullptr, | |||
780 | TemplateArgs != nullptr, TemplateKWLoc); | |||
781 | ||||
782 | if (BaseResult.isInvalid()) | |||
783 | return ExprError(); | |||
784 | Base = BaseResult.get(); | |||
785 | ||||
786 | if (Result.isInvalid()) | |||
787 | return ExprError(); | |||
788 | ||||
789 | if (Result.get()) | |||
790 | return Result; | |||
791 | ||||
792 | // LookupMemberExpr can modify Base, and thus change BaseType | |||
793 | BaseType = Base->getType(); | |||
794 | } | |||
795 | ||||
796 | return BuildMemberReferenceExpr(Base, BaseType, | |||
797 | OpLoc, IsArrow, SS, TemplateKWLoc, | |||
798 | FirstQualifierInScope, R, TemplateArgs, S, | |||
799 | false, ExtraArgs); | |||
800 | } | |||
801 | ||||
802 | ExprResult | |||
803 | Sema::BuildAnonymousStructUnionMemberReference(const CXXScopeSpec &SS, | |||
804 | SourceLocation loc, | |||
805 | IndirectFieldDecl *indirectField, | |||
806 | DeclAccessPair foundDecl, | |||
807 | Expr *baseObjectExpr, | |||
808 | SourceLocation opLoc) { | |||
809 | // First, build the expression that refers to the base object. | |||
810 | ||||
811 | // Case 1: the base of the indirect field is not a field. | |||
812 | VarDecl *baseVariable = indirectField->getVarDecl(); | |||
813 | CXXScopeSpec EmptySS; | |||
814 | if (baseVariable) { | |||
815 | assert(baseVariable->getType()->isRecordType())((baseVariable->getType()->isRecordType()) ? static_cast <void> (0) : __assert_fail ("baseVariable->getType()->isRecordType()" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp" , 815, __PRETTY_FUNCTION__)); | |||
816 | ||||
817 | // In principle we could have a member access expression that | |||
818 | // accesses an anonymous struct/union that's a static member of | |||
819 | // the base object's class. However, under the current standard, | |||
820 | // static data members cannot be anonymous structs or unions. | |||
821 | // Supporting this is as easy as building a MemberExpr here. | |||
822 | assert(!baseObjectExpr && "anonymous struct/union is static data member?")((!baseObjectExpr && "anonymous struct/union is static data member?" ) ? static_cast<void> (0) : __assert_fail ("!baseObjectExpr && \"anonymous struct/union is static data member?\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp" , 822, __PRETTY_FUNCTION__)); | |||
823 | ||||
824 | DeclarationNameInfo baseNameInfo(DeclarationName(), loc); | |||
825 | ||||
826 | ExprResult result | |||
827 | = BuildDeclarationNameExpr(EmptySS, baseNameInfo, baseVariable); | |||
828 | if (result.isInvalid()) return ExprError(); | |||
829 | ||||
830 | baseObjectExpr = result.get(); | |||
831 | } | |||
832 | ||||
833 | assert((baseVariable || baseObjectExpr) &&(((baseVariable || baseObjectExpr) && "referencing anonymous struct/union without a base variable or " "expression") ? static_cast<void> (0) : __assert_fail ( "(baseVariable || baseObjectExpr) && \"referencing anonymous struct/union without a base variable or \" \"expression\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp" , 835, __PRETTY_FUNCTION__)) | |||
834 | "referencing anonymous struct/union without a base variable or "(((baseVariable || baseObjectExpr) && "referencing anonymous struct/union without a base variable or " "expression") ? static_cast<void> (0) : __assert_fail ( "(baseVariable || baseObjectExpr) && \"referencing anonymous struct/union without a base variable or \" \"expression\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp" , 835, __PRETTY_FUNCTION__)) | |||
835 | "expression")(((baseVariable || baseObjectExpr) && "referencing anonymous struct/union without a base variable or " "expression") ? static_cast<void> (0) : __assert_fail ( "(baseVariable || baseObjectExpr) && \"referencing anonymous struct/union without a base variable or \" \"expression\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp" , 835, __PRETTY_FUNCTION__)); | |||
836 | ||||
837 | // Build the implicit member references to the field of the | |||
838 | // anonymous struct/union. | |||
839 | Expr *result = baseObjectExpr; | |||
840 | IndirectFieldDecl::chain_iterator | |||
841 | FI = indirectField->chain_begin(), FEnd = indirectField->chain_end(); | |||
842 | ||||
843 | // Case 2: the base of the indirect field is a field and the user | |||
844 | // wrote a member expression. | |||
845 | if (!baseVariable) { | |||
846 | FieldDecl *field = cast<FieldDecl>(*FI); | |||
847 | ||||
848 | bool baseObjectIsPointer = baseObjectExpr->getType()->isPointerType(); | |||
849 | ||||
850 | // Make a nameInfo that properly uses the anonymous name. | |||
851 | DeclarationNameInfo memberNameInfo(field->getDeclName(), loc); | |||
852 | ||||
853 | // Build the first member access in the chain with full information. | |||
854 | result = | |||
855 | BuildFieldReferenceExpr(result, baseObjectIsPointer, SourceLocation(), | |||
856 | SS, field, foundDecl, memberNameInfo) | |||
857 | .get(); | |||
858 | if (!result) | |||
859 | return ExprError(); | |||
860 | } | |||
861 | ||||
862 | // In all cases, we should now skip the first declaration in the chain. | |||
863 | ++FI; | |||
864 | ||||
865 | while (FI != FEnd) { | |||
866 | FieldDecl *field = cast<FieldDecl>(*FI++); | |||
867 | ||||
868 | // FIXME: these are somewhat meaningless | |||
869 | DeclarationNameInfo memberNameInfo(field->getDeclName(), loc); | |||
870 | DeclAccessPair fakeFoundDecl = | |||
871 | DeclAccessPair::make(field, field->getAccess()); | |||
872 | ||||
873 | result = | |||
874 | BuildFieldReferenceExpr(result, /*isarrow*/ false, SourceLocation(), | |||
875 | (FI == FEnd ? SS : EmptySS), field, | |||
876 | fakeFoundDecl, memberNameInfo) | |||
877 | .get(); | |||
878 | } | |||
879 | ||||
880 | return result; | |||
881 | } | |||
882 | ||||
883 | static ExprResult | |||
884 | BuildMSPropertyRefExpr(Sema &S, Expr *BaseExpr, bool IsArrow, | |||
885 | const CXXScopeSpec &SS, | |||
886 | MSPropertyDecl *PD, | |||
887 | const DeclarationNameInfo &NameInfo) { | |||
888 | // Property names are always simple identifiers and therefore never | |||
889 | // require any interesting additional storage. | |||
890 | return new (S.Context) MSPropertyRefExpr(BaseExpr, PD, IsArrow, | |||
891 | S.Context.PseudoObjectTy, VK_LValue, | |||
892 | SS.getWithLocInContext(S.Context), | |||
893 | NameInfo.getLoc()); | |||
894 | } | |||
895 | ||||
896 | MemberExpr *Sema::BuildMemberExpr( | |||
897 | Expr *Base, bool IsArrow, SourceLocation OpLoc, const CXXScopeSpec *SS, | |||
898 | SourceLocation TemplateKWLoc, ValueDecl *Member, DeclAccessPair FoundDecl, | |||
899 | bool HadMultipleCandidates, const DeclarationNameInfo &MemberNameInfo, | |||
900 | QualType Ty, ExprValueKind VK, ExprObjectKind OK, | |||
901 | const TemplateArgumentListInfo *TemplateArgs) { | |||
902 | NestedNameSpecifierLoc NNS = | |||
903 | SS ? SS->getWithLocInContext(Context) : NestedNameSpecifierLoc(); | |||
904 | return BuildMemberExpr(Base, IsArrow, OpLoc, NNS, TemplateKWLoc, Member, | |||
905 | FoundDecl, HadMultipleCandidates, MemberNameInfo, Ty, | |||
906 | VK, OK, TemplateArgs); | |||
907 | } | |||
908 | ||||
909 | MemberExpr *Sema::BuildMemberExpr( | |||
910 | Expr *Base, bool IsArrow, SourceLocation OpLoc, NestedNameSpecifierLoc NNS, | |||
911 | SourceLocation TemplateKWLoc, ValueDecl *Member, DeclAccessPair FoundDecl, | |||
912 | bool HadMultipleCandidates, const DeclarationNameInfo &MemberNameInfo, | |||
913 | QualType Ty, ExprValueKind VK, ExprObjectKind OK, | |||
914 | const TemplateArgumentListInfo *TemplateArgs) { | |||
915 | assert((!IsArrow || Base->isRValue()) && "-> base must be a pointer rvalue")(((!IsArrow || Base->isRValue()) && "-> base must be a pointer rvalue" ) ? static_cast<void> (0) : __assert_fail ("(!IsArrow || Base->isRValue()) && \"-> base must be a pointer rvalue\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp" , 915, __PRETTY_FUNCTION__)); | |||
916 | MemberExpr *E = | |||
917 | MemberExpr::Create(Context, Base, IsArrow, OpLoc, NNS, TemplateKWLoc, | |||
918 | Member, FoundDecl, MemberNameInfo, TemplateArgs, Ty, | |||
919 | VK, OK, getNonOdrUseReasonInCurrentContext(Member)); | |||
920 | E->setHadMultipleCandidates(HadMultipleCandidates); | |||
921 | MarkMemberReferenced(E); | |||
922 | return E; | |||
923 | } | |||
924 | ||||
925 | /// Determine if the given scope is within a function-try-block handler. | |||
926 | static bool IsInFnTryBlockHandler(const Scope *S) { | |||
927 | // Walk the scope stack until finding a FnTryCatchScope, or leave the | |||
928 | // function scope. If a FnTryCatchScope is found, check whether the TryScope | |||
929 | // flag is set. If it is not, it's a function-try-block handler. | |||
930 | for (; S != S->getFnParent(); S = S->getParent()) { | |||
931 | if (S->getFlags() & Scope::FnTryCatchScope) | |||
932 | return (S->getFlags() & Scope::TryScope) != Scope::TryScope; | |||
933 | } | |||
934 | return false; | |||
935 | } | |||
936 | ||||
937 | VarDecl * | |||
938 | Sema::getVarTemplateSpecialization(VarTemplateDecl *VarTempl, | |||
939 | const TemplateArgumentListInfo *TemplateArgs, | |||
940 | const DeclarationNameInfo &MemberNameInfo, | |||
941 | SourceLocation TemplateKWLoc) { | |||
942 | if (!TemplateArgs) { | |||
943 | diagnoseMissingTemplateArguments(TemplateName(VarTempl), | |||
944 | MemberNameInfo.getBeginLoc()); | |||
945 | return nullptr; | |||
946 | } | |||
947 | ||||
948 | DeclResult VDecl = CheckVarTemplateId(VarTempl, TemplateKWLoc, | |||
949 | MemberNameInfo.getLoc(), *TemplateArgs); | |||
950 | if (VDecl.isInvalid()) | |||
951 | return nullptr; | |||
952 | VarDecl *Var = cast<VarDecl>(VDecl.get()); | |||
953 | if (!Var->getTemplateSpecializationKind()) | |||
954 | Var->setTemplateSpecializationKind(TSK_ImplicitInstantiation, | |||
955 | MemberNameInfo.getLoc()); | |||
956 | return Var; | |||
957 | } | |||
958 | ||||
959 | ExprResult | |||
960 | Sema::BuildMemberReferenceExpr(Expr *BaseExpr, QualType BaseExprType, | |||
961 | SourceLocation OpLoc, bool IsArrow, | |||
962 | const CXXScopeSpec &SS, | |||
963 | SourceLocation TemplateKWLoc, | |||
964 | NamedDecl *FirstQualifierInScope, | |||
965 | LookupResult &R, | |||
966 | const TemplateArgumentListInfo *TemplateArgs, | |||
967 | const Scope *S, | |||
968 | bool SuppressQualifierCheck, | |||
969 | ActOnMemberAccessExtraArgs *ExtraArgs) { | |||
970 | QualType BaseType = BaseExprType; | |||
971 | if (IsArrow) { | |||
972 | assert(BaseType->isPointerType())((BaseType->isPointerType()) ? static_cast<void> (0) : __assert_fail ("BaseType->isPointerType()", "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp" , 972, __PRETTY_FUNCTION__)); | |||
973 | BaseType = BaseType->castAs<PointerType>()->getPointeeType(); | |||
974 | } | |||
975 | R.setBaseObjectType(BaseType); | |||
976 | ||||
977 | // C++1z [expr.ref]p2: | |||
978 | // For the first option (dot) the first expression shall be a glvalue [...] | |||
979 | if (!IsArrow && BaseExpr && BaseExpr->isRValue()) { | |||
980 | ExprResult Converted = TemporaryMaterializationConversion(BaseExpr); | |||
981 | if (Converted.isInvalid()) | |||
982 | return ExprError(); | |||
983 | BaseExpr = Converted.get(); | |||
984 | } | |||
985 | ||||
986 | ||||
987 | const DeclarationNameInfo &MemberNameInfo = R.getLookupNameInfo(); | |||
988 | DeclarationName MemberName = MemberNameInfo.getName(); | |||
989 | SourceLocation MemberLoc = MemberNameInfo.getLoc(); | |||
990 | ||||
991 | if (R.isAmbiguous()) | |||
992 | return ExprError(); | |||
993 | ||||
994 | // [except.handle]p10: Referring to any non-static member or base class of an | |||
995 | // object in the handler for a function-try-block of a constructor or | |||
996 | // destructor for that object results in undefined behavior. | |||
997 | const auto *FD = getCurFunctionDecl(); | |||
998 | if (S && BaseExpr && FD && | |||
999 | (isa<CXXDestructorDecl>(FD) || isa<CXXConstructorDecl>(FD)) && | |||
1000 | isa<CXXThisExpr>(BaseExpr->IgnoreImpCasts()) && | |||
1001 | IsInFnTryBlockHandler(S)) | |||
1002 | Diag(MemberLoc, diag::warn_cdtor_function_try_handler_mem_expr) | |||
1003 | << isa<CXXDestructorDecl>(FD); | |||
1004 | ||||
1005 | if (R.empty()) { | |||
1006 | // Rederive where we looked up. | |||
1007 | DeclContext *DC = (SS.isSet() | |||
1008 | ? computeDeclContext(SS, false) | |||
1009 | : BaseType->castAs<RecordType>()->getDecl()); | |||
1010 | ||||
1011 | if (ExtraArgs) { | |||
1012 | ExprResult RetryExpr; | |||
1013 | if (!IsArrow && BaseExpr) { | |||
1014 | SFINAETrap Trap(*this, true); | |||
1015 | ParsedType ObjectType; | |||
1016 | bool MayBePseudoDestructor = false; | |||
1017 | RetryExpr = ActOnStartCXXMemberReference(getCurScope(), BaseExpr, | |||
1018 | OpLoc, tok::arrow, ObjectType, | |||
1019 | MayBePseudoDestructor); | |||
1020 | if (RetryExpr.isUsable() && !Trap.hasErrorOccurred()) { | |||
1021 | CXXScopeSpec TempSS(SS); | |||
1022 | RetryExpr = ActOnMemberAccessExpr( | |||
1023 | ExtraArgs->S, RetryExpr.get(), OpLoc, tok::arrow, TempSS, | |||
1024 | TemplateKWLoc, ExtraArgs->Id, ExtraArgs->ObjCImpDecl); | |||
1025 | } | |||
1026 | if (Trap.hasErrorOccurred()) | |||
1027 | RetryExpr = ExprError(); | |||
1028 | } | |||
1029 | if (RetryExpr.isUsable()) { | |||
1030 | Diag(OpLoc, diag::err_no_member_overloaded_arrow) | |||
1031 | << MemberName << DC << FixItHint::CreateReplacement(OpLoc, "->"); | |||
1032 | return RetryExpr; | |||
1033 | } | |||
1034 | } | |||
1035 | ||||
1036 | Diag(R.getNameLoc(), diag::err_no_member) | |||
1037 | << MemberName << DC | |||
1038 | << (BaseExpr ? BaseExpr->getSourceRange() : SourceRange()); | |||
1039 | return ExprError(); | |||
1040 | } | |||
1041 | ||||
1042 | // Diagnose lookups that find only declarations from a non-base | |||
1043 | // type. This is possible for either qualified lookups (which may | |||
1044 | // have been qualified with an unrelated type) or implicit member | |||
1045 | // expressions (which were found with unqualified lookup and thus | |||
1046 | // may have come from an enclosing scope). Note that it's okay for | |||
1047 | // lookup to find declarations from a non-base type as long as those | |||
1048 | // aren't the ones picked by overload resolution. | |||
1049 | if ((SS.isSet() || !BaseExpr || | |||
1050 | (isa<CXXThisExpr>(BaseExpr) && | |||
1051 | cast<CXXThisExpr>(BaseExpr)->isImplicit())) && | |||
1052 | !SuppressQualifierCheck && | |||
1053 | CheckQualifiedMemberReference(BaseExpr, BaseType, SS, R)) | |||
1054 | return ExprError(); | |||
1055 | ||||
1056 | // Construct an unresolved result if we in fact got an unresolved | |||
1057 | // result. | |||
1058 | if (R.isOverloadedResult() || R.isUnresolvableResult()) { | |||
1059 | // Suppress any lookup-related diagnostics; we'll do these when we | |||
1060 | // pick a member. | |||
1061 | R.suppressDiagnostics(); | |||
1062 | ||||
1063 | UnresolvedMemberExpr *MemExpr | |||
1064 | = UnresolvedMemberExpr::Create(Context, R.isUnresolvableResult(), | |||
1065 | BaseExpr, BaseExprType, | |||
1066 | IsArrow, OpLoc, | |||
1067 | SS.getWithLocInContext(Context), | |||
1068 | TemplateKWLoc, MemberNameInfo, | |||
1069 | TemplateArgs, R.begin(), R.end()); | |||
1070 | ||||
1071 | return MemExpr; | |||
1072 | } | |||
1073 | ||||
1074 | assert(R.isSingleResult())((R.isSingleResult()) ? static_cast<void> (0) : __assert_fail ("R.isSingleResult()", "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp" , 1074, __PRETTY_FUNCTION__)); | |||
1075 | DeclAccessPair FoundDecl = R.begin().getPair(); | |||
1076 | NamedDecl *MemberDecl = R.getFoundDecl(); | |||
1077 | ||||
1078 | // FIXME: diagnose the presence of template arguments now. | |||
1079 | ||||
1080 | // If the decl being referenced had an error, return an error for this | |||
1081 | // sub-expr without emitting another error, in order to avoid cascading | |||
1082 | // error cases. | |||
1083 | if (MemberDecl->isInvalidDecl()) | |||
1084 | return ExprError(); | |||
1085 | ||||
1086 | // Handle the implicit-member-access case. | |||
1087 | if (!BaseExpr) { | |||
1088 | // If this is not an instance member, convert to a non-member access. | |||
1089 | if (!MemberDecl->isCXXInstanceMember()) { | |||
1090 | // If this is a variable template, get the instantiated variable | |||
1091 | // declaration corresponding to the supplied template arguments | |||
1092 | // (while emitting diagnostics as necessary) that will be referenced | |||
1093 | // by this expression. | |||
1094 | assert((!TemplateArgs || isa<VarTemplateDecl>(MemberDecl)) &&(((!TemplateArgs || isa<VarTemplateDecl>(MemberDecl)) && "How did we get template arguments here sans a variable template" ) ? static_cast<void> (0) : __assert_fail ("(!TemplateArgs || isa<VarTemplateDecl>(MemberDecl)) && \"How did we get template arguments here sans a variable template\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp" , 1095, __PRETTY_FUNCTION__)) | |||
1095 | "How did we get template arguments here sans a variable template")(((!TemplateArgs || isa<VarTemplateDecl>(MemberDecl)) && "How did we get template arguments here sans a variable template" ) ? static_cast<void> (0) : __assert_fail ("(!TemplateArgs || isa<VarTemplateDecl>(MemberDecl)) && \"How did we get template arguments here sans a variable template\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp" , 1095, __PRETTY_FUNCTION__)); | |||
1096 | if (isa<VarTemplateDecl>(MemberDecl)) { | |||
1097 | MemberDecl = getVarTemplateSpecialization( | |||
1098 | cast<VarTemplateDecl>(MemberDecl), TemplateArgs, | |||
1099 | R.getLookupNameInfo(), TemplateKWLoc); | |||
1100 | if (!MemberDecl) | |||
1101 | return ExprError(); | |||
1102 | } | |||
1103 | return BuildDeclarationNameExpr(SS, R.getLookupNameInfo(), MemberDecl, | |||
1104 | FoundDecl, TemplateArgs); | |||
1105 | } | |||
1106 | SourceLocation Loc = R.getNameLoc(); | |||
1107 | if (SS.getRange().isValid()) | |||
1108 | Loc = SS.getRange().getBegin(); | |||
1109 | BaseExpr = BuildCXXThisExpr(Loc, BaseExprType, /*IsImplicit=*/true); | |||
1110 | } | |||
1111 | ||||
1112 | // Check the use of this member. | |||
1113 | if (DiagnoseUseOfDecl(MemberDecl, MemberLoc)) | |||
1114 | return ExprError(); | |||
1115 | ||||
1116 | if (FieldDecl *FD = dyn_cast<FieldDecl>(MemberDecl)) | |||
1117 | return BuildFieldReferenceExpr(BaseExpr, IsArrow, OpLoc, SS, FD, FoundDecl, | |||
1118 | MemberNameInfo); | |||
1119 | ||||
1120 | if (MSPropertyDecl *PD = dyn_cast<MSPropertyDecl>(MemberDecl)) | |||
1121 | return BuildMSPropertyRefExpr(*this, BaseExpr, IsArrow, SS, PD, | |||
1122 | MemberNameInfo); | |||
1123 | ||||
1124 | if (IndirectFieldDecl *FD = dyn_cast<IndirectFieldDecl>(MemberDecl)) | |||
1125 | // We may have found a field within an anonymous union or struct | |||
1126 | // (C++ [class.union]). | |||
1127 | return BuildAnonymousStructUnionMemberReference(SS, MemberLoc, FD, | |||
1128 | FoundDecl, BaseExpr, | |||
1129 | OpLoc); | |||
1130 | ||||
1131 | if (VarDecl *Var = dyn_cast<VarDecl>(MemberDecl)) { | |||
1132 | return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc, Var, | |||
1133 | FoundDecl, /*HadMultipleCandidates=*/false, | |||
1134 | MemberNameInfo, Var->getType().getNonReferenceType(), | |||
1135 | VK_LValue, OK_Ordinary); | |||
1136 | } | |||
1137 | ||||
1138 | if (CXXMethodDecl *MemberFn = dyn_cast<CXXMethodDecl>(MemberDecl)) { | |||
1139 | ExprValueKind valueKind; | |||
1140 | QualType type; | |||
1141 | if (MemberFn->isInstance()) { | |||
1142 | valueKind = VK_RValue; | |||
1143 | type = Context.BoundMemberTy; | |||
1144 | } else { | |||
1145 | valueKind = VK_LValue; | |||
1146 | type = MemberFn->getType(); | |||
1147 | } | |||
1148 | ||||
1149 | return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc, | |||
1150 | MemberFn, FoundDecl, /*HadMultipleCandidates=*/false, | |||
1151 | MemberNameInfo, type, valueKind, OK_Ordinary); | |||
1152 | } | |||
1153 | assert(!isa<FunctionDecl>(MemberDecl) && "member function not C++ method?")((!isa<FunctionDecl>(MemberDecl) && "member function not C++ method?" ) ? static_cast<void> (0) : __assert_fail ("!isa<FunctionDecl>(MemberDecl) && \"member function not C++ method?\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp" , 1153, __PRETTY_FUNCTION__)); | |||
1154 | ||||
1155 | if (EnumConstantDecl *Enum = dyn_cast<EnumConstantDecl>(MemberDecl)) { | |||
1156 | return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc, Enum, | |||
1157 | FoundDecl, /*HadMultipleCandidates=*/false, | |||
1158 | MemberNameInfo, Enum->getType(), VK_RValue, | |||
1159 | OK_Ordinary); | |||
1160 | } | |||
1161 | if (VarTemplateDecl *VarTempl = dyn_cast<VarTemplateDecl>(MemberDecl)) { | |||
1162 | if (VarDecl *Var = getVarTemplateSpecialization( | |||
1163 | VarTempl, TemplateArgs, MemberNameInfo, TemplateKWLoc)) | |||
1164 | return BuildMemberExpr( | |||
1165 | BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc, Var, FoundDecl, | |||
1166 | /*HadMultipleCandidates=*/false, MemberNameInfo, | |||
1167 | Var->getType().getNonReferenceType(), VK_LValue, OK_Ordinary); | |||
1168 | return ExprError(); | |||
1169 | } | |||
1170 | ||||
1171 | // We found something that we didn't expect. Complain. | |||
1172 | if (isa<TypeDecl>(MemberDecl)) | |||
1173 | Diag(MemberLoc, diag::err_typecheck_member_reference_type) | |||
1174 | << MemberName << BaseType << int(IsArrow); | |||
1175 | else | |||
1176 | Diag(MemberLoc, diag::err_typecheck_member_reference_unknown) | |||
1177 | << MemberName << BaseType << int(IsArrow); | |||
1178 | ||||
1179 | Diag(MemberDecl->getLocation(), diag::note_member_declared_here) | |||
1180 | << MemberName; | |||
1181 | R.suppressDiagnostics(); | |||
1182 | return ExprError(); | |||
1183 | } | |||
1184 | ||||
1185 | /// Given that normal member access failed on the given expression, | |||
1186 | /// and given that the expression's type involves builtin-id or | |||
1187 | /// builtin-Class, decide whether substituting in the redefinition | |||
1188 | /// types would be profitable. The redefinition type is whatever | |||
1189 | /// this translation unit tried to typedef to id/Class; we store | |||
1190 | /// it to the side and then re-use it in places like this. | |||
1191 | static bool ShouldTryAgainWithRedefinitionType(Sema &S, ExprResult &base) { | |||
1192 | const ObjCObjectPointerType *opty | |||
1193 | = base.get()->getType()->getAs<ObjCObjectPointerType>(); | |||
1194 | if (!opty) return false; | |||
1195 | ||||
1196 | const ObjCObjectType *ty = opty->getObjectType(); | |||
1197 | ||||
1198 | QualType redef; | |||
1199 | if (ty->isObjCId()) { | |||
1200 | redef = S.Context.getObjCIdRedefinitionType(); | |||
1201 | } else if (ty->isObjCClass()) { | |||
1202 | redef = S.Context.getObjCClassRedefinitionType(); | |||
1203 | } else { | |||
1204 | return false; | |||
1205 | } | |||
1206 | ||||
1207 | // Do the substitution as long as the redefinition type isn't just a | |||
1208 | // possibly-qualified pointer to builtin-id or builtin-Class again. | |||
1209 | opty = redef->getAs<ObjCObjectPointerType>(); | |||
1210 | if (opty && !opty->getObjectType()->getInterface()) | |||
1211 | return false; | |||
1212 | ||||
1213 | base = S.ImpCastExprToType(base.get(), redef, CK_BitCast); | |||
1214 | return true; | |||
1215 | } | |||
1216 | ||||
1217 | static bool isRecordType(QualType T) { | |||
1218 | return T->isRecordType(); | |||
1219 | } | |||
1220 | static bool isPointerToRecordType(QualType T) { | |||
1221 | if (const PointerType *PT = T->getAs<PointerType>()) | |||
1222 | return PT->getPointeeType()->isRecordType(); | |||
1223 | return false; | |||
1224 | } | |||
1225 | ||||
1226 | /// Perform conversions on the LHS of a member access expression. | |||
1227 | ExprResult | |||
1228 | Sema::PerformMemberExprBaseConversion(Expr *Base, bool IsArrow) { | |||
1229 | if (IsArrow && !Base->getType()->isFunctionType()) | |||
1230 | return DefaultFunctionArrayLvalueConversion(Base); | |||
1231 | ||||
1232 | return CheckPlaceholderExpr(Base); | |||
1233 | } | |||
1234 | ||||
1235 | /// Look up the given member of the given non-type-dependent | |||
1236 | /// expression. This can return in one of two ways: | |||
1237 | /// * If it returns a sentinel null-but-valid result, the caller will | |||
1238 | /// assume that lookup was performed and the results written into | |||
1239 | /// the provided structure. It will take over from there. | |||
1240 | /// * Otherwise, the returned expression will be produced in place of | |||
1241 | /// an ordinary member expression. | |||
1242 | /// | |||
1243 | /// The ObjCImpDecl bit is a gross hack that will need to be properly | |||
1244 | /// fixed for ObjC++. | |||
1245 | static ExprResult LookupMemberExpr(Sema &S, LookupResult &R, | |||
1246 | ExprResult &BaseExpr, bool &IsArrow, | |||
1247 | SourceLocation OpLoc, CXXScopeSpec &SS, | |||
1248 | Decl *ObjCImpDecl, bool HasTemplateArgs, | |||
1249 | SourceLocation TemplateKWLoc) { | |||
1250 | assert(BaseExpr.get() && "no base expression")((BaseExpr.get() && "no base expression") ? static_cast <void> (0) : __assert_fail ("BaseExpr.get() && \"no base expression\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp" , 1250, __PRETTY_FUNCTION__)); | |||
| ||||
1251 | ||||
1252 | // Perform default conversions. | |||
1253 | BaseExpr = S.PerformMemberExprBaseConversion(BaseExpr.get(), IsArrow); | |||
1254 | if (BaseExpr.isInvalid()) | |||
1255 | return ExprError(); | |||
1256 | ||||
1257 | QualType BaseType = BaseExpr.get()->getType(); | |||
1258 | assert(!BaseType->isDependentType())((!BaseType->isDependentType()) ? static_cast<void> ( 0) : __assert_fail ("!BaseType->isDependentType()", "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp" , 1258, __PRETTY_FUNCTION__)); | |||
1259 | ||||
1260 | DeclarationName MemberName = R.getLookupName(); | |||
1261 | SourceLocation MemberLoc = R.getNameLoc(); | |||
1262 | ||||
1263 | // For later type-checking purposes, turn arrow accesses into dot | |||
1264 | // accesses. The only access type we support that doesn't follow | |||
1265 | // the C equivalence "a->b === (*a).b" is ObjC property accesses, | |||
1266 | // and those never use arrows, so this is unaffected. | |||
1267 | if (IsArrow
| |||
1268 | if (const PointerType *Ptr = BaseType->getAs<PointerType>()) | |||
1269 | BaseType = Ptr->getPointeeType(); | |||
1270 | else if (const ObjCObjectPointerType *Ptr | |||
1271 | = BaseType->getAs<ObjCObjectPointerType>()) | |||
1272 | BaseType = Ptr->getPointeeType(); | |||
1273 | else if (BaseType->isRecordType()) { | |||
1274 | // Recover from arrow accesses to records, e.g.: | |||
1275 | // struct MyRecord foo; | |||
1276 | // foo->bar | |||
1277 | // This is actually well-formed in C++ if MyRecord has an | |||
1278 | // overloaded operator->, but that should have been dealt with | |||
1279 | // by now--or a diagnostic message already issued if a problem | |||
1280 | // was encountered while looking for the overloaded operator->. | |||
1281 | if (!S.getLangOpts().CPlusPlus) { | |||
1282 | S.Diag(OpLoc, diag::err_typecheck_member_reference_suggestion) | |||
1283 | << BaseType << int(IsArrow) << BaseExpr.get()->getSourceRange() | |||
1284 | << FixItHint::CreateReplacement(OpLoc, "."); | |||
1285 | } | |||
1286 | IsArrow = false; | |||
1287 | } else if (BaseType->isFunctionType()) { | |||
1288 | goto fail; | |||
1289 | } else { | |||
1290 | S.Diag(MemberLoc, diag::err_typecheck_member_reference_arrow) | |||
1291 | << BaseType << BaseExpr.get()->getSourceRange(); | |||
1292 | return ExprError(); | |||
1293 | } | |||
1294 | } | |||
1295 | ||||
1296 | // Handle field access to simple records. | |||
1297 | if (const RecordType *RTy
| |||
1298 | TypoExpr *TE = nullptr; | |||
1299 | if (LookupMemberExprInRecord(S, R, BaseExpr.get(), RTy, OpLoc, IsArrow, SS, | |||
1300 | HasTemplateArgs, TemplateKWLoc, TE)) | |||
1301 | return ExprError(); | |||
1302 | ||||
1303 | // Returning valid-but-null is how we indicate to the caller that | |||
1304 | // the lookup result was filled in. If typo correction was attempted and | |||
1305 | // failed, the lookup result will have been cleared--that combined with the | |||
1306 | // valid-but-null ExprResult will trigger the appropriate diagnostics. | |||
1307 | return ExprResult(TE); | |||
1308 | } | |||
1309 | ||||
1310 | // Handle ivar access to Objective-C objects. | |||
1311 | if (const ObjCObjectType *OTy
| |||
1312 | if (!SS.isEmpty() && !SS.isInvalid()) { | |||
1313 | S.Diag(SS.getRange().getBegin(), diag::err_qualified_objc_access) | |||
1314 | << 1 << SS.getScopeRep() | |||
1315 | << FixItHint::CreateRemoval(SS.getRange()); | |||
1316 | SS.clear(); | |||
1317 | } | |||
1318 | ||||
1319 | IdentifierInfo *Member = MemberName.getAsIdentifierInfo(); | |||
1320 | ||||
1321 | // There are three cases for the base type: | |||
1322 | // - builtin id (qualified or unqualified) | |||
1323 | // - builtin Class (qualified or unqualified) | |||
1324 | // - an interface | |||
1325 | ObjCInterfaceDecl *IDecl = OTy->getInterface(); | |||
1326 | if (!IDecl) { | |||
1327 | if (S.getLangOpts().ObjCAutoRefCount && | |||
1328 | (OTy->isObjCId() || OTy->isObjCClass())) | |||
1329 | goto fail; | |||
1330 | // There's an implicit 'isa' ivar on all objects. | |||
1331 | // But we only actually find it this way on objects of type 'id', | |||
1332 | // apparently. | |||
1333 | if (OTy->isObjCId() && Member->isStr("isa")) | |||
1334 | return new (S.Context) ObjCIsaExpr(BaseExpr.get(), IsArrow, MemberLoc, | |||
1335 | OpLoc, S.Context.getObjCClassType()); | |||
1336 | if (ShouldTryAgainWithRedefinitionType(S, BaseExpr)) | |||
1337 | return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS, | |||
1338 | ObjCImpDecl, HasTemplateArgs, TemplateKWLoc); | |||
1339 | goto fail; | |||
1340 | } | |||
1341 | ||||
1342 | if (S.RequireCompleteType(OpLoc, BaseType, | |||
1343 | diag::err_typecheck_incomplete_tag, | |||
1344 | BaseExpr.get())) | |||
1345 | return ExprError(); | |||
1346 | ||||
1347 | ObjCInterfaceDecl *ClassDeclared = nullptr; | |||
1348 | ObjCIvarDecl *IV = IDecl->lookupInstanceVariable(Member, ClassDeclared); | |||
1349 | ||||
1350 | if (!IV) { | |||
1351 | // Attempt to correct for typos in ivar names. | |||
1352 | DeclFilterCCC<ObjCIvarDecl> Validator{}; | |||
1353 | Validator.IsObjCIvarLookup = IsArrow; | |||
1354 | if (TypoCorrection Corrected = S.CorrectTypo( | |||
1355 | R.getLookupNameInfo(), Sema::LookupMemberName, nullptr, nullptr, | |||
1356 | Validator, Sema::CTK_ErrorRecovery, IDecl)) { | |||
1357 | IV = Corrected.getCorrectionDeclAs<ObjCIvarDecl>(); | |||
1358 | S.diagnoseTypo( | |||
1359 | Corrected, | |||
1360 | S.PDiag(diag::err_typecheck_member_reference_ivar_suggest) | |||
1361 | << IDecl->getDeclName() << MemberName); | |||
1362 | ||||
1363 | // Figure out the class that declares the ivar. | |||
1364 | assert(!ClassDeclared)((!ClassDeclared) ? static_cast<void> (0) : __assert_fail ("!ClassDeclared", "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp" , 1364, __PRETTY_FUNCTION__)); | |||
1365 | ||||
1366 | Decl *D = cast<Decl>(IV->getDeclContext()); | |||
1367 | if (auto *Category = dyn_cast<ObjCCategoryDecl>(D)) | |||
1368 | D = Category->getClassInterface(); | |||
1369 | ||||
1370 | if (auto *Implementation = dyn_cast<ObjCImplementationDecl>(D)) | |||
1371 | ClassDeclared = Implementation->getClassInterface(); | |||
1372 | else if (auto *Interface = dyn_cast<ObjCInterfaceDecl>(D)) | |||
1373 | ClassDeclared = Interface; | |||
1374 | ||||
1375 | assert(ClassDeclared && "cannot query interface")((ClassDeclared && "cannot query interface") ? static_cast <void> (0) : __assert_fail ("ClassDeclared && \"cannot query interface\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp" , 1375, __PRETTY_FUNCTION__)); | |||
1376 | } else { | |||
1377 | if (IsArrow && | |||
1378 | IDecl->FindPropertyDeclaration( | |||
1379 | Member, ObjCPropertyQueryKind::OBJC_PR_query_instance)) { | |||
1380 | S.Diag(MemberLoc, diag::err_property_found_suggest) | |||
1381 | << Member << BaseExpr.get()->getType() | |||
1382 | << FixItHint::CreateReplacement(OpLoc, "."); | |||
1383 | return ExprError(); | |||
1384 | } | |||
1385 | ||||
1386 | S.Diag(MemberLoc, diag::err_typecheck_member_reference_ivar) | |||
1387 | << IDecl->getDeclName() << MemberName | |||
1388 | << BaseExpr.get()->getSourceRange(); | |||
1389 | return ExprError(); | |||
1390 | } | |||
1391 | } | |||
1392 | ||||
1393 | assert(ClassDeclared)((ClassDeclared) ? static_cast<void> (0) : __assert_fail ("ClassDeclared", "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp" , 1393, __PRETTY_FUNCTION__)); | |||
1394 | ||||
1395 | // If the decl being referenced had an error, return an error for this | |||
1396 | // sub-expr without emitting another error, in order to avoid cascading | |||
1397 | // error cases. | |||
1398 | if (IV->isInvalidDecl()) | |||
1399 | return ExprError(); | |||
1400 | ||||
1401 | // Check whether we can reference this field. | |||
1402 | if (S.DiagnoseUseOfDecl(IV, MemberLoc)) | |||
1403 | return ExprError(); | |||
1404 | if (IV->getAccessControl() != ObjCIvarDecl::Public && | |||
1405 | IV->getAccessControl() != ObjCIvarDecl::Package) { | |||
1406 | ObjCInterfaceDecl *ClassOfMethodDecl = nullptr; | |||
1407 | if (ObjCMethodDecl *MD = S.getCurMethodDecl()) | |||
1408 | ClassOfMethodDecl = MD->getClassInterface(); | |||
1409 | else if (ObjCImpDecl && S.getCurFunctionDecl()) { | |||
1410 | // Case of a c-function declared inside an objc implementation. | |||
1411 | // FIXME: For a c-style function nested inside an objc implementation | |||
1412 | // class, there is no implementation context available, so we pass | |||
1413 | // down the context as argument to this routine. Ideally, this context | |||
1414 | // need be passed down in the AST node and somehow calculated from the | |||
1415 | // AST for a function decl. | |||
1416 | if (ObjCImplementationDecl *IMPD = | |||
1417 | dyn_cast<ObjCImplementationDecl>(ObjCImpDecl)) | |||
1418 | ClassOfMethodDecl = IMPD->getClassInterface(); | |||
1419 | else if (ObjCCategoryImplDecl* CatImplClass = | |||
1420 | dyn_cast<ObjCCategoryImplDecl>(ObjCImpDecl)) | |||
1421 | ClassOfMethodDecl = CatImplClass->getClassInterface(); | |||
1422 | } | |||
1423 | if (!S.getLangOpts().DebuggerSupport) { | |||
1424 | if (IV->getAccessControl() == ObjCIvarDecl::Private) { | |||
1425 | if (!declaresSameEntity(ClassDeclared, IDecl) || | |||
1426 | !declaresSameEntity(ClassOfMethodDecl, ClassDeclared)) | |||
1427 | S.Diag(MemberLoc, diag::err_private_ivar_access) | |||
1428 | << IV->getDeclName(); | |||
1429 | } else if (!IDecl->isSuperClassOf(ClassOfMethodDecl)) | |||
1430 | // @protected | |||
1431 | S.Diag(MemberLoc, diag::err_protected_ivar_access) | |||
1432 | << IV->getDeclName(); | |||
1433 | } | |||
1434 | } | |||
1435 | bool warn = true; | |||
1436 | if (S.getLangOpts().ObjCWeak) { | |||
1437 | Expr *BaseExp = BaseExpr.get()->IgnoreParenImpCasts(); | |||
1438 | if (UnaryOperator *UO = dyn_cast<UnaryOperator>(BaseExp)) | |||
1439 | if (UO->getOpcode() == UO_Deref) | |||
1440 | BaseExp = UO->getSubExpr()->IgnoreParenCasts(); | |||
1441 | ||||
1442 | if (DeclRefExpr *DE = dyn_cast<DeclRefExpr>(BaseExp)) | |||
1443 | if (DE->getType().getObjCLifetime() == Qualifiers::OCL_Weak) { | |||
1444 | S.Diag(DE->getLocation(), diag::err_arc_weak_ivar_access); | |||
1445 | warn = false; | |||
1446 | } | |||
1447 | } | |||
1448 | if (warn) { | |||
1449 | if (ObjCMethodDecl *MD = S.getCurMethodDecl()) { | |||
1450 | ObjCMethodFamily MF = MD->getMethodFamily(); | |||
1451 | warn = (MF != OMF_init && MF != OMF_dealloc && | |||
1452 | MF != OMF_finalize && | |||
1453 | !S.IvarBacksCurrentMethodAccessor(IDecl, MD, IV)); | |||
1454 | } | |||
1455 | if (warn) | |||
1456 | S.Diag(MemberLoc, diag::warn_direct_ivar_access) << IV->getDeclName(); | |||
1457 | } | |||
1458 | ||||
1459 | ObjCIvarRefExpr *Result = new (S.Context) ObjCIvarRefExpr( | |||
1460 | IV, IV->getUsageType(BaseType), MemberLoc, OpLoc, BaseExpr.get(), | |||
1461 | IsArrow); | |||
1462 | ||||
1463 | if (IV->getType().getObjCLifetime() == Qualifiers::OCL_Weak) { | |||
1464 | if (!S.isUnevaluatedContext() && | |||
1465 | !S.Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, MemberLoc)) | |||
1466 | S.getCurFunction()->recordUseOfWeak(Result); | |||
1467 | } | |||
1468 | ||||
1469 | return Result; | |||
1470 | } | |||
1471 | ||||
1472 | // Objective-C property access. | |||
1473 | const ObjCObjectPointerType *OPT; | |||
1474 | if (!IsArrow
| |||
1475 | if (!SS.isEmpty() && !SS.isInvalid()) { | |||
1476 | S.Diag(SS.getRange().getBegin(), diag::err_qualified_objc_access) | |||
1477 | << 0 << SS.getScopeRep() << FixItHint::CreateRemoval(SS.getRange()); | |||
1478 | SS.clear(); | |||
1479 | } | |||
1480 | ||||
1481 | // This actually uses the base as an r-value. | |||
1482 | BaseExpr = S.DefaultLvalueConversion(BaseExpr.get()); | |||
1483 | if (BaseExpr.isInvalid()) | |||
1484 | return ExprError(); | |||
1485 | ||||
1486 | assert(S.Context.hasSameUnqualifiedType(BaseType,((S.Context.hasSameUnqualifiedType(BaseType, BaseExpr.get()-> getType())) ? static_cast<void> (0) : __assert_fail ("S.Context.hasSameUnqualifiedType(BaseType, BaseExpr.get()->getType())" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp" , 1487, __PRETTY_FUNCTION__)) | |||
1487 | BaseExpr.get()->getType()))((S.Context.hasSameUnqualifiedType(BaseType, BaseExpr.get()-> getType())) ? static_cast<void> (0) : __assert_fail ("S.Context.hasSameUnqualifiedType(BaseType, BaseExpr.get()->getType())" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp" , 1487, __PRETTY_FUNCTION__)); | |||
1488 | ||||
1489 | IdentifierInfo *Member = MemberName.getAsIdentifierInfo(); | |||
1490 | ||||
1491 | const ObjCObjectType *OT = OPT->getObjectType(); | |||
1492 | ||||
1493 | // id, with and without qualifiers. | |||
1494 | if (OT->isObjCId()) { | |||
1495 | // Check protocols on qualified interfaces. | |||
1496 | Selector Sel = S.PP.getSelectorTable().getNullarySelector(Member); | |||
1497 | if (Decl *PMDecl = | |||
1498 | FindGetterSetterNameDecl(OPT, Member, Sel, S.Context)) { | |||
1499 | if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(PMDecl)) { | |||
1500 | // Check the use of this declaration | |||
1501 | if (S.DiagnoseUseOfDecl(PD, MemberLoc)) | |||
1502 | return ExprError(); | |||
1503 | ||||
1504 | return new (S.Context) | |||
1505 | ObjCPropertyRefExpr(PD, S.Context.PseudoObjectTy, VK_LValue, | |||
1506 | OK_ObjCProperty, MemberLoc, BaseExpr.get()); | |||
1507 | } | |||
1508 | ||||
1509 | if (ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(PMDecl)) { | |||
1510 | Selector SetterSel = | |||
1511 | SelectorTable::constructSetterSelector(S.PP.getIdentifierTable(), | |||
1512 | S.PP.getSelectorTable(), | |||
1513 | Member); | |||
1514 | ObjCMethodDecl *SMD = nullptr; | |||
1515 | if (Decl *SDecl = FindGetterSetterNameDecl(OPT, | |||
1516 | /*Property id*/ nullptr, | |||
1517 | SetterSel, S.Context)) | |||
1518 | SMD = dyn_cast<ObjCMethodDecl>(SDecl); | |||
1519 | ||||
1520 | return new (S.Context) | |||
1521 | ObjCPropertyRefExpr(OMD, SMD, S.Context.PseudoObjectTy, VK_LValue, | |||
1522 | OK_ObjCProperty, MemberLoc, BaseExpr.get()); | |||
1523 | } | |||
1524 | } | |||
1525 | // Use of id.member can only be for a property reference. Do not | |||
1526 | // use the 'id' redefinition in this case. | |||
1527 | if (IsArrow && ShouldTryAgainWithRedefinitionType(S, BaseExpr)) | |||
1528 | return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS, | |||
1529 | ObjCImpDecl, HasTemplateArgs, TemplateKWLoc); | |||
1530 | ||||
1531 | return ExprError(S.Diag(MemberLoc, diag::err_property_not_found) | |||
1532 | << MemberName << BaseType); | |||
1533 | } | |||
1534 | ||||
1535 | // 'Class', unqualified only. | |||
1536 | if (OT->isObjCClass()) { | |||
1537 | // Only works in a method declaration (??!). | |||
1538 | ObjCMethodDecl *MD = S.getCurMethodDecl(); | |||
1539 | if (!MD) { | |||
1540 | if (ShouldTryAgainWithRedefinitionType(S, BaseExpr)) | |||
1541 | return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS, | |||
1542 | ObjCImpDecl, HasTemplateArgs, TemplateKWLoc); | |||
1543 | ||||
1544 | goto fail; | |||
1545 | } | |||
1546 | ||||
1547 | // Also must look for a getter name which uses property syntax. | |||
1548 | Selector Sel = S.PP.getSelectorTable().getNullarySelector(Member); | |||
1549 | ObjCInterfaceDecl *IFace = MD->getClassInterface(); | |||
1550 | if (!IFace) | |||
1551 | goto fail; | |||
1552 | ||||
1553 | ObjCMethodDecl *Getter; | |||
1554 | if ((Getter = IFace->lookupClassMethod(Sel))) { | |||
1555 | // Check the use of this method. | |||
1556 | if (S.DiagnoseUseOfDecl(Getter, MemberLoc)) | |||
1557 | return ExprError(); | |||
1558 | } else | |||
1559 | Getter = IFace->lookupPrivateMethod(Sel, false); | |||
1560 | // If we found a getter then this may be a valid dot-reference, we | |||
1561 | // will look for the matching setter, in case it is needed. | |||
1562 | Selector SetterSel = | |||
1563 | SelectorTable::constructSetterSelector(S.PP.getIdentifierTable(), | |||
1564 | S.PP.getSelectorTable(), | |||
1565 | Member); | |||
1566 | ObjCMethodDecl *Setter = IFace->lookupClassMethod(SetterSel); | |||
1567 | if (!Setter) { | |||
1568 | // If this reference is in an @implementation, also check for 'private' | |||
1569 | // methods. | |||
1570 | Setter = IFace->lookupPrivateMethod(SetterSel, false); | |||
1571 | } | |||
1572 | ||||
1573 | if (Setter && S.DiagnoseUseOfDecl(Setter, MemberLoc)) | |||
1574 | return ExprError(); | |||
1575 | ||||
1576 | if (Getter || Setter) { | |||
1577 | return new (S.Context) ObjCPropertyRefExpr( | |||
1578 | Getter, Setter, S.Context.PseudoObjectTy, VK_LValue, | |||
1579 | OK_ObjCProperty, MemberLoc, BaseExpr.get()); | |||
1580 | } | |||
1581 | ||||
1582 | if (ShouldTryAgainWithRedefinitionType(S, BaseExpr)) | |||
1583 | return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS, | |||
1584 | ObjCImpDecl, HasTemplateArgs, TemplateKWLoc); | |||
1585 | ||||
1586 | return ExprError(S.Diag(MemberLoc, diag::err_property_not_found) | |||
1587 | << MemberName << BaseType); | |||
1588 | } | |||
1589 | ||||
1590 | // Normal property access. | |||
1591 | return S.HandleExprPropertyRefExpr(OPT, BaseExpr.get(), OpLoc, MemberName, | |||
1592 | MemberLoc, SourceLocation(), QualType(), | |||
1593 | false); | |||
1594 | } | |||
1595 | ||||
1596 | // Handle 'field access' to vectors, such as 'V.xx'. | |||
1597 | if (BaseType->isExtVectorType()) { | |||
1598 | // FIXME: this expr should store IsArrow. | |||
1599 | IdentifierInfo *Member = MemberName.getAsIdentifierInfo(); | |||
1600 | ExprValueKind VK; | |||
1601 | if (IsArrow
| |||
1602 | VK = VK_LValue; | |||
1603 | else { | |||
1604 | if (PseudoObjectExpr *POE
| |||
1605 | VK = POE->getSyntacticForm()->getValueKind(); | |||
1606 | else | |||
1607 | VK = BaseExpr.get()->getValueKind(); | |||
1608 | } | |||
1609 | ||||
1610 | QualType ret = CheckExtVectorComponent(S, BaseType, VK, OpLoc, | |||
1611 | Member, MemberLoc); | |||
1612 | if (ret.isNull()) | |||
1613 | return ExprError(); | |||
1614 | Qualifiers BaseQ = | |||
1615 | S.Context.getCanonicalType(BaseExpr.get()->getType()).getQualifiers(); | |||
1616 | ret = S.Context.getQualifiedType(ret, BaseQ); | |||
1617 | ||||
1618 | return new (S.Context) | |||
1619 | ExtVectorElementExpr(ret, VK, BaseExpr.get(), *Member, MemberLoc); | |||
1620 | } | |||
1621 | ||||
1622 | // Adjust builtin-sel to the appropriate redefinition type if that's | |||
1623 | // not just a pointer to builtin-sel again. | |||
1624 | if (IsArrow && BaseType->isSpecificBuiltinType(BuiltinType::ObjCSel) && | |||
1625 | !S.Context.getObjCSelRedefinitionType()->isObjCSelType()) { | |||
1626 | BaseExpr = S.ImpCastExprToType( | |||
1627 | BaseExpr.get(), S.Context.getObjCSelRedefinitionType(), CK_BitCast); | |||
1628 | return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS, | |||
1629 | ObjCImpDecl, HasTemplateArgs, TemplateKWLoc); | |||
1630 | } | |||
1631 | ||||
1632 | // Failure cases. | |||
1633 | fail: | |||
1634 | ||||
1635 | // Recover from dot accesses to pointers, e.g.: | |||
1636 | // type *foo; | |||
1637 | // foo.bar | |||
1638 | // This is actually well-formed in two cases: | |||
1639 | // - 'type' is an Objective C type | |||
1640 | // - 'bar' is a pseudo-destructor name which happens to refer to | |||
1641 | // the appropriate pointer type | |||
1642 | if (const PointerType *Ptr = BaseType->getAs<PointerType>()) { | |||
1643 | if (!IsArrow && Ptr->getPointeeType()->isRecordType() && | |||
1644 | MemberName.getNameKind() != DeclarationName::CXXDestructorName) { | |||
1645 | S.Diag(OpLoc, diag::err_typecheck_member_reference_suggestion) | |||
1646 | << BaseType << int(IsArrow) << BaseExpr.get()->getSourceRange() | |||
1647 | << FixItHint::CreateReplacement(OpLoc, "->"); | |||
1648 | ||||
1649 | // Recurse as an -> access. | |||
1650 | IsArrow = true; | |||
1651 | return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS, | |||
1652 | ObjCImpDecl, HasTemplateArgs, TemplateKWLoc); | |||
1653 | } | |||
1654 | } | |||
1655 | ||||
1656 | // If the user is trying to apply -> or . to a function name, it's probably | |||
1657 | // because they forgot parentheses to call that function. | |||
1658 | if (S.tryToRecoverWithCall( | |||
1659 | BaseExpr, S.PDiag(diag::err_member_reference_needs_call), | |||
1660 | /*complain*/ false, | |||
1661 | IsArrow ? &isPointerToRecordType : &isRecordType)) { | |||
1662 | if (BaseExpr.isInvalid()) | |||
1663 | return ExprError(); | |||
1664 | BaseExpr = S.DefaultFunctionArrayConversion(BaseExpr.get()); | |||
1665 | return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS, | |||
1666 | ObjCImpDecl, HasTemplateArgs, TemplateKWLoc); | |||
1667 | } | |||
1668 | ||||
1669 | S.Diag(OpLoc, diag::err_typecheck_member_reference_struct_union) | |||
1670 | << BaseType << BaseExpr.get()->getSourceRange() << MemberLoc; | |||
1671 | ||||
1672 | return ExprError(); | |||
1673 | } | |||
1674 | ||||
1675 | /// The main callback when the parser finds something like | |||
1676 | /// expression . [nested-name-specifier] identifier | |||
1677 | /// expression -> [nested-name-specifier] identifier | |||
1678 | /// where 'identifier' encompasses a fairly broad spectrum of | |||
1679 | /// possibilities, including destructor and operator references. | |||
1680 | /// | |||
1681 | /// \param OpKind either tok::arrow or tok::period | |||
1682 | /// \param ObjCImpDecl the current Objective-C \@implementation | |||
1683 | /// decl; this is an ugly hack around the fact that Objective-C | |||
1684 | /// \@implementations aren't properly put in the context chain | |||
1685 | ExprResult Sema::ActOnMemberAccessExpr(Scope *S, Expr *Base, | |||
1686 | SourceLocation OpLoc, | |||
1687 | tok::TokenKind OpKind, | |||
1688 | CXXScopeSpec &SS, | |||
1689 | SourceLocation TemplateKWLoc, | |||
1690 | UnqualifiedId &Id, | |||
1691 | Decl *ObjCImpDecl) { | |||
1692 | if (SS.isSet() && SS.isInvalid()) | |||
1693 | return ExprError(); | |||
1694 | ||||
1695 | // Warn about the explicit constructor calls Microsoft extension. | |||
1696 | if (getLangOpts().MicrosoftExt && | |||
1697 | Id.getKind() == UnqualifiedIdKind::IK_ConstructorName) | |||
1698 | Diag(Id.getSourceRange().getBegin(), | |||
1699 | diag::ext_ms_explicit_constructor_call); | |||
1700 | ||||
1701 | TemplateArgumentListInfo TemplateArgsBuffer; | |||
1702 | ||||
1703 | // Decompose the name into its component parts. | |||
1704 | DeclarationNameInfo NameInfo; | |||
1705 | const TemplateArgumentListInfo *TemplateArgs; | |||
1706 | DecomposeUnqualifiedId(Id, TemplateArgsBuffer, | |||
1707 | NameInfo, TemplateArgs); | |||
1708 | ||||
1709 | DeclarationName Name = NameInfo.getName(); | |||
1710 | bool IsArrow = (OpKind == tok::arrow); | |||
1711 | ||||
1712 | NamedDecl *FirstQualifierInScope | |||
1713 | = (!SS.isSet() ? nullptr : FindFirstQualifierInScope(S, SS.getScopeRep())); | |||
1714 | ||||
1715 | // This is a postfix expression, so get rid of ParenListExprs. | |||
1716 | ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Base); | |||
1717 | if (Result.isInvalid()) return ExprError(); | |||
1718 | Base = Result.get(); | |||
1719 | ||||
1720 | if (Base->getType()->isDependentType() || Name.isDependentName() || | |||
1721 | isDependentScopeSpecifier(SS)) { | |||
1722 | return ActOnDependentMemberExpr(Base, Base->getType(), IsArrow, OpLoc, SS, | |||
1723 | TemplateKWLoc, FirstQualifierInScope, | |||
1724 | NameInfo, TemplateArgs); | |||
1725 | } | |||
1726 | ||||
1727 | ActOnMemberAccessExtraArgs ExtraArgs = {S, Id, ObjCImpDecl}; | |||
1728 | ExprResult Res = BuildMemberReferenceExpr( | |||
1729 | Base, Base->getType(), OpLoc, IsArrow, SS, TemplateKWLoc, | |||
1730 | FirstQualifierInScope, NameInfo, TemplateArgs, S, &ExtraArgs); | |||
1731 | ||||
1732 | if (!Res.isInvalid() && isa<MemberExpr>(Res.get())) | |||
1733 | CheckMemberAccessOfNoDeref(cast<MemberExpr>(Res.get())); | |||
1734 | ||||
1735 | return Res; | |||
1736 | } | |||
1737 | ||||
1738 | void Sema::CheckMemberAccessOfNoDeref(const MemberExpr *E) { | |||
1739 | QualType ResultTy = E->getType(); | |||
1740 | ||||
1741 | // Do not warn on member accesses to arrays since this returns an array | |||
1742 | // lvalue and does not actually dereference memory. | |||
1743 | if (isa<ArrayType>(ResultTy)) | |||
1744 | return; | |||
1745 | ||||
1746 | if (E->isArrow()) { | |||
1747 | if (const auto *Ptr = dyn_cast<PointerType>( | |||
1748 | E->getBase()->getType().getDesugaredType(Context))) { | |||
1749 | if (Ptr->getPointeeType()->hasAttr(attr::NoDeref)) | |||
1750 | ExprEvalContexts.back().PossibleDerefs.insert(E); | |||
1751 | } | |||
1752 | } | |||
1753 | } | |||
1754 | ||||
1755 | ExprResult | |||
1756 | Sema::BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow, | |||
1757 | SourceLocation OpLoc, const CXXScopeSpec &SS, | |||
1758 | FieldDecl *Field, DeclAccessPair FoundDecl, | |||
1759 | const DeclarationNameInfo &MemberNameInfo) { | |||
1760 | // x.a is an l-value if 'a' has a reference type. Otherwise: | |||
1761 | // x.a is an l-value/x-value/pr-value if the base is (and note | |||
1762 | // that *x is always an l-value), except that if the base isn't | |||
1763 | // an ordinary object then we must have an rvalue. | |||
1764 | ExprValueKind VK = VK_LValue; | |||
1765 | ExprObjectKind OK = OK_Ordinary; | |||
1766 | if (!IsArrow) { | |||
1767 | if (BaseExpr->getObjectKind() == OK_Ordinary) | |||
1768 | VK = BaseExpr->getValueKind(); | |||
1769 | else | |||
1770 | VK = VK_RValue; | |||
1771 | } | |||
1772 | if (VK != VK_RValue && Field->isBitField()) | |||
1773 | OK = OK_BitField; | |||
1774 | ||||
1775 | // Figure out the type of the member; see C99 6.5.2.3p3, C++ [expr.ref] | |||
1776 | QualType MemberType = Field->getType(); | |||
1777 | if (const ReferenceType *Ref = MemberType->getAs<ReferenceType>()) { | |||
1778 | MemberType = Ref->getPointeeType(); | |||
1779 | VK = VK_LValue; | |||
1780 | } else { | |||
1781 | QualType BaseType = BaseExpr->getType(); | |||
1782 | if (IsArrow) BaseType = BaseType->getAs<PointerType>()->getPointeeType(); | |||
1783 | ||||
1784 | Qualifiers BaseQuals = BaseType.getQualifiers(); | |||
1785 | ||||
1786 | // GC attributes are never picked up by members. | |||
1787 | BaseQuals.removeObjCGCAttr(); | |||
1788 | ||||
1789 | // CVR attributes from the base are picked up by members, | |||
1790 | // except that 'mutable' members don't pick up 'const'. | |||
1791 | if (Field->isMutable()) BaseQuals.removeConst(); | |||
1792 | ||||
1793 | Qualifiers MemberQuals = | |||
1794 | Context.getCanonicalType(MemberType).getQualifiers(); | |||
1795 | ||||
1796 | assert(!MemberQuals.hasAddressSpace())((!MemberQuals.hasAddressSpace()) ? static_cast<void> ( 0) : __assert_fail ("!MemberQuals.hasAddressSpace()", "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp" , 1796, __PRETTY_FUNCTION__)); | |||
1797 | ||||
1798 | Qualifiers Combined = BaseQuals + MemberQuals; | |||
1799 | if (Combined != MemberQuals) | |||
1800 | MemberType = Context.getQualifiedType(MemberType, Combined); | |||
1801 | } | |||
1802 | ||||
1803 | auto *CurMethod = dyn_cast<CXXMethodDecl>(CurContext); | |||
1804 | if (!(CurMethod && CurMethod->isDefaulted())) | |||
1805 | UnusedPrivateFields.remove(Field); | |||
1806 | ||||
1807 | ExprResult Base = PerformObjectMemberConversion(BaseExpr, SS.getScopeRep(), | |||
1808 | FoundDecl, Field); | |||
1809 | if (Base.isInvalid()) | |||
1810 | return ExprError(); | |||
1811 | ||||
1812 | // Build a reference to a private copy for non-static data members in | |||
1813 | // non-static member functions, privatized by OpenMP constructs. | |||
1814 | if (getLangOpts().OpenMP && IsArrow && | |||
1815 | !CurContext->isDependentContext() && | |||
1816 | isa<CXXThisExpr>(Base.get()->IgnoreParenImpCasts())) { | |||
1817 | if (auto *PrivateCopy = isOpenMPCapturedDecl(Field)) { | |||
1818 | return getOpenMPCapturedExpr(PrivateCopy, VK, OK, | |||
1819 | MemberNameInfo.getLoc()); | |||
1820 | } | |||
1821 | } | |||
1822 | ||||
1823 | return BuildMemberExpr(Base.get(), IsArrow, OpLoc, &SS, | |||
1824 | /*TemplateKWLoc=*/SourceLocation(), Field, FoundDecl, | |||
1825 | /*HadMultipleCandidates=*/false, MemberNameInfo, | |||
1826 | MemberType, VK, OK); | |||
1827 | } | |||
1828 | ||||
1829 | /// Builds an implicit member access expression. The current context | |||
1830 | /// is known to be an instance method, and the given unqualified lookup | |||
1831 | /// set is known to contain only instance members, at least one of which | |||
1832 | /// is from an appropriate type. | |||
1833 | ExprResult | |||
1834 | Sema::BuildImplicitMemberExpr(const CXXScopeSpec &SS, | |||
1835 | SourceLocation TemplateKWLoc, | |||
1836 | LookupResult &R, | |||
1837 | const TemplateArgumentListInfo *TemplateArgs, | |||
1838 | bool IsKnownInstance, const Scope *S) { | |||
1839 | assert(!R.empty() && !R.isAmbiguous())((!R.empty() && !R.isAmbiguous()) ? static_cast<void > (0) : __assert_fail ("!R.empty() && !R.isAmbiguous()" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp" , 1839, __PRETTY_FUNCTION__)); | |||
1840 | ||||
1841 | SourceLocation loc = R.getNameLoc(); | |||
1842 | ||||
1843 | // If this is known to be an instance access, go ahead and build an | |||
1844 | // implicit 'this' expression now. | |||
1845 | // 'this' expression now. | |||
1846 | QualType ThisTy = getCurrentThisType(); | |||
1847 | assert(!ThisTy.isNull() && "didn't correctly pre-flight capture of 'this'")((!ThisTy.isNull() && "didn't correctly pre-flight capture of 'this'" ) ? static_cast<void> (0) : __assert_fail ("!ThisTy.isNull() && \"didn't correctly pre-flight capture of 'this'\"" , "/build/llvm-toolchain-snapshot-10~+201911111502510600c19528f1809/clang/lib/Sema/SemaExprMember.cpp" , 1847, __PRETTY_FUNCTION__)); | |||
1848 | ||||
1849 | Expr *baseExpr = nullptr; // null signifies implicit access | |||
1850 | if (IsKnownInstance) { | |||
1851 | SourceLocation Loc = R.getNameLoc(); | |||
1852 | if (SS.getRange().isValid()) | |||
1853 | Loc = SS.getRange().getBegin(); | |||
1854 | baseExpr = BuildCXXThisExpr(loc, ThisTy, /*IsImplicit=*/true); | |||
1855 | } | |||
1856 | ||||
1857 | return BuildMemberReferenceExpr(baseExpr, ThisTy, | |||
1858 | /*OpLoc*/ SourceLocation(), | |||
1859 | /*IsArrow*/ true, | |||
1860 | SS, TemplateKWLoc, | |||
1861 | /*FirstQualifierInScope*/ nullptr, | |||
1862 | R, TemplateArgs, S); | |||
1863 | } |