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