1 //===--- SemaExprMember.cpp - Semantic Analysis for Expressions -----------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements semantic analysis member access expressions.
12 //===----------------------------------------------------------------------===//
13 #include "clang/Sema/Overload.h"
14 #include "clang/AST/ASTLambda.h"
15 #include "clang/AST/DeclCXX.h"
16 #include "clang/AST/DeclObjC.h"
17 #include "clang/AST/DeclTemplate.h"
18 #include "clang/AST/ExprCXX.h"
19 #include "clang/AST/ExprObjC.h"
20 #include "clang/Lex/Preprocessor.h"
21 #include "clang/Sema/Lookup.h"
22 #include "clang/Sema/Scope.h"
23 #include "clang/Sema/ScopeInfo.h"
24 #include "clang/Sema/SemaInternal.h"
26 using namespace clang;
29 typedef llvm::SmallPtrSet<const CXXRecordDecl*, 4> BaseSet;
31 /// Determines if the given class is provably not derived from all of
32 /// the prospective base classes.
33 static bool isProvablyNotDerivedFrom(Sema &SemaRef, CXXRecordDecl *Record,
34 const BaseSet &Bases) {
35 auto BaseIsNotInSet = [&Bases](const CXXRecordDecl *Base) {
36 return !Bases.count(Base->getCanonicalDecl());
38 return BaseIsNotInSet(Record) && Record->forallBases(BaseIsNotInSet);
42 /// The reference is definitely not an instance member access.
45 /// The reference may be an implicit instance member access.
48 /// The reference may be to an instance member, but it might be invalid if
49 /// so, because the context is not an instance method.
50 IMA_Mixed_StaticContext,
52 /// The reference may be to an instance member, but it is invalid if
53 /// so, because the context is from an unrelated class.
56 /// The reference is definitely an implicit instance member access.
59 /// The reference may be to an unresolved using declaration.
62 /// The reference is a contextually-permitted abstract member reference.
65 /// The reference may be to an unresolved using declaration and the
66 /// context is not an instance method.
67 IMA_Unresolved_StaticContext,
69 // The reference refers to a field which is not a member of the containing
70 // class, which is allowed because we're in C++11 mode and the context is
72 IMA_Field_Uneval_Context,
74 /// All possible referrents are instance members and the current
75 /// context is not an instance method.
76 IMA_Error_StaticContext,
78 /// All possible referrents are instance members of an unrelated
83 /// The given lookup names class member(s) and is not being used for
84 /// an address-of-member expression. Classify the type of access
85 /// according to whether it's possible that this reference names an
86 /// instance member. This is best-effort in dependent contexts; it is okay to
87 /// conservatively answer "yes", in which case some errors will simply
88 /// not be caught until template-instantiation.
89 static IMAKind ClassifyImplicitMemberAccess(Sema &SemaRef,
90 const LookupResult &R) {
91 assert(!R.empty() && (*R.begin())->isCXXClassMember());
93 DeclContext *DC = SemaRef.getFunctionLevelDeclContext();
95 bool isStaticContext = SemaRef.CXXThisTypeOverride.isNull() &&
96 (!isa<CXXMethodDecl>(DC) || cast<CXXMethodDecl>(DC)->isStatic());
98 if (R.isUnresolvableResult())
99 return isStaticContext ? IMA_Unresolved_StaticContext : IMA_Unresolved;
101 // Collect all the declaring classes of instance members we find.
102 bool hasNonInstance = false;
103 bool isField = false;
105 for (NamedDecl *D : R) {
106 // Look through any using decls.
107 D = D->getUnderlyingDecl();
109 if (D->isCXXInstanceMember()) {
110 isField |= isa<FieldDecl>(D) || isa<MSPropertyDecl>(D) ||
111 isa<IndirectFieldDecl>(D);
113 CXXRecordDecl *R = cast<CXXRecordDecl>(D->getDeclContext());
114 Classes.insert(R->getCanonicalDecl());
116 hasNonInstance = true;
119 // If we didn't find any instance members, it can't be an implicit
124 // C++11 [expr.prim.general]p12:
125 // An id-expression that denotes a non-static data member or non-static
126 // member function of a class can only be used:
128 // - if that id-expression denotes a non-static data member and it
129 // appears in an unevaluated operand.
131 // This rule is specific to C++11. However, we also permit this form
132 // in unevaluated inline assembly operands, like the operand to a SIZE.
133 IMAKind AbstractInstanceResult = IMA_Static; // happens to be 'false'
134 assert(!AbstractInstanceResult);
135 switch (SemaRef.ExprEvalContexts.back().Context) {
136 case Sema::Unevaluated:
137 if (isField && SemaRef.getLangOpts().CPlusPlus11)
138 AbstractInstanceResult = IMA_Field_Uneval_Context;
141 case Sema::UnevaluatedAbstract:
142 AbstractInstanceResult = IMA_Abstract;
145 case Sema::ConstantEvaluated:
146 case Sema::PotentiallyEvaluated:
147 case Sema::PotentiallyEvaluatedIfUsed:
151 // If the current context is not an instance method, it can't be
152 // an implicit member reference.
153 if (isStaticContext) {
155 return IMA_Mixed_StaticContext;
157 return AbstractInstanceResult ? AbstractInstanceResult
158 : IMA_Error_StaticContext;
161 CXXRecordDecl *contextClass;
162 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(DC))
163 contextClass = MD->getParent()->getCanonicalDecl();
165 contextClass = cast<CXXRecordDecl>(DC);
167 // [class.mfct.non-static]p3:
168 // ...is used in the body of a non-static member function of class X,
169 // if name lookup (3.4.1) resolves the name in the id-expression to a
170 // non-static non-type member of some class C [...]
171 // ...if C is not X or a base class of X, the class member access expression
173 if (R.getNamingClass() &&
174 contextClass->getCanonicalDecl() !=
175 R.getNamingClass()->getCanonicalDecl()) {
176 // If the naming class is not the current context, this was a qualified
177 // member name lookup, and it's sufficient to check that we have the naming
178 // class as a base class.
180 Classes.insert(R.getNamingClass()->getCanonicalDecl());
183 // If we can prove that the current context is unrelated to all the
184 // declaring classes, it can't be an implicit member reference (in
185 // which case it's an error if any of those members are selected).
186 if (isProvablyNotDerivedFrom(SemaRef, contextClass, Classes))
187 return hasNonInstance ? IMA_Mixed_Unrelated :
188 AbstractInstanceResult ? AbstractInstanceResult :
191 return (hasNonInstance ? IMA_Mixed : IMA_Instance);
194 /// Diagnose a reference to a field with no object available.
195 static void diagnoseInstanceReference(Sema &SemaRef,
196 const CXXScopeSpec &SS,
198 const DeclarationNameInfo &nameInfo) {
199 SourceLocation Loc = nameInfo.getLoc();
200 SourceRange Range(Loc);
201 if (SS.isSet()) Range.setBegin(SS.getRange().getBegin());
203 // Look through using shadow decls and aliases.
204 Rep = Rep->getUnderlyingDecl();
206 DeclContext *FunctionLevelDC = SemaRef.getFunctionLevelDeclContext();
207 CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FunctionLevelDC);
208 CXXRecordDecl *ContextClass = Method ? Method->getParent() : nullptr;
209 CXXRecordDecl *RepClass = dyn_cast<CXXRecordDecl>(Rep->getDeclContext());
211 bool InStaticMethod = Method && Method->isStatic();
212 bool IsField = isa<FieldDecl>(Rep) || isa<IndirectFieldDecl>(Rep);
214 if (IsField && InStaticMethod)
215 // "invalid use of member 'x' in static member function"
216 SemaRef.Diag(Loc, diag::err_invalid_member_use_in_static_method)
217 << Range << nameInfo.getName();
218 else if (ContextClass && RepClass && SS.isEmpty() && !InStaticMethod &&
219 !RepClass->Equals(ContextClass) && RepClass->Encloses(ContextClass))
220 // Unqualified lookup in a non-static member function found a member of an
222 SemaRef.Diag(Loc, diag::err_nested_non_static_member_use)
223 << IsField << RepClass << nameInfo.getName() << ContextClass << Range;
225 SemaRef.Diag(Loc, diag::err_invalid_non_static_member_use)
226 << nameInfo.getName() << Range;
228 SemaRef.Diag(Loc, diag::err_member_call_without_object)
232 /// Builds an expression which might be an implicit member expression.
234 Sema::BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS,
235 SourceLocation TemplateKWLoc,
237 const TemplateArgumentListInfo *TemplateArgs,
239 switch (ClassifyImplicitMemberAccess(*this, R)) {
241 return BuildImplicitMemberExpr(SS, TemplateKWLoc, R, TemplateArgs, true, S);
244 case IMA_Mixed_Unrelated:
246 return BuildImplicitMemberExpr(SS, TemplateKWLoc, R, TemplateArgs, false,
249 case IMA_Field_Uneval_Context:
250 Diag(R.getNameLoc(), diag::warn_cxx98_compat_non_static_member_use)
251 << R.getLookupNameInfo().getName();
255 case IMA_Mixed_StaticContext:
256 case IMA_Unresolved_StaticContext:
257 if (TemplateArgs || TemplateKWLoc.isValid())
258 return BuildTemplateIdExpr(SS, TemplateKWLoc, R, false, TemplateArgs);
259 return BuildDeclarationNameExpr(SS, R, false);
261 case IMA_Error_StaticContext:
262 case IMA_Error_Unrelated:
263 diagnoseInstanceReference(*this, SS, R.getRepresentativeDecl(),
264 R.getLookupNameInfo());
268 llvm_unreachable("unexpected instance member access kind");
271 /// Check an ext-vector component access expression.
273 /// VK should be set in advance to the value kind of the base
276 CheckExtVectorComponent(Sema &S, QualType baseType, ExprValueKind &VK,
277 SourceLocation OpLoc, const IdentifierInfo *CompName,
278 SourceLocation CompLoc) {
279 // FIXME: Share logic with ExtVectorElementExpr::containsDuplicateElements,
282 // FIXME: This logic can be greatly simplified by splitting it along
283 // halving/not halving and reworking the component checking.
284 const ExtVectorType *vecType = baseType->getAs<ExtVectorType>();
286 // The vector accessor can't exceed the number of elements.
287 const char *compStr = CompName->getNameStart();
289 // This flag determines whether or not the component is one of the four
290 // special names that indicate a subset of exactly half the elements are
292 bool HalvingSwizzle = false;
294 // This flag determines whether or not CompName has an 's' char prefix,
295 // indicating that it is a string of hex values to be used as vector indices.
296 bool HexSwizzle = (*compStr == 's' || *compStr == 'S') && compStr[1];
298 bool HasRepeated = false;
299 bool HasIndex[16] = {};
303 // Check that we've found one of the special components, or that the component
304 // names must come from the same set.
305 if (!strcmp(compStr, "hi") || !strcmp(compStr, "lo") ||
306 !strcmp(compStr, "even") || !strcmp(compStr, "odd")) {
307 HalvingSwizzle = true;
308 } else if (!HexSwizzle &&
309 (Idx = vecType->getPointAccessorIdx(*compStr)) != -1) {
311 if (HasIndex[Idx]) HasRepeated = true;
312 HasIndex[Idx] = true;
314 } while (*compStr && (Idx = vecType->getPointAccessorIdx(*compStr)) != -1);
316 if (HexSwizzle) compStr++;
317 while ((Idx = vecType->getNumericAccessorIdx(*compStr)) != -1) {
318 if (HasIndex[Idx]) HasRepeated = true;
319 HasIndex[Idx] = true;
324 if (!HalvingSwizzle && *compStr) {
325 // We didn't get to the end of the string. This means the component names
326 // didn't come from the same set *or* we encountered an illegal name.
327 S.Diag(OpLoc, diag::err_ext_vector_component_name_illegal)
328 << StringRef(compStr, 1) << SourceRange(CompLoc);
332 // Ensure no component accessor exceeds the width of the vector type it
334 if (!HalvingSwizzle) {
335 compStr = CompName->getNameStart();
341 if (!vecType->isAccessorWithinNumElements(*compStr++)) {
342 S.Diag(OpLoc, diag::err_ext_vector_component_exceeds_length)
343 << baseType << SourceRange(CompLoc);
349 // The component accessor looks fine - now we need to compute the actual type.
350 // The vector type is implied by the component accessor. For example,
351 // vec4.b is a float, vec4.xy is a vec2, vec4.rgb is a vec3, etc.
352 // vec4.s0 is a float, vec4.s23 is a vec3, etc.
353 // vec4.hi, vec4.lo, vec4.e, and vec4.o all return vec2.
354 unsigned CompSize = HalvingSwizzle ? (vecType->getNumElements() + 1) / 2
355 : CompName->getLength();
360 return vecType->getElementType();
362 if (HasRepeated) VK = VK_RValue;
364 QualType VT = S.Context.getExtVectorType(vecType->getElementType(), CompSize);
365 // Now look up the TypeDefDecl from the vector type. Without this,
366 // diagostics look bad. We want extended vector types to appear built-in.
367 for (Sema::ExtVectorDeclsType::iterator
368 I = S.ExtVectorDecls.begin(S.getExternalSource()),
369 E = S.ExtVectorDecls.end();
371 if ((*I)->getUnderlyingType() == VT)
372 return S.Context.getTypedefType(*I);
375 return VT; // should never get here (a typedef type should always be found).
378 static Decl *FindGetterSetterNameDeclFromProtocolList(const ObjCProtocolDecl*PDecl,
379 IdentifierInfo *Member,
381 ASTContext &Context) {
383 if (ObjCPropertyDecl *PD = PDecl->FindPropertyDeclaration(Member))
385 if (ObjCMethodDecl *OMD = PDecl->getInstanceMethod(Sel))
388 for (const auto *I : PDecl->protocols()) {
389 if (Decl *D = FindGetterSetterNameDeclFromProtocolList(I, Member, Sel,
396 static Decl *FindGetterSetterNameDecl(const ObjCObjectPointerType *QIdTy,
397 IdentifierInfo *Member,
399 ASTContext &Context) {
400 // Check protocols on qualified interfaces.
401 Decl *GDecl = nullptr;
402 for (const auto *I : QIdTy->quals()) {
404 if (ObjCPropertyDecl *PD = I->FindPropertyDeclaration(Member)) {
408 // Also must look for a getter or setter name which uses property syntax.
409 if (ObjCMethodDecl *OMD = I->getInstanceMethod(Sel)) {
415 for (const auto *I : QIdTy->quals()) {
416 // Search in the protocol-qualifier list of current protocol.
417 GDecl = FindGetterSetterNameDeclFromProtocolList(I, Member, Sel, Context);
426 Sema::ActOnDependentMemberExpr(Expr *BaseExpr, QualType BaseType,
427 bool IsArrow, SourceLocation OpLoc,
428 const CXXScopeSpec &SS,
429 SourceLocation TemplateKWLoc,
430 NamedDecl *FirstQualifierInScope,
431 const DeclarationNameInfo &NameInfo,
432 const TemplateArgumentListInfo *TemplateArgs) {
433 // Even in dependent contexts, try to diagnose base expressions with
434 // obviously wrong types, e.g.:
439 // In Obj-C++, however, the above expression is valid, since it could be
440 // accessing the 'f' property if T is an Obj-C interface. The extra check
441 // allows this, while still reporting an error if T is a struct pointer.
443 const PointerType *PT = BaseType->getAs<PointerType>();
444 if (PT && (!getLangOpts().ObjC1 ||
445 PT->getPointeeType()->isRecordType())) {
446 assert(BaseExpr && "cannot happen with implicit member accesses");
447 Diag(OpLoc, diag::err_typecheck_member_reference_struct_union)
448 << BaseType << BaseExpr->getSourceRange() << NameInfo.getSourceRange();
453 assert(BaseType->isDependentType() ||
454 NameInfo.getName().isDependentName() ||
455 isDependentScopeSpecifier(SS));
457 // Get the type being accessed in BaseType. If this is an arrow, the BaseExpr
458 // must have pointer type, and the accessed type is the pointee.
459 return CXXDependentScopeMemberExpr::Create(
460 Context, BaseExpr, BaseType, IsArrow, OpLoc,
461 SS.getWithLocInContext(Context), TemplateKWLoc, FirstQualifierInScope,
462 NameInfo, TemplateArgs);
465 /// We know that the given qualified member reference points only to
466 /// declarations which do not belong to the static type of the base
467 /// expression. Diagnose the problem.
468 static void DiagnoseQualifiedMemberReference(Sema &SemaRef,
471 const CXXScopeSpec &SS,
473 const DeclarationNameInfo &nameInfo) {
474 // If this is an implicit member access, use a different set of
477 return diagnoseInstanceReference(SemaRef, SS, rep, nameInfo);
479 SemaRef.Diag(nameInfo.getLoc(), diag::err_qualified_member_of_unrelated)
480 << SS.getRange() << rep << BaseType;
483 // Check whether the declarations we found through a nested-name
484 // specifier in a member expression are actually members of the base
485 // type. The restriction here is:
488 // ... In these cases, the id-expression shall name a
489 // member of the class or of one of its base classes.
491 // So it's perfectly legitimate for the nested-name specifier to name
492 // an unrelated class, and for us to find an overload set including
493 // decls from classes which are not superclasses, as long as the decl
494 // we actually pick through overload resolution is from a superclass.
495 bool Sema::CheckQualifiedMemberReference(Expr *BaseExpr,
497 const CXXScopeSpec &SS,
498 const LookupResult &R) {
499 CXXRecordDecl *BaseRecord =
500 cast_or_null<CXXRecordDecl>(computeDeclContext(BaseType));
502 // We can't check this yet because the base type is still
504 assert(BaseType->isDependentType());
508 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {
509 // If this is an implicit member reference and we find a
510 // non-instance member, it's not an error.
511 if (!BaseExpr && !(*I)->isCXXInstanceMember())
514 // Note that we use the DC of the decl, not the underlying decl.
515 DeclContext *DC = (*I)->getDeclContext();
516 while (DC->isTransparentContext())
517 DC = DC->getParent();
522 CXXRecordDecl *MemberRecord = cast<CXXRecordDecl>(DC)->getCanonicalDecl();
523 if (BaseRecord->getCanonicalDecl() == MemberRecord ||
524 !BaseRecord->isProvablyNotDerivedFrom(MemberRecord))
528 DiagnoseQualifiedMemberReference(*this, BaseExpr, BaseType, SS,
529 R.getRepresentativeDecl(),
530 R.getLookupNameInfo());
536 // Callback to only accept typo corrections that are either a ValueDecl or a
537 // FunctionTemplateDecl and are declared in the current record or, for a C++
538 // classes, one of its base classes.
539 class RecordMemberExprValidatorCCC : public CorrectionCandidateCallback {
541 explicit RecordMemberExprValidatorCCC(const RecordType *RTy)
542 : Record(RTy->getDecl()) {
543 // Don't add bare keywords to the consumer since they will always fail
544 // validation by virtue of not being associated with any decls.
545 WantTypeSpecifiers = false;
546 WantExpressionKeywords = false;
547 WantCXXNamedCasts = false;
548 WantFunctionLikeCasts = false;
549 WantRemainingKeywords = false;
552 bool ValidateCandidate(const TypoCorrection &candidate) override {
553 NamedDecl *ND = candidate.getCorrectionDecl();
554 // Don't accept candidates that cannot be member functions, constants,
555 // variables, or templates.
556 if (!ND || !(isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND)))
559 // Accept candidates that occur in the current record.
560 if (Record->containsDecl(ND))
563 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Record)) {
564 // Accept candidates that occur in any of the current class' base classes.
565 for (const auto &BS : RD->bases()) {
566 if (const RecordType *BSTy =
567 dyn_cast_or_null<RecordType>(BS.getType().getTypePtrOrNull())) {
568 if (BSTy->getDecl()->containsDecl(ND))
578 const RecordDecl *const Record;
583 static bool LookupMemberExprInRecord(Sema &SemaRef, LookupResult &R,
585 const RecordType *RTy,
586 SourceLocation OpLoc, bool IsArrow,
587 CXXScopeSpec &SS, bool HasTemplateArgs,
589 SourceRange BaseRange = BaseExpr ? BaseExpr->getSourceRange() : SourceRange();
590 RecordDecl *RDecl = RTy->getDecl();
591 if (!SemaRef.isThisOutsideMemberFunctionBody(QualType(RTy, 0)) &&
592 SemaRef.RequireCompleteType(OpLoc, QualType(RTy, 0),
593 diag::err_typecheck_incomplete_tag,
597 if (HasTemplateArgs) {
598 // LookupTemplateName doesn't expect these both to exist simultaneously.
599 QualType ObjectType = SS.isSet() ? QualType() : QualType(RTy, 0);
602 SemaRef.LookupTemplateName(R, nullptr, SS, ObjectType, false, MOUS);
606 DeclContext *DC = RDecl;
608 // If the member name was a qualified-id, look into the
609 // nested-name-specifier.
610 DC = SemaRef.computeDeclContext(SS, false);
612 if (SemaRef.RequireCompleteDeclContext(SS, DC)) {
613 SemaRef.Diag(SS.getRange().getEnd(), diag::err_typecheck_incomplete_tag)
614 << SS.getRange() << DC;
618 assert(DC && "Cannot handle non-computable dependent contexts in lookup");
620 if (!isa<TypeDecl>(DC)) {
621 SemaRef.Diag(R.getNameLoc(), diag::err_qualified_member_nonclass)
622 << DC << SS.getRange();
627 // The record definition is complete, now look up the member.
628 SemaRef.LookupQualifiedName(R, DC, SS);
633 DeclarationName Typo = R.getLookupName();
634 SourceLocation TypoLoc = R.getNameLoc();
638 DeclarationNameInfo NameInfo;
639 Sema::LookupNameKind LookupKind;
640 Sema::RedeclarationKind Redecl;
642 QueryState Q = {R.getSema(), R.getLookupNameInfo(), R.getLookupKind(),
643 R.isForRedeclaration() ? Sema::ForRedeclaration
644 : Sema::NotForRedeclaration};
645 TE = SemaRef.CorrectTypoDelayed(
646 R.getLookupNameInfo(), R.getLookupKind(), nullptr, &SS,
647 llvm::make_unique<RecordMemberExprValidatorCCC>(RTy),
648 [=, &SemaRef](const TypoCorrection &TC) {
650 assert(!TC.isKeyword() &&
651 "Got a keyword as a correction for a member!");
652 bool DroppedSpecifier =
653 TC.WillReplaceSpecifier() &&
654 Typo.getAsString() == TC.getAsString(SemaRef.getLangOpts());
655 SemaRef.diagnoseTypo(TC, SemaRef.PDiag(diag::err_no_member_suggest)
656 << Typo << DC << DroppedSpecifier
659 SemaRef.Diag(TypoLoc, diag::err_no_member) << Typo << DC << BaseRange;
662 [=](Sema &SemaRef, TypoExpr *TE, TypoCorrection TC) mutable {
663 LookupResult R(Q.SemaRef, Q.NameInfo, Q.LookupKind, Q.Redecl);
664 R.clear(); // Ensure there's no decls lingering in the shared state.
665 R.suppressDiagnostics();
666 R.setLookupName(TC.getCorrection());
667 for (NamedDecl *ND : TC)
670 return SemaRef.BuildMemberReferenceExpr(
671 BaseExpr, BaseExpr->getType(), OpLoc, IsArrow, SS, SourceLocation(),
672 nullptr, R, nullptr, nullptr);
674 Sema::CTK_ErrorRecovery, DC);
679 static ExprResult LookupMemberExpr(Sema &S, LookupResult &R,
680 ExprResult &BaseExpr, bool &IsArrow,
681 SourceLocation OpLoc, CXXScopeSpec &SS,
682 Decl *ObjCImpDecl, bool HasTemplateArgs);
685 Sema::BuildMemberReferenceExpr(Expr *Base, QualType BaseType,
686 SourceLocation OpLoc, bool IsArrow,
688 SourceLocation TemplateKWLoc,
689 NamedDecl *FirstQualifierInScope,
690 const DeclarationNameInfo &NameInfo,
691 const TemplateArgumentListInfo *TemplateArgs,
693 ActOnMemberAccessExtraArgs *ExtraArgs) {
694 if (BaseType->isDependentType() ||
695 (SS.isSet() && isDependentScopeSpecifier(SS)))
696 return ActOnDependentMemberExpr(Base, BaseType,
698 SS, TemplateKWLoc, FirstQualifierInScope,
699 NameInfo, TemplateArgs);
701 LookupResult R(*this, NameInfo, LookupMemberName);
703 // Implicit member accesses.
705 TypoExpr *TE = nullptr;
706 QualType RecordTy = BaseType;
707 if (IsArrow) RecordTy = RecordTy->getAs<PointerType>()->getPointeeType();
708 if (LookupMemberExprInRecord(*this, R, nullptr,
709 RecordTy->getAs<RecordType>(), OpLoc, IsArrow,
710 SS, TemplateArgs != nullptr, TE))
715 // Explicit member accesses.
717 ExprResult BaseResult = Base;
718 ExprResult Result = LookupMemberExpr(
719 *this, R, BaseResult, IsArrow, OpLoc, SS,
720 ExtraArgs ? ExtraArgs->ObjCImpDecl : nullptr,
721 TemplateArgs != nullptr);
723 if (BaseResult.isInvalid())
725 Base = BaseResult.get();
727 if (Result.isInvalid())
733 // LookupMemberExpr can modify Base, and thus change BaseType
734 BaseType = Base->getType();
737 return BuildMemberReferenceExpr(Base, BaseType,
738 OpLoc, IsArrow, SS, TemplateKWLoc,
739 FirstQualifierInScope, R, TemplateArgs, S,
744 BuildFieldReferenceExpr(Sema &S, Expr *BaseExpr, bool IsArrow,
745 SourceLocation OpLoc, const CXXScopeSpec &SS,
746 FieldDecl *Field, DeclAccessPair FoundDecl,
747 const DeclarationNameInfo &MemberNameInfo);
750 Sema::BuildAnonymousStructUnionMemberReference(const CXXScopeSpec &SS,
752 IndirectFieldDecl *indirectField,
753 DeclAccessPair foundDecl,
754 Expr *baseObjectExpr,
755 SourceLocation opLoc) {
756 // First, build the expression that refers to the base object.
758 bool baseObjectIsPointer = false;
759 Qualifiers baseQuals;
761 // Case 1: the base of the indirect field is not a field.
762 VarDecl *baseVariable = indirectField->getVarDecl();
763 CXXScopeSpec EmptySS;
765 assert(baseVariable->getType()->isRecordType());
767 // In principle we could have a member access expression that
768 // accesses an anonymous struct/union that's a static member of
769 // the base object's class. However, under the current standard,
770 // static data members cannot be anonymous structs or unions.
771 // Supporting this is as easy as building a MemberExpr here.
772 assert(!baseObjectExpr && "anonymous struct/union is static data member?");
774 DeclarationNameInfo baseNameInfo(DeclarationName(), loc);
777 = BuildDeclarationNameExpr(EmptySS, baseNameInfo, baseVariable);
778 if (result.isInvalid()) return ExprError();
780 baseObjectExpr = result.get();
781 baseObjectIsPointer = false;
782 baseQuals = baseObjectExpr->getType().getQualifiers();
784 // Case 2: the base of the indirect field is a field and the user
785 // wrote a member expression.
786 } else if (baseObjectExpr) {
787 // The caller provided the base object expression. Determine
788 // whether its a pointer and whether it adds any qualifiers to the
789 // anonymous struct/union fields we're looking into.
790 QualType objectType = baseObjectExpr->getType();
792 if (const PointerType *ptr = objectType->getAs<PointerType>()) {
793 baseObjectIsPointer = true;
794 objectType = ptr->getPointeeType();
796 baseObjectIsPointer = false;
798 baseQuals = objectType.getQualifiers();
800 // Case 3: the base of the indirect field is a field and we should
801 // build an implicit member access.
803 // We've found a member of an anonymous struct/union that is
804 // inside a non-anonymous struct/union, so in a well-formed
805 // program our base object expression is "this".
806 QualType ThisTy = getCurrentThisType();
807 if (ThisTy.isNull()) {
808 Diag(loc, diag::err_invalid_member_use_in_static_method)
809 << indirectField->getDeclName();
813 // Our base object expression is "this".
814 CheckCXXThisCapture(loc);
816 = new (Context) CXXThisExpr(loc, ThisTy, /*isImplicit=*/ true);
817 baseObjectIsPointer = true;
818 baseQuals = ThisTy->castAs<PointerType>()->getPointeeType().getQualifiers();
821 // Build the implicit member references to the field of the
822 // anonymous struct/union.
823 Expr *result = baseObjectExpr;
824 IndirectFieldDecl::chain_iterator
825 FI = indirectField->chain_begin(), FEnd = indirectField->chain_end();
827 // Build the first member access in the chain with full information.
829 FieldDecl *field = cast<FieldDecl>(*FI);
831 // Make a nameInfo that properly uses the anonymous name.
832 DeclarationNameInfo memberNameInfo(field->getDeclName(), loc);
834 result = BuildFieldReferenceExpr(*this, result, baseObjectIsPointer,
835 SourceLocation(), EmptySS, field,
836 foundDecl, memberNameInfo).get();
840 // FIXME: check qualified member access
843 // In all cases, we should now skip the first declaration in the chain.
847 FieldDecl *field = cast<FieldDecl>(*FI++);
849 // FIXME: these are somewhat meaningless
850 DeclarationNameInfo memberNameInfo(field->getDeclName(), loc);
851 DeclAccessPair fakeFoundDecl =
852 DeclAccessPair::make(field, field->getAccess());
855 BuildFieldReferenceExpr(*this, result, /*isarrow*/ false,
856 SourceLocation(), (FI == FEnd ? SS : EmptySS),
857 field, fakeFoundDecl, memberNameInfo).get();
864 BuildMSPropertyRefExpr(Sema &S, Expr *BaseExpr, bool IsArrow,
865 const CXXScopeSpec &SS,
867 const DeclarationNameInfo &NameInfo) {
868 // Property names are always simple identifiers and therefore never
869 // require any interesting additional storage.
870 return new (S.Context) MSPropertyRefExpr(BaseExpr, PD, IsArrow,
871 S.Context.PseudoObjectTy, VK_LValue,
872 SS.getWithLocInContext(S.Context),
876 /// \brief Build a MemberExpr AST node.
877 static MemberExpr *BuildMemberExpr(
878 Sema &SemaRef, ASTContext &C, Expr *Base, bool isArrow,
879 SourceLocation OpLoc, const CXXScopeSpec &SS, SourceLocation TemplateKWLoc,
880 ValueDecl *Member, DeclAccessPair FoundDecl,
881 const DeclarationNameInfo &MemberNameInfo, QualType Ty, ExprValueKind VK,
882 ExprObjectKind OK, const TemplateArgumentListInfo *TemplateArgs = nullptr) {
883 assert((!isArrow || Base->isRValue()) && "-> base must be a pointer rvalue");
884 MemberExpr *E = MemberExpr::Create(
885 C, Base, isArrow, OpLoc, SS.getWithLocInContext(C), TemplateKWLoc, Member,
886 FoundDecl, MemberNameInfo, TemplateArgs, Ty, VK, OK);
887 SemaRef.MarkMemberReferenced(E);
891 /// \brief Determine if the given scope is within a function-try-block handler.
892 static bool IsInFnTryBlockHandler(const Scope *S) {
893 // Walk the scope stack until finding a FnTryCatchScope, or leave the
894 // function scope. If a FnTryCatchScope is found, check whether the TryScope
895 // flag is set. If it is not, it's a function-try-block handler.
896 for (; S != S->getFnParent(); S = S->getParent()) {
897 if (S->getFlags() & Scope::FnTryCatchScope)
898 return (S->getFlags() & Scope::TryScope) != Scope::TryScope;
904 Sema::BuildMemberReferenceExpr(Expr *BaseExpr, QualType BaseExprType,
905 SourceLocation OpLoc, bool IsArrow,
906 const CXXScopeSpec &SS,
907 SourceLocation TemplateKWLoc,
908 NamedDecl *FirstQualifierInScope,
910 const TemplateArgumentListInfo *TemplateArgs,
912 bool SuppressQualifierCheck,
913 ActOnMemberAccessExtraArgs *ExtraArgs) {
914 QualType BaseType = BaseExprType;
916 assert(BaseType->isPointerType());
917 BaseType = BaseType->castAs<PointerType>()->getPointeeType();
919 R.setBaseObjectType(BaseType);
921 LambdaScopeInfo *const CurLSI = getCurLambda();
922 // If this is an implicit member reference and the overloaded
923 // name refers to both static and non-static member functions
924 // (i.e. BaseExpr is null) and if we are currently processing a lambda,
925 // check if we should/can capture 'this'...
926 // Keep this example in mind:
929 // static void f(double) { }
932 // auto L = [=](auto a) {
933 // return [](int i) {
934 // return [=](auto b) {
936 // //f(decltype(a){});
942 // N(5.32); // OK, must not error.
947 if (!BaseExpr && CurLSI) {
948 SourceLocation Loc = R.getNameLoc();
949 if (SS.getRange().isValid())
950 Loc = SS.getRange().getBegin();
951 DeclContext *EnclosingFunctionCtx = CurContext->getParent()->getParent();
952 // If the enclosing function is not dependent, then this lambda is
953 // capture ready, so if we can capture this, do so.
954 if (!EnclosingFunctionCtx->isDependentContext()) {
955 // If the current lambda and all enclosing lambdas can capture 'this' -
956 // then go ahead and capture 'this' (since our unresolved overload set
957 // contains both static and non-static member functions).
958 if (!CheckCXXThisCapture(Loc, /*Explcit*/false, /*Diagnose*/false))
959 CheckCXXThisCapture(Loc);
960 } else if (CurContext->isDependentContext()) {
961 // ... since this is an implicit member reference, that might potentially
962 // involve a 'this' capture, mark 'this' for potential capture in
963 // enclosing lambdas.
964 if (CurLSI->ImpCaptureStyle != CurLSI->ImpCap_None)
965 CurLSI->addPotentialThisCapture(Loc);
968 const DeclarationNameInfo &MemberNameInfo = R.getLookupNameInfo();
969 DeclarationName MemberName = MemberNameInfo.getName();
970 SourceLocation MemberLoc = MemberNameInfo.getLoc();
975 // [except.handle]p10: Referring to any non-static member or base class of an
976 // object in the handler for a function-try-block of a constructor or
977 // destructor for that object results in undefined behavior.
978 const auto *FD = getCurFunctionDecl();
979 if (S && BaseExpr && FD &&
980 (isa<CXXDestructorDecl>(FD) || isa<CXXConstructorDecl>(FD)) &&
981 isa<CXXThisExpr>(BaseExpr->IgnoreImpCasts()) &&
982 IsInFnTryBlockHandler(S))
983 Diag(MemberLoc, diag::warn_cdtor_function_try_handler_mem_expr)
984 << isa<CXXDestructorDecl>(FD);
987 // Rederive where we looked up.
988 DeclContext *DC = (SS.isSet()
989 ? computeDeclContext(SS, false)
990 : BaseType->getAs<RecordType>()->getDecl());
993 ExprResult RetryExpr;
994 if (!IsArrow && BaseExpr) {
995 SFINAETrap Trap(*this, true);
996 ParsedType ObjectType;
997 bool MayBePseudoDestructor = false;
998 RetryExpr = ActOnStartCXXMemberReference(getCurScope(), BaseExpr,
999 OpLoc, tok::arrow, ObjectType,
1000 MayBePseudoDestructor);
1001 if (RetryExpr.isUsable() && !Trap.hasErrorOccurred()) {
1002 CXXScopeSpec TempSS(SS);
1003 RetryExpr = ActOnMemberAccessExpr(
1004 ExtraArgs->S, RetryExpr.get(), OpLoc, tok::arrow, TempSS,
1005 TemplateKWLoc, ExtraArgs->Id, ExtraArgs->ObjCImpDecl);
1007 if (Trap.hasErrorOccurred())
1008 RetryExpr = ExprError();
1010 if (RetryExpr.isUsable()) {
1011 Diag(OpLoc, diag::err_no_member_overloaded_arrow)
1012 << MemberName << DC << FixItHint::CreateReplacement(OpLoc, "->");
1017 Diag(R.getNameLoc(), diag::err_no_member)
1019 << (BaseExpr ? BaseExpr->getSourceRange() : SourceRange());
1023 // Diagnose lookups that find only declarations from a non-base
1024 // type. This is possible for either qualified lookups (which may
1025 // have been qualified with an unrelated type) or implicit member
1026 // expressions (which were found with unqualified lookup and thus
1027 // may have come from an enclosing scope). Note that it's okay for
1028 // lookup to find declarations from a non-base type as long as those
1029 // aren't the ones picked by overload resolution.
1030 if ((SS.isSet() || !BaseExpr ||
1031 (isa<CXXThisExpr>(BaseExpr) &&
1032 cast<CXXThisExpr>(BaseExpr)->isImplicit())) &&
1033 !SuppressQualifierCheck &&
1034 CheckQualifiedMemberReference(BaseExpr, BaseType, SS, R))
1037 // Construct an unresolved result if we in fact got an unresolved
1039 if (R.isOverloadedResult() || R.isUnresolvableResult()) {
1040 // Suppress any lookup-related diagnostics; we'll do these when we
1042 R.suppressDiagnostics();
1044 UnresolvedMemberExpr *MemExpr
1045 = UnresolvedMemberExpr::Create(Context, R.isUnresolvableResult(),
1046 BaseExpr, BaseExprType,
1048 SS.getWithLocInContext(Context),
1049 TemplateKWLoc, MemberNameInfo,
1050 TemplateArgs, R.begin(), R.end());
1055 assert(R.isSingleResult());
1056 DeclAccessPair FoundDecl = R.begin().getPair();
1057 NamedDecl *MemberDecl = R.getFoundDecl();
1059 // FIXME: diagnose the presence of template arguments now.
1061 // If the decl being referenced had an error, return an error for this
1062 // sub-expr without emitting another error, in order to avoid cascading
1064 if (MemberDecl->isInvalidDecl())
1067 // Handle the implicit-member-access case.
1069 // If this is not an instance member, convert to a non-member access.
1070 if (!MemberDecl->isCXXInstanceMember())
1071 return BuildDeclarationNameExpr(SS, R.getLookupNameInfo(), MemberDecl);
1073 SourceLocation Loc = R.getNameLoc();
1074 if (SS.getRange().isValid())
1075 Loc = SS.getRange().getBegin();
1076 CheckCXXThisCapture(Loc);
1077 BaseExpr = new (Context) CXXThisExpr(Loc, BaseExprType,/*isImplicit=*/true);
1080 // Check the use of this member.
1081 if (DiagnoseUseOfDecl(MemberDecl, MemberLoc))
1084 if (FieldDecl *FD = dyn_cast<FieldDecl>(MemberDecl))
1085 return BuildFieldReferenceExpr(*this, BaseExpr, IsArrow, OpLoc, SS, FD,
1086 FoundDecl, MemberNameInfo);
1088 if (MSPropertyDecl *PD = dyn_cast<MSPropertyDecl>(MemberDecl))
1089 return BuildMSPropertyRefExpr(*this, BaseExpr, IsArrow, SS, PD,
1092 if (IndirectFieldDecl *FD = dyn_cast<IndirectFieldDecl>(MemberDecl))
1093 // We may have found a field within an anonymous union or struct
1094 // (C++ [class.union]).
1095 return BuildAnonymousStructUnionMemberReference(SS, MemberLoc, FD,
1096 FoundDecl, BaseExpr,
1099 if (VarDecl *Var = dyn_cast<VarDecl>(MemberDecl)) {
1100 return BuildMemberExpr(*this, Context, BaseExpr, IsArrow, OpLoc, SS,
1101 TemplateKWLoc, Var, FoundDecl, MemberNameInfo,
1102 Var->getType().getNonReferenceType(), VK_LValue,
1106 if (CXXMethodDecl *MemberFn = dyn_cast<CXXMethodDecl>(MemberDecl)) {
1107 ExprValueKind valueKind;
1109 if (MemberFn->isInstance()) {
1110 valueKind = VK_RValue;
1111 type = Context.BoundMemberTy;
1113 valueKind = VK_LValue;
1114 type = MemberFn->getType();
1117 return BuildMemberExpr(*this, Context, BaseExpr, IsArrow, OpLoc, SS,
1118 TemplateKWLoc, MemberFn, FoundDecl, MemberNameInfo,
1119 type, valueKind, OK_Ordinary);
1121 assert(!isa<FunctionDecl>(MemberDecl) && "member function not C++ method?");
1123 if (EnumConstantDecl *Enum = dyn_cast<EnumConstantDecl>(MemberDecl)) {
1124 return BuildMemberExpr(*this, Context, BaseExpr, IsArrow, OpLoc, SS,
1125 TemplateKWLoc, Enum, FoundDecl, MemberNameInfo,
1126 Enum->getType(), VK_RValue, OK_Ordinary);
1129 // We found something that we didn't expect. Complain.
1130 if (isa<TypeDecl>(MemberDecl))
1131 Diag(MemberLoc, diag::err_typecheck_member_reference_type)
1132 << MemberName << BaseType << int(IsArrow);
1134 Diag(MemberLoc, diag::err_typecheck_member_reference_unknown)
1135 << MemberName << BaseType << int(IsArrow);
1137 Diag(MemberDecl->getLocation(), diag::note_member_declared_here)
1139 R.suppressDiagnostics();
1143 /// Given that normal member access failed on the given expression,
1144 /// and given that the expression's type involves builtin-id or
1145 /// builtin-Class, decide whether substituting in the redefinition
1146 /// types would be profitable. The redefinition type is whatever
1147 /// this translation unit tried to typedef to id/Class; we store
1148 /// it to the side and then re-use it in places like this.
1149 static bool ShouldTryAgainWithRedefinitionType(Sema &S, ExprResult &base) {
1150 const ObjCObjectPointerType *opty
1151 = base.get()->getType()->getAs<ObjCObjectPointerType>();
1152 if (!opty) return false;
1154 const ObjCObjectType *ty = opty->getObjectType();
1157 if (ty->isObjCId()) {
1158 redef = S.Context.getObjCIdRedefinitionType();
1159 } else if (ty->isObjCClass()) {
1160 redef = S.Context.getObjCClassRedefinitionType();
1165 // Do the substitution as long as the redefinition type isn't just a
1166 // possibly-qualified pointer to builtin-id or builtin-Class again.
1167 opty = redef->getAs<ObjCObjectPointerType>();
1168 if (opty && !opty->getObjectType()->getInterface())
1171 base = S.ImpCastExprToType(base.get(), redef, CK_BitCast);
1175 static bool isRecordType(QualType T) {
1176 return T->isRecordType();
1178 static bool isPointerToRecordType(QualType T) {
1179 if (const PointerType *PT = T->getAs<PointerType>())
1180 return PT->getPointeeType()->isRecordType();
1184 /// Perform conversions on the LHS of a member access expression.
1186 Sema::PerformMemberExprBaseConversion(Expr *Base, bool IsArrow) {
1187 if (IsArrow && !Base->getType()->isFunctionType())
1188 return DefaultFunctionArrayLvalueConversion(Base);
1190 return CheckPlaceholderExpr(Base);
1193 /// Look up the given member of the given non-type-dependent
1194 /// expression. This can return in one of two ways:
1195 /// * If it returns a sentinel null-but-valid result, the caller will
1196 /// assume that lookup was performed and the results written into
1197 /// the provided structure. It will take over from there.
1198 /// * Otherwise, the returned expression will be produced in place of
1199 /// an ordinary member expression.
1201 /// The ObjCImpDecl bit is a gross hack that will need to be properly
1202 /// fixed for ObjC++.
1203 static ExprResult LookupMemberExpr(Sema &S, LookupResult &R,
1204 ExprResult &BaseExpr, bool &IsArrow,
1205 SourceLocation OpLoc, CXXScopeSpec &SS,
1206 Decl *ObjCImpDecl, bool HasTemplateArgs) {
1207 assert(BaseExpr.get() && "no base expression");
1209 // Perform default conversions.
1210 BaseExpr = S.PerformMemberExprBaseConversion(BaseExpr.get(), IsArrow);
1211 if (BaseExpr.isInvalid())
1214 QualType BaseType = BaseExpr.get()->getType();
1215 assert(!BaseType->isDependentType());
1217 DeclarationName MemberName = R.getLookupName();
1218 SourceLocation MemberLoc = R.getNameLoc();
1220 // For later type-checking purposes, turn arrow accesses into dot
1221 // accesses. The only access type we support that doesn't follow
1222 // the C equivalence "a->b === (*a).b" is ObjC property accesses,
1223 // and those never use arrows, so this is unaffected.
1225 if (const PointerType *Ptr = BaseType->getAs<PointerType>())
1226 BaseType = Ptr->getPointeeType();
1227 else if (const ObjCObjectPointerType *Ptr
1228 = BaseType->getAs<ObjCObjectPointerType>())
1229 BaseType = Ptr->getPointeeType();
1230 else if (BaseType->isRecordType()) {
1231 // Recover from arrow accesses to records, e.g.:
1232 // struct MyRecord foo;
1234 // This is actually well-formed in C++ if MyRecord has an
1235 // overloaded operator->, but that should have been dealt with
1236 // by now--or a diagnostic message already issued if a problem
1237 // was encountered while looking for the overloaded operator->.
1238 if (!S.getLangOpts().CPlusPlus) {
1239 S.Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
1240 << BaseType << int(IsArrow) << BaseExpr.get()->getSourceRange()
1241 << FixItHint::CreateReplacement(OpLoc, ".");
1244 } else if (BaseType->isFunctionType()) {
1247 S.Diag(MemberLoc, diag::err_typecheck_member_reference_arrow)
1248 << BaseType << BaseExpr.get()->getSourceRange();
1253 // Handle field access to simple records.
1254 if (const RecordType *RTy = BaseType->getAs<RecordType>()) {
1255 TypoExpr *TE = nullptr;
1256 if (LookupMemberExprInRecord(S, R, BaseExpr.get(), RTy,
1257 OpLoc, IsArrow, SS, HasTemplateArgs, TE))
1260 // Returning valid-but-null is how we indicate to the caller that
1261 // the lookup result was filled in. If typo correction was attempted and
1262 // failed, the lookup result will have been cleared--that combined with the
1263 // valid-but-null ExprResult will trigger the appropriate diagnostics.
1264 return ExprResult(TE);
1267 // Handle ivar access to Objective-C objects.
1268 if (const ObjCObjectType *OTy = BaseType->getAs<ObjCObjectType>()) {
1269 if (!SS.isEmpty() && !SS.isInvalid()) {
1270 S.Diag(SS.getRange().getBegin(), diag::err_qualified_objc_access)
1271 << 1 << SS.getScopeRep()
1272 << FixItHint::CreateRemoval(SS.getRange());
1276 IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
1278 // There are three cases for the base type:
1279 // - builtin id (qualified or unqualified)
1280 // - builtin Class (qualified or unqualified)
1282 ObjCInterfaceDecl *IDecl = OTy->getInterface();
1284 if (S.getLangOpts().ObjCAutoRefCount &&
1285 (OTy->isObjCId() || OTy->isObjCClass()))
1287 // There's an implicit 'isa' ivar on all objects.
1288 // But we only actually find it this way on objects of type 'id',
1290 if (OTy->isObjCId() && Member->isStr("isa"))
1291 return new (S.Context) ObjCIsaExpr(BaseExpr.get(), IsArrow, MemberLoc,
1292 OpLoc, S.Context.getObjCClassType());
1293 if (ShouldTryAgainWithRedefinitionType(S, BaseExpr))
1294 return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1295 ObjCImpDecl, HasTemplateArgs);
1299 if (S.RequireCompleteType(OpLoc, BaseType,
1300 diag::err_typecheck_incomplete_tag,
1304 ObjCInterfaceDecl *ClassDeclared = nullptr;
1305 ObjCIvarDecl *IV = IDecl->lookupInstanceVariable(Member, ClassDeclared);
1308 // Attempt to correct for typos in ivar names.
1309 auto Validator = llvm::make_unique<DeclFilterCCC<ObjCIvarDecl>>();
1310 Validator->IsObjCIvarLookup = IsArrow;
1311 if (TypoCorrection Corrected = S.CorrectTypo(
1312 R.getLookupNameInfo(), Sema::LookupMemberName, nullptr, nullptr,
1313 std::move(Validator), Sema::CTK_ErrorRecovery, IDecl)) {
1314 IV = Corrected.getCorrectionDeclAs<ObjCIvarDecl>();
1317 S.PDiag(diag::err_typecheck_member_reference_ivar_suggest)
1318 << IDecl->getDeclName() << MemberName);
1320 // Figure out the class that declares the ivar.
1321 assert(!ClassDeclared);
1322 Decl *D = cast<Decl>(IV->getDeclContext());
1323 if (ObjCCategoryDecl *CAT = dyn_cast<ObjCCategoryDecl>(D))
1324 D = CAT->getClassInterface();
1325 ClassDeclared = cast<ObjCInterfaceDecl>(D);
1327 if (IsArrow && IDecl->FindPropertyDeclaration(Member)) {
1328 S.Diag(MemberLoc, diag::err_property_found_suggest)
1329 << Member << BaseExpr.get()->getType()
1330 << FixItHint::CreateReplacement(OpLoc, ".");
1334 S.Diag(MemberLoc, diag::err_typecheck_member_reference_ivar)
1335 << IDecl->getDeclName() << MemberName
1336 << BaseExpr.get()->getSourceRange();
1341 assert(ClassDeclared);
1343 // If the decl being referenced had an error, return an error for this
1344 // sub-expr without emitting another error, in order to avoid cascading
1346 if (IV->isInvalidDecl())
1349 // Check whether we can reference this field.
1350 if (S.DiagnoseUseOfDecl(IV, MemberLoc))
1352 if (IV->getAccessControl() != ObjCIvarDecl::Public &&
1353 IV->getAccessControl() != ObjCIvarDecl::Package) {
1354 ObjCInterfaceDecl *ClassOfMethodDecl = nullptr;
1355 if (ObjCMethodDecl *MD = S.getCurMethodDecl())
1356 ClassOfMethodDecl = MD->getClassInterface();
1357 else if (ObjCImpDecl && S.getCurFunctionDecl()) {
1358 // Case of a c-function declared inside an objc implementation.
1359 // FIXME: For a c-style function nested inside an objc implementation
1360 // class, there is no implementation context available, so we pass
1361 // down the context as argument to this routine. Ideally, this context
1362 // need be passed down in the AST node and somehow calculated from the
1363 // AST for a function decl.
1364 if (ObjCImplementationDecl *IMPD =
1365 dyn_cast<ObjCImplementationDecl>(ObjCImpDecl))
1366 ClassOfMethodDecl = IMPD->getClassInterface();
1367 else if (ObjCCategoryImplDecl* CatImplClass =
1368 dyn_cast<ObjCCategoryImplDecl>(ObjCImpDecl))
1369 ClassOfMethodDecl = CatImplClass->getClassInterface();
1371 if (!S.getLangOpts().DebuggerSupport) {
1372 if (IV->getAccessControl() == ObjCIvarDecl::Private) {
1373 if (!declaresSameEntity(ClassDeclared, IDecl) ||
1374 !declaresSameEntity(ClassOfMethodDecl, ClassDeclared))
1375 S.Diag(MemberLoc, diag::error_private_ivar_access)
1376 << IV->getDeclName();
1377 } else if (!IDecl->isSuperClassOf(ClassOfMethodDecl))
1379 S.Diag(MemberLoc, diag::error_protected_ivar_access)
1380 << IV->getDeclName();
1384 if (S.getLangOpts().ObjCAutoRefCount) {
1385 Expr *BaseExp = BaseExpr.get()->IgnoreParenImpCasts();
1386 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(BaseExp))
1387 if (UO->getOpcode() == UO_Deref)
1388 BaseExp = UO->getSubExpr()->IgnoreParenCasts();
1390 if (DeclRefExpr *DE = dyn_cast<DeclRefExpr>(BaseExp))
1391 if (DE->getType().getObjCLifetime() == Qualifiers::OCL_Weak) {
1392 S.Diag(DE->getLocation(), diag::error_arc_weak_ivar_access);
1397 if (ObjCMethodDecl *MD = S.getCurMethodDecl()) {
1398 ObjCMethodFamily MF = MD->getMethodFamily();
1399 warn = (MF != OMF_init && MF != OMF_dealloc &&
1400 MF != OMF_finalize &&
1401 !S.IvarBacksCurrentMethodAccessor(IDecl, MD, IV));
1404 S.Diag(MemberLoc, diag::warn_direct_ivar_access) << IV->getDeclName();
1407 ObjCIvarRefExpr *Result = new (S.Context) ObjCIvarRefExpr(
1408 IV, IV->getUsageType(BaseType), MemberLoc, OpLoc, BaseExpr.get(),
1411 if (S.getLangOpts().ObjCAutoRefCount) {
1412 if (IV->getType().getObjCLifetime() == Qualifiers::OCL_Weak) {
1413 if (!S.Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, MemberLoc))
1414 S.recordUseOfEvaluatedWeak(Result);
1421 // Objective-C property access.
1422 const ObjCObjectPointerType *OPT;
1423 if (!IsArrow && (OPT = BaseType->getAs<ObjCObjectPointerType>())) {
1424 if (!SS.isEmpty() && !SS.isInvalid()) {
1425 S.Diag(SS.getRange().getBegin(), diag::err_qualified_objc_access)
1426 << 0 << SS.getScopeRep() << FixItHint::CreateRemoval(SS.getRange());
1430 // This actually uses the base as an r-value.
1431 BaseExpr = S.DefaultLvalueConversion(BaseExpr.get());
1432 if (BaseExpr.isInvalid())
1435 assert(S.Context.hasSameUnqualifiedType(BaseType,
1436 BaseExpr.get()->getType()));
1438 IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
1440 const ObjCObjectType *OT = OPT->getObjectType();
1442 // id, with and without qualifiers.
1443 if (OT->isObjCId()) {
1444 // Check protocols on qualified interfaces.
1445 Selector Sel = S.PP.getSelectorTable().getNullarySelector(Member);
1447 FindGetterSetterNameDecl(OPT, Member, Sel, S.Context)) {
1448 if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(PMDecl)) {
1449 // Check the use of this declaration
1450 if (S.DiagnoseUseOfDecl(PD, MemberLoc))
1453 return new (S.Context)
1454 ObjCPropertyRefExpr(PD, S.Context.PseudoObjectTy, VK_LValue,
1455 OK_ObjCProperty, MemberLoc, BaseExpr.get());
1458 if (ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(PMDecl)) {
1459 // Check the use of this method.
1460 if (S.DiagnoseUseOfDecl(OMD, MemberLoc))
1462 Selector SetterSel =
1463 SelectorTable::constructSetterSelector(S.PP.getIdentifierTable(),
1464 S.PP.getSelectorTable(),
1466 ObjCMethodDecl *SMD = nullptr;
1467 if (Decl *SDecl = FindGetterSetterNameDecl(OPT,
1468 /*Property id*/ nullptr,
1469 SetterSel, S.Context))
1470 SMD = dyn_cast<ObjCMethodDecl>(SDecl);
1472 return new (S.Context)
1473 ObjCPropertyRefExpr(OMD, SMD, S.Context.PseudoObjectTy, VK_LValue,
1474 OK_ObjCProperty, MemberLoc, BaseExpr.get());
1477 // Use of id.member can only be for a property reference. Do not
1478 // use the 'id' redefinition in this case.
1479 if (IsArrow && ShouldTryAgainWithRedefinitionType(S, BaseExpr))
1480 return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1481 ObjCImpDecl, HasTemplateArgs);
1483 return ExprError(S.Diag(MemberLoc, diag::err_property_not_found)
1484 << MemberName << BaseType);
1487 // 'Class', unqualified only.
1488 if (OT->isObjCClass()) {
1489 // Only works in a method declaration (??!).
1490 ObjCMethodDecl *MD = S.getCurMethodDecl();
1492 if (ShouldTryAgainWithRedefinitionType(S, BaseExpr))
1493 return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1494 ObjCImpDecl, HasTemplateArgs);
1499 // Also must look for a getter name which uses property syntax.
1500 Selector Sel = S.PP.getSelectorTable().getNullarySelector(Member);
1501 ObjCInterfaceDecl *IFace = MD->getClassInterface();
1502 ObjCMethodDecl *Getter;
1503 if ((Getter = IFace->lookupClassMethod(Sel))) {
1504 // Check the use of this method.
1505 if (S.DiagnoseUseOfDecl(Getter, MemberLoc))
1508 Getter = IFace->lookupPrivateMethod(Sel, false);
1509 // If we found a getter then this may be a valid dot-reference, we
1510 // will look for the matching setter, in case it is needed.
1511 Selector SetterSel =
1512 SelectorTable::constructSetterSelector(S.PP.getIdentifierTable(),
1513 S.PP.getSelectorTable(),
1515 ObjCMethodDecl *Setter = IFace->lookupClassMethod(SetterSel);
1517 // If this reference is in an @implementation, also check for 'private'
1519 Setter = IFace->lookupPrivateMethod(SetterSel, false);
1522 if (Setter && S.DiagnoseUseOfDecl(Setter, MemberLoc))
1525 if (Getter || Setter) {
1526 return new (S.Context) ObjCPropertyRefExpr(
1527 Getter, Setter, S.Context.PseudoObjectTy, VK_LValue,
1528 OK_ObjCProperty, MemberLoc, BaseExpr.get());
1531 if (ShouldTryAgainWithRedefinitionType(S, BaseExpr))
1532 return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1533 ObjCImpDecl, HasTemplateArgs);
1535 return ExprError(S.Diag(MemberLoc, diag::err_property_not_found)
1536 << MemberName << BaseType);
1539 // Normal property access.
1540 return S.HandleExprPropertyRefExpr(OPT, BaseExpr.get(), OpLoc, MemberName,
1541 MemberLoc, SourceLocation(), QualType(),
1545 // Handle 'field access' to vectors, such as 'V.xx'.
1546 if (BaseType->isExtVectorType()) {
1547 // FIXME: this expr should store IsArrow.
1548 IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
1553 if (PseudoObjectExpr *POE = dyn_cast<PseudoObjectExpr>(BaseExpr.get()))
1554 VK = POE->getSyntacticForm()->getValueKind();
1556 VK = BaseExpr.get()->getValueKind();
1558 QualType ret = CheckExtVectorComponent(S, BaseType, VK, OpLoc,
1563 return new (S.Context)
1564 ExtVectorElementExpr(ret, VK, BaseExpr.get(), *Member, MemberLoc);
1567 // Adjust builtin-sel to the appropriate redefinition type if that's
1568 // not just a pointer to builtin-sel again.
1569 if (IsArrow && BaseType->isSpecificBuiltinType(BuiltinType::ObjCSel) &&
1570 !S.Context.getObjCSelRedefinitionType()->isObjCSelType()) {
1571 BaseExpr = S.ImpCastExprToType(
1572 BaseExpr.get(), S.Context.getObjCSelRedefinitionType(), CK_BitCast);
1573 return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1574 ObjCImpDecl, HasTemplateArgs);
1580 // Recover from dot accesses to pointers, e.g.:
1583 // This is actually well-formed in two cases:
1584 // - 'type' is an Objective C type
1585 // - 'bar' is a pseudo-destructor name which happens to refer to
1586 // the appropriate pointer type
1587 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) {
1588 if (!IsArrow && Ptr->getPointeeType()->isRecordType() &&
1589 MemberName.getNameKind() != DeclarationName::CXXDestructorName) {
1590 S.Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
1591 << BaseType << int(IsArrow) << BaseExpr.get()->getSourceRange()
1592 << FixItHint::CreateReplacement(OpLoc, "->");
1594 // Recurse as an -> access.
1596 return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1597 ObjCImpDecl, HasTemplateArgs);
1601 // If the user is trying to apply -> or . to a function name, it's probably
1602 // because they forgot parentheses to call that function.
1603 if (S.tryToRecoverWithCall(
1604 BaseExpr, S.PDiag(diag::err_member_reference_needs_call),
1606 IsArrow ? &isPointerToRecordType : &isRecordType)) {
1607 if (BaseExpr.isInvalid())
1609 BaseExpr = S.DefaultFunctionArrayConversion(BaseExpr.get());
1610 return LookupMemberExpr(S, R, BaseExpr, IsArrow, OpLoc, SS,
1611 ObjCImpDecl, HasTemplateArgs);
1614 S.Diag(OpLoc, diag::err_typecheck_member_reference_struct_union)
1615 << BaseType << BaseExpr.get()->getSourceRange() << MemberLoc;
1620 /// The main callback when the parser finds something like
1621 /// expression . [nested-name-specifier] identifier
1622 /// expression -> [nested-name-specifier] identifier
1623 /// where 'identifier' encompasses a fairly broad spectrum of
1624 /// possibilities, including destructor and operator references.
1626 /// \param OpKind either tok::arrow or tok::period
1627 /// \param ObjCImpDecl the current Objective-C \@implementation
1628 /// decl; this is an ugly hack around the fact that Objective-C
1629 /// \@implementations aren't properly put in the context chain
1630 ExprResult Sema::ActOnMemberAccessExpr(Scope *S, Expr *Base,
1631 SourceLocation OpLoc,
1632 tok::TokenKind OpKind,
1634 SourceLocation TemplateKWLoc,
1636 Decl *ObjCImpDecl) {
1637 if (SS.isSet() && SS.isInvalid())
1640 // Warn about the explicit constructor calls Microsoft extension.
1641 if (getLangOpts().MicrosoftExt &&
1642 Id.getKind() == UnqualifiedId::IK_ConstructorName)
1643 Diag(Id.getSourceRange().getBegin(),
1644 diag::ext_ms_explicit_constructor_call);
1646 TemplateArgumentListInfo TemplateArgsBuffer;
1648 // Decompose the name into its component parts.
1649 DeclarationNameInfo NameInfo;
1650 const TemplateArgumentListInfo *TemplateArgs;
1651 DecomposeUnqualifiedId(Id, TemplateArgsBuffer,
1652 NameInfo, TemplateArgs);
1654 DeclarationName Name = NameInfo.getName();
1655 bool IsArrow = (OpKind == tok::arrow);
1657 NamedDecl *FirstQualifierInScope
1658 = (!SS.isSet() ? nullptr : FindFirstQualifierInScope(S, SS.getScopeRep()));
1660 // This is a postfix expression, so get rid of ParenListExprs.
1661 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Base);
1662 if (Result.isInvalid()) return ExprError();
1663 Base = Result.get();
1665 if (Base->getType()->isDependentType() || Name.isDependentName() ||
1666 isDependentScopeSpecifier(SS)) {
1667 return ActOnDependentMemberExpr(Base, Base->getType(), IsArrow, OpLoc, SS,
1668 TemplateKWLoc, FirstQualifierInScope,
1669 NameInfo, TemplateArgs);
1672 ActOnMemberAccessExtraArgs ExtraArgs = {S, Id, ObjCImpDecl};
1673 return BuildMemberReferenceExpr(Base, Base->getType(), OpLoc, IsArrow, SS,
1674 TemplateKWLoc, FirstQualifierInScope,
1675 NameInfo, TemplateArgs, S, &ExtraArgs);
1679 BuildFieldReferenceExpr(Sema &S, Expr *BaseExpr, bool IsArrow,
1680 SourceLocation OpLoc, const CXXScopeSpec &SS,
1681 FieldDecl *Field, DeclAccessPair FoundDecl,
1682 const DeclarationNameInfo &MemberNameInfo) {
1683 // x.a is an l-value if 'a' has a reference type. Otherwise:
1684 // x.a is an l-value/x-value/pr-value if the base is (and note
1685 // that *x is always an l-value), except that if the base isn't
1686 // an ordinary object then we must have an rvalue.
1687 ExprValueKind VK = VK_LValue;
1688 ExprObjectKind OK = OK_Ordinary;
1690 if (BaseExpr->getObjectKind() == OK_Ordinary)
1691 VK = BaseExpr->getValueKind();
1695 if (VK != VK_RValue && Field->isBitField())
1698 // Figure out the type of the member; see C99 6.5.2.3p3, C++ [expr.ref]
1699 QualType MemberType = Field->getType();
1700 if (const ReferenceType *Ref = MemberType->getAs<ReferenceType>()) {
1701 MemberType = Ref->getPointeeType();
1704 QualType BaseType = BaseExpr->getType();
1705 if (IsArrow) BaseType = BaseType->getAs<PointerType>()->getPointeeType();
1707 Qualifiers BaseQuals = BaseType.getQualifiers();
1709 // GC attributes are never picked up by members.
1710 BaseQuals.removeObjCGCAttr();
1712 // CVR attributes from the base are picked up by members,
1713 // except that 'mutable' members don't pick up 'const'.
1714 if (Field->isMutable()) BaseQuals.removeConst();
1716 Qualifiers MemberQuals
1717 = S.Context.getCanonicalType(MemberType).getQualifiers();
1719 assert(!MemberQuals.hasAddressSpace());
1722 Qualifiers Combined = BaseQuals + MemberQuals;
1723 if (Combined != MemberQuals)
1724 MemberType = S.Context.getQualifiedType(MemberType, Combined);
1727 S.UnusedPrivateFields.remove(Field);
1730 S.PerformObjectMemberConversion(BaseExpr, SS.getScopeRep(),
1732 if (Base.isInvalid())
1734 return BuildMemberExpr(S, S.Context, Base.get(), IsArrow, OpLoc, SS,
1735 /*TemplateKWLoc=*/SourceLocation(), Field, FoundDecl,
1736 MemberNameInfo, MemberType, VK, OK);
1739 /// Builds an implicit member access expression. The current context
1740 /// is known to be an instance method, and the given unqualified lookup
1741 /// set is known to contain only instance members, at least one of which
1742 /// is from an appropriate type.
1744 Sema::BuildImplicitMemberExpr(const CXXScopeSpec &SS,
1745 SourceLocation TemplateKWLoc,
1747 const TemplateArgumentListInfo *TemplateArgs,
1748 bool IsKnownInstance, const Scope *S) {
1749 assert(!R.empty() && !R.isAmbiguous());
1751 SourceLocation loc = R.getNameLoc();
1753 // If this is known to be an instance access, go ahead and build an
1754 // implicit 'this' expression now.
1755 // 'this' expression now.
1756 QualType ThisTy = getCurrentThisType();
1757 assert(!ThisTy.isNull() && "didn't correctly pre-flight capture of 'this'");
1759 Expr *baseExpr = nullptr; // null signifies implicit access
1760 if (IsKnownInstance) {
1761 SourceLocation Loc = R.getNameLoc();
1762 if (SS.getRange().isValid())
1763 Loc = SS.getRange().getBegin();
1764 CheckCXXThisCapture(Loc);
1765 baseExpr = new (Context) CXXThisExpr(loc, ThisTy, /*isImplicit=*/true);
1768 return BuildMemberReferenceExpr(baseExpr, ThisTy,
1769 /*OpLoc*/ SourceLocation(),
1772 /*FirstQualifierInScope*/ nullptr,
1773 R, TemplateArgs, S);