contrib/llvm/tools/clang/lib/Sema/SemaExprMember.cpp

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