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