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