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