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