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/SemaInternal.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"
25 using namespace clang;
28 typedef llvm::SmallPtrSet<const CXXRecordDecl*, 4> BaseSet;
29 static bool BaseIsNotInSet(const CXXRecordDecl *Base, void *BasesPtr) {
30 const BaseSet &Bases = *reinterpret_cast<const BaseSet*>(BasesPtr);
31 return !Bases.count(Base->getCanonicalDecl());
34 /// Determines if the given class is provably not derived from all of
35 /// the prospective base classes.
36 static bool isProvablyNotDerivedFrom(Sema &SemaRef, CXXRecordDecl *Record,
37 const BaseSet &Bases) {
38 void *BasesPtr = const_cast<void*>(reinterpret_cast<const void*>(&Bases));
39 return BaseIsNotInSet(Record, BasesPtr) &&
40 Record->forallBases(BaseIsNotInSet, BasesPtr);
44 /// The reference is definitely not an instance member access.
47 /// The reference may be an implicit instance member access.
50 /// The reference may be to an instance member, but it might be invalid if
51 /// so, because the context is not an instance method.
52 IMA_Mixed_StaticContext,
54 /// The reference may be to an instance member, but it is invalid if
55 /// so, because the context is from an unrelated class.
58 /// The reference is definitely an implicit instance member access.
61 /// The reference may be to an unresolved using declaration.
64 /// The reference is a contextually-permitted abstract member reference.
67 /// The reference may be to an unresolved using declaration and the
68 /// context is not an instance method.
69 IMA_Unresolved_StaticContext,
71 // The reference refers to a field which is not a member of the containing
72 // class, which is allowed because we're in C++11 mode and the context is
74 IMA_Field_Uneval_Context,
76 /// All possible referrents are instance members and the current
77 /// context is not an instance method.
78 IMA_Error_StaticContext,
80 /// All possible referrents are instance members of an unrelated
85 /// The given lookup names class member(s) and is not being used for
86 /// an address-of-member expression. Classify the type of access
87 /// according to whether it's possible that this reference names an
88 /// instance member. This is best-effort in dependent contexts; it is okay to
89 /// conservatively answer "yes", in which case some errors will simply
90 /// not be caught until template-instantiation.
91 static IMAKind ClassifyImplicitMemberAccess(Sema &SemaRef,
93 const LookupResult &R) {
94 assert(!R.empty() && (*R.begin())->isCXXClassMember());
96 DeclContext *DC = SemaRef.getFunctionLevelDeclContext();
98 bool isStaticContext = SemaRef.CXXThisTypeOverride.isNull() &&
99 (!isa<CXXMethodDecl>(DC) || cast<CXXMethodDecl>(DC)->isStatic());
101 if (R.isUnresolvableResult())
102 return isStaticContext ? IMA_Unresolved_StaticContext : IMA_Unresolved;
104 // Collect all the declaring classes of instance members we find.
105 bool hasNonInstance = false;
106 bool isField = false;
108 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {
111 if (D->isCXXInstanceMember()) {
112 if (dyn_cast<FieldDecl>(D) || dyn_cast<MSPropertyDecl>(D)
113 || dyn_cast<IndirectFieldDecl>(D))
116 CXXRecordDecl *R = cast<CXXRecordDecl>(D->getDeclContext());
117 Classes.insert(R->getCanonicalDecl());
120 hasNonInstance = true;
123 // If we didn't find any instance members, it can't be an implicit
128 // C++11 [expr.prim.general]p12:
129 // An id-expression that denotes a non-static data member or non-static
130 // member function of a class can only be used:
132 // - if that id-expression denotes a non-static data member and it
133 // appears in an unevaluated operand.
135 // This rule is specific to C++11. However, we also permit this form
136 // in unevaluated inline assembly operands, like the operand to a SIZE.
137 IMAKind AbstractInstanceResult = IMA_Static; // happens to be 'false'
138 assert(!AbstractInstanceResult);
139 switch (SemaRef.ExprEvalContexts.back().Context) {
140 case Sema::Unevaluated:
141 if (isField && SemaRef.getLangOpts().CPlusPlus11)
142 AbstractInstanceResult = IMA_Field_Uneval_Context;
145 case Sema::UnevaluatedAbstract:
146 AbstractInstanceResult = IMA_Abstract;
149 case Sema::ConstantEvaluated:
150 case Sema::PotentiallyEvaluated:
151 case Sema::PotentiallyEvaluatedIfUsed:
155 // If the current context is not an instance method, it can't be
156 // an implicit member reference.
157 if (isStaticContext) {
159 return IMA_Mixed_StaticContext;
161 return AbstractInstanceResult ? AbstractInstanceResult
162 : IMA_Error_StaticContext;
165 CXXRecordDecl *contextClass;
166 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(DC))
167 contextClass = MD->getParent()->getCanonicalDecl();
169 contextClass = cast<CXXRecordDecl>(DC);
171 // [class.mfct.non-static]p3:
172 // ...is used in the body of a non-static member function of class X,
173 // if name lookup (3.4.1) resolves the name in the id-expression to a
174 // non-static non-type member of some class C [...]
175 // ...if C is not X or a base class of X, the class member access expression
177 if (R.getNamingClass() &&
178 contextClass->getCanonicalDecl() !=
179 R.getNamingClass()->getCanonicalDecl()) {
180 // If the naming class is not the current context, this was a qualified
181 // member name lookup, and it's sufficient to check that we have the naming
182 // class as a base class.
184 Classes.insert(R.getNamingClass()->getCanonicalDecl());
187 // If we can prove that the current context is unrelated to all the
188 // declaring classes, it can't be an implicit member reference (in
189 // which case it's an error if any of those members are selected).
190 if (isProvablyNotDerivedFrom(SemaRef, contextClass, Classes))
191 return hasNonInstance ? IMA_Mixed_Unrelated :
192 AbstractInstanceResult ? AbstractInstanceResult :
195 return (hasNonInstance ? IMA_Mixed : IMA_Instance);
198 /// Diagnose a reference to a field with no object available.
199 static void diagnoseInstanceReference(Sema &SemaRef,
200 const CXXScopeSpec &SS,
202 const DeclarationNameInfo &nameInfo) {
203 SourceLocation Loc = nameInfo.getLoc();
204 SourceRange Range(Loc);
205 if (SS.isSet()) Range.setBegin(SS.getRange().getBegin());
207 DeclContext *FunctionLevelDC = SemaRef.getFunctionLevelDeclContext();
208 CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FunctionLevelDC);
209 CXXRecordDecl *ContextClass = Method ? Method->getParent() : 0;
210 CXXRecordDecl *RepClass = dyn_cast<CXXRecordDecl>(Rep->getDeclContext());
212 bool InStaticMethod = Method && Method->isStatic();
213 bool IsField = isa<FieldDecl>(Rep) || isa<IndirectFieldDecl>(Rep);
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
223 SemaRef.Diag(Loc, diag::err_nested_non_static_member_use)
224 << IsField << RepClass << nameInfo.getName() << ContextClass << Range;
226 SemaRef.Diag(Loc, diag::err_invalid_non_static_member_use)
227 << nameInfo.getName() << Range;
229 SemaRef.Diag(Loc, diag::err_member_call_without_object)
233 /// Builds an expression which might be an implicit member expression.
235 Sema::BuildPossibleImplicitMemberExpr(const CXXScopeSpec &SS,
236 SourceLocation TemplateKWLoc,
238 const TemplateArgumentListInfo *TemplateArgs) {
239 switch (ClassifyImplicitMemberAccess(*this, CurScope, R)) {
241 return BuildImplicitMemberExpr(SS, TemplateKWLoc, R, TemplateArgs, true);
244 case IMA_Mixed_Unrelated:
246 return BuildImplicitMemberExpr(SS, TemplateKWLoc, R, TemplateArgs, false);
248 case IMA_Field_Uneval_Context:
249 Diag(R.getNameLoc(), diag::warn_cxx98_compat_non_static_member_use)
250 << R.getLookupNameInfo().getName();
254 case IMA_Mixed_StaticContext:
255 case IMA_Unresolved_StaticContext:
256 if (TemplateArgs || TemplateKWLoc.isValid())
257 return BuildTemplateIdExpr(SS, TemplateKWLoc, R, false, TemplateArgs);
258 return BuildDeclarationNameExpr(SS, R, false);
260 case IMA_Error_StaticContext:
261 case IMA_Error_Unrelated:
262 diagnoseInstanceReference(*this, SS, R.getRepresentativeDecl(),
263 R.getLookupNameInfo());
267 llvm_unreachable("unexpected instance member access kind");
270 /// Check an ext-vector component access expression.
272 /// VK should be set in advance to the value kind of the base
275 CheckExtVectorComponent(Sema &S, QualType baseType, ExprValueKind &VK,
276 SourceLocation OpLoc, const IdentifierInfo *CompName,
277 SourceLocation CompLoc) {
278 // FIXME: Share logic with ExtVectorElementExpr::containsDuplicateElements,
281 // FIXME: This logic can be greatly simplified by splitting it along
282 // halving/not halving and reworking the component checking.
283 const ExtVectorType *vecType = baseType->getAs<ExtVectorType>();
285 // The vector accessor can't exceed the number of elements.
286 const char *compStr = CompName->getNameStart();
288 // This flag determines whether or not the component is one of the four
289 // special names that indicate a subset of exactly half the elements are
291 bool HalvingSwizzle = false;
293 // This flag determines whether or not CompName has an 's' char prefix,
294 // indicating that it is a string of hex values to be used as vector indices.
295 bool HexSwizzle = *compStr == 's' || *compStr == 'S';
297 bool HasRepeated = false;
298 bool HasIndex[16] = {};
302 // Check that we've found one of the special components, or that the component
303 // names must come from the same set.
304 if (!strcmp(compStr, "hi") || !strcmp(compStr, "lo") ||
305 !strcmp(compStr, "even") || !strcmp(compStr, "odd")) {
306 HalvingSwizzle = true;
307 } else if (!HexSwizzle &&
308 (Idx = vecType->getPointAccessorIdx(*compStr)) != -1) {
310 if (HasIndex[Idx]) HasRepeated = true;
311 HasIndex[Idx] = true;
313 } while (*compStr && (Idx = vecType->getPointAccessorIdx(*compStr)) != -1);
315 if (HexSwizzle) compStr++;
316 while ((Idx = vecType->getNumericAccessorIdx(*compStr)) != -1) {
317 if (HasIndex[Idx]) HasRepeated = true;
318 HasIndex[Idx] = true;
323 if (!HalvingSwizzle && *compStr) {
324 // We didn't get to the end of the string. This means the component names
325 // didn't come from the same set *or* we encountered an illegal name.
326 S.Diag(OpLoc, diag::err_ext_vector_component_name_illegal)
327 << StringRef(compStr, 1) << SourceRange(CompLoc);
331 // Ensure no component accessor exceeds the width of the vector type it
333 if (!HalvingSwizzle) {
334 compStr = CompName->getNameStart();
340 if (!vecType->isAccessorWithinNumElements(*compStr++)) {
341 S.Diag(OpLoc, diag::err_ext_vector_component_exceeds_length)
342 << baseType << SourceRange(CompLoc);
348 // The component accessor looks fine - now we need to compute the actual type.
349 // The vector type is implied by the component accessor. For example,
350 // vec4.b is a float, vec4.xy is a vec2, vec4.rgb is a vec3, etc.
351 // vec4.s0 is a float, vec4.s23 is a vec3, etc.
352 // vec4.hi, vec4.lo, vec4.e, and vec4.o all return vec2.
353 unsigned CompSize = HalvingSwizzle ? (vecType->getNumElements() + 1) / 2
354 : CompName->getLength();
359 return vecType->getElementType();
361 if (HasRepeated) VK = VK_RValue;
363 QualType VT = S.Context.getExtVectorType(vecType->getElementType(), CompSize);
364 // Now look up the TypeDefDecl from the vector type. Without this,
365 // diagostics look bad. We want extended vector types to appear built-in.
366 for (Sema::ExtVectorDeclsType::iterator
367 I = S.ExtVectorDecls.begin(S.getExternalSource()),
368 E = S.ExtVectorDecls.end();
370 if ((*I)->getUnderlyingType() == VT)
371 return S.Context.getTypedefType(*I);
374 return VT; // should never get here (a typedef type should always be found).
377 static Decl *FindGetterSetterNameDeclFromProtocolList(const ObjCProtocolDecl*PDecl,
378 IdentifierInfo *Member,
380 ASTContext &Context) {
382 if (ObjCPropertyDecl *PD = PDecl->FindPropertyDeclaration(Member))
384 if (ObjCMethodDecl *OMD = PDecl->getInstanceMethod(Sel))
387 for (ObjCProtocolDecl::protocol_iterator I = PDecl->protocol_begin(),
388 E = PDecl->protocol_end(); I != E; ++I) {
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.
402 for (ObjCObjectPointerType::qual_iterator I = QIdTy->qual_begin(),
403 E = QIdTy->qual_end(); I != E; ++I) {
405 if (ObjCPropertyDecl *PD = (*I)->FindPropertyDeclaration(Member)) {
409 // Also must look for a getter or setter name which uses property syntax.
410 if (ObjCMethodDecl *OMD = (*I)->getInstanceMethod(Sel)) {
416 for (ObjCObjectPointerType::qual_iterator I = QIdTy->qual_begin(),
417 E = QIdTy->qual_end(); I != E; ++I) {
418 // Search in the protocol-qualifier list of current protocol.
419 GDecl = FindGetterSetterNameDeclFromProtocolList(*I, Member, Sel,
429 Sema::ActOnDependentMemberExpr(Expr *BaseExpr, QualType BaseType,
430 bool IsArrow, SourceLocation OpLoc,
431 const CXXScopeSpec &SS,
432 SourceLocation TemplateKWLoc,
433 NamedDecl *FirstQualifierInScope,
434 const DeclarationNameInfo &NameInfo,
435 const TemplateArgumentListInfo *TemplateArgs) {
436 // Even in dependent contexts, try to diagnose base expressions with
437 // obviously wrong types, e.g.:
442 // In Obj-C++, however, the above expression is valid, since it could be
443 // accessing the 'f' property if T is an Obj-C interface. The extra check
444 // allows this, while still reporting an error if T is a struct pointer.
446 const PointerType *PT = BaseType->getAs<PointerType>();
447 if (PT && (!getLangOpts().ObjC1 ||
448 PT->getPointeeType()->isRecordType())) {
449 assert(BaseExpr && "cannot happen with implicit member accesses");
450 Diag(OpLoc, diag::err_typecheck_member_reference_struct_union)
451 << BaseType << BaseExpr->getSourceRange() << NameInfo.getSourceRange();
456 assert(BaseType->isDependentType() ||
457 NameInfo.getName().isDependentName() ||
458 isDependentScopeSpecifier(SS));
460 // Get the type being accessed in BaseType. If this is an arrow, the BaseExpr
461 // must have pointer type, and the accessed type is the pointee.
462 return Owned(CXXDependentScopeMemberExpr::Create(Context, BaseExpr, BaseType,
464 SS.getWithLocInContext(Context),
466 FirstQualifierInScope,
467 NameInfo, TemplateArgs));
470 /// We know that the given qualified member reference points only to
471 /// declarations which do not belong to the static type of the base
472 /// expression. Diagnose the problem.
473 static void DiagnoseQualifiedMemberReference(Sema &SemaRef,
476 const CXXScopeSpec &SS,
478 const DeclarationNameInfo &nameInfo) {
479 // If this is an implicit member access, use a different set of
482 return diagnoseInstanceReference(SemaRef, SS, rep, nameInfo);
484 SemaRef.Diag(nameInfo.getLoc(), diag::err_qualified_member_of_unrelated)
485 << SS.getRange() << rep << BaseType;
488 // Check whether the declarations we found through a nested-name
489 // specifier in a member expression are actually members of the base
490 // type. The restriction here is:
493 // ... In these cases, the id-expression shall name a
494 // member of the class or of one of its base classes.
496 // So it's perfectly legitimate for the nested-name specifier to name
497 // an unrelated class, and for us to find an overload set including
498 // decls from classes which are not superclasses, as long as the decl
499 // we actually pick through overload resolution is from a superclass.
500 bool Sema::CheckQualifiedMemberReference(Expr *BaseExpr,
502 const CXXScopeSpec &SS,
503 const LookupResult &R) {
504 CXXRecordDecl *BaseRecord =
505 cast_or_null<CXXRecordDecl>(computeDeclContext(BaseType));
507 // We can't check this yet because the base type is still
509 assert(BaseType->isDependentType());
513 for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {
514 // If this is an implicit member reference and we find a
515 // non-instance member, it's not an error.
516 if (!BaseExpr && !(*I)->isCXXInstanceMember())
519 // Note that we use the DC of the decl, not the underlying decl.
520 DeclContext *DC = (*I)->getDeclContext();
521 while (DC->isTransparentContext())
522 DC = DC->getParent();
527 CXXRecordDecl *MemberRecord = cast<CXXRecordDecl>(DC)->getCanonicalDecl();
528 if (BaseRecord->getCanonicalDecl() == MemberRecord ||
529 !BaseRecord->isProvablyNotDerivedFrom(MemberRecord))
533 DiagnoseQualifiedMemberReference(*this, BaseExpr, BaseType, SS,
534 R.getRepresentativeDecl(),
535 R.getLookupNameInfo());
541 // Callback to only accept typo corrections that are either a ValueDecl or a
542 // FunctionTemplateDecl and are declared in the current record or, for a C++
543 // classes, one of its base classes.
544 class RecordMemberExprValidatorCCC : public CorrectionCandidateCallback {
546 explicit RecordMemberExprValidatorCCC(const RecordType *RTy)
547 : Record(RTy->getDecl()) {}
549 virtual bool ValidateCandidate(const TypoCorrection &candidate) {
550 NamedDecl *ND = candidate.getCorrectionDecl();
551 // Don't accept candidates that cannot be member functions, constants,
552 // variables, or templates.
553 if (!ND || !(isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND)))
556 // Accept candidates that occur in the current record.
557 if (Record->containsDecl(ND))
560 if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(Record)) {
561 // Accept candidates that occur in any of the current class' base classes.
562 for (CXXRecordDecl::base_class_const_iterator BS = RD->bases_begin(),
563 BSEnd = RD->bases_end();
565 if (const RecordType *BSTy = dyn_cast_or_null<RecordType>(
566 BS->getType().getTypePtrOrNull())) {
567 if (BSTy->getDecl()->containsDecl(ND))
577 const RecordDecl *const Record;
583 LookupMemberExprInRecord(Sema &SemaRef, LookupResult &R,
584 SourceRange BaseRange, const RecordType *RTy,
585 SourceLocation OpLoc, CXXScopeSpec &SS,
586 bool HasTemplateArgs) {
587 RecordDecl *RDecl = RTy->getDecl();
588 if (!SemaRef.isThisOutsideMemberFunctionBody(QualType(RTy, 0)) &&
589 SemaRef.RequireCompleteType(OpLoc, QualType(RTy, 0),
590 diag::err_typecheck_incomplete_tag,
594 if (HasTemplateArgs) {
595 // LookupTemplateName doesn't expect these both to exist simultaneously.
596 QualType ObjectType = SS.isSet() ? QualType() : QualType(RTy, 0);
599 SemaRef.LookupTemplateName(R, 0, SS, ObjectType, false, MOUS);
603 DeclContext *DC = RDecl;
605 // If the member name was a qualified-id, look into the
606 // nested-name-specifier.
607 DC = SemaRef.computeDeclContext(SS, false);
609 if (SemaRef.RequireCompleteDeclContext(SS, DC)) {
610 SemaRef.Diag(SS.getRange().getEnd(), diag::err_typecheck_incomplete_tag)
611 << SS.getRange() << DC;
615 assert(DC && "Cannot handle non-computable dependent contexts in lookup");
617 if (!isa<TypeDecl>(DC)) {
618 SemaRef.Diag(R.getNameLoc(), diag::err_qualified_member_nonclass)
619 << DC << SS.getRange();
624 // The record definition is complete, now look up the member.
625 SemaRef.LookupQualifiedName(R, DC);
630 // We didn't find anything with the given name, so try to correct
632 DeclarationName Name = R.getLookupName();
633 RecordMemberExprValidatorCCC Validator(RTy);
634 TypoCorrection Corrected = SemaRef.CorrectTypo(R.getLookupNameInfo(),
635 R.getLookupKind(), NULL,
638 if (Corrected.isResolved() && !Corrected.isKeyword()) {
639 R.setLookupName(Corrected.getCorrection());
640 for (TypoCorrection::decl_iterator DI = Corrected.begin(),
641 DIEnd = Corrected.end();
647 // If we're typo-correcting to an overloaded name, we don't yet have enough
648 // information to do overload resolution, so we don't know which previous
649 // declaration to point to.
650 if (Corrected.isOverloaded())
651 Corrected.setCorrectionDecl(0);
652 bool DroppedSpecifier =
653 Corrected.WillReplaceSpecifier() &&
654 Name.getAsString() == Corrected.getAsString(SemaRef.getLangOpts());
655 SemaRef.diagnoseTypo(Corrected,
656 SemaRef.PDiag(diag::err_no_member_suggest)
657 << Name << DC << DroppedSpecifier << SS.getRange());
664 Sema::BuildMemberReferenceExpr(Expr *Base, QualType BaseType,
665 SourceLocation OpLoc, bool IsArrow,
667 SourceLocation TemplateKWLoc,
668 NamedDecl *FirstQualifierInScope,
669 const DeclarationNameInfo &NameInfo,
670 const TemplateArgumentListInfo *TemplateArgs) {
671 if (BaseType->isDependentType() ||
672 (SS.isSet() && isDependentScopeSpecifier(SS)))
673 return ActOnDependentMemberExpr(Base, BaseType,
675 SS, TemplateKWLoc, FirstQualifierInScope,
676 NameInfo, TemplateArgs);
678 LookupResult R(*this, NameInfo, LookupMemberName);
680 // Implicit member accesses.
682 QualType RecordTy = BaseType;
683 if (IsArrow) RecordTy = RecordTy->getAs<PointerType>()->getPointeeType();
684 if (LookupMemberExprInRecord(*this, R, SourceRange(),
685 RecordTy->getAs<RecordType>(),
686 OpLoc, SS, TemplateArgs != 0))
689 // Explicit member accesses.
691 ExprResult BaseResult = Owned(Base);
693 LookupMemberExpr(R, BaseResult, IsArrow, OpLoc,
694 SS, /*ObjCImpDecl*/ 0, TemplateArgs != 0);
696 if (BaseResult.isInvalid())
698 Base = BaseResult.take();
700 if (Result.isInvalid()) {
708 // LookupMemberExpr can modify Base, and thus change BaseType
709 BaseType = Base->getType();
712 return BuildMemberReferenceExpr(Base, BaseType,
713 OpLoc, IsArrow, SS, TemplateKWLoc,
714 FirstQualifierInScope, R, TemplateArgs);
718 BuildFieldReferenceExpr(Sema &S, Expr *BaseExpr, bool IsArrow,
719 const CXXScopeSpec &SS, FieldDecl *Field,
720 DeclAccessPair FoundDecl,
721 const DeclarationNameInfo &MemberNameInfo);
724 Sema::BuildAnonymousStructUnionMemberReference(const CXXScopeSpec &SS,
726 IndirectFieldDecl *indirectField,
727 DeclAccessPair foundDecl,
728 Expr *baseObjectExpr,
729 SourceLocation opLoc) {
730 // First, build the expression that refers to the base object.
732 bool baseObjectIsPointer = false;
733 Qualifiers baseQuals;
735 // Case 1: the base of the indirect field is not a field.
736 VarDecl *baseVariable = indirectField->getVarDecl();
737 CXXScopeSpec EmptySS;
739 assert(baseVariable->getType()->isRecordType());
741 // In principle we could have a member access expression that
742 // accesses an anonymous struct/union that's a static member of
743 // the base object's class. However, under the current standard,
744 // static data members cannot be anonymous structs or unions.
745 // Supporting this is as easy as building a MemberExpr here.
746 assert(!baseObjectExpr && "anonymous struct/union is static data member?");
748 DeclarationNameInfo baseNameInfo(DeclarationName(), loc);
751 = BuildDeclarationNameExpr(EmptySS, baseNameInfo, baseVariable);
752 if (result.isInvalid()) return ExprError();
754 baseObjectExpr = result.take();
755 baseObjectIsPointer = false;
756 baseQuals = baseObjectExpr->getType().getQualifiers();
758 // Case 2: the base of the indirect field is a field and the user
759 // wrote a member expression.
760 } else if (baseObjectExpr) {
761 // The caller provided the base object expression. Determine
762 // whether its a pointer and whether it adds any qualifiers to the
763 // anonymous struct/union fields we're looking into.
764 QualType objectType = baseObjectExpr->getType();
766 if (const PointerType *ptr = objectType->getAs<PointerType>()) {
767 baseObjectIsPointer = true;
768 objectType = ptr->getPointeeType();
770 baseObjectIsPointer = false;
772 baseQuals = objectType.getQualifiers();
774 // Case 3: the base of the indirect field is a field and we should
775 // build an implicit member access.
777 // We've found a member of an anonymous struct/union that is
778 // inside a non-anonymous struct/union, so in a well-formed
779 // program our base object expression is "this".
780 QualType ThisTy = getCurrentThisType();
781 if (ThisTy.isNull()) {
782 Diag(loc, diag::err_invalid_member_use_in_static_method)
783 << indirectField->getDeclName();
787 // Our base object expression is "this".
788 CheckCXXThisCapture(loc);
790 = new (Context) CXXThisExpr(loc, ThisTy, /*isImplicit=*/ true);
791 baseObjectIsPointer = true;
792 baseQuals = ThisTy->castAs<PointerType>()->getPointeeType().getQualifiers();
795 // Build the implicit member references to the field of the
796 // anonymous struct/union.
797 Expr *result = baseObjectExpr;
798 IndirectFieldDecl::chain_iterator
799 FI = indirectField->chain_begin(), FEnd = indirectField->chain_end();
801 // Build the first member access in the chain with full information.
803 FieldDecl *field = cast<FieldDecl>(*FI);
805 // Make a nameInfo that properly uses the anonymous name.
806 DeclarationNameInfo memberNameInfo(field->getDeclName(), loc);
808 result = BuildFieldReferenceExpr(*this, result, baseObjectIsPointer,
809 EmptySS, field, foundDecl,
810 memberNameInfo).take();
814 baseObjectIsPointer = false;
816 // FIXME: check qualified member access
819 // In all cases, we should now skip the first declaration in the chain.
823 FieldDecl *field = cast<FieldDecl>(*FI++);
825 // FIXME: these are somewhat meaningless
826 DeclarationNameInfo memberNameInfo(field->getDeclName(), loc);
827 DeclAccessPair fakeFoundDecl =
828 DeclAccessPair::make(field, field->getAccess());
830 result = BuildFieldReferenceExpr(*this, result, /*isarrow*/ false,
831 (FI == FEnd? SS : EmptySS), field,
832 fakeFoundDecl, memberNameInfo).take();
835 return Owned(result);
839 BuildMSPropertyRefExpr(Sema &S, Expr *BaseExpr, bool IsArrow,
840 const CXXScopeSpec &SS,
842 const DeclarationNameInfo &NameInfo) {
843 // Property names are always simple identifiers and therefore never
844 // require any interesting additional storage.
845 return new (S.Context) MSPropertyRefExpr(BaseExpr, PD, IsArrow,
846 S.Context.PseudoObjectTy, VK_LValue,
847 SS.getWithLocInContext(S.Context),
851 /// \brief Build a MemberExpr AST node.
852 static MemberExpr *BuildMemberExpr(Sema &SemaRef,
853 ASTContext &C, Expr *Base, bool isArrow,
854 const CXXScopeSpec &SS,
855 SourceLocation TemplateKWLoc,
857 DeclAccessPair FoundDecl,
858 const DeclarationNameInfo &MemberNameInfo,
860 ExprValueKind VK, ExprObjectKind OK,
861 const TemplateArgumentListInfo *TemplateArgs = 0) {
862 assert((!isArrow || Base->isRValue()) && "-> base must be a pointer rvalue");
864 MemberExpr::Create(C, Base, isArrow, SS.getWithLocInContext(C),
865 TemplateKWLoc, Member, FoundDecl, MemberNameInfo,
866 TemplateArgs, Ty, VK, OK);
867 SemaRef.MarkMemberReferenced(E);
872 Sema::BuildMemberReferenceExpr(Expr *BaseExpr, QualType BaseExprType,
873 SourceLocation OpLoc, bool IsArrow,
874 const CXXScopeSpec &SS,
875 SourceLocation TemplateKWLoc,
876 NamedDecl *FirstQualifierInScope,
878 const TemplateArgumentListInfo *TemplateArgs,
879 bool SuppressQualifierCheck,
880 ActOnMemberAccessExtraArgs *ExtraArgs) {
881 QualType BaseType = BaseExprType;
883 assert(BaseType->isPointerType());
884 BaseType = BaseType->castAs<PointerType>()->getPointeeType();
886 R.setBaseObjectType(BaseType);
888 LambdaScopeInfo *const CurLSI = getCurLambda();
889 // If this is an implicit member reference and the overloaded
890 // name refers to both static and non-static member functions
891 // (i.e. BaseExpr is null) and if we are currently processing a lambda,
892 // check if we should/can capture 'this'...
893 // Keep this example in mind:
896 // static void f(double) { }
899 // auto L = [=](auto a) {
900 // return [](int i) {
901 // return [=](auto b) {
903 // //f(decltype(a){});
909 // N(5.32); // OK, must not error.
914 if (!BaseExpr && CurLSI) {
915 SourceLocation Loc = R.getNameLoc();
916 if (SS.getRange().isValid())
917 Loc = SS.getRange().getBegin();
918 DeclContext *EnclosingFunctionCtx = CurContext->getParent()->getParent();
919 // If the enclosing function is not dependent, then this lambda is
920 // capture ready, so if we can capture this, do so.
921 if (!EnclosingFunctionCtx->isDependentContext()) {
922 // If the current lambda and all enclosing lambdas can capture 'this' -
923 // then go ahead and capture 'this' (since our unresolved overload set
924 // contains both static and non-static member functions).
925 if (!CheckCXXThisCapture(Loc, /*Explcit*/false, /*Diagnose*/false))
926 CheckCXXThisCapture(Loc);
927 } else if (CurContext->isDependentContext()) {
928 // ... since this is an implicit member reference, that might potentially
929 // involve a 'this' capture, mark 'this' for potential capture in
930 // enclosing lambdas.
931 if (CurLSI->ImpCaptureStyle != CurLSI->ImpCap_None)
932 CurLSI->addPotentialThisCapture(Loc);
935 const DeclarationNameInfo &MemberNameInfo = R.getLookupNameInfo();
936 DeclarationName MemberName = MemberNameInfo.getName();
937 SourceLocation MemberLoc = MemberNameInfo.getLoc();
943 // Rederive where we looked up.
944 DeclContext *DC = (SS.isSet()
945 ? computeDeclContext(SS, false)
946 : BaseType->getAs<RecordType>()->getDecl());
949 ExprResult RetryExpr;
950 if (!IsArrow && BaseExpr) {
951 SFINAETrap Trap(*this, true);
952 ParsedType ObjectType;
953 bool MayBePseudoDestructor = false;
954 RetryExpr = ActOnStartCXXMemberReference(getCurScope(), BaseExpr,
955 OpLoc, tok::arrow, ObjectType,
956 MayBePseudoDestructor);
957 if (RetryExpr.isUsable() && !Trap.hasErrorOccurred()) {
958 CXXScopeSpec TempSS(SS);
959 RetryExpr = ActOnMemberAccessExpr(
960 ExtraArgs->S, RetryExpr.get(), OpLoc, tok::arrow, TempSS,
961 TemplateKWLoc, ExtraArgs->Id, ExtraArgs->ObjCImpDecl,
962 ExtraArgs->HasTrailingLParen);
964 if (Trap.hasErrorOccurred())
965 RetryExpr = ExprError();
967 if (RetryExpr.isUsable()) {
968 Diag(OpLoc, diag::err_no_member_overloaded_arrow)
969 << MemberName << DC << FixItHint::CreateReplacement(OpLoc, "->");
974 Diag(R.getNameLoc(), diag::err_no_member)
976 << (BaseExpr ? BaseExpr->getSourceRange() : SourceRange());
980 // Diagnose lookups that find only declarations from a non-base
981 // type. This is possible for either qualified lookups (which may
982 // have been qualified with an unrelated type) or implicit member
983 // expressions (which were found with unqualified lookup and thus
984 // may have come from an enclosing scope). Note that it's okay for
985 // lookup to find declarations from a non-base type as long as those
986 // aren't the ones picked by overload resolution.
987 if ((SS.isSet() || !BaseExpr ||
988 (isa<CXXThisExpr>(BaseExpr) &&
989 cast<CXXThisExpr>(BaseExpr)->isImplicit())) &&
990 !SuppressQualifierCheck &&
991 CheckQualifiedMemberReference(BaseExpr, BaseType, SS, R))
994 // Construct an unresolved result if we in fact got an unresolved
996 if (R.isOverloadedResult() || R.isUnresolvableResult()) {
997 // Suppress any lookup-related diagnostics; we'll do these when we
999 R.suppressDiagnostics();
1001 UnresolvedMemberExpr *MemExpr
1002 = UnresolvedMemberExpr::Create(Context, R.isUnresolvableResult(),
1003 BaseExpr, BaseExprType,
1005 SS.getWithLocInContext(Context),
1006 TemplateKWLoc, MemberNameInfo,
1007 TemplateArgs, R.begin(), R.end());
1009 return Owned(MemExpr);
1012 assert(R.isSingleResult());
1013 DeclAccessPair FoundDecl = R.begin().getPair();
1014 NamedDecl *MemberDecl = R.getFoundDecl();
1016 // FIXME: diagnose the presence of template arguments now.
1018 // If the decl being referenced had an error, return an error for this
1019 // sub-expr without emitting another error, in order to avoid cascading
1021 if (MemberDecl->isInvalidDecl())
1024 // Handle the implicit-member-access case.
1026 // If this is not an instance member, convert to a non-member access.
1027 if (!MemberDecl->isCXXInstanceMember())
1028 return BuildDeclarationNameExpr(SS, R.getLookupNameInfo(), MemberDecl);
1030 SourceLocation Loc = R.getNameLoc();
1031 if (SS.getRange().isValid())
1032 Loc = SS.getRange().getBegin();
1033 CheckCXXThisCapture(Loc);
1034 BaseExpr = new (Context) CXXThisExpr(Loc, BaseExprType,/*isImplicit=*/true);
1037 bool ShouldCheckUse = true;
1038 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(MemberDecl)) {
1039 // Don't diagnose the use of a virtual member function unless it's
1040 // explicitly qualified.
1041 if (MD->isVirtual() && !SS.isSet())
1042 ShouldCheckUse = false;
1045 // Check the use of this member.
1046 if (ShouldCheckUse && DiagnoseUseOfDecl(MemberDecl, MemberLoc)) {
1051 if (FieldDecl *FD = dyn_cast<FieldDecl>(MemberDecl))
1052 return BuildFieldReferenceExpr(*this, BaseExpr, IsArrow,
1053 SS, FD, FoundDecl, MemberNameInfo);
1055 if (MSPropertyDecl *PD = dyn_cast<MSPropertyDecl>(MemberDecl))
1056 return BuildMSPropertyRefExpr(*this, BaseExpr, IsArrow, SS, PD,
1059 if (IndirectFieldDecl *FD = dyn_cast<IndirectFieldDecl>(MemberDecl))
1060 // We may have found a field within an anonymous union or struct
1061 // (C++ [class.union]).
1062 return BuildAnonymousStructUnionMemberReference(SS, MemberLoc, FD,
1063 FoundDecl, BaseExpr,
1066 if (VarDecl *Var = dyn_cast<VarDecl>(MemberDecl)) {
1067 return Owned(BuildMemberExpr(*this, Context, BaseExpr, IsArrow, SS,
1068 TemplateKWLoc, Var, FoundDecl, MemberNameInfo,
1069 Var->getType().getNonReferenceType(),
1070 VK_LValue, OK_Ordinary));
1073 if (CXXMethodDecl *MemberFn = dyn_cast<CXXMethodDecl>(MemberDecl)) {
1074 ExprValueKind valueKind;
1076 if (MemberFn->isInstance()) {
1077 valueKind = VK_RValue;
1078 type = Context.BoundMemberTy;
1080 valueKind = VK_LValue;
1081 type = MemberFn->getType();
1084 return Owned(BuildMemberExpr(*this, Context, BaseExpr, IsArrow, SS,
1085 TemplateKWLoc, MemberFn, FoundDecl,
1086 MemberNameInfo, type, valueKind,
1089 assert(!isa<FunctionDecl>(MemberDecl) && "member function not C++ method?");
1091 if (EnumConstantDecl *Enum = dyn_cast<EnumConstantDecl>(MemberDecl)) {
1092 return Owned(BuildMemberExpr(*this, Context, BaseExpr, IsArrow, SS,
1093 TemplateKWLoc, Enum, FoundDecl, MemberNameInfo,
1094 Enum->getType(), VK_RValue, OK_Ordinary));
1099 // We found something that we didn't expect. Complain.
1100 if (isa<TypeDecl>(MemberDecl))
1101 Diag(MemberLoc, diag::err_typecheck_member_reference_type)
1102 << MemberName << BaseType << int(IsArrow);
1104 Diag(MemberLoc, diag::err_typecheck_member_reference_unknown)
1105 << MemberName << BaseType << int(IsArrow);
1107 Diag(MemberDecl->getLocation(), diag::note_member_declared_here)
1109 R.suppressDiagnostics();
1113 /// Given that normal member access failed on the given expression,
1114 /// and given that the expression's type involves builtin-id or
1115 /// builtin-Class, decide whether substituting in the redefinition
1116 /// types would be profitable. The redefinition type is whatever
1117 /// this translation unit tried to typedef to id/Class; we store
1118 /// it to the side and then re-use it in places like this.
1119 static bool ShouldTryAgainWithRedefinitionType(Sema &S, ExprResult &base) {
1120 const ObjCObjectPointerType *opty
1121 = base.get()->getType()->getAs<ObjCObjectPointerType>();
1122 if (!opty) return false;
1124 const ObjCObjectType *ty = opty->getObjectType();
1127 if (ty->isObjCId()) {
1128 redef = S.Context.getObjCIdRedefinitionType();
1129 } else if (ty->isObjCClass()) {
1130 redef = S.Context.getObjCClassRedefinitionType();
1135 // Do the substitution as long as the redefinition type isn't just a
1136 // possibly-qualified pointer to builtin-id or builtin-Class again.
1137 opty = redef->getAs<ObjCObjectPointerType>();
1138 if (opty && !opty->getObjectType()->getInterface())
1141 base = S.ImpCastExprToType(base.take(), redef, CK_BitCast);
1145 static bool isRecordType(QualType T) {
1146 return T->isRecordType();
1148 static bool isPointerToRecordType(QualType T) {
1149 if (const PointerType *PT = T->getAs<PointerType>())
1150 return PT->getPointeeType()->isRecordType();
1154 /// Perform conversions on the LHS of a member access expression.
1156 Sema::PerformMemberExprBaseConversion(Expr *Base, bool IsArrow) {
1157 if (IsArrow && !Base->getType()->isFunctionType())
1158 return DefaultFunctionArrayLvalueConversion(Base);
1160 return CheckPlaceholderExpr(Base);
1163 /// Look up the given member of the given non-type-dependent
1164 /// expression. This can return in one of two ways:
1165 /// * If it returns a sentinel null-but-valid result, the caller will
1166 /// assume that lookup was performed and the results written into
1167 /// the provided structure. It will take over from there.
1168 /// * Otherwise, the returned expression will be produced in place of
1169 /// an ordinary member expression.
1171 /// The ObjCImpDecl bit is a gross hack that will need to be properly
1172 /// fixed for ObjC++.
1174 Sema::LookupMemberExpr(LookupResult &R, ExprResult &BaseExpr,
1175 bool &IsArrow, SourceLocation OpLoc,
1177 Decl *ObjCImpDecl, bool HasTemplateArgs) {
1178 assert(BaseExpr.get() && "no base expression");
1180 // Perform default conversions.
1181 BaseExpr = PerformMemberExprBaseConversion(BaseExpr.take(), IsArrow);
1182 if (BaseExpr.isInvalid())
1185 QualType BaseType = BaseExpr.get()->getType();
1186 assert(!BaseType->isDependentType());
1188 DeclarationName MemberName = R.getLookupName();
1189 SourceLocation MemberLoc = R.getNameLoc();
1191 // For later type-checking purposes, turn arrow accesses into dot
1192 // accesses. The only access type we support that doesn't follow
1193 // the C equivalence "a->b === (*a).b" is ObjC property accesses,
1194 // and those never use arrows, so this is unaffected.
1196 if (const PointerType *Ptr = BaseType->getAs<PointerType>())
1197 BaseType = Ptr->getPointeeType();
1198 else if (const ObjCObjectPointerType *Ptr
1199 = BaseType->getAs<ObjCObjectPointerType>())
1200 BaseType = Ptr->getPointeeType();
1201 else if (BaseType->isRecordType()) {
1202 // Recover from arrow accesses to records, e.g.:
1203 // struct MyRecord foo;
1205 // This is actually well-formed in C++ if MyRecord has an
1206 // overloaded operator->, but that should have been dealt with
1207 // by now--or a diagnostic message already issued if a problem
1208 // was encountered while looking for the overloaded operator->.
1209 if (!getLangOpts().CPlusPlus) {
1210 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
1211 << BaseType << int(IsArrow) << BaseExpr.get()->getSourceRange()
1212 << FixItHint::CreateReplacement(OpLoc, ".");
1215 } else if (BaseType->isFunctionType()) {
1218 Diag(MemberLoc, diag::err_typecheck_member_reference_arrow)
1219 << BaseType << BaseExpr.get()->getSourceRange();
1224 // Handle field access to simple records.
1225 if (const RecordType *RTy = BaseType->getAs<RecordType>()) {
1226 if (LookupMemberExprInRecord(*this, R, BaseExpr.get()->getSourceRange(),
1227 RTy, OpLoc, SS, HasTemplateArgs))
1230 // Returning valid-but-null is how we indicate to the caller that
1231 // the lookup result was filled in.
1232 return Owned((Expr*) 0);
1235 // Handle ivar access to Objective-C objects.
1236 if (const ObjCObjectType *OTy = BaseType->getAs<ObjCObjectType>()) {
1237 if (!SS.isEmpty() && !SS.isInvalid()) {
1238 Diag(SS.getRange().getBegin(), diag::err_qualified_objc_access)
1239 << 1 << SS.getScopeRep()
1240 << FixItHint::CreateRemoval(SS.getRange());
1244 IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
1246 // There are three cases for the base type:
1247 // - builtin id (qualified or unqualified)
1248 // - builtin Class (qualified or unqualified)
1250 ObjCInterfaceDecl *IDecl = OTy->getInterface();
1252 if (getLangOpts().ObjCAutoRefCount &&
1253 (OTy->isObjCId() || OTy->isObjCClass()))
1255 // There's an implicit 'isa' ivar on all objects.
1256 // But we only actually find it this way on objects of type 'id',
1258 if (OTy->isObjCId() && Member->isStr("isa"))
1259 return Owned(new (Context) ObjCIsaExpr(BaseExpr.take(), IsArrow, MemberLoc,
1261 Context.getObjCClassType()));
1262 if (ShouldTryAgainWithRedefinitionType(*this, BaseExpr))
1263 return LookupMemberExpr(R, BaseExpr, IsArrow, OpLoc, SS,
1264 ObjCImpDecl, HasTemplateArgs);
1268 if (RequireCompleteType(OpLoc, BaseType, diag::err_typecheck_incomplete_tag,
1272 ObjCInterfaceDecl *ClassDeclared = 0;
1273 ObjCIvarDecl *IV = IDecl->lookupInstanceVariable(Member, ClassDeclared);
1276 // Attempt to correct for typos in ivar names.
1277 DeclFilterCCC<ObjCIvarDecl> Validator;
1278 Validator.IsObjCIvarLookup = IsArrow;
1279 if (TypoCorrection Corrected = CorrectTypo(R.getLookupNameInfo(),
1280 LookupMemberName, NULL, NULL,
1281 Validator, IDecl)) {
1282 IV = Corrected.getCorrectionDeclAs<ObjCIvarDecl>();
1283 diagnoseTypo(Corrected,
1284 PDiag(diag::err_typecheck_member_reference_ivar_suggest)
1285 << IDecl->getDeclName() << MemberName);
1287 // Figure out the class that declares the ivar.
1288 assert(!ClassDeclared);
1289 Decl *D = cast<Decl>(IV->getDeclContext());
1290 if (ObjCCategoryDecl *CAT = dyn_cast<ObjCCategoryDecl>(D))
1291 D = CAT->getClassInterface();
1292 ClassDeclared = cast<ObjCInterfaceDecl>(D);
1294 if (IsArrow && IDecl->FindPropertyDeclaration(Member)) {
1296 diag::err_property_found_suggest)
1297 << Member << BaseExpr.get()->getType()
1298 << FixItHint::CreateReplacement(OpLoc, ".");
1302 Diag(MemberLoc, diag::err_typecheck_member_reference_ivar)
1303 << IDecl->getDeclName() << MemberName
1304 << BaseExpr.get()->getSourceRange();
1309 assert(ClassDeclared);
1311 // If the decl being referenced had an error, return an error for this
1312 // sub-expr without emitting another error, in order to avoid cascading
1314 if (IV->isInvalidDecl())
1317 // Check whether we can reference this field.
1318 if (DiagnoseUseOfDecl(IV, MemberLoc))
1320 if (IV->getAccessControl() != ObjCIvarDecl::Public &&
1321 IV->getAccessControl() != ObjCIvarDecl::Package) {
1322 ObjCInterfaceDecl *ClassOfMethodDecl = 0;
1323 if (ObjCMethodDecl *MD = getCurMethodDecl())
1324 ClassOfMethodDecl = MD->getClassInterface();
1325 else if (ObjCImpDecl && getCurFunctionDecl()) {
1326 // Case of a c-function declared inside an objc implementation.
1327 // FIXME: For a c-style function nested inside an objc implementation
1328 // class, there is no implementation context available, so we pass
1329 // down the context as argument to this routine. Ideally, this context
1330 // need be passed down in the AST node and somehow calculated from the
1331 // AST for a function decl.
1332 if (ObjCImplementationDecl *IMPD =
1333 dyn_cast<ObjCImplementationDecl>(ObjCImpDecl))
1334 ClassOfMethodDecl = IMPD->getClassInterface();
1335 else if (ObjCCategoryImplDecl* CatImplClass =
1336 dyn_cast<ObjCCategoryImplDecl>(ObjCImpDecl))
1337 ClassOfMethodDecl = CatImplClass->getClassInterface();
1339 if (!getLangOpts().DebuggerSupport) {
1340 if (IV->getAccessControl() == ObjCIvarDecl::Private) {
1341 if (!declaresSameEntity(ClassDeclared, IDecl) ||
1342 !declaresSameEntity(ClassOfMethodDecl, ClassDeclared))
1343 Diag(MemberLoc, diag::error_private_ivar_access)
1344 << IV->getDeclName();
1345 } else if (!IDecl->isSuperClassOf(ClassOfMethodDecl))
1347 Diag(MemberLoc, diag::error_protected_ivar_access)
1348 << IV->getDeclName();
1352 if (getLangOpts().ObjCAutoRefCount) {
1353 Expr *BaseExp = BaseExpr.get()->IgnoreParenImpCasts();
1354 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(BaseExp))
1355 if (UO->getOpcode() == UO_Deref)
1356 BaseExp = UO->getSubExpr()->IgnoreParenCasts();
1358 if (DeclRefExpr *DE = dyn_cast<DeclRefExpr>(BaseExp))
1359 if (DE->getType().getObjCLifetime() == Qualifiers::OCL_Weak) {
1360 Diag(DE->getLocation(), diag::error_arc_weak_ivar_access);
1365 if (ObjCMethodDecl *MD = getCurMethodDecl()) {
1366 ObjCMethodFamily MF = MD->getMethodFamily();
1367 warn = (MF != OMF_init && MF != OMF_dealloc &&
1368 MF != OMF_finalize &&
1369 !IvarBacksCurrentMethodAccessor(IDecl, MD, IV));
1372 Diag(MemberLoc, diag::warn_direct_ivar_access) << IV->getDeclName();
1375 ObjCIvarRefExpr *Result = new (Context) ObjCIvarRefExpr(IV, IV->getType(),
1380 if (getLangOpts().ObjCAutoRefCount) {
1381 if (IV->getType().getObjCLifetime() == Qualifiers::OCL_Weak) {
1382 DiagnosticsEngine::Level Level =
1383 Diags.getDiagnosticLevel(diag::warn_arc_repeated_use_of_weak,
1385 if (Level != DiagnosticsEngine::Ignored)
1386 recordUseOfEvaluatedWeak(Result);
1390 return Owned(Result);
1393 // Objective-C property access.
1394 const ObjCObjectPointerType *OPT;
1395 if (!IsArrow && (OPT = BaseType->getAs<ObjCObjectPointerType>())) {
1396 if (!SS.isEmpty() && !SS.isInvalid()) {
1397 Diag(SS.getRange().getBegin(), diag::err_qualified_objc_access)
1398 << 0 << SS.getScopeRep()
1399 << FixItHint::CreateRemoval(SS.getRange());
1403 // This actually uses the base as an r-value.
1404 BaseExpr = DefaultLvalueConversion(BaseExpr.take());
1405 if (BaseExpr.isInvalid())
1408 assert(Context.hasSameUnqualifiedType(BaseType, BaseExpr.get()->getType()));
1410 IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
1412 const ObjCObjectType *OT = OPT->getObjectType();
1414 // id, with and without qualifiers.
1415 if (OT->isObjCId()) {
1416 // Check protocols on qualified interfaces.
1417 Selector Sel = PP.getSelectorTable().getNullarySelector(Member);
1418 if (Decl *PMDecl = FindGetterSetterNameDecl(OPT, Member, Sel, Context)) {
1419 if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(PMDecl)) {
1420 // Check the use of this declaration
1421 if (DiagnoseUseOfDecl(PD, MemberLoc))
1424 return Owned(new (Context) ObjCPropertyRefExpr(PD,
1425 Context.PseudoObjectTy,
1432 if (ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(PMDecl)) {
1433 // Check the use of this method.
1434 if (DiagnoseUseOfDecl(OMD, MemberLoc))
1436 Selector SetterSel =
1437 SelectorTable::constructSetterSelector(PP.getIdentifierTable(),
1438 PP.getSelectorTable(),
1440 ObjCMethodDecl *SMD = 0;
1441 if (Decl *SDecl = FindGetterSetterNameDecl(OPT, /*Property id*/0,
1442 SetterSel, Context))
1443 SMD = dyn_cast<ObjCMethodDecl>(SDecl);
1445 return Owned(new (Context) ObjCPropertyRefExpr(OMD, SMD,
1446 Context.PseudoObjectTy,
1447 VK_LValue, OK_ObjCProperty,
1448 MemberLoc, BaseExpr.take()));
1451 // Use of id.member can only be for a property reference. Do not
1452 // use the 'id' redefinition in this case.
1453 if (IsArrow && ShouldTryAgainWithRedefinitionType(*this, BaseExpr))
1454 return LookupMemberExpr(R, BaseExpr, IsArrow, OpLoc, SS,
1455 ObjCImpDecl, HasTemplateArgs);
1457 return ExprError(Diag(MemberLoc, diag::err_property_not_found)
1458 << MemberName << BaseType);
1461 // 'Class', unqualified only.
1462 if (OT->isObjCClass()) {
1463 // Only works in a method declaration (??!).
1464 ObjCMethodDecl *MD = getCurMethodDecl();
1466 if (ShouldTryAgainWithRedefinitionType(*this, BaseExpr))
1467 return LookupMemberExpr(R, BaseExpr, IsArrow, OpLoc, SS,
1468 ObjCImpDecl, HasTemplateArgs);
1473 // Also must look for a getter name which uses property syntax.
1474 Selector Sel = PP.getSelectorTable().getNullarySelector(Member);
1475 ObjCInterfaceDecl *IFace = MD->getClassInterface();
1476 ObjCMethodDecl *Getter;
1477 if ((Getter = IFace->lookupClassMethod(Sel))) {
1478 // Check the use of this method.
1479 if (DiagnoseUseOfDecl(Getter, MemberLoc))
1482 Getter = IFace->lookupPrivateMethod(Sel, false);
1483 // If we found a getter then this may be a valid dot-reference, we
1484 // will look for the matching setter, in case it is needed.
1485 Selector SetterSel =
1486 SelectorTable::constructSetterSelector(PP.getIdentifierTable(),
1487 PP.getSelectorTable(),
1489 ObjCMethodDecl *Setter = IFace->lookupClassMethod(SetterSel);
1491 // If this reference is in an @implementation, also check for 'private'
1493 Setter = IFace->lookupPrivateMethod(SetterSel, false);
1496 if (Setter && DiagnoseUseOfDecl(Setter, MemberLoc))
1499 if (Getter || Setter) {
1500 return Owned(new (Context) ObjCPropertyRefExpr(Getter, Setter,
1501 Context.PseudoObjectTy,
1502 VK_LValue, OK_ObjCProperty,
1503 MemberLoc, BaseExpr.take()));
1506 if (ShouldTryAgainWithRedefinitionType(*this, BaseExpr))
1507 return LookupMemberExpr(R, BaseExpr, IsArrow, OpLoc, SS,
1508 ObjCImpDecl, HasTemplateArgs);
1510 return ExprError(Diag(MemberLoc, diag::err_property_not_found)
1511 << MemberName << BaseType);
1514 // Normal property access.
1515 return HandleExprPropertyRefExpr(OPT, BaseExpr.get(), OpLoc,
1516 MemberName, MemberLoc,
1517 SourceLocation(), QualType(), false);
1520 // Handle 'field access' to vectors, such as 'V.xx'.
1521 if (BaseType->isExtVectorType()) {
1522 // FIXME: this expr should store IsArrow.
1523 IdentifierInfo *Member = MemberName.getAsIdentifierInfo();
1524 ExprValueKind VK = (IsArrow ? VK_LValue : BaseExpr.get()->getValueKind());
1525 QualType ret = CheckExtVectorComponent(*this, BaseType, VK, OpLoc,
1530 return Owned(new (Context) ExtVectorElementExpr(ret, VK, BaseExpr.take(),
1531 *Member, MemberLoc));
1534 // Adjust builtin-sel to the appropriate redefinition type if that's
1535 // not just a pointer to builtin-sel again.
1537 BaseType->isSpecificBuiltinType(BuiltinType::ObjCSel) &&
1538 !Context.getObjCSelRedefinitionType()->isObjCSelType()) {
1539 BaseExpr = ImpCastExprToType(BaseExpr.take(),
1540 Context.getObjCSelRedefinitionType(),
1542 return LookupMemberExpr(R, BaseExpr, IsArrow, OpLoc, SS,
1543 ObjCImpDecl, HasTemplateArgs);
1549 // Recover from dot accesses to pointers, e.g.:
1552 // This is actually well-formed in two cases:
1553 // - 'type' is an Objective C type
1554 // - 'bar' is a pseudo-destructor name which happens to refer to
1555 // the appropriate pointer type
1556 if (const PointerType *Ptr = BaseType->getAs<PointerType>()) {
1557 if (!IsArrow && Ptr->getPointeeType()->isRecordType() &&
1558 MemberName.getNameKind() != DeclarationName::CXXDestructorName) {
1559 Diag(OpLoc, diag::err_typecheck_member_reference_suggestion)
1560 << BaseType << int(IsArrow) << BaseExpr.get()->getSourceRange()
1561 << FixItHint::CreateReplacement(OpLoc, "->");
1563 // Recurse as an -> access.
1565 return LookupMemberExpr(R, BaseExpr, IsArrow, OpLoc, SS,
1566 ObjCImpDecl, HasTemplateArgs);
1570 // If the user is trying to apply -> or . to a function name, it's probably
1571 // because they forgot parentheses to call that function.
1572 if (tryToRecoverWithCall(BaseExpr,
1573 PDiag(diag::err_member_reference_needs_call),
1575 IsArrow ? &isPointerToRecordType : &isRecordType)) {
1576 if (BaseExpr.isInvalid())
1578 BaseExpr = DefaultFunctionArrayConversion(BaseExpr.take());
1579 return LookupMemberExpr(R, BaseExpr, IsArrow, OpLoc, SS,
1580 ObjCImpDecl, HasTemplateArgs);
1583 Diag(OpLoc, diag::err_typecheck_member_reference_struct_union)
1584 << BaseType << BaseExpr.get()->getSourceRange() << MemberLoc;
1589 /// The main callback when the parser finds something like
1590 /// expression . [nested-name-specifier] identifier
1591 /// expression -> [nested-name-specifier] identifier
1592 /// where 'identifier' encompasses a fairly broad spectrum of
1593 /// possibilities, including destructor and operator references.
1595 /// \param OpKind either tok::arrow or tok::period
1596 /// \param HasTrailingLParen whether the next token is '(', which
1597 /// is used to diagnose mis-uses of special members that can
1599 /// \param ObjCImpDecl the current Objective-C \@implementation
1600 /// decl; this is an ugly hack around the fact that Objective-C
1601 /// \@implementations aren't properly put in the context chain
1602 ExprResult Sema::ActOnMemberAccessExpr(Scope *S, Expr *Base,
1603 SourceLocation OpLoc,
1604 tok::TokenKind OpKind,
1606 SourceLocation TemplateKWLoc,
1609 bool HasTrailingLParen) {
1610 if (SS.isSet() && SS.isInvalid())
1613 // Warn about the explicit constructor calls Microsoft extension.
1614 if (getLangOpts().MicrosoftExt &&
1615 Id.getKind() == UnqualifiedId::IK_ConstructorName)
1616 Diag(Id.getSourceRange().getBegin(),
1617 diag::ext_ms_explicit_constructor_call);
1619 TemplateArgumentListInfo TemplateArgsBuffer;
1621 // Decompose the name into its component parts.
1622 DeclarationNameInfo NameInfo;
1623 const TemplateArgumentListInfo *TemplateArgs;
1624 DecomposeUnqualifiedId(Id, TemplateArgsBuffer,
1625 NameInfo, TemplateArgs);
1627 DeclarationName Name = NameInfo.getName();
1628 bool IsArrow = (OpKind == tok::arrow);
1630 NamedDecl *FirstQualifierInScope
1631 = (!SS.isSet() ? 0 : FindFirstQualifierInScope(S,
1632 static_cast<NestedNameSpecifier*>(SS.getScopeRep())));
1634 // This is a postfix expression, so get rid of ParenListExprs.
1635 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Base);
1636 if (Result.isInvalid()) return ExprError();
1637 Base = Result.take();
1639 if (Base->getType()->isDependentType() || Name.isDependentName() ||
1640 isDependentScopeSpecifier(SS)) {
1641 Result = ActOnDependentMemberExpr(Base, Base->getType(),
1643 SS, TemplateKWLoc, FirstQualifierInScope,
1644 NameInfo, TemplateArgs);
1646 LookupResult R(*this, NameInfo, LookupMemberName);
1647 ExprResult BaseResult = Owned(Base);
1648 Result = LookupMemberExpr(R, BaseResult, IsArrow, OpLoc,
1649 SS, ObjCImpDecl, TemplateArgs != 0);
1650 if (BaseResult.isInvalid())
1652 Base = BaseResult.take();
1654 if (Result.isInvalid()) {
1660 // The only way a reference to a destructor can be used is to
1661 // immediately call it, which falls into this case. If the
1662 // next token is not a '(', produce a diagnostic and build the
1664 if (!HasTrailingLParen &&
1665 Id.getKind() == UnqualifiedId::IK_DestructorName)
1666 return DiagnoseDtorReference(NameInfo.getLoc(), Result.get());
1671 ActOnMemberAccessExtraArgs ExtraArgs = {S, Id, ObjCImpDecl, HasTrailingLParen};
1672 Result = BuildMemberReferenceExpr(Base, Base->getType(),
1673 OpLoc, IsArrow, SS, TemplateKWLoc,
1674 FirstQualifierInScope, R, TemplateArgs,
1682 BuildFieldReferenceExpr(Sema &S, Expr *BaseExpr, bool IsArrow,
1683 const CXXScopeSpec &SS, FieldDecl *Field,
1684 DeclAccessPair FoundDecl,
1685 const DeclarationNameInfo &MemberNameInfo) {
1686 // x.a is an l-value if 'a' has a reference type. Otherwise:
1687 // x.a is an l-value/x-value/pr-value if the base is (and note
1688 // that *x is always an l-value), except that if the base isn't
1689 // an ordinary object then we must have an rvalue.
1690 ExprValueKind VK = VK_LValue;
1691 ExprObjectKind OK = OK_Ordinary;
1693 if (BaseExpr->getObjectKind() == OK_Ordinary)
1694 VK = BaseExpr->getValueKind();
1698 if (VK != VK_RValue && Field->isBitField())
1701 // Figure out the type of the member; see C99 6.5.2.3p3, C++ [expr.ref]
1702 QualType MemberType = Field->getType();
1703 if (const ReferenceType *Ref = MemberType->getAs<ReferenceType>()) {
1704 MemberType = Ref->getPointeeType();
1707 QualType BaseType = BaseExpr->getType();
1708 if (IsArrow) BaseType = BaseType->getAs<PointerType>()->getPointeeType();
1710 Qualifiers BaseQuals = BaseType.getQualifiers();
1712 // GC attributes are never picked up by members.
1713 BaseQuals.removeObjCGCAttr();
1715 // CVR attributes from the base are picked up by members,
1716 // except that 'mutable' members don't pick up 'const'.
1717 if (Field->isMutable()) BaseQuals.removeConst();
1719 Qualifiers MemberQuals
1720 = S.Context.getCanonicalType(MemberType).getQualifiers();
1722 assert(!MemberQuals.hasAddressSpace());
1725 Qualifiers Combined = BaseQuals + MemberQuals;
1726 if (Combined != MemberQuals)
1727 MemberType = S.Context.getQualifiedType(MemberType, Combined);
1730 S.UnusedPrivateFields.remove(Field);
1733 S.PerformObjectMemberConversion(BaseExpr, SS.getScopeRep(),
1735 if (Base.isInvalid())
1737 return S.Owned(BuildMemberExpr(S, S.Context, Base.take(), IsArrow, SS,
1738 /*TemplateKWLoc=*/SourceLocation(),
1739 Field, FoundDecl, MemberNameInfo,
1740 MemberType, VK, OK));
1743 /// Builds an implicit member access expression. The current context
1744 /// is known to be an instance method, and the given unqualified lookup
1745 /// set is known to contain only instance members, at least one of which
1746 /// is from an appropriate type.
1748 Sema::BuildImplicitMemberExpr(const CXXScopeSpec &SS,
1749 SourceLocation TemplateKWLoc,
1751 const TemplateArgumentListInfo *TemplateArgs,
1752 bool IsKnownInstance) {
1753 assert(!R.empty() && !R.isAmbiguous());
1755 SourceLocation loc = R.getNameLoc();
1757 // We may have found a field within an anonymous union or struct
1758 // (C++ [class.union]).
1759 // FIXME: template-ids inside anonymous structs?
1760 if (IndirectFieldDecl *FD = R.getAsSingle<IndirectFieldDecl>())
1761 return BuildAnonymousStructUnionMemberReference(SS, R.getNameLoc(), FD,
1762 R.begin().getPair());
1764 // If this is known to be an instance access, go ahead and build an
1765 // implicit 'this' expression now.
1766 // 'this' expression now.
1767 QualType ThisTy = getCurrentThisType();
1768 assert(!ThisTy.isNull() && "didn't correctly pre-flight capture of 'this'");
1770 Expr *baseExpr = 0; // null signifies implicit access
1771 if (IsKnownInstance) {
1772 SourceLocation Loc = R.getNameLoc();
1773 if (SS.getRange().isValid())
1774 Loc = SS.getRange().getBegin();
1775 CheckCXXThisCapture(Loc);
1776 baseExpr = new (Context) CXXThisExpr(loc, ThisTy, /*isImplicit=*/true);
1779 return BuildMemberReferenceExpr(baseExpr, ThisTy,
1780 /*OpLoc*/ SourceLocation(),
1783 /*FirstQualifierInScope*/ 0,