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