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