clang 10.0.0git

SemaExprMember.cpp
Go to the documentation of this file.
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());
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);
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;
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");
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) compStr++;
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 && *compStr) {
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 ? (vecType->getNumElements() + 1) / 2
407 : CompName->getLength();
408 if (HexSwizzle)
409 CompSize--;
410
411 if (CompSize == 1)
412 return vecType->getElementType();
413
414 if (HasRepeated) VK = VK_RValue;
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");
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() ||
508 NameInfo.getName().isDependentName() ||
509 isDependentScopeSpecifier(SS));
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());
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");
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() &&
709 "Got a keyword as a correction for a member!");
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());
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?");
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) &&
834 "referencing anonymous struct/union without a base variable or "
835 "expression");
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");
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
923 // C++ [except.spec]p17:
924 // An exception-specification is considered to be needed when:
925 // - in an expression the function is the unique lookup result or the
926 // selected member of a set of overloaded functions
927 if (auto *FPT = Ty->getAs<FunctionProtoType>()) {
928 if (isUnresolvedExceptionSpec(FPT->getExceptionSpecType())) {
929 if (auto *NewFPT = ResolveExceptionSpec(MemberNameInfo.getLoc(), FPT))
930 E->setType(Context.getQualifiedType(NewFPT, Ty.getQualifiers()));
931 }
932 }
933
934 return E;
935 }
936
937 /// Determine if the given scope is within a function-try-block handler.
938 static bool IsInFnTryBlockHandler(const Scope *S) {
939 // Walk the scope stack until finding a FnTryCatchScope, or leave the
940 // function scope. If a FnTryCatchScope is found, check whether the TryScope
941 // flag is set. If it is not, it's a function-try-block handler.
942 for (; S != S->getFnParent(); S = S->getParent()) {
943 if (S->getFlags() & Scope::FnTryCatchScope)
944 return (S->getFlags() & Scope::TryScope) != Scope::TryScope;
945 }
946 return false;
947 }
948
949 VarDecl *
950 Sema::getVarTemplateSpecialization(VarTemplateDecl *VarTempl,
951 const TemplateArgumentListInfo *TemplateArgs,
952 const DeclarationNameInfo &MemberNameInfo,
953 SourceLocation TemplateKWLoc) {
954 if (!TemplateArgs) {
955 diagnoseMissingTemplateArguments(TemplateName(VarTempl),
956 MemberNameInfo.getBeginLoc());
957 return nullptr;
958 }
959
960 DeclResult VDecl = CheckVarTemplateId(VarTempl, TemplateKWLoc,
961 MemberNameInfo.getLoc(), *TemplateArgs);
962 if (VDecl.isInvalid())
963 return nullptr;
964 VarDecl *Var = cast<VarDecl>(VDecl.get());
965 if (!Var->getTemplateSpecializationKind())
966 Var->setTemplateSpecializationKind(TSK_ImplicitInstantiation,
967 MemberNameInfo.getLoc());
968 return Var;
969 }
970
971 ExprResult
972 Sema::BuildMemberReferenceExpr(Expr *BaseExpr, QualType BaseExprType,
973 SourceLocation OpLoc, bool IsArrow,
974 const CXXScopeSpec &SS,
975 SourceLocation TemplateKWLoc,
976 NamedDecl *FirstQualifierInScope,
977 LookupResult &R,
978 const TemplateArgumentListInfo *TemplateArgs,
979 const Scope *S,
980 bool SuppressQualifierCheck,
981 ActOnMemberAccessExtraArgs *ExtraArgs) {
982 QualType BaseType = BaseExprType;
983 if (IsArrow) {
984 assert(BaseType->isPointerType());
985 BaseType = BaseType->castAs<PointerType>()->getPointeeType();
986 }
987 R.setBaseObjectType(BaseType);
988
989 // C++1z [expr.ref]p2:
990 // For the first option (dot) the first expression shall be a glvalue [...]
991 if (!IsArrow && BaseExpr && BaseExpr->isRValue()) {
992 ExprResult Converted = TemporaryMaterializationConversion(BaseExpr);
993 if (Converted.isInvalid())
994 return ExprError();
995 BaseExpr = Converted.get();
996 }
997
998
999 const DeclarationNameInfo &MemberNameInfo = R.getLookupNameInfo();
1000 DeclarationName MemberName = MemberNameInfo.getName();
1001 SourceLocation MemberLoc = MemberNameInfo.getLoc();
1002
1003 if (R.isAmbiguous())
1004 return ExprError();
1005
1006 // [except.handle]p10: Referring to any non-static member or base class of an
1007 // object in the handler for a function-try-block of a constructor or
1008 // destructor for that object results in undefined behavior.
1009 const auto *FD = getCurFunctionDecl();
1010 if (S && BaseExpr && FD &&
1011 (isa<CXXDestructorDecl>(FD) || isa<CXXConstructorDecl>(FD)) &&
1012 isa<CXXThisExpr>(BaseExpr->IgnoreImpCasts()) &&
1013 IsInFnTryBlockHandler(S))
1014 Diag(MemberLoc, diag::warn_cdtor_function_try_handler_mem_expr)
1015 << isa<CXXDestructorDecl>(FD);
1016
1017 if (R.empty()) {
1018 // Rederive where we looked up.
1019 DeclContext *DC = (SS.isSet()
1020 ? computeDeclContext(SS, false)
1021 : BaseType->castAs<RecordType>()->getDecl());
1022
1023 if (ExtraArgs) {
1024 ExprResult RetryExpr;
1025 if (!IsArrow && BaseExpr) {
1026 SFINAETrap Trap(*this, true);
1027 ParsedType ObjectType;
1028 bool MayBePseudoDestructor = false;
1029 RetryExpr = ActOnStartCXXMemberReference(getCurScope(), BaseExpr,
1030 OpLoc, tok::arrow, ObjectType,
1031 MayBePseudoDestructor);
1032 if (RetryExpr.isUsable() && !Trap.hasErrorOccurred()) {
1033 CXXScopeSpec TempSS(SS);
1034 RetryExpr = ActOnMemberAccessExpr(
1035 ExtraArgs->S, RetryExpr.get(), OpLoc, tok::arrow, TempSS,
1036 TemplateKWLoc, ExtraArgs->Id, ExtraArgs->ObjCImpDecl);
1037 }
1038 if (Trap.hasErrorOccurred())
1039 RetryExpr = ExprError();
1040 }
1041 if (RetryExpr.isUsable()) {
1042 Diag(OpLoc, diag::err_no_member_overloaded_arrow)
1043 << MemberName << DC << FixItHint::CreateReplacement(OpLoc, "->");
1044 return RetryExpr;
1045 }
1046 }
1047
1048 Diag(R.getNameLoc(), diag::err_no_member)
1049 << MemberName << DC
1050 << (BaseExpr ? BaseExpr->getSourceRange() : SourceRange());
1051 return ExprError();
1052 }
1053
1054 // Diagnose lookups that find only declarations from a non-base
1055 // type. This is possible for either qualified lookups (which may
1056 // have been qualified with an unrelated type) or implicit member
1057 // expressions (which were found with unqualified lookup and thus
1058 // may have come from an enclosing scope). Note that it's okay for
1059 // lookup to find declarations from a non-base type as long as those
1060 // aren't the ones picked by overload resolution.
1061 if ((SS.isSet() || !BaseExpr ||
1062 (isa<CXXThisExpr>(BaseExpr) &&
1063 cast<CXXThisExpr>(BaseExpr)->isImplicit())) &&
1064 !SuppressQualifierCheck &&
1065 CheckQualifiedMemberReference(BaseExpr, BaseType, SS, R))
1066 return ExprError();
1067
1068 // Construct an unresolved result if we in fact got an unresolved
1069 // result.
1070 if (R.isOverloadedResult() || R.isUnresolvableResult()) {
1071 // Suppress any lookup-related diagnostics; we'll do these when we
1072 // pick a member.
1073 R.suppressDiagnostics();
1074
1075 UnresolvedMemberExpr *MemExpr
1076 = UnresolvedMemberExpr::Create(Context, R.isUnresolvableResult(),
1077 BaseExpr, BaseExprType,
1078 IsArrow, OpLoc,
1079 SS.getWithLocInContext(Context),
1080 TemplateKWLoc, MemberNameInfo,
1081 TemplateArgs, R.begin(), R.end());
1082
1083 return MemExpr;
1084 }
1085
1086 assert(R.isSingleResult());
1087 DeclAccessPair FoundDecl = R.begin().getPair();
1088 NamedDecl *MemberDecl = R.getFoundDecl();
1089
1090 // FIXME: diagnose the presence of template arguments now.
1091
1092 // If the decl being referenced had an error, return an error for this
1093 // sub-expr without emitting another error, in order to avoid cascading
1094 // error cases.
1095 if (MemberDecl->isInvalidDecl())
1096 return ExprError();
1097
1098 // Handle the implicit-member-access case.
1099 if (!BaseExpr) {
1100 // If this is not an instance member, convert to a non-member access.
1101 if (!MemberDecl->isCXXInstanceMember()) {
1102 // If this is a variable template, get the instantiated variable
1103 // declaration corresponding to the supplied template arguments
1104 // (while emitting diagnostics as necessary) that will be referenced
1105 // by this expression.
1106 assert((!TemplateArgs || isa<VarTemplateDecl>(MemberDecl)) &&
1107 "How did we get template arguments here sans a variable template");
1108 if (isa<VarTemplateDecl>(MemberDecl)) {
1109 MemberDecl = getVarTemplateSpecialization(
1110 cast<VarTemplateDecl>(MemberDecl), TemplateArgs,
1111 R.getLookupNameInfo(), TemplateKWLoc);
1112 if (!MemberDecl)
1113 return ExprError();
1114 }
1115 return BuildDeclarationNameExpr(SS, R.getLookupNameInfo(), MemberDecl,
1116 FoundDecl, TemplateArgs);
1117 }
1118 SourceLocation Loc = R.getNameLoc();
1119 if (SS.getRange().isValid())
1120 Loc = SS.getRange().getBegin();
1121 BaseExpr = BuildCXXThisExpr(Loc, BaseExprType, /*IsImplicit=*/true);
1122 }
1123
1124 // Check the use of this member.
1125 if (DiagnoseUseOfDecl(MemberDecl, MemberLoc))
1126 return ExprError();
1127
1128 if (FieldDecl *FD = dyn_cast<FieldDecl>(MemberDecl))
1129 return BuildFieldReferenceExpr(BaseExpr, IsArrow, OpLoc, SS, FD, FoundDecl,
1130 MemberNameInfo);
1131
1132 if (MSPropertyDecl *PD = dyn_cast<MSPropertyDecl>(MemberDecl))
1133 return BuildMSPropertyRefExpr(*this, BaseExpr, IsArrow, SS, PD,
1134 MemberNameInfo);
1135
1136 if (IndirectFieldDecl *FD = dyn_cast<IndirectFieldDecl>(MemberDecl))
1137 // We may have found a field within an anonymous union or struct
1138 // (C++ [class.union]).
1139 return BuildAnonymousStructUnionMemberReference(SS, MemberLoc, FD,
1140 FoundDecl, BaseExpr,
1141 OpLoc);
1142
1143 if (VarDecl *Var = dyn_cast<VarDecl>(MemberDecl)) {
1144 return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc, Var,
1145 FoundDecl, /*HadMultipleCandidates=*/false,
1146 MemberNameInfo, Var->getType().getNonReferenceType(),
1147 VK_LValue, OK_Ordinary);
1148 }
1149
1150 if (CXXMethodDecl *MemberFn = dyn_cast<CXXMethodDecl>(MemberDecl)) {
1151 ExprValueKind valueKind;
1152 QualType type;
1153 if (MemberFn->isInstance()) {
1154 valueKind = VK_RValue;
1155 type = Context.BoundMemberTy;
1156 } else {
1157 valueKind = VK_LValue;
1158 type = MemberFn->getType();
1159 }
1160
1161 return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc,
1162 MemberFn, FoundDecl, /*HadMultipleCandidates=*/false,
1163 MemberNameInfo, type, valueKind, OK_Ordinary);
1164 }
1165 assert(!isa<FunctionDecl>(MemberDecl) && "member function not C++ method?");
1166
1167 if (EnumConstantDecl *Enum = dyn_cast<EnumConstantDecl>(MemberDecl)) {
1168 return BuildMemberExpr(BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc, Enum,
1169 FoundDecl, /*HadMultipleCandidates=*/false,
1170 MemberNameInfo, Enum->getType(), VK_RValue,
1171 OK_Ordinary);
1172 }
1173 if (VarTemplateDecl *VarTempl = dyn_cast<VarTemplateDecl>(MemberDecl)) {
1174 if (VarDecl *Var = getVarTemplateSpecialization(
1175 VarTempl, TemplateArgs, MemberNameInfo, TemplateKWLoc))
1176 return BuildMemberExpr(
1177 BaseExpr, IsArrow, OpLoc, &SS, TemplateKWLoc, Var, FoundDecl,
1178 /*HadMultipleCandidates=*/false, MemberNameInfo,
1179 Var->getType().getNonReferenceType(), VK_LValue, OK_Ordinary);
1180 return ExprError();
1181 }
1182
1183 // We found something that we didn't expect. Complain.
1184 if (isa<TypeDecl>(MemberDecl))
1185 Diag(MemberLoc, diag::err_typecheck_member_reference_type)
1186 << MemberName << BaseType << int(IsArrow);
1187 else
1188 Diag(MemberLoc, diag::err_typecheck_member_reference_unknown)
1189 << MemberName << BaseType << int(IsArrow);
1190
1191 Diag(MemberDecl->getLocation(), diag::note_member_declared_here)
1192 << MemberName;
1193 R.suppressDiagnostics();
1194 return ExprError();
1195 }
1196
1197 /// Given that normal member access failed on the given expression,
1198 /// and given that the expression's type involves builtin-id or
1199 /// builtin-Class, decide whether substituting in the redefinition
1200 /// types would be profitable. The redefinition type is whatever
1201 /// this translation unit tried to typedef to id/Class; we store
1202 /// it to the side and then re-use it in places like this.
1203 static bool ShouldTryAgainWithRedefinitionType(Sema &S, ExprResult &base) {
1204 const ObjCObjectPointerType *opty
1205 = base.get()->getType()->getAs<ObjCObjectPointerType>();
1206 if (!opty) return false;
1207
1208 const ObjCObjectType *ty = opty->getObjectType();
1209
1210 QualType redef;
1211 if (ty->isObjCId()) {
1212 redef = S.Context.getObjCIdRedefinitionType();
1213 } else if (ty->isObjCClass()) {
1214 redef = S.Context.getObjCClassRedefinitionType();
1215 } else {
1216 return false;
1217 }
1218
1219 // Do the substitution as long as the redefinition type isn't just a
1220 // possibly-qualified pointer to builtin-id or builtin-Class again.
1221 opty = redef->getAs<ObjCObjectPointerType>();
1222 if (opty && !opty->getObjectType()->getInterface())
1223 return false;
1224
1225 base = S.ImpCastExprToType(base.get(), redef, CK_BitCast);
1226 return true;
1227 }
1228
1229 static bool isRecordType(QualType T) {
1230 return T->isRecordType();
1231 }
1232 static bool isPointerToRecordType(QualType T) {
1233 if (const PointerType *PT = T->getAs<PointerType>())
1234 return PT->getPointeeType()->isRecordType();
1235 return false;
1236 }
1237
1238 /// Perform conversions on the LHS of a member access expression.
1239 ExprResult
1240 Sema::PerformMemberExprBaseConversion(Expr *Base, bool IsArrow) {
1241 if (IsArrow && !Base->getType()->isFunctionType())
1242 return DefaultFunctionArrayLvalueConversion(Base);
1243
1244 return CheckPlaceholderExpr(Base);
1245 }
1246
1247 /// Look up the given member of the given non-type-dependent
1248 /// expression. This can return in one of two ways:
1249 /// * If it returns a sentinel null-but-valid result, the caller will
1250 /// assume that lookup was performed and the results written into
1251 /// the provided structure. It will take over from there.
1252 /// * Otherwise, the returned expression will be produced in place of
1253 /// an ordinary member expression.
1254 ///
1255 /// The ObjCImpDecl bit is a gross hack that will need to be properly
1256 /// fixed for ObjC++.
1257 static ExprResult LookupMemberExpr(Sema &S, LookupResult &R,
1258 ExprResult &BaseExpr, bool &IsArrow,
1259 SourceLocation OpLoc, CXXScopeSpec &SS,
1260 Decl *ObjCImpDecl, bool HasTemplateArgs,
1261 SourceLocation TemplateKWLoc) {
1262 assert(BaseExpr.get() && "no base expression");
1263
1264 // Perform default conversions.
1265 BaseExpr = S.PerformMemberExprBaseConversion(BaseExpr.get(), IsArrow);
1266 if (BaseExpr.isInvalid())
1267 return ExprError();
1268
1269 QualType BaseType = BaseExpr.get()->getType();
1270 assert(!BaseType->isDependentType());
1271
1272 DeclarationName MemberName = R.getLookupName();
1273 SourceLocation MemberLoc = R.getNameLoc();
1274
1275 // For later type-checking purposes, turn arrow accesses into dot
1276 // accesses. The only access type we support that doesn't follow
1277 // the C equivalence "a->b === (*a).b" is ObjC property accesses,
1278 // and those never use arrows, so this is unaffected.
1279 if (IsArrow) {
1280 if (const PointerType *Ptr = BaseType->getAs<PointerType>())
1281 BaseType = Ptr->getPointeeType();
1282 else if (const ObjCObjectPointerType *Ptr
1283 = BaseType->getAs<ObjCObjectPointerType>())
1284 BaseType = Ptr->getPointeeType();
1285 else if (BaseType->isRecordType()) {
1286 // Recover from arrow accesses to records, e.g.:
1287 // struct MyRecord foo;
1288 // foo->bar
1289 // This is actually well-formed in C++ if MyRecord has an
1290 // overloaded operator->, but that should have been dealt with
1291 // by now--or a diagnostic message already issued if a problem
1292 // was encountered while looking for the overloaded operator->.
1293 if (!S.getLangOpts().CPlusPlus) {
1294 S.Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
1295 << BaseType << int(IsArrow) << BaseExpr.get()->getSourceRange()
1296 << FixItHint::CreateReplacement(OpLoc, ".");
1297 }
1298 IsArrow = false;
1299 } else if (BaseType->isFunctionType()) {
1300 goto fail;
1301 } else {
1302 S.Diag(MemberLoc, diag::err_typecheck_member_reference_arrow)
1303 << BaseType << BaseExpr.get()->getSourceRange();
1304 return ExprError();
1305 }
1306 }
1307
1308 // Handle field access to simple records.
1309 if (const RecordType *RTy = BaseType->getAs<RecordType>()) {
1310 TypoExpr *TE = nullptr;
1311 if (LookupMemberExprInRecord(S, R, BaseExpr.get(), RTy, OpLoc, IsArrow, SS,
1312 HasTemplateArgs, TemplateKWLoc, TE))
1313 return ExprError();
1314
1315 // Returning valid-but-null is how we indicate to the caller that
1316 // the lookup result was filled in. If typo correction was attempted and
1317 // failed, the lookup result will have been cleared--that combined with the
1318 // valid-but-null ExprResult will trigger the appropriate diagnostics.
1319 return ExprResult(TE);
1320 }
1321
1322 // Handle ivar access to Objective-C objects.
1323 if (const ObjCObjectType *OTy = BaseType->getAs<ObjCObjectType>()) {
1324 if (!SS.isEmpty() && !SS.isInvalid()) {
1325 S.Diag(SS.getRange().getBegin(), diag::err_qualified_objc_access)
1326 << 1 << SS.getScopeRep()
1327 << FixItHint::CreateRemoval(SS.getRange());
1328 SS.clear();
1329 }
1330
1331 IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
1332
1333 // There are three cases for the base type:
1334 // - builtin id (qualified or unqualified)
1335 // - builtin Class (qualified or unqualified)
1336 // - an interface
1337 ObjCInterfaceDecl *IDecl = OTy->getInterface();
1338 if (!IDecl) {
1339 if (S.getLangOpts().ObjCAutoRefCount &&
1340 (OTy->isObjCId() || OTy->isObjCClass()))
1341 goto fail;
1342 // There's an implicit 'isa' ivar on all objects.
1343 // But we only actually find it this way on objects of type 'id',
1344 // apparently.
1345 if (OTy->isObjCId() && Member->isStr("isa"))
1346 return new (S.Context) ObjCIsaExpr(BaseExpr.get(), IsArrow, MemberLoc,
1347 OpLoc, S.Context.getObjCClassType());
1348 if (ShouldTryAgainWithRedefinitionType(S, BaseExpr))
1349 return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1350 ObjCImpDecl, HasTemplateArgs, TemplateKWLoc);
1351 goto fail;
1352 }
1353
1354 if (S.RequireCompleteType(OpLoc, BaseType,
1355 diag::err_typecheck_incomplete_tag,
1356 BaseExpr.get()))
1357 return ExprError();
1358
1359 ObjCInterfaceDecl *ClassDeclared = nullptr;
1360 ObjCIvarDecl *IV = IDecl->lookupInstanceVariable(Member, ClassDeclared);
1361
1362 if (!IV) {
1363 // Attempt to correct for typos in ivar names.
1364 DeclFilterCCC<ObjCIvarDecl> Validator{};
1365 Validator.IsObjCIvarLookup = IsArrow;
1366 if (TypoCorrection Corrected = S.CorrectTypo(
1367 R.getLookupNameInfo(), Sema::LookupMemberName, nullptr, nullptr,
1368 Validator, Sema::CTK_ErrorRecovery, IDecl)) {
1369 IV = Corrected.getCorrectionDeclAs<ObjCIvarDecl>();
1370 S.diagnoseTypo(
1371 Corrected,
1372 S.PDiag(diag::err_typecheck_member_reference_ivar_suggest)
1373 << IDecl->getDeclName() << MemberName);
1374
1375 // Figure out the class that declares the ivar.
1376 assert(!ClassDeclared);
1377
1378 Decl *D = cast<Decl>(IV->getDeclContext());
1379 if (auto *Category = dyn_cast<ObjCCategoryDecl>(D))
1380 D = Category->getClassInterface();
1381
1382 if (auto *Implementation = dyn_cast<ObjCImplementationDecl>(D))
1383 ClassDeclared = Implementation->getClassInterface();
1384 else if (auto *Interface = dyn_cast<ObjCInterfaceDecl>(D))
1385 ClassDeclared = Interface;
1386
1387 assert(ClassDeclared && "cannot query interface");
1388 } else {
1389 if (IsArrow &&
1390 IDecl->FindPropertyDeclaration(
1391 Member, ObjCPropertyQueryKind::OBJC_PR_query_instance)) {
1392 S.Diag(MemberLoc, diag::err_property_found_suggest)
1393 << Member << BaseExpr.get()->getType()
1394 << FixItHint::CreateReplacement(OpLoc, ".");
1395 return ExprError();
1396 }
1397
1398 S.Diag(MemberLoc, diag::err_typecheck_member_reference_ivar)
1399 << IDecl->getDeclName() << MemberName
1400 << BaseExpr.get()->getSourceRange();
1401 return ExprError();
1402 }
1403 }
1404
1405 assert(ClassDeclared);
1406
1407 // If the decl being referenced had an error, return an error for this
1408 // sub-expr without emitting another error, in order to avoid cascading
1409 // error cases.
1410 if (IV->isInvalidDecl())
1411 return ExprError();
1412
1413 // Check whether we can reference this field.
1414 if (S.DiagnoseUseOfDecl(IV, MemberLoc))
1415 return ExprError();
1416 if (IV->getAccessControl() != ObjCIvarDecl::Public &&
1417 IV->getAccessControl() != ObjCIvarDecl::Package) {
1418 ObjCInterfaceDecl *ClassOfMethodDecl = nullptr;
1419 if (ObjCMethodDecl *MD = S.getCurMethodDecl())
1420 ClassOfMethodDecl = MD->getClassInterface();
1421 else if (ObjCImpDecl && S.getCurFunctionDecl()) {
1422 // Case of a c-function declared inside an objc implementation.
1423 // FIXME: For a c-style function nested inside an objc implementation
1424 // class, there is no implementation context available, so we pass
1425 // down the context as argument to this routine. Ideally, this context
1426 // need be passed down in the AST node and somehow calculated from the
1427 // AST for a function decl.
1428 if (ObjCImplementationDecl *IMPD =
1429 dyn_cast<ObjCImplementationDecl>(ObjCImpDecl))
1430 ClassOfMethodDecl = IMPD->getClassInterface();
1431 else if (ObjCCategoryImplDecl* CatImplClass =
1432 dyn_cast<ObjCCategoryImplDecl>(ObjCImpDecl))
1433 ClassOfMethodDecl = CatImplClass->getClassInterface();
1434 }
1435 if (!S.getLangOpts().DebuggerSupport) {
1436 if (IV->getAccessControl() == ObjCIvarDecl::Private) {
1437 if (!declaresSameEntity(ClassDeclared, IDecl) ||
1438 !declaresSameEntity(ClassOfMethodDecl, ClassDeclared))
1439 S.Diag(MemberLoc, diag::err_private_ivar_access)
1440 << IV->getDeclName();
1441 } else if (!IDecl->isSuperClassOf(ClassOfMethodDecl))
1442 // @protected
1443 S.Diag(MemberLoc, diag::err_protected_ivar_access)
1444 << IV->getDeclName();
1445 }
1446 }
1447 bool warn = true;
1448 if (S.getLangOpts().ObjCWeak) {
1449 Expr *BaseExp = BaseExpr.get()->IgnoreParenImpCasts();
1450 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(BaseExp))
1451 if (UO->getOpcode() == UO_Deref)
1452 BaseExp = UO->getSubExpr()->IgnoreParenCasts();
1453
1454 if (DeclRefExpr *DE = dyn_cast<DeclRefExpr>(BaseExp))
1455 if (DE->getType().getObjCLifetime() == Qualifiers::OCL_Weak) {
1456 S.Diag(DE->getLocation(), diag::err_arc_weak_ivar_access);
1457 warn = false;
1458 }
1459 }
1460 if (warn) {
1461 if (ObjCMethodDecl *MD = S.getCurMethodDecl()) {
1462 ObjCMethodFamily MF = MD->getMethodFamily();
1463 warn = (MF != OMF_init && MF != OMF_dealloc &&
1464 MF != OMF_finalize &&
1465 !S.IvarBacksCurrentMethodAccessor(IDecl, MD, IV));
1466 }
1467 if (warn)
1468 S.Diag(MemberLoc, diag::warn_direct_ivar_access) << IV->getDeclName();
1469 }
1470
1471 ObjCIvarRefExpr *Result = new (S.Context) ObjCIvarRefExpr(
1472 IV, IV->getUsageType(BaseType), MemberLoc, OpLoc, BaseExpr.get(),
1473 IsArrow);
1474
1475 if (IV->getType().getObjCLifetime() == Qualifiers::OCL_Weak) {
1476 if (!S.isUnevaluatedContext() &&
1477 !S.Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, MemberLoc))
1478 S.getCurFunction()->recordUseOfWeak(Result);
1479 }
1480
1481 return Result;
1482 }
1483
1484 // Objective-C property access.
1485 const ObjCObjectPointerType *OPT;
1486 if (!IsArrow && (OPT = BaseType->getAs<ObjCObjectPointerType>())) {
1487 if (!SS.isEmpty() && !SS.isInvalid()) {
1488 S.Diag(SS.getRange().getBegin(), diag::err_qualified_objc_access)
1489 << 0 << SS.getScopeRep() << FixItHint::CreateRemoval(SS.getRange());
1490 SS.clear();
1491 }
1492
1493 // This actually uses the base as an r-value.
1494 BaseExpr = S.DefaultLvalueConversion(BaseExpr.get());
1495 if (BaseExpr.isInvalid())
1496 return ExprError();
1497
1498 assert(S.Context.hasSameUnqualifiedType(BaseType,
1499 BaseExpr.get()->getType()));
1500
1501 IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
1502
1503 const ObjCObjectType *OT = OPT->getObjectType();
1504
1505 // id, with and without qualifiers.
1506 if (OT->isObjCId()) {
1507 // Check protocols on qualified interfaces.
1508 Selector Sel = S.PP.getSelectorTable().getNullarySelector(Member);
1509 if (Decl *PMDecl =
1510 FindGetterSetterNameDecl(OPT, Member, Sel, S.Context)) {
1511 if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(PMDecl)) {
1512 // Check the use of this declaration
1513 if (S.DiagnoseUseOfDecl(PD, MemberLoc))
1514 return ExprError();
1515
1516 return new (S.Context)
1517 ObjCPropertyRefExpr(PD, S.Context.PseudoObjectTy, VK_LValue,
1518 OK_ObjCProperty, MemberLoc, BaseExpr.get());
1519 }
1520
1521 if (ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(PMDecl)) {
1522 Selector SetterSel =
1523 SelectorTable::constructSetterSelector(S.PP.getIdentifierTable(),
1524 S.PP.getSelectorTable(),
1525 Member);
1526 ObjCMethodDecl *SMD = nullptr;
1527 if (Decl *SDecl = FindGetterSetterNameDecl(OPT,
1528 /*Property id*/ nullptr,
1529 SetterSel, S.Context))
1530 SMD = dyn_cast<ObjCMethodDecl>(SDecl);
1531
1532 return new (S.Context)
1533 ObjCPropertyRefExpr(OMD, SMD, S.Context.PseudoObjectTy, VK_LValue,
1534 OK_ObjCProperty, MemberLoc, BaseExpr.get());
1535 }
1536 }
1537 // Use of id.member can only be for a property reference. Do not
1538 // use the 'id' redefinition in this case.
1539 if (IsArrow && ShouldTryAgainWithRedefinitionType(S, BaseExpr))
1540 return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1541 ObjCImpDecl, HasTemplateArgs, TemplateKWLoc);
1542
1543 return ExprError(S.Diag(MemberLoc, diag::err_property_not_found)
1544 << MemberName << BaseType);
1545 }
1546
1547 // 'Class', unqualified only.
1548 if (OT->isObjCClass()) {
1549 // Only works in a method declaration (??!).
1550 ObjCMethodDecl *MD = S.getCurMethodDecl();
1551 if (!MD) {
1552 if (ShouldTryAgainWithRedefinitionType(S, BaseExpr))
1553 return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1554 ObjCImpDecl, HasTemplateArgs, TemplateKWLoc);
1555
1556 goto fail;
1557 }
1558
1559 // Also must look for a getter name which uses property syntax.
1560 Selector Sel = S.PP.getSelectorTable().getNullarySelector(Member);
1561 ObjCInterfaceDecl *IFace = MD->getClassInterface();
1562 if (!IFace)
1563 goto fail;
1564
1565 ObjCMethodDecl *Getter;
1566 if ((Getter = IFace->lookupClassMethod(Sel))) {
1567 // Check the use of this method.
1568 if (S.DiagnoseUseOfDecl(Getter, MemberLoc))
1569 return ExprError();
1570 } else
1571 Getter = IFace->lookupPrivateMethod(Sel, false);
1572 // If we found a getter then this may be a valid dot-reference, we
1573 // will look for the matching setter, in case it is needed.
1574 Selector SetterSel =
1575 SelectorTable::constructSetterSelector(S.PP.getIdentifierTable(),
1576 S.PP.getSelectorTable(),
1577 Member);
1578 ObjCMethodDecl *Setter = IFace->lookupClassMethod(SetterSel);
1579 if (!Setter) {
1580 // If this reference is in an @implementation, also check for 'private'
1581 // methods.
1582 Setter = IFace->lookupPrivateMethod(SetterSel, false);
1583 }
1584
1585 if (Setter && S.DiagnoseUseOfDecl(Setter, MemberLoc))
1586 return ExprError();
1587
1588 if (Getter || Setter) {
1589 return new (S.Context) ObjCPropertyRefExpr(
1590 Getter, Setter, S.Context.PseudoObjectTy, VK_LValue,
1591 OK_ObjCProperty, MemberLoc, BaseExpr.get());
1592 }
1593
1594 if (ShouldTryAgainWithRedefinitionType(S, BaseExpr))
1595 return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1596 ObjCImpDecl, HasTemplateArgs, TemplateKWLoc);
1597
1598 return ExprError(S.Diag(MemberLoc, diag::err_property_not_found)
1599 << MemberName << BaseType);
1600 }
1601
1602 // Normal property access.
1603 return S.HandleExprPropertyRefExpr(OPT, BaseExpr.get(), OpLoc, MemberName,
1604 MemberLoc, SourceLocation(), QualType(),
1605 false);
1606 }
1607
1608 // Handle 'field access' to vectors, such as 'V.xx'.
1609 if (BaseType->isExtVectorType()) {
1610 // FIXME: this expr should store IsArrow.
1611 IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
1612 ExprValueKind VK;
1613 if (IsArrow)
1614 VK = VK_LValue;
1615 else {
1616 if (PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(BaseExpr.get()))
1617 VK = POE->getSyntacticForm()->getValueKind();
1618 else
1619 VK = BaseExpr.get()->getValueKind();
1620 }
1621
1622 QualType ret = CheckExtVectorComponent(S, BaseType, VK, OpLoc,
1623 Member, MemberLoc);
1624 if (ret.isNull())
1625 return ExprError();
1626 Qualifiers BaseQ =
1627 S.Context.getCanonicalType(BaseExpr.get()->getType()).getQualifiers();
1628 ret = S.Context.getQualifiedType(ret, BaseQ);
1629
1630 return new (S.Context)
1631 ExtVectorElementExpr(ret, VK, BaseExpr.get(), *Member, MemberLoc);
1632 }
1633
1634 // Adjust builtin-sel to the appropriate redefinition type if that's
1635 // not just a pointer to builtin-sel again.
1636 if (IsArrow && BaseType->isSpecificBuiltinType(BuiltinType::ObjCSel) &&
1637 !S.Context.getObjCSelRedefinitionType()->isObjCSelType()) {
1638 BaseExpr = S.ImpCastExprToType(
1639 BaseExpr.get(), S.Context.getObjCSelRedefinitionType(), CK_BitCast);
1640 return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1641 ObjCImpDecl, HasTemplateArgs, TemplateKWLoc);
1642 }
1643
1644 // Failure cases.
1645 fail:
1646
1647 // Recover from dot accesses to pointers, e.g.:
1648 // type *foo;
1649 // foo.bar
1650 // This is actually well-formed in two cases:
1651 // - 'type' is an Objective C type
1652 // - 'bar' is a pseudo-destructor name which happens to refer to
1653 // the appropriate pointer type
1654 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) {
1655 if (!IsArrow && Ptr->getPointeeType()->isRecordType() &&
1656 MemberName.getNameKind() != DeclarationName::CXXDestructorName) {
1657 S.Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
1658 << BaseType << int(IsArrow) << BaseExpr.get()->getSourceRange()
1659 << FixItHint::CreateReplacement(OpLoc, "->");
1660
1661 // Recurse as an -> access.
1662 IsArrow = true;
1663 return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1664 ObjCImpDecl, HasTemplateArgs, TemplateKWLoc);
1665 }
1666 }
1667
1668 // If the user is trying to apply -> or . to a function name, it's probably
1669 // because they forgot parentheses to call that function.
1670 if (S.tryToRecoverWithCall(
1671 BaseExpr, S.PDiag(diag::err_member_reference_needs_call),
1672 /*complain*/ false,
1673 IsArrow ? &isPointerToRecordType : &isRecordType)) {
1674 if (BaseExpr.isInvalid())
1675 return ExprError();
1676 BaseExpr = S.DefaultFunctionArrayConversion(BaseExpr.get());
1677 return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1678 ObjCImpDecl, HasTemplateArgs, TemplateKWLoc);
1679 }
1680
1681 S.Diag(OpLoc, diag::err_typecheck_member_reference_struct_union)
1682 << BaseType << BaseExpr.get()->getSourceRange() << MemberLoc;
1683
1684 return ExprError();
1685 }
1686
1687 /// The main callback when the parser finds something like
1688 /// expression . [nested-name-specifier] identifier
1689 /// expression -> [nested-name-specifier] identifier
1690 /// where 'identifier' encompasses a fairly broad spectrum of
1691 /// possibilities, including destructor and operator references.
1692 ///
1693 /// \param OpKind either tok::arrow or tok::period
1694 /// \param ObjCImpDecl the current Objective-C \@implementation
1695 /// decl; this is an ugly hack around the fact that Objective-C
1696 /// \@implementations aren't properly put in the context chain
1697 ExprResult Sema::ActOnMemberAccessExpr(Scope *S, Expr *Base,
1698 SourceLocation OpLoc,
1699 tok::TokenKind OpKind,
1700 CXXScopeSpec &SS,
1701 SourceLocation TemplateKWLoc,
1702 UnqualifiedId &Id,
1703 Decl *ObjCImpDecl) {
1704 if (SS.isSet() && SS.isInvalid())
1705 return ExprError();
1706
1707 // Warn about the explicit constructor calls Microsoft extension.
1708 if (getLangOpts().MicrosoftExt &&
1709 Id.getKind() == UnqualifiedIdKind::IK_ConstructorName)
1710 Diag(Id.getSourceRange().getBegin(),
1711 diag::ext_ms_explicit_constructor_call);
1712
1713 TemplateArgumentListInfo TemplateArgsBuffer;
1714
1715 // Decompose the name into its component parts.
1716 DeclarationNameInfo NameInfo;
1717 const TemplateArgumentListInfo *TemplateArgs;
1718 DecomposeUnqualifiedId(Id, TemplateArgsBuffer,
1719 NameInfo, TemplateArgs);
1720
1721 DeclarationName Name = NameInfo.getName();
1722 bool IsArrow = (OpKind == tok::arrow);
1723
1724 NamedDecl *FirstQualifierInScope
1725 = (!SS.isSet() ? nullptr : FindFirstQualifierInScope(S, SS.getScopeRep()));
1726
1727 // This is a postfix expression, so get rid of ParenListExprs.
1728 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Base);
1729 if (Result.isInvalid()) return ExprError();
1730 Base = Result.get();
1731
1732 if (Base->getType()->isDependentType() || Name.isDependentName() ||
1733 isDependentScopeSpecifier(SS)) {
1734 return ActOnDependentMemberExpr(Base, Base->getType(), IsArrow, OpLoc, SS,
1735 TemplateKWLoc, FirstQualifierInScope,
1736 NameInfo, TemplateArgs);
1737 }
1738
1739 ActOnMemberAccessExtraArgs ExtraArgs = {S, Id, ObjCImpDecl};
1740 ExprResult Res = BuildMemberReferenceExpr(
1741 Base, Base->getType(), OpLoc, IsArrow, SS, TemplateKWLoc,
1742 FirstQualifierInScope, NameInfo, TemplateArgs, S, &ExtraArgs);
1743
1744 if (!Res.isInvalid() && isa<MemberExpr>(Res.get()))
1745 CheckMemberAccessOfNoDeref(cast<MemberExpr>(Res.get()));
1746
1747 return Res;
1748 }
1749
1750 void Sema::CheckMemberAccessOfNoDeref(const MemberExpr *E) {
1751 QualType ResultTy = E->getType();
1752
1753 // Do not warn on member accesses to arrays since this returns an array
1754 // lvalue and does not actually dereference memory.
1755 if (isa<ArrayType>(ResultTy))
1756 return;
1757
1758 if (E->isArrow()) {
1759 if (const auto *Ptr = dyn_cast<PointerType>(
1760 E->getBase()->getType().getDesugaredType(Context))) {
1761 if (Ptr->getPointeeType()->hasAttr(attr::NoDeref))
1762 ExprEvalContexts.back().PossibleDerefs.insert(E);
1763 }
1764 }
1765 }
1766
1767 ExprResult
1768 Sema::BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow,
1769 SourceLocation OpLoc, const CXXScopeSpec &SS,
1770 FieldDecl *Field, DeclAccessPair FoundDecl,
1771 const DeclarationNameInfo &MemberNameInfo) {
1772 // x.a is an l-value if 'a' has a reference type. Otherwise:
1773 // x.a is an l-value/x-value/pr-value if the base is (and note
1774 // that *x is always an l-value), except that if the base isn't
1775 // an ordinary object then we must have an rvalue.
1776 ExprValueKind VK = VK_LValue;
1777 ExprObjectKind OK = OK_Ordinary;
1778 if (!IsArrow) {
1779 if (BaseExpr->getObjectKind() == OK_Ordinary)
1780 VK = BaseExpr->getValueKind();
1781 else
1782 VK = VK_RValue;
1783 }
1784 if (VK != VK_RValue && Field->isBitField())
1785 OK = OK_BitField;
1786
1787 // Figure out the type of the member; see C99 6.5.2.3p3, C++ [expr.ref]
1788 QualType MemberType = Field->getType();
1789 if (const ReferenceType *Ref = MemberType->getAs<ReferenceType>()) {
1790 MemberType = Ref->getPointeeType();
1791 VK = VK_LValue;
1792 } else {
1793 QualType BaseType = BaseExpr->getType();
1794 if (IsArrow) BaseType = BaseType->getAs<PointerType>()->getPointeeType();
1795
1796 Qualifiers BaseQuals = BaseType.getQualifiers();
1797
1798 // GC attributes are never picked up by members.
1799 BaseQuals.removeObjCGCAttr();
1800
1801 // CVR attributes from the base are picked up by members,
1802 // except that 'mutable' members don't pick up 'const'.
1803 if (Field->isMutable()) BaseQuals.removeConst();
1804
1805 Qualifiers MemberQuals =
1806 Context.getCanonicalType(MemberType).getQualifiers();
1807
1808 assert(!MemberQuals.hasAddressSpace());
1809
1810 Qualifiers Combined = BaseQuals + MemberQuals;
1811 if (Combined != MemberQuals)
1812 MemberType = Context.getQualifiedType(MemberType, Combined);
1813 }
1814
1815 auto *CurMethod = dyn_cast<CXXMethodDecl>(CurContext);
1816 if (!(CurMethod && CurMethod->isDefaulted()))
1817 UnusedPrivateFields.remove(Field);
1818
1819 ExprResult Base = PerformObjectMemberConversion(BaseExpr, SS.getScopeRep(),
1820 FoundDecl, Field);
1821 if (Base.isInvalid())
1822 return ExprError();
1823
1824 // Build a reference to a private copy for non-static data members in
1825 // non-static member functions, privatized by OpenMP constructs.
1826 if (getLangOpts().OpenMP && IsArrow &&
1827 !CurContext->isDependentContext() &&
1828 isa<CXXThisExpr>(Base.get()->IgnoreParenImpCasts())) {
1829 if (auto *PrivateCopy = isOpenMPCapturedDecl(Field)) {
1830 return getOpenMPCapturedExpr(PrivateCopy, VK, OK,
1831 MemberNameInfo.getLoc());
1832 }
1833 }
1834
1835 return BuildMemberExpr(Base.get(), IsArrow, OpLoc, &SS,
1836 /*TemplateKWLoc=*/SourceLocation(), Field, FoundDecl,
1837 /*HadMultipleCandidates=*/false, MemberNameInfo,
1838 MemberType, VK, OK);
1839 }
1840
1841 /// Builds an implicit member access expression. The current context
1842 /// is known to be an instance method, and the given unqualified lookup
1843 /// set is known to contain only instance members, at least one of which
1844 /// is from an appropriate type.
1845 ExprResult
1846 Sema::BuildImplicitMemberExpr(const CXXScopeSpec &SS,
1847 SourceLocation TemplateKWLoc,
1848 LookupResult &R,
1849 const TemplateArgumentListInfo *TemplateArgs,
1850 bool IsKnownInstance, const Scope *S) {
1851 assert(!R.empty() && !R.isAmbiguous());
1852
1853 SourceLocation loc = R.getNameLoc();
1854
1855 // If this is known to be an instance access, go ahead and build an
1856 // implicit 'this' expression now.
1857 // 'this' expression now.
1858 QualType ThisTy = getCurrentThisType();
1859 assert(!ThisTy.isNull() && "didn't correctly pre-flight capture of 'this'");
1860
1861 Expr *baseExpr = nullptr; // null signifies implicit access
1862 if (IsKnownInstance) {
1863 SourceLocation Loc = R.getNameLoc();
1864 if (SS.getRange().isValid())
1865 Loc = SS.getRange().getBegin();
1866 baseExpr = BuildCXXThisExpr(loc, ThisTy, /*IsImplicit=*/true);
1867 }
1868
1869 return BuildMemberReferenceExpr(baseExpr, ThisTy,
1870 /*OpLoc*/ SourceLocation(),
1871 /*IsArrow*/ true,
1872 SS, TemplateKWLoc,
1873 /*FirstQualifierInScope*/ nullptr,
1874 R, TemplateArgs, S);
1875 }
clang::OMF_finalize
Definition: IdentifierTable.h:641
clang::ObjCPropertyRefExpr
ObjCPropertyRefExpr - A dot-syntax expression to access an ObjC property.
Definition: ExprObjC.h:614
clang::DeclarationNameInfo::getLoc
SourceLocation getLoc() const
getLoc - Returns the main location of the declaration name.
Definition: DeclarationName.h:719
clang::ast_matchers::type
const internal::VariadicAllOfMatcher< Type > type
Matches Types in the clang AST.
Definition: ASTMatchersInternal.cpp:638
clang::Scope::TryScope
This is the scope of a C++ try statement.
Definition: Scope.h:101
getCanonicalDecl
static const Decl * getCanonicalDecl(const Decl *D)
Definition: IndexingContext.cpp:292
Diag
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags, const LangOptions &Features, FullSourceLoc TokLoc, const char *TokBegin, const char *TokRangeBegin, const char *TokRangeEnd, unsigned DiagID)
Produce a diagnostic highlighting some portion of a literal.
Definition: LiteralSupport.cpp:77
clang::Sema::ExtVectorDecls
ExtVectorDeclsType ExtVectorDecls
ExtVectorDecls - This is a list all the extended vector types.
Definition: Sema.h:637
clang::Sema::getExternalSource
ExternalSemaSource * getExternalSource() const
Definition: Sema.h:1334
clang::Selector
Smart pointer class that efficiently represents Objective-C method names.
Definition: IdentifierTable.h:685
clang::Preprocessor::getSelectorTable
SelectorTable & getSelectorTable()
Definition: Preprocessor.h:916
clang::PointerType
PointerType - C99 6.7.5.1 - Pointer Declarators.
Definition: Type.h:2614
clang::PointerType::getPointeeType
QualType getPointeeType() const
Definition: Type.h:2627
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:654
clang::TypoCorrection
Simple class containing the result of Sema::CorrectTypo.
Definition: TypoCorrection.h:42
clang::ObjCMethodDecl::getClassInterface
ObjCInterfaceDecl * getClassInterface()
Definition: DeclObjC.cpp:1155
clang::Sema::IvarBacksCurrentMethodAccessor
bool IvarBacksCurrentMethodAccessor(ObjCInterfaceDecl *IFace, ObjCMethodDecl *Method, ObjCIvarDecl *IV)
IvarBacksCurrentMethodAccessor - This routine returns &#39;true&#39; if &#39;IV&#39; is an ivar synthesized for &#39;Meth...
Definition: SemaObjCProperty.cpp:1847
IMA_Mixed_StaticContext
The reference may be to an instance member, but it might be invalid if so, because the context is not...
Definition: SemaExprMember.cpp:49
clang::UnqualifiedId::getSourceRange
SourceRange getSourceRange() const LLVM_READONLY
Return the source range that covers this unqualified-id.
Definition: DeclSpec.h:1160
clang::Sema::getFunctionLevelDeclContext
DeclContext * getFunctionLevelDeclContext()
Definition: Sema.cpp:1283
diagnoseInstanceReference
static void diagnoseInstanceReference(Sema &SemaRef, const CXXScopeSpec &SS, NamedDecl *Rep, const DeclarationNameInfo &nameInfo)
Diagnose a reference to a field with no object available.
Definition: SemaExprMember.cpp:196
clang::QualType::getDesugaredType
QualType getDesugaredType(const ASTContext &Context) const
Return the specified type with any "sugar" removed from the type.
Definition: Type.h:954
clang::IndirectFieldDecl::getVarDecl
VarDecl * getVarDecl() const
Definition: Decl.h:3015
clang::LookupResult::setLookupName
void setLookupName(DeclarationName Name)
Sets the name to look up.
Definition: Lookup.h:248
clang::Sema::CXXThisTypeOverride
QualType CXXThisTypeOverride
When non-NULL, the C++ &#39;this&#39; expression is allowed despite the current context not being a non-stati...
Definition: Sema.h:5612
clang::Type::getPointeeType
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee...
Definition: Type.cpp:557
IMAKind
IMAKind
Definition: SemaExprMember.cpp:40
clang::EnumConstantDecl
An instance of this object exists for each enum constant that is defined.
Definition: Decl.h:2941
Base
clang::UnresolvedMemberExpr::Create
static UnresolvedMemberExpr * Create(const ASTContext &Context, bool HasUnresolvedUsing, Expr *Base, QualType BaseType, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, const DeclarationNameInfo &MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs, UnresolvedSetIterator Begin, UnresolvedSetIterator End)
Definition: ExprCXX.cpp:1538
clang::Type::isRecordType
bool isRecordType() const
Definition: Type.h:6594
clang::MemberExpr::getBase
Expr * getBase() const
Definition: Expr.h:2913
clang::CXXScopeSpec::isEmpty
bool isEmpty() const
No scope specifier.
Definition: DeclSpec.h:189
clang::ASTContext::getQualifiedType
QualType getQualifiedType(SplitQualType split) const
Un-split a SplitQualType.
Definition: ASTContext.h:1958
clang::Sema::Diag
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1411
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:88
clang::Type::isExtVectorType
bool isExtVectorType() const
Definition: Type.h:6610
clang::Expr::setType
void setType(QualType t)
Definition: Expr.h:138
clang::Sema::LookupTemplateName
bool LookupTemplateName(LookupResult &R, Scope *S, CXXScopeSpec &SS, QualType ObjectType, bool EnteringContext, bool &MemberOfUnknownSpecialization, SourceLocation TemplateKWLoc=SourceLocation(), AssumedTemplateKind *ATK=nullptr)
Definition: SemaTemplate.cpp:326
DeclTemplate.h
Defines the C++ template declaration subclasses.
clang::Sema::getVarTemplateSpecialization
VarDecl * getVarTemplateSpecialization(VarTemplateDecl *VarTempl, const TemplateArgumentListInfo *TemplateArgs, const DeclarationNameInfo &MemberNameInfo, SourceLocation TemplateKWLoc)
Definition: SemaExprMember.cpp:950
IMA_Instance
The reference is definitely an implicit instance member access.
Definition: SemaExprMember.cpp:56
clang::DeclarationNameInfo::getBeginLoc
SourceLocation getBeginLoc() const
getBeginLoc - Retrieve the location of the first token.
Definition: DeclarationName.h:798
clang::VarTemplateDecl
Declaration of a variable template.
Definition: DeclTemplate.h:3070
clang::Sema::RedeclarationKind
RedeclarationKind
Specifies whether (or how) name lookup is being performed for a redeclaration (vs.
Definition: Sema.h:3482
DeclObjC.h
clang::OpaquePtr< QualType >
IsInFnTryBlockHandler
static bool IsInFnTryBlockHandler(const Scope *S)
Determine if the given scope is within a function-try-block handler.
Definition: SemaExprMember.cpp:938
clang::LookupResult::clear
LLVM_ATTRIBUTE_REINITIALIZES void clear()
Clears out any current state.
Definition: Lookup.h:554
clang::UnresolvedSetIterator::getPair
const DeclAccessPair & getPair() const
Definition: UnresolvedSet.h:54
ASTLambda.h
This file provides some common utility functions for processing Lambda related AST Constructs...
clang::VarDecl
Represents a variable declaration or definition.
Definition: Decl.h:820
clang::Sema::PDiag
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
Definition: SemaInternal.h:24
clang::LookupResult::getLookupName
DeclarationName getLookupName() const
Gets the name to look up.
Definition: Lookup.h:243
clang::ObjCIsaExpr
ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC &#39;id&#39; type.
Definition: ExprObjC.h:1492
clang::Sema::Diags
DiagnosticsEngine & Diags
Definition: Sema.h:387
clang::Type::getAs
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:7002
clang::Sema::computeDeclContext
DeclContext * computeDeclContext(QualType T)
Compute the DeclContext that is associated with the given type.
Definition: SemaCXXScopeSpec.cpp:53
clang::ObjCMethodDecl
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:138
clang::NamedDecl::getUnderlyingDecl
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:414
clang::LookupResult::isAmbiguous
bool isAmbiguous() const
Definition: Lookup.h:301
clang::Decl::isInvalidDecl
bool isInvalidDecl() const
Definition: DeclBase.h:553
clang::ASTContext::getObjCClassType
QualType getObjCClassType() const
Represents the Objective-C Class type.
Definition: ASTContext.h:1896
clang::SourceRange::setBegin
void setBegin(SourceLocation b)
Definition: SourceLocation.h:219
SemaInternal.h
clang::CXXMethodDecl::isStatic
bool isStatic() const
Definition: DeclCXX.cpp:1983
clang::ObjCProtocolDecl::protocols
protocol_range protocols() const
Definition: DeclObjC.h:2143
ExprCXX.h
Defines the clang::Expr interface and subclasses for C++ expressions.
clang::LazyVector::begin
iterator begin(Source *source, bool LocalOnly=false)
Definition: ExternalASTSource.h:568
clang::Qualifiers
The collection of all-type qualifiers we support.
Definition: Type.h:143
clang::CanQual::getQualifiers
Qualifiers getQualifiers() const
Retrieve all qualifiers.
Definition: CanonicalType.h:129
clang::RecordDecl
Represents a struct/union/class.
Definition: Decl.h:3748
clang::NamedDecl::getDeclName
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:272
clang::DeclContext::Encloses
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context encloses the declaration context DC.
Definition: DeclBase.cpp:1161
clang::IdentifierInfo
One of these records is kept for each identifier that is lexed.
Definition: IdentifierTable.h:57
clang::IdentifierInfo::isStr
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
Definition: IdentifierTable.h:136
clang::ObjCObjectType
Represents a class type in Objective C.
Definition: Type.h:5694
clang::ASTContext
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:168
clang::NestedNameSpecifierLoc
A C++ nested-name-specifier augmented with source location information.
Definition: NestedNameSpecifier.h:236
clang::Sema::CheckQualifiedMemberReference
bool CheckQualifiedMemberReference(Expr *BaseExpr, QualType BaseType, const CXXScopeSpec &SS, const LookupResult &R)
Definition: SemaExprMember.cpp:549
clang::ObjCMethodFamily
ObjCMethodFamily
A family of Objective-C methods.
Definition: IdentifierTable.h:623
clang::CorrectionCandidateCallback
Base class for callback objects used by Sema::CorrectTypo to check the validity of a potential typo c...
Definition: TypoCorrection.h:281
clang::FieldDecl
Represents a member of a struct/union/class.
Definition: Decl.h:2729
clang::Sema::ExpressionEvaluationContext::PotentiallyEvaluated
The current expression is potentially evaluated at run time, which means that code may be generated t...
clang::Qualifiers::removeConst
void removeConst()
Definition: Type.h:262
IMA_Unresolved_StaticContext
The reference may be to an unresolved using declaration and the context is not an instance method...
Definition: SemaExprMember.cpp:66
clang::LookupResult::getLookupNameInfo
const DeclarationNameInfo & getLookupNameInfo() const
Gets the name info to look up.
Definition: Lookup.h:233
clang::UnresolvedSetIterator
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:32
ShouldTryAgainWithRedefinitionType
static bool ShouldTryAgainWithRedefinitionType(Sema &S, ExprResult &base)
Given that normal member access failed on the given expression, and given that the expression&#39;s type ...
Definition: SemaExprMember.cpp:1203
ScopeInfo.h
Category
int Category
Definition: Format.cpp:1828
clang::Type::isSpecificBuiltinType
bool isSpecificBuiltinType(unsigned K) const
Test for a particular builtin type.
Definition: Type.h:6744
clang::DeclContext::Equals
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC...
Definition: DeclBase.h:1908
clang::UnresolvedMemberExpr
Represents a C++ member access expression for which lookup produced a set of overloaded functions...
Definition: ExprCXX.h:3771
clang::ExtVectorType::getPointAccessorIdx
static int getPointAccessorIdx(char c)
Definition: Type.h:3361
clang::Type::isObjCSelType
bool isObjCSelType() const
Definition: Type.h:6663
clang::ExtVectorElementExpr
ExtVectorElementExpr - This represents access to specific elements of a vector, and may occur on the ...
Definition: Expr.h:5518
clang::Sema::DefaultFunctionArrayConversion
ExprResult DefaultFunctionArrayConversion(Expr *E, bool Diagnose=true)
DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4).
Definition: SemaExpr.cpp:472
clang::VK_RValue
An r-value expression (a pr-value in the C++11 taxonomy) produces a temporary value.
Definition: Specifiers.h:125
clang::DeclarationName::isDependentName
bool isDependentName() const
Determines whether the name itself is dependent, e.g., because it involves a C++ type that is itself ...
Definition: DeclarationName.cpp:210
clang::SelectorTable::constructSetterSelector
static Selector constructSetterSelector(IdentifierTable &Idents, SelectorTable &SelTable, const IdentifierInfo *Name)
Return the default setter selector for the given identifier.
Definition: IdentifierTable.cpp:632
clang::UnqualifiedId
Represents a C++ unqualified-id that has been parsed.
Definition: DeclSpec.h:960
clang::FieldDecl::isBitField
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:2807
clang::SelectorTable::getNullarySelector
Selector getNullarySelector(IdentifierInfo *ID)
Definition: IdentifierTable.h:850
clang::LookupResult::resolveKind
void resolveKind()
Resolves the result kind of the lookup, possibly hiding decls.
Definition: SemaLookup.cpp:475
clang::LookupResult
Represents the results of name lookup.
Definition: Lookup.h:46
clang::ActionResult::get
PtrTy get() const
Definition: Ownership.h:170
clang::DeclAccessPair::make
static DeclAccessPair make(NamedDecl *D, AccessSpecifier AS)
Definition: DeclAccessPair.h:35
clang::Sema::getCurMethodDecl
ObjCMethodDecl * getCurMethodDecl()
getCurMethodDecl - If inside of a method body, this returns a pointer to the method decl for the meth...
Definition: Sema.cpp:1309
clang::TemplateArgumentListInfo
A convenient class for passing around template argument information.
Definition: TemplateBase.h:554
ClassifyImplicitMemberAccess
static IMAKind ClassifyImplicitMemberAccess(Sema &SemaRef, const LookupResult &R)
The given lookup names class member(s) and is not being used for an address-of-member expression...
Definition: SemaExprMember.cpp:88
clang::Qualifiers::hasAddressSpace
bool hasAddressSpace() const
Definition: Type.h:358
clang::Expr::getValueKind
ExprValueKind getValueKind() const
getValueKind - The value kind that this expression produces.
Definition: Expr.h:414
clang::Sema::BuildAnonymousStructUnionMemberReference
ExprResult BuildAnonymousStructUnionMemberReference(const CXXScopeSpec &SS, SourceLocation nameLoc, IndirectFieldDecl *indirectField, DeclAccessPair FoundDecl=DeclAccessPair::make(nullptr, AS_none), Expr *baseObjectExpr=nullptr, SourceLocation opLoc=SourceLocation())
Definition: SemaExprMember.cpp:803
isRecordType
static bool isRecordType(QualType T)
Definition: SemaExprMember.cpp:1229
clang::VarDecl::getTemplateSpecializationKind
TemplateSpecializationKind getTemplateSpecializationKind() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
Definition: Decl.cpp:2549
IMA_Abstract
The reference is a contextually-permitted abstract member reference.
Definition: SemaExprMember.cpp:62
clang::ASTContext::PseudoObjectTy
CanQualType PseudoObjectTy
Definition: ASTContext.h:1047
clang::CXXScopeSpec::clear
void clear()
Definition: DeclSpec.h:211
ExprObjC.h
clang::MemberExpr::isArrow
bool isArrow() const
Definition: Expr.h:3020
clang::ASTContext::getObjCClassRedefinitionType
QualType getObjCClassRedefinitionType() const
Retrieve the type that Class has been defined to, which may be different from the built-in Class if C...
Definition: ASTContext.h:1674
clang::Expr::IgnoreParenCasts
Expr * IgnoreParenCasts() LLVM_READONLY
Skip past any parentheses and casts which might surround this expression until reaching a fixed point...
Definition: Expr.cpp:2995
clang::Scope
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:40
clang::CXXRecordDecl::getCanonicalDecl
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:492
clang::declaresSameEntity
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Definition: DeclBase.h:1166
clang::TypoExpr
TypoExpr - Internal placeholder for expressions where typo correction still needs to be performed and...
Definition: Expr.h:5978
clang::ObjCInterfaceDecl::lookupClassMethod
ObjCMethodDecl * lookupClassMethod(Selector Sel) const
Lookup a class method for a given selector.
Definition: DeclObjC.h:1866
clang::Sema::ActOnDependentMemberExpr
ExprResult ActOnDependentMemberExpr(Expr *Base, QualType BaseType, bool IsArrow, SourceLocation OpLoc, const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierInScope, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs)
Definition: SemaExprMember.cpp:480
clang::CXXScopeSpec
Represents a C++ nested-name-specifier or a global scope specifier.
Definition: DeclSpec.h:63
clang::Sema::ExpressionEvaluationContext::DiscardedStatement
The current expression occurs within a discarded statement.
clang::ObjCProtocolDecl
Represents an Objective-C protocol declaration.
Definition: DeclObjC.h:2078
clang::LazyVector::end
iterator end()
Definition: ExternalASTSource.h:577
clang::Sema::PP
Preprocessor & PP
Definition: Sema.h:384
clang::Sema::getLangOpts
const LangOptions & getLangOpts() const
Definition: Sema.h:1324
IMA_Mixed
The reference may be an implicit instance member access.
Definition: SemaExprMember.cpp:45
clang::OK_Ordinary
An ordinary object is located at an address in memory.
Definition: Specifiers.h:141
clang::Sema::ActOnMemberAccessExtraArgs
Definition: Sema.h:4757
clang::Sema::isUnevaluatedContext
bool isUnevaluatedContext() const
Determines whether we are currently in a context that is not evaluated as per C++ [expr] p5...
Definition: Sema.h:8441
clang::ObjCInterfaceDecl
Represents an ObjC class declaration.
Definition: DeclObjC.h:1186
clang::Sema::BuildMemberReferenceExpr
ExprResult BuildMemberReferenceExpr(Expr *Base, QualType BaseType, SourceLocation OpLoc, bool IsArrow, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierInScope, const DeclarationNameInfo &NameInfo, const TemplateArgumentListInfo *TemplateArgs, const Scope *S, ActOnMemberAccessExtraArgs *ExtraArgs=nullptr)
Definition: SemaExprMember.cpp:744
clang::LookupResult::addDecl
void addDecl(NamedDecl *D)
Add a declaration to these results with its natural access.
Definition: Lookup.h:426
clang::Sema::LookupMemberName
Member name lookup, which finds the names of class/struct/union members.
Definition: Sema.h:3443
clang::ObjCObjectType::getInterface
ObjCInterfaceDecl * getInterface() const
Gets the interface declaration for this object type, if the base type really is an interface...
Definition: Type.h:5930
clang::Sema::ExpressionEvaluationContext::ConstantEvaluated
The current context is "potentially evaluated" in C++11 terms, but the expression is evaluated at com...
clang::CXXScopeSpec::getWithLocInContext
NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const
Retrieve a nested-name-specifier with location information, copied into the given AST context...
Definition: DeclSpec.cpp:142
clang::IdentifierInfo::getLength
unsigned getLength() const
Efficiently return the length of this identifier info.
Definition: IdentifierTable.h:152
clang::LookupResult::redeclarationKind
Sema::RedeclarationKind redeclarationKind() const
Definition: Lookup.h:268
clang::Expr::IgnoreImpCasts
Expr * IgnoreImpCasts() LLVM_READONLY
Skip past any implicit casts which might surround this expression until reaching a fixed point...
Definition: Expr.cpp:2970
clang::MemberExpr::Create
static MemberExpr * Create(const ASTContext &C, Expr *Base, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, ValueDecl *MemberDecl, DeclAccessPair FoundDecl, DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs, QualType T, ExprValueKind VK, ExprObjectKind OK, NonOdrUseReason NOUR)
Definition: Expr.cpp:1662
BaseSet
llvm::SmallPtrSet< const CXXRecordDecl *, 4 > BaseSet
Definition: SemaExprMember.cpp:28
clang::Sema::SFINAETrap
RAII class used to determine whether SFINAE has trapped any errors that occur during template argumen...
Definition: Sema.h:8450
clang::Scope::getFlags
unsigned getFlags() const
getFlags - Return the flags for this scope.
Definition: Scope.h:220
clang::Sema
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:336
IMA_Error_StaticContext
All possible referrents are instance members and the current context is not an instance method...
Definition: SemaExprMember.cpp:75
clang::FunctionProtoType
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3754
clang::sema::FunctionScopeInfo::recordUseOfWeak
void recordUseOfWeak(const ExprT *E, bool IsRead=true)
Record that a weak object was accessed.
Definition: ScopeInfo.h:1007
clang::CXXScopeSpec::getRange
SourceRange getRange() const
Definition: DeclSpec.h:68
Overload.h
clang::ObjCIvarDecl::getUsageType
QualType getUsageType(QualType objectType) const
Retrieve the type of this instance variable when viewed as a member of a specific object type...
Definition: DeclObjC.cpp:1839
clang::Sema::CTK_ErrorRecovery
Definition: Sema.h:3669
clang::OK_ObjCProperty
An Objective-C property is a logical field of an Objective-C object which is read and written via Obj...
Definition: Specifiers.h:151
LookupMemberExprInRecord
static bool LookupMemberExprInRecord(Sema &SemaRef, LookupResult &R, Expr *BaseExpr, const RecordType *RTy, SourceLocation OpLoc, bool IsArrow, CXXScopeSpec &SS, bool HasTemplateArgs, SourceLocation TemplateKWLoc, TypoExpr *&TE)
Definition: SemaExprMember.cpp:641
clang::Sema::ExpressionEvaluationContext::PotentiallyEvaluatedIfUsed
The current expression is potentially evaluated, but any declarations referenced inside that expressi...
clang::ValueDecl
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:619
clang::Sema::CorrectTypoDelayed
TypoExpr * CorrectTypoDelayed(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, CorrectionCandidateCallback &CCC, TypoDiagnosticGenerator TDG, TypoRecoveryCallback TRC, CorrectTypoKind Mode, DeclContext *MemberContext=nullptr, bool EnteringContext=false, const ObjCObjectPointerType *OPT=nullptr)
Try to "correct" a typo in the source code by finding visible declarations whose names are similar to...
Definition: SemaLookup.cpp:5134
clang::Expr
This represents one expression.
Definition: Expr.h:108
clang::Sema::LookupNameKind
LookupNameKind
Describes the kind of name lookup to perform.
Definition: Sema.h:3431
clang::ExprValueKind
ExprValueKind
The categorization of expression values, currently following the C++11 scheme.
Definition: Specifiers.h:122
IsRGBA
static bool IsRGBA(char c)
Determine whether input char is from rgba component set.
Definition: SemaExprMember.cpp:274
Id
int Id
Definition: ASTDiff.cpp:190
clang::Type::castAs
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:7067
clang::DeclarationName::getAsString
std::string getAsString() const
Retrieve the human-readable string for this name.
Definition: DeclarationName.cpp:223
Lookup.h
Preprocessor.h
Defines the clang::Preprocessor interface.
clang::OMF_dealloc
Definition: IdentifierTable.h:640
IMA_Error_Unrelated
All possible referrents are instance members of an unrelated class.
Definition: SemaExprMember.cpp:79
clang::Decl::getDeclContext
DeclContext * getDeclContext()
Definition: DeclBase.h:438
clang::CorrectionCandidateCallback::IsObjCIvarLookup
bool IsObjCIvarLookup
Definition: TypoCorrection.h:336
clang::CXXDependentScopeMemberExpr::Create
static CXXDependentScopeMemberExpr * Create(const ASTContext &Ctx, Expr *Base, QualType BaseType, bool IsArrow, SourceLocation OperatorLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierFoundInScope, DeclarationNameInfo MemberNameInfo, const TemplateArgumentListInfo *TemplateArgs)
Definition: ExprCXX.cpp:1446
Scope.h
clang::TemplateName
Represents a C++ template name within the type system.
Definition: TemplateName.h:191
clang::Sema::RequireCompleteType
bool RequireCompleteType(SourceLocation Loc, QualType T, TypeDiagnoser &Diagnoser)
Ensure that the type T is a complete type.
Definition: SemaType.cpp:7919
clang::UnqualifiedId::getKind
UnqualifiedIdKind getKind() const
Determine what kind of name we have.
Definition: DeclSpec.h:1042
clang::Sema::ExpressionEvaluationContext::Unevaluated
The current expression and its subexpressions occur within an unevaluated operand (C++11 [expr]p7)...
clang::ObjCIvarDecl::Public
Definition: DeclObjC.h:1964
clang::Expr::getType
QualType getType() const
Definition: Expr.h:137
clang::ObjCInterfaceDecl::lookupInstanceVariable
ObjCIvarDecl * lookupInstanceVariable(IdentifierInfo *IVarName, ObjCInterfaceDecl *&ClassDeclared)
Definition: DeclObjC.cpp:620
clang::LookupResult::isSingleResult
bool isSingleResult() const
Determines if this names a single result which is not an unresolved value using decl.
Definition: Lookup.h:308
clang::DeclContext::getParent
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1784
clang::ActionResult::isInvalid
bool isInvalid() const
Definition: Ownership.h:166
clang::SourceRange::getEnd
SourceLocation getEnd() const
Definition: SourceLocation.h:217
clang::UnaryOperator
UnaryOperator - This represents the unary-expression&#39;s (except sizeof and alignof), the postinc/postdec operators from postfix-expression, and various extensions.
Definition: Expr.h:2046
DiagnoseQualifiedMemberReference
static void DiagnoseQualifiedMemberReference(Sema &SemaRef, Expr *BaseExpr, QualType BaseType, const CXXScopeSpec &SS, NamedDecl *rep, const DeclarationNameInfo &nameInfo)
We know that the given qualified member reference points only to declarations which do not belong to ...
Definition: SemaExprMember.cpp:522
clang::Sema::BuildPossibleImplicitMemberExpr
ExprResult BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, const TemplateArgumentListInfo *TemplateArgs, const Scope *S)
Builds an expression which might be an implicit member expression.
Definition: SemaExprMember.cpp:235
clang::MSPropertyRefExpr
A member reference to an MSPropertyDecl.
Definition: ExprCXX.h:863
clang::ActionResult::isUsable
bool isUsable() const
Definition: Ownership.h:167
clang::TSK_ImplicitInstantiation
This template specialization was implicitly instantiated from a template.
Definition: Specifiers.h:181
clang::ObjCObjectType::isObjCClass
bool isObjCClass() const
Definition: Type.h:5763
clang::QualType::isNull
bool isNull() const
Return true if this QualType doesn&#39;t point to a type yet.
Definition: Type.h:719
clang::ObjCPropertyQueryKind::OBJC_PR_query_instance
clang::CXXRecordDecl::isProvablyNotDerivedFrom
bool isProvablyNotDerivedFrom(const CXXRecordDecl *Base) const
Determine whether this class is provably not derived from the type Base.
Definition: CXXInheritance.cpp:132
clang::Expr::getObjectKind
ExprObjectKind getObjectKind() const
getObjectKind - The object kind that this expression produces.
Definition: Expr.h:421
clang::LookupResult::isUnresolvableResult
bool isUnresolvableResult() const
Definition: Lookup.h:317
clang::RecordType::getDecl
RecordDecl * getDecl() const
Definition: Type.h:4505
clang::CXXScopeSpec::getScopeRep
NestedNameSpecifier * getScopeRep() const
Retrieve the representation of the nested-name-specifier.
Definition: DeclSpec.h:76
clang::ObjCIvarDecl::Private
Definition: DeclObjC.h:1964
clang::IndirectFieldDecl::chain_end
chain_iterator chain_end() const
Definition: Decl.h:3006
clang::ASTContext::getObjCIdRedefinitionType
QualType getObjCIdRedefinitionType() const
Retrieve the type that id has been defined to, which may be different from the built-in id if id has ...
Definition: ASTContext.h:1661
isPointerToRecordType
static bool isPointerToRecordType(QualType T)
Definition: SemaExprMember.cpp:1232
clang::IndirectFieldDecl::chain_iterator
ArrayRef< NamedDecl * >::const_iterator chain_iterator
Definition: Decl.h:3000
clang::ActionResult
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:153
clang::PseudoObjectExpr
PseudoObjectExpr - An expression which accesses a pseudo-object l-value.
Definition: Expr.h:5715
BuildMSPropertyRefExpr
static ExprResult BuildMSPropertyRefExpr(Sema &S, Expr *BaseExpr, bool IsArrow, const CXXScopeSpec &SS, MSPropertyDecl *PD, const DeclarationNameInfo &NameInfo)
Definition: SemaExprMember.cpp:884
clang::ExtVectorType::isAccessorWithinNumElements
bool isAccessorWithinNumElements(char c, bool isNumericAccessor) const
Definition: Type.h:3406
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:86
clang::ASTContext::getObjCSelRedefinitionType
QualType getObjCSelRedefinitionType() const
Retrieve the type that &#39;SEL&#39; has been defined to, which may be different from the built-in &#39;SEL&#39; if &#39;...
Definition: ASTContext.h:1687
clang::Sema::BuildMemberExpr
MemberExpr * BuildMemberExpr(Expr *Base, bool IsArrow, SourceLocation OpLoc, const CXXScopeSpec *SS, SourceLocation TemplateKWLoc, ValueDecl *Member, DeclAccessPair FoundDecl, bool HadMultipleCandidates, const DeclarationNameInfo &MemberNameInfo, QualType Ty, ExprValueKind VK, ExprObjectKind OK, const TemplateArgumentListInfo *TemplateArgs=nullptr)
Definition: SemaExprMember.cpp:896
clang::DeclarationNameInfo::getName
DeclarationName getName() const
getName - Returns the embedded declaration name.
Definition: DeclarationName.h:713
clang::VectorType::getElementType
QualType getElementType() const
Definition: Type.h:3270
clang::Preprocessor::getIdentifierTable
IdentifierTable & getIdentifierTable()
Definition: Preprocessor.h:914
clang::LookupResult::isOverloadedResult
bool isOverloadedResult() const
Determines if the results are overloaded.
Definition: Lookup.h:313
clang::ExprObjectKind
ExprObjectKind
A further classification of the kind of object referenced by an l-value or x-value.
Definition: Specifiers.h:139
clang::CXXMethodDecl
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1931
clang::ASTContext::getExtVectorType
QualType getExtVectorType(QualType VectorType, unsigned NumElts) const
Return the unique reference to an extended vector type of the specified element type and size...
Definition: ASTContext.cpp:3722
clang::Sema::DefaultLvalueConversion
ExprResult DefaultLvalueConversion(Expr *E)
Definition: SemaExpr.cpp:592
IMA_Unresolved
The reference may be to an unresolved using declaration.
Definition: SemaExprMember.cpp:59
clang::IdentifierInfo::getNameStart
const char * getNameStart() const
Return the beginning of the actual null-terminated string for this identifier.
Definition: IdentifierTable.h:149
clang::tok::TokenKind
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:24
clang::Sema::CorrectTypo
TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo, Sema::LookupNameKind LookupKind, Scope *S, CXXScopeSpec *SS, CorrectionCandidateCallback &CCC, CorrectTypoKind Mode, DeclContext *MemberContext=nullptr, bool EnteringContext=false, const ObjCObjectPointerType *OPT=nullptr, bool RecordFailure=true)
Try to "correct" a typo in the source code by finding visible declarations whose names are similar to...
Definition: SemaLookup.cpp:4999
clang::CXXRecordDecl::forallBases
bool forallBases(ForallBasesCallback BaseMatches, bool AllowShortCircuit=true) const
Determines if the given callback holds for all the direct or indirect base classes of this type...
Definition: CXXInheritance.cpp:150
clang::ObjCPropertyDecl
Represents one property declaration in an Objective-C interface.
Definition: DeclObjC.h:741
clang::Sema::DiagnoseUseOfDecl
bool DiagnoseUseOfDecl(NamedDecl *D, ArrayRef< SourceLocation > Locs, const ObjCInterfaceDecl *UnknownObjCClass=nullptr, bool ObjCPropertyAccess=false, bool AvoidPartialAvailabilityChecks=false, ObjCInterfaceDecl *ClassReciever=nullptr)
Determine whether the use of this declaration is valid, and emit any corresponding diagnostics...
Definition: SemaExpr.cpp:207
FindGetterSetterNameDecl
static Decl * FindGetterSetterNameDecl(const ObjCObjectPointerType *QIdTy, IdentifierInfo *Member, const Selector &Sel, ASTContext &Context)
Definition: SemaExprMember.cpp:449
clang::ObjCInterfaceDecl::isSuperClassOf
bool isSuperClassOf(const ObjCInterfaceDecl *I) const
isSuperClassOf - Return true if this class is the specified class or is a super class of the specifie...
Definition: DeclObjC.h:1824
clang::Sema::isThisOutsideMemberFunctionBody
bool isThisOutsideMemberFunctionBody(QualType BaseType)
Determine whether the given type is the type of *this that is used outside of the body of a member fu...
Definition: SemaExprCXX.cpp:1280
clang::Qualifiers::removeObjCGCAttr
void removeObjCGCAttr()
Definition: Type.h:311
clang::Sema::RequireCompleteDeclContext
bool RequireCompleteDeclContext(CXXScopeSpec &SS, DeclContext *DC)
Require that the context specified by SS be complete.
Definition: SemaCXXScopeSpec.cpp:199
clang::CXXScopeSpec::isInvalid
bool isInvalid() const
An error occurred during parsing of the scope specifier.
Definition: DeclSpec.h:194
clang::ASTContext::hasSameUnqualifiedType
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2345
clang::LookupResult::getSema
Sema & getSema() const
Get the Sema object that this lookup result is searching with.
Definition: Lookup.h:612
clang::DeclAccessPair
A POD class for pairing a NamedDecl* with an access specifier.
Definition: DeclAccessPair.h:29
clang::VarDecl::setTemplateSpecializationKind
void setTemplateSpecializationKind(TemplateSpecializationKind TSK, SourceLocation PointOfInstantiation=SourceLocation())
For a static data member that was instantiated from a static data member of a class template...
Definition: Decl.cpp:2633
clang::Sema::diagnoseTypo
void diagnoseTypo(const TypoCorrection &Correction, const PartialDiagnostic &TypoDiag, bool ErrorRecovery=true)
Definition: SemaLookup.cpp:5296
clang::ASTContext::getTypedefType
QualType getTypedefType(const TypedefNameDecl *Decl, QualType Canon=QualType()) const
Return the unique reference to the type for the specified typedef-name decl.
Definition: ASTContext.cpp:4160
clang::ObjCObjectType::isObjCId
bool isObjCId() const
Definition: Type.h:5759
clang
Dataflow Directional Tag Classes.
Definition: CFGReachabilityAnalysis.h:21
clang::SourceLocation::isValid
bool isValid() const
Return true if this is a valid SourceLocation object.
Definition: SourceLocation.h:106
clang::ObjCInterfaceDecl::lookupPrivateMethod
ObjCMethodDecl * lookupPrivateMethod(const Selector &Sel, bool Instance=true) const
Lookup a method in the classes implementation hierarchy.
Definition: DeclObjC.cpp:739
clang::ObjCContainerDecl::FindPropertyDeclaration
ObjCPropertyDecl * FindPropertyDeclaration(const IdentifierInfo *PropertyId, ObjCPropertyQueryKind QueryKind) const
FindPropertyDeclaration - Finds declaration of the property given its name in &#39;PropertyId&#39; and return...
Definition: DeclObjC.cpp:235
clang::DeclContext
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1271
clang::Scope::getParent
const Scope * getParent() const
getParent - Return the scope that this is nested in.
Definition: Scope.h:228
clang::Sema::ImpCastExprToType
ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_RValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CCK_ImplicitConversion)
ImpCastExprToType - If Expr is not of type &#39;Type&#39;, insert an implicit cast.
Definition: Sema.cpp:529
clang::DeclContext::isRecord
bool isRecord() const
Definition: DeclBase.h:1863
clang::Sema::ExpressionEvaluationContext::UnevaluatedAbstract
The current expression occurs within an unevaluated operand that unconditionally permits abstract ref...
clang::IndirectFieldDecl
Represents a field injected from an anonymous union/struct into the parent scope. ...
Definition: Decl.h:2980
clang::FixItHint::CreateRemoval
static FixItHint CreateRemoval(CharSourceRange RemoveRange)
Create a code modification hint that removes the given source range.
Definition: Diagnostic.h:118
clang::Decl::getAccess
AccessSpecifier getAccess() const
Definition: DeclBase.h:473
LookupMemberExpr
static ExprResult LookupMemberExpr(Sema &S, LookupResult &R, ExprResult &BaseExpr, bool &IsArrow, SourceLocation OpLoc, CXXScopeSpec &SS, Decl *ObjCImpDecl, bool HasTemplateArgs, SourceLocation TemplateKWLoc)
Look up the given member of the given non-type-dependent expression.
Definition: SemaExprMember.cpp:1257
clang::Sema::ActOnMemberAccessExtraArgs::ObjCImpDecl
Decl * ObjCImpDecl
Definition: Sema.h:4760
clang::TypoCorrection::getCorrectionDecl
NamedDecl * getCorrectionDecl() const
Gets the pointer to the declaration of the typo correction.
Definition: TypoCorrection.h:151
clang::DeclarationName
The name of a declaration.
Definition: DeclarationName.h:145
clang::LookupResult::getFoundDecl
NamedDecl * getFoundDecl() const
Fetch the unique decl found by this lookup.
Definition: Lookup.h:517
clang::CXXMethodDecl::getParent
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:2046
clang::Sema::tryToRecoverWithCall
bool tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD, bool ForceComplain=false, bool(*IsPlausibleResult)(QualType)=nullptr)
Try to recover by turning the given expression into a call.
Definition: Sema.cpp:2150
clang::ObjCObjectPointerType::getObjectType
const ObjCObjectType * getObjectType() const
Gets the type pointed to by this ObjC pointer.
Definition: Type.h:5992
clang::DeclarationName::CXXDestructorName
Definition: DeclarationName.h:207
clang::Sema::ActOnMemberAccessExpr
ExprResult ActOnMemberAccessExpr(Scope *S, Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, UnqualifiedId &Member, Decl *ObjCImpDecl)
The main callback when the parser finds something like expression .
Definition: SemaExprMember.cpp:1697
clang::DeclarationNameInfo
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
Definition: DeclarationName.h:690
clang::Expr::IgnoreParenImpCasts
Expr * IgnoreParenImpCasts() LLVM_READONLY
Skip past any parentheses and implicit casts which might surround this expression until reaching a fi...
Definition: Expr.cpp:2990
clang::Sema::BuildImplicitMemberExpr
ExprResult BuildImplicitMemberExpr(const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, LookupResult &R, const TemplateArgumentListInfo *TemplateArgs, bool IsDefiniteInstance, const Scope *S)
Builds an implicit member access expression.
Definition: SemaExprMember.cpp:1846
clang::ObjCObjectPointerType
Represents a pointer to an Objective C object.
Definition: Type.h:5951
clang::ObjCImplementationDecl
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition: DeclObjC.h:2566
clang::MemberExpr::setHadMultipleCandidates
void setHadMultipleCandidates(bool V=true)
Sets the flag telling whether this expression refers to a method that was resolved from an overloaded...
Definition: Expr.h:3046
clang::RecordType
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4495
clang::Scope::FnTryCatchScope
This is the scope for a function-level C++ try or catch scope.
Definition: Scope.h:104
clang::DeclarationNameInfo::getSourceRange
SourceRange getSourceRange() const LLVM_READONLY
getSourceRange - The range of the declaration name.
Definition: DeclarationName.h:801
clang::IndirectFieldDecl::chain_begin
chain_iterator chain_begin() const
Definition: Decl.h:3005
clang::Sema::getCurFunctionDecl
FunctionDecl * getCurFunctionDecl()
getCurFunctionDecl - If inside of a function body, this returns a pointer to the function decl for th...
Definition: Sema.cpp:1304
clang::Type::isFunctionType
bool isFunctionType() const
Definition: Type.h:6500
clang::Sema::HandleExprPropertyRefExpr
ExprResult HandleExprPropertyRefExpr(const ObjCObjectPointerType *OPT, Expr *BaseExpr, SourceLocation OpLoc, DeclarationName MemberName, SourceLocation MemberLoc, SourceLocation SuperLoc, QualType SuperType, bool Super)
HandleExprPropertyRefExpr - Handle foo.bar where foo is a pointer to an objective C interface...
Definition: SemaExprObjC.cpp:1850
clang::ExtVectorType
ExtVectorType - Extended vector type.
Definition: Type.h:3354
clang::ReferenceType
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2750
clang::ASTContext::BoundMemberTy
CanQualType BoundMemberTy
Definition: ASTContext.h:1045
clang::DeclFilterCCC
Simple template class for restricting typo correction candidates to ones having a single Decl* of the...
Definition: TypoCorrection.h:366
clang::Sema::ExprEvalContexts
SmallVector< ExpressionEvaluationContextRecord, 8 > ExprEvalContexts
A stack of expression evaluation contexts.
Definition: Sema.h:1112
clang::Sema::BuildFieldReferenceExpr
ExprResult BuildFieldReferenceExpr(Expr *BaseExpr, bool IsArrow, SourceLocation OpLoc, const CXXScopeSpec &SS, FieldDecl *Field, DeclAccessPair FoundDecl, const DeclarationNameInfo &MemberNameInfo)
Definition: SemaExprMember.cpp:1768
clang::ObjCObjectPointerType::quals
qual_range quals() const
Definition: Type.h:6074
clang::LookupResult::getLookupKind
Sema::LookupNameKind getLookupKind() const
Gets the kind of lookup to perform.
Definition: Lookup.h:253
clang::OK_BitField
A bitfield object is a bitfield on a C or C++ record.
Definition: Specifiers.h:144
clang::ObjCIvarRefExpr
ObjCIvarRefExpr - A reference to an ObjC instance variable.
Definition: ExprObjC.h:546
clang::Sema::LookupQualifiedName
bool LookupQualifiedName(LookupResult &R, DeclContext *LookupCtx, bool InUnqualifiedLookup=false)
Perform qualified name lookup into a given context.
Definition: SemaLookup.cpp:2221
clang::ASTContext::getCanonicalType
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2305
clang::CXXScopeSpec::isSet
bool isSet() const
Deprecated.
Definition: DeclSpec.h:209
IMA_Mixed_Unrelated
The reference may be to an instance member, but it is invalid if so, because the context is from an u...
Definition: SemaExprMember.cpp:53
clang::Sema::PerformMemberExprBaseConversion
ExprResult PerformMemberExprBaseConversion(Expr *Base, bool IsArrow)
Perform conversions on the LHS of a member access expression.
Definition: SemaExprMember.cpp:1240
clang::Qualifiers::OCL_Weak
Reading or writing from this object requires a barrier call.
Definition: Type.h:174
DeclCXX.h
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate.h) and friends (in DeclFriend.h).
clang::MemberExpr
MemberExpr - [C99 6.5.2.3] Structure and Union Members.
Definition: Expr.h:2836
clang::ExprResult
ActionResult< Expr * > ExprResult
Definition: Ownership.h:263
clang::FieldDecl::isMutable
bool isMutable() const
Determines whether this field is mutable (C++ only).
Definition: Decl.h:2804
clang::CXXRecordDecl
Represents a C++ struct/union/class.
Definition: DeclCXX.h:253
clang::SourceRange::isValid
bool isValid() const
Definition: SourceLocation.h:222
clang::Sema::getCurFunction
sema::FunctionScopeInfo * getCurFunction() const
Definition: Sema.h:1493
clang::QualType::getQualifiers
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:6283
clang::ObjCIvarDecl
ObjCIvarDecl - Represents an ObjC instance variable.
Definition: DeclObjC.h:1959
clang::Expr::isRValue
bool isRValue() const
Definition: Expr.h:259
IsValidOpenCLComponentSwizzleLength
static bool IsValidOpenCLComponentSwizzleLength(unsigned len)
Definition: SemaExprMember.cpp:289
clang::FixItHint::CreateReplacement
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string...
Definition: Diagnostic.h:129
clang::LookupResult::end
iterator end() const
Definition: Lookup.h:336
clang::Stmt::getSourceRange
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:263
clang::OMF_init
Definition: IdentifierTable.h:633
clang::ExprError
ExprResult ExprError()
Definition: Ownership.h:279
clang::UnqualifiedIdKind::IK_ConstructorName
A constructor name.
clang::ObjCIvarDecl::Package
Definition: DeclObjC.h:1964
clang::VectorType::getNumElements
unsigned getNumElements() const
Definition: Type.h:3271
clang::Type::isDependentType
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:2150
clang::DeclRefExpr
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:1171
clang::Scope::getFnParent
const Scope * getFnParent() const
getFnParent - Return the closest scope that is a function body.
Definition: Scope.h:232
clang::DiagnosticsEngine::isIgnored
bool isIgnored(unsigned DiagID, SourceLocation Loc) const
Determine whether the diagnostic is known to be ignored.
Definition: Diagnostic.h:825
clang::Type::isPointerType
bool isPointerType() const
Definition: Type.h:6504
clang::Sema::ActOnMemberAccessExtraArgs::Id
UnqualifiedId & Id
Definition: Sema.h:4759
clang::LookupResult::setBaseObjectType
void setBaseObjectType(QualType T)
Sets the base object type for this lookup.
Definition: Lookup.h:420
IMA_Static
The reference is definitely not an instance member access.
Definition: SemaExprMember.cpp:42
clang::LookupResult::suppressDiagnostics
void suppressDiagnostics()
Suppress the diagnostics that would normally fire because of this lookup.
Definition: Lookup.h:583
clang::MSPropertyDecl
An instance of this class represents the declaration of a property member.
Definition: DeclCXX.h:3940
clang::ValueDecl::getType
QualType getType() const
Definition: Decl.h:630
clang::VK_LValue
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:129
clang::LookupResult::empty
bool empty() const
Return true if no decls were found.
Definition: Lookup.h:339
FindGetterSetterNameDeclFromProtocolList
static Decl * FindGetterSetterNameDeclFromProtocolList(const ObjCProtocolDecl *PDecl, IdentifierInfo *Member, const Selector &Sel, ASTContext &Context)
Definition: SemaExprMember.cpp:430
clang::isUnresolvedExceptionSpec
bool isUnresolvedExceptionSpec(ExceptionSpecificationType ESpecType)
Definition: ExceptionSpecificationType.h:49
clang::ExtVectorType::getNumericAccessorIdx
static int getNumericAccessorIdx(char c)
Definition: Type.h:3371
clang::SourceRange
A trivial tuple used to represent a source range.
Definition: SourceLocation.h:207
clang::Sema::Context
ASTContext & Context
Definition: Sema.h:385
clang::NamedDecl
This represents a decl that may have a name.
Definition: Decl.h:223
clang::Sema::ActOnMemberAccessExtraArgs::S
Scope * S
Definition: Sema.h:4758
clang::ObjCContainerDecl::getInstanceMethod
ObjCMethodDecl * getInstanceMethod(Selector Sel, bool AllowHidden=false) const
Definition: DeclObjC.h:1101
clang::ObjCIvarDecl::getAccessControl
AccessControl getAccessControl() const
Definition: DeclObjC.h:1998
clang::LookupResult::begin
iterator begin() const
Definition: Lookup.h:335
clang::LookupResult::getNameLoc
SourceLocation getNameLoc() const
Gets the location of the identifier.
Definition: Lookup.h:606
CheckExtVectorComponent
static QualType CheckExtVectorComponent(Sema &S, QualType baseType, ExprValueKind &VK, SourceLocation OpLoc, const IdentifierInfo *CompName, SourceLocation CompLoc)
Check an ext-vector component access expression.
Definition: SemaExprMember.cpp:299
clang::LookupResult::getRepresentativeDecl
NamedDecl * getRepresentativeDecl() const
Fetches a representative decl. Useful for lazy diagnostics.
Definition: Lookup.h:524
clang::SourceRange::getBegin
SourceLocation getBegin() const
Definition: SourceLocation.h:216
IMA_Field_Uneval_Context
Definition: SemaExprMember.cpp:71
clang::ObjCCategoryImplDecl
ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration...
Definition: DeclObjC.h:2513
clang::Sema::ExpressionEvaluationContext::UnevaluatedList
The current expression occurs within a braced-init-list within an unevaluated operand.
clang::Decl::getLocation
SourceLocation getLocation() const
Definition: DeclBase.h:429
isProvablyNotDerivedFrom
static bool isProvablyNotDerivedFrom(Sema &SemaRef, CXXRecordDecl *Record, const BaseSet &Bases)
Determines if the given class is provably not derived from all of the prospective base classes...
Definition: SemaExprMember.cpp:32
clang::NamedDecl::isCXXInstanceMember
bool isCXXInstanceMember() const
Determine whether the given declaration is an instance member of a C++ class.
Definition: Decl.cpp:1790
clang::Sema::SFINAETrap::hasErrorOccurred
bool hasErrorOccurred() const
Determine whether any SFINAE errors have been trapped.
Definition: Sema.h:8481
clang::QualType::getObjCLifetime
Qualifiers::ObjCLifetime getObjCLifetime() const
Returns lifetime attribute of this type.
Definition: Type.h:1080
clang::DeclContext::isTransparentContext
bool isTransparentContext() const
isTransparentContext - Determines whether this context is a "transparent" context, meaning that the members declared in this context are semantically declared in the nearest enclosing non-transparent (opaque) context but are lexically declared in this context.
Definition: DeclBase.cpp:1123