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

   1 //===--- SemaCXXScopeSpec.cpp - Semantic Analysis for C++ scope specifiers-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file implements C++ semantic analysis for scope specifiers.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "TypeLocBuilder.h"
  14 #include "clang/AST/ASTContext.h"
  15 #include "clang/AST/DeclTemplate.h"
  16 #include "clang/AST/ExprCXX.h"
  17 #include "clang/AST/NestedNameSpecifier.h"
  18 #include "clang/Basic/PartialDiagnostic.h"
  19 #include "clang/Sema/DeclSpec.h"
  20 #include "clang/Sema/Lookup.h"
  21 #include "clang/Sema/SemaInternal.h"
  22 #include "clang/Sema/Template.h"
  23 #include "llvm/ADT/STLExtras.h"
  24 using namespace clang;
  25
  26 /// Find the current instantiation that associated with the given type.
  27 static CXXRecordDecl *getCurrentInstantiationOf(QualType T,
  28                                                 DeclContext *CurContext) {
  29   if (T.isNull())
  30     return nullptr;
  31
  32   const Type *Ty = T->getCanonicalTypeInternal().getTypePtr();
  33   if (const RecordType *RecordTy = dyn_cast<RecordType>(Ty)) {
  34     CXXRecordDecl *Record = cast<CXXRecordDecl>(RecordTy->getDecl());
  35     if (!Record->isDependentContext() ||
  36         Record->isCurrentInstantiation(CurContext))
  37       return Record;
  38
  39     return nullptr;
  40   } else if (isa<InjectedClassNameType>(Ty))
  41     return cast<InjectedClassNameType>(Ty)->getDecl();
  42   else
  43     return nullptr;
  44 }
  45
  46 /// Compute the DeclContext that is associated with the given type.
  47 ///
  48 /// \param T the type for which we are attempting to find a DeclContext.
  49 ///
  50 /// \returns the declaration context represented by the type T,
  51 /// or NULL if the declaration context cannot be computed (e.g., because it is
  52 /// dependent and not the current instantiation).
  53 DeclContext *Sema::computeDeclContext(QualType T) {
  54   if (!T->isDependentType())
  55     if (const TagType *Tag = T->getAs<TagType>())
  56       return Tag->getDecl();
  57
  58   return ::getCurrentInstantiationOf(T, CurContext);
  59 }
  60
  61 /// Compute the DeclContext that is associated with the given
  62 /// scope specifier.
  63 ///
  64 /// \param SS the C++ scope specifier as it appears in the source
  65 ///
  66 /// \param EnteringContext when true, we will be entering the context of
  67 /// this scope specifier, so we can retrieve the declaration context of a
  68 /// class template or class template partial specialization even if it is
  69 /// not the current instantiation.
  70 ///
  71 /// \returns the declaration context represented by the scope specifier @p SS,
  72 /// or NULL if the declaration context cannot be computed (e.g., because it is
  73 /// dependent and not the current instantiation).
  74 DeclContext *Sema::computeDeclContext(const CXXScopeSpec &SS,
  75                                       bool EnteringContext) {
  76   if (!SS.isSet() || SS.isInvalid())
  77     return nullptr;
  78
  79   NestedNameSpecifier *NNS = SS.getScopeRep();
  80   if (NNS->isDependent()) {
  81     // If this nested-name-specifier refers to the current
  82     // instantiation, return its DeclContext.
  83     if (CXXRecordDecl *Record = getCurrentInstantiationOf(NNS))
  84       return Record;
  85
  86     if (EnteringContext) {
  87       const Type *NNSType = NNS->getAsType();
  88       if (!NNSType) {
  89         return nullptr;
  90       }
  91
  92       // Look through type alias templates, per C++0x [temp.dep.type]p1.
  93       NNSType = Context.getCanonicalType(NNSType);
  94       if (const TemplateSpecializationType *SpecType
  95             = NNSType->getAs<TemplateSpecializationType>()) {
  96         // We are entering the context of the nested name specifier, so try to
  97         // match the nested name specifier to either a primary class template
  98         // or a class template partial specialization.
  99         if (ClassTemplateDecl *ClassTemplate
 100               = dyn_cast_or_null<ClassTemplateDecl>(
 101                             SpecType->getTemplateName().getAsTemplateDecl())) {
 102           QualType ContextType
 103             = Context.getCanonicalType(QualType(SpecType, 0));
 104
 105           // If the type of the nested name specifier is the same as the
 106           // injected class name of the named class template, we're entering
 107           // into that class template definition.
 108           QualType Injected
 109             = ClassTemplate->getInjectedClassNameSpecialization();
 110           if (Context.hasSameType(Injected, ContextType))
 111             return ClassTemplate->getTemplatedDecl();
 112
 113           // If the type of the nested name specifier is the same as the
 114           // type of one of the class template's class template partial
 115           // specializations, we're entering into the definition of that
 116           // class template partial specialization.
 117           if (ClassTemplatePartialSpecializationDecl *PartialSpec
 118                 = ClassTemplate->findPartialSpecialization(ContextType)) {
 119             // A declaration of the partial specialization must be visible.
 120             // We can always recover here, because this only happens when we're
 121             // entering the context, and that can't happen in a SFINAE context.
 122             assert(!isSFINAEContext() &&
 123                    "partial specialization scope specifier in SFINAE context?");
 124             if (!hasVisibleDeclaration(PartialSpec))
 125               diagnoseMissingImport(SS.getLastQualifierNameLoc(), PartialSpec,
 126                                     MissingImportKind::PartialSpecialization,
 127                                     /*Recover*/true);
 128             return PartialSpec;
 129           }
 130         }
 131       } else if (const RecordType *RecordT = NNSType->getAs<RecordType>()) {
 132         // The nested name specifier refers to a member of a class template.
 133         return RecordT->getDecl();
 134       }
 135     }
 136
 137     return nullptr;
 138   }
 139
 140   switch (NNS->getKind()) {
 141   case NestedNameSpecifier::Identifier:
 142     llvm_unreachable("Dependent nested-name-specifier has no DeclContext");
 143
 144   case NestedNameSpecifier::Namespace:
 145     return NNS->getAsNamespace();
 146
 147   case NestedNameSpecifier::NamespaceAlias:
 148     return NNS->getAsNamespaceAlias()->getNamespace();
 149
 150   case NestedNameSpecifier::TypeSpec:
 151   case NestedNameSpecifier::TypeSpecWithTemplate: {
 152     const TagType *Tag = NNS->getAsType()->getAs<TagType>();
 153     assert(Tag && "Non-tag type in nested-name-specifier");
 154     return Tag->getDecl();
 155   }
 156
 157   case NestedNameSpecifier::Global:
 158     return Context.getTranslationUnitDecl();
 159
 160   case NestedNameSpecifier::Super:
 161     return NNS->getAsRecordDecl();
 162   }
 163
 164   llvm_unreachable("Invalid NestedNameSpecifier::Kind!");
 165 }
 166
 167 bool Sema::isDependentScopeSpecifier(const CXXScopeSpec &SS) {
 168   if (!SS.isSet() || SS.isInvalid())
 169     return false;
 170
 171   return SS.getScopeRep()->isDependent();
 172 }
 173
 174 /// If the given nested name specifier refers to the current
 175 /// instantiation, return the declaration that corresponds to that
 176 /// current instantiation (C++0x [temp.dep.type]p1).
 177 ///
 178 /// \param NNS a dependent nested name specifier.
 179 CXXRecordDecl *Sema::getCurrentInstantiationOf(NestedNameSpecifier *NNS) {
 180   assert(getLangOpts().CPlusPlus && "Only callable in C++");
 181   assert(NNS->isDependent() && "Only dependent nested-name-specifier allowed");
 182
 183   if (!NNS->getAsType())
 184     return nullptr;
 185
 186   QualType T = QualType(NNS->getAsType(), 0);
 187   return ::getCurrentInstantiationOf(T, CurContext);
 188 }
 189
 190 /// Require that the context specified by SS be complete.
 191 ///
 192 /// If SS refers to a type, this routine checks whether the type is
 193 /// complete enough (or can be made complete enough) for name lookup
 194 /// into the DeclContext. A type that is not yet completed can be
 195 /// considered "complete enough" if it is a class/struct/union/enum
 196 /// that is currently being defined. Or, if we have a type that names
 197 /// a class template specialization that is not a complete type, we
 198 /// will attempt to instantiate that class template.
 199 bool Sema::RequireCompleteDeclContext(CXXScopeSpec &SS,
 200                                       DeclContext *DC) {
 201   assert(DC && "given null context");
 202
 203   TagDecl *tag = dyn_cast<TagDecl>(DC);
 204
 205   // If this is a dependent type, then we consider it complete.
 206   // FIXME: This is wrong; we should require a (visible) definition to
 207   // exist in this case too.
 208   if (!tag || tag->isDependentContext())
 209     return false;
 210
 211   // Grab the tag definition, if there is one.
 212   QualType type = Context.getTypeDeclType(tag);
 213   tag = type->getAsTagDecl();
 214
 215   // If we're currently defining this type, then lookup into the
 216   // type is okay: don't complain that it isn't complete yet.
 217   if (tag->isBeingDefined())
 218     return false;
 219
 220   SourceLocation loc = SS.getLastQualifierNameLoc();
 221   if (loc.isInvalid()) loc = SS.getRange().getBegin();
 222
 223   // The type must be complete.
 224   if (RequireCompleteType(loc, type, diag::err_incomplete_nested_name_spec,
 225                           SS.getRange())) {
 226     SS.SetInvalid(SS.getRange());
 227     return true;
 228   }
 229
 230   // Fixed enum types are complete, but they aren't valid as scopes
 231   // until we see a definition, so awkwardly pull out this special
 232   // case.
 233   auto *EnumD = dyn_cast<EnumDecl>(tag);
 234   if (!EnumD)
 235     return false;
 236   if (EnumD->isCompleteDefinition()) {
 237     // If we know about the definition but it is not visible, complain.
 238     NamedDecl *SuggestedDef = nullptr;
 239     if (!hasVisibleDefinition(EnumD, &SuggestedDef,
 240                               /*OnlyNeedComplete*/false)) {
 241       // If the user is going to see an error here, recover by making the
 242       // definition visible.
 243       bool TreatAsComplete = !isSFINAEContext();
 244       diagnoseMissingImport(loc, SuggestedDef, MissingImportKind::Definition,
 245                             /*Recover*/TreatAsComplete);
 246       return !TreatAsComplete;
 247     }
 248     return false;
 249   }
 250
 251   // Try to instantiate the definition, if this is a specialization of an
 252   // enumeration temploid.
 253   if (EnumDecl *Pattern = EnumD->getInstantiatedFromMemberEnum()) {
 254     MemberSpecializationInfo *MSI = EnumD->getMemberSpecializationInfo();
 255     if (MSI->getTemplateSpecializationKind() != TSK_ExplicitSpecialization) {
 256       if (InstantiateEnum(loc, EnumD, Pattern,
 257                           getTemplateInstantiationArgs(EnumD),
 258                           TSK_ImplicitInstantiation)) {
 259         SS.SetInvalid(SS.getRange());
 260         return true;
 261       }
 262       return false;
 263     }
 264   }
 265
 266   Diag(loc, diag::err_incomplete_nested_name_spec)
 267     << type << SS.getRange();
 268   SS.SetInvalid(SS.getRange());
 269   return true;
 270 }
 271
 272 bool Sema::ActOnCXXGlobalScopeSpecifier(SourceLocation CCLoc,
 273                                         CXXScopeSpec &SS) {
 274   SS.MakeGlobal(Context, CCLoc);
 275   return false;
 276 }
 277
 278 bool Sema::ActOnSuperScopeSpecifier(SourceLocation SuperLoc,
 279                                     SourceLocation ColonColonLoc,
 280                                     CXXScopeSpec &SS) {
 281   CXXRecordDecl *RD = nullptr;
 282   for (Scope *S = getCurScope(); S; S = S->getParent()) {
 283     if (S->isFunctionScope()) {
 284       if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(S->getEntity()))
 285         RD = MD->getParent();
 286       break;
 287     }
 288     if (S->isClassScope()) {
 289       RD = cast<CXXRecordDecl>(S->getEntity());
 290       break;
 291     }
 292   }
 293
 294   if (!RD) {
 295     Diag(SuperLoc, diag::err_invalid_super_scope);
 296     return true;
 297   } else if (RD->isLambda()) {
 298     Diag(SuperLoc, diag::err_super_in_lambda_unsupported);
 299     return true;
 300   } else if (RD->getNumBases() == 0) {
 301     Diag(SuperLoc, diag::err_no_base_classes) << RD->getName();
 302     return true;
 303   }
 304
 305   SS.MakeSuper(Context, RD, SuperLoc, ColonColonLoc);
 306   return false;
 307 }
 308
 309 /// Determines whether the given declaration is an valid acceptable
 310 /// result for name lookup of a nested-name-specifier.
 311 /// \param SD Declaration checked for nested-name-specifier.
 312 /// \param IsExtension If not null and the declaration is accepted as an
 313 /// extension, the pointed variable is assigned true.
 314 bool Sema::isAcceptableNestedNameSpecifier(const NamedDecl *SD,
 315                                            bool *IsExtension) {
 316   if (!SD)
 317     return false;
 318
 319   SD = SD->getUnderlyingDecl();
 320
 321   // Namespace and namespace aliases are fine.
 322   if (isa<NamespaceDecl>(SD))
 323     return true;
 324
 325   if (!isa<TypeDecl>(SD))
 326     return false;
 327
 328   // Determine whether we have a class (or, in C++11, an enum) or
 329   // a typedef thereof. If so, build the nested-name-specifier.
 330   QualType T = Context.getTypeDeclType(cast<TypeDecl>(SD));
 331   if (T->isDependentType())
 332     return true;
 333   if (const TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(SD)) {
 334     if (TD->getUnderlyingType()->isRecordType())
 335       return true;
 336     if (TD->getUnderlyingType()->isEnumeralType()) {
 337       if (Context.getLangOpts().CPlusPlus11)
 338         return true;
 339       if (IsExtension)
 340         *IsExtension = true;
 341     }
 342   } else if (isa<RecordDecl>(SD)) {
 343     return true;
 344   } else if (isa<EnumDecl>(SD)) {
 345     if (Context.getLangOpts().CPlusPlus11)
 346       return true;
 347     if (IsExtension)
 348       *IsExtension = true;
 349   }
 350
 351   return false;
 352 }
 353
 354 /// If the given nested-name-specifier begins with a bare identifier
 355 /// (e.g., Base::), perform name lookup for that identifier as a
 356 /// nested-name-specifier within the given scope, and return the result of that
 357 /// name lookup.
 358 NamedDecl *Sema::FindFirstQualifierInScope(Scope *S, NestedNameSpecifier *NNS) {
 359   if (!S || !NNS)
 360     return nullptr;
 361
 362   while (NNS->getPrefix())
 363     NNS = NNS->getPrefix();
 364
 365   if (NNS->getKind() != NestedNameSpecifier::Identifier)
 366     return nullptr;
 367
 368   LookupResult Found(*this, NNS->getAsIdentifier(), SourceLocation(),
 369                      LookupNestedNameSpecifierName);
 370   LookupName(Found, S);
 371   assert(!Found.isAmbiguous() && "Cannot handle ambiguities here yet");
 372
 373   if (!Found.isSingleResult())
 374     return nullptr;
 375
 376   NamedDecl *Result = Found.getFoundDecl();
 377   if (isAcceptableNestedNameSpecifier(Result))
 378     return Result;
 379
 380   return nullptr;
 381 }
 382
 383 bool Sema::isNonTypeNestedNameSpecifier(Scope *S, CXXScopeSpec &SS,
 384                                         NestedNameSpecInfo &IdInfo) {
 385   QualType ObjectType = GetTypeFromParser(IdInfo.ObjectType);
 386   LookupResult Found(*this, IdInfo.Identifier, IdInfo.IdentifierLoc,
 387                      LookupNestedNameSpecifierName);
 388
 389   // Determine where to perform name lookup
 390   DeclContext *LookupCtx = nullptr;
 391   bool isDependent = false;
 392   if (!ObjectType.isNull()) {
 393     // This nested-name-specifier occurs in a member access expression, e.g.,
 394     // x->B::f, and we are looking into the type of the object.
 395     assert(!SS.isSet() && "ObjectType and scope specifier cannot coexist");
 396     LookupCtx = computeDeclContext(ObjectType);
 397     isDependent = ObjectType->isDependentType();
 398   } else if (SS.isSet()) {
 399     // This nested-name-specifier occurs after another nested-name-specifier,
 400     // so long into the context associated with the prior nested-name-specifier.
 401     LookupCtx = computeDeclContext(SS, false);
 402     isDependent = isDependentScopeSpecifier(SS);
 403     Found.setContextRange(SS.getRange());
 404   }
 405
 406   if (LookupCtx) {
 407     // Perform "qualified" name lookup into the declaration context we
 408     // computed, which is either the type of the base of a member access
 409     // expression or the declaration context associated with a prior
 410     // nested-name-specifier.
 411
 412     // The declaration context must be complete.
 413     if (!LookupCtx->isDependentContext() &&
 414         RequireCompleteDeclContext(SS, LookupCtx))
 415       return false;
 416
 417     LookupQualifiedName(Found, LookupCtx);
 418   } else if (isDependent) {
 419     return false;
 420   } else {
 421     LookupName(Found, S);
 422   }
 423   Found.suppressDiagnostics();
 424
 425   return Found.getAsSingle<NamespaceDecl>();
 426 }
 427
 428 namespace {
 429
 430 // Callback to only accept typo corrections that can be a valid C++ member
 431 // intializer: either a non-static field member or a base class.
 432 class NestedNameSpecifierValidatorCCC final
 433     : public CorrectionCandidateCallback {
 434 public:
 435   explicit NestedNameSpecifierValidatorCCC(Sema &SRef)
 436       : SRef(SRef) {}
 437
 438   bool ValidateCandidate(const TypoCorrection &candidate) override {
 439     return SRef.isAcceptableNestedNameSpecifier(candidate.getCorrectionDecl());
 440   }
 441
 442   std::unique_ptr<CorrectionCandidateCallback> clone() override {
 443     return llvm::make_unique<NestedNameSpecifierValidatorCCC>(*this);
 444   }
 445
 446  private:
 447   Sema &SRef;
 448 };
 449
 450 }
 451
 452 /// Build a new nested-name-specifier for "identifier::", as described
 453 /// by ActOnCXXNestedNameSpecifier.
 454 ///
 455 /// \param S Scope in which the nested-name-specifier occurs.
 456 /// \param IdInfo Parser information about an identifier in the
 457 ///        nested-name-spec.
 458 /// \param EnteringContext If true, enter the context specified by the
 459 ///        nested-name-specifier.
 460 /// \param SS Optional nested name specifier preceding the identifier.
 461 /// \param ScopeLookupResult Provides the result of name lookup within the
 462 ///        scope of the nested-name-specifier that was computed at template
 463 ///        definition time.
 464 /// \param ErrorRecoveryLookup Specifies if the method is called to improve
 465 ///        error recovery and what kind of recovery is performed.
 466 /// \param IsCorrectedToColon If not null, suggestion of replace '::' -> ':'
 467 ///        are allowed.  The bool value pointed by this parameter is set to
 468 ///       'true' if the identifier is treated as if it was followed by ':',
 469 ///        not '::'.
 470 /// \param OnlyNamespace If true, only considers namespaces in lookup.
 471 ///
 472 /// This routine differs only slightly from ActOnCXXNestedNameSpecifier, in
 473 /// that it contains an extra parameter \p ScopeLookupResult, which provides
 474 /// the result of name lookup within the scope of the nested-name-specifier
 475 /// that was computed at template definition time.
 476 ///
 477 /// If ErrorRecoveryLookup is true, then this call is used to improve error
 478 /// recovery.  This means that it should not emit diagnostics, it should
 479 /// just return true on failure.  It also means it should only return a valid
 480 /// scope if it *knows* that the result is correct.  It should not return in a
 481 /// dependent context, for example. Nor will it extend \p SS with the scope
 482 /// specifier.
 483 bool Sema::BuildCXXNestedNameSpecifier(Scope *S, NestedNameSpecInfo &IdInfo,
 484                                        bool EnteringContext, CXXScopeSpec &SS,
 485                                        NamedDecl *ScopeLookupResult,
 486                                        bool ErrorRecoveryLookup,
 487                                        bool *IsCorrectedToColon,
 488                                        bool OnlyNamespace) {
 489   if (IdInfo.Identifier->isEditorPlaceholder())
 490     return true;
 491   LookupResult Found(*this, IdInfo.Identifier, IdInfo.IdentifierLoc,
 492                      OnlyNamespace ? LookupNamespaceName
 493                                    : LookupNestedNameSpecifierName);
 494   QualType ObjectType = GetTypeFromParser(IdInfo.ObjectType);
 495
 496   // Determine where to perform name lookup
 497   DeclContext *LookupCtx = nullptr;
 498   bool isDependent = false;
 499   if (IsCorrectedToColon)
 500     *IsCorrectedToColon = false;
 501   if (!ObjectType.isNull()) {
 502     // This nested-name-specifier occurs in a member access expression, e.g.,
 503     // x->B::f, and we are looking into the type of the object.
 504     assert(!SS.isSet() && "ObjectType and scope specifier cannot coexist");
 505     LookupCtx = computeDeclContext(ObjectType);
 506     isDependent = ObjectType->isDependentType();
 507   } else if (SS.isSet()) {
 508     // This nested-name-specifier occurs after another nested-name-specifier,
 509     // so look into the context associated with the prior nested-name-specifier.
 510     LookupCtx = computeDeclContext(SS, EnteringContext);
 511     isDependent = isDependentScopeSpecifier(SS);
 512     Found.setContextRange(SS.getRange());
 513   }
 514
 515   bool ObjectTypeSearchedInScope = false;
 516   if (LookupCtx) {
 517     // Perform "qualified" name lookup into the declaration context we
 518     // computed, which is either the type of the base of a member access
 519     // expression or the declaration context associated with a prior
 520     // nested-name-specifier.
 521
 522     // The declaration context must be complete.
 523     if (!LookupCtx->isDependentContext() &&
 524         RequireCompleteDeclContext(SS, LookupCtx))
 525       return true;
 526
 527     LookupQualifiedName(Found, LookupCtx);
 528
 529     if (!ObjectType.isNull() && Found.empty()) {
 530       // C++ [basic.lookup.classref]p4:
 531       //   If the id-expression in a class member access is a qualified-id of
 532       //   the form
 533       //
 534       //        class-name-or-namespace-name::...
 535       //
 536       //   the class-name-or-namespace-name following the . or -> operator is
 537       //   looked up both in the context of the entire postfix-expression and in
 538       //   the scope of the class of the object expression. If the name is found
 539       //   only in the scope of the class of the object expression, the name
 540       //   shall refer to a class-name. If the name is found only in the
 541       //   context of the entire postfix-expression, the name shall refer to a
 542       //   class-name or namespace-name. [...]
 543       //
 544       // Qualified name lookup into a class will not find a namespace-name,
 545       // so we do not need to diagnose that case specifically. However,
 546       // this qualified name lookup may find nothing. In that case, perform
 547       // unqualified name lookup in the given scope (if available) or
 548       // reconstruct the result from when name lookup was performed at template
 549       // definition time.
 550       if (S)
 551         LookupName(Found, S);
 552       else if (ScopeLookupResult)
 553         Found.addDecl(ScopeLookupResult);
 554
 555       ObjectTypeSearchedInScope = true;
 556     }
 557   } else if (!isDependent) {
 558     // Perform unqualified name lookup in the current scope.
 559     LookupName(Found, S);
 560   }
 561
 562   if (Found.isAmbiguous())
 563     return true;
 564
 565   // If we performed lookup into a dependent context and did not find anything,
 566   // that's fine: just build a dependent nested-name-specifier.
 567   if (Found.empty() && isDependent &&
 568       !(LookupCtx && LookupCtx->isRecord() &&
 569         (!cast<CXXRecordDecl>(LookupCtx)->hasDefinition() ||
 570          !cast<CXXRecordDecl>(LookupCtx)->hasAnyDependentBases()))) {
 571     // Don't speculate if we're just trying to improve error recovery.
 572     if (ErrorRecoveryLookup)
 573       return true;
 574
 575     // We were not able to compute the declaration context for a dependent
 576     // base object type or prior nested-name-specifier, so this
 577     // nested-name-specifier refers to an unknown specialization. Just build
 578     // a dependent nested-name-specifier.
 579     SS.Extend(Context, IdInfo.Identifier, IdInfo.IdentifierLoc, IdInfo.CCLoc);
 580     return false;
 581   }
 582
 583   if (Found.empty() && !ErrorRecoveryLookup) {
 584     // If identifier is not found as class-name-or-namespace-name, but is found
 585     // as other entity, don't look for typos.
 586     LookupResult R(*this, Found.getLookupNameInfo(), LookupOrdinaryName);
 587     if (LookupCtx)
 588       LookupQualifiedName(R, LookupCtx);
 589     else if (S && !isDependent)
 590       LookupName(R, S);
 591     if (!R.empty()) {
 592       // Don't diagnose problems with this speculative lookup.
 593       R.suppressDiagnostics();
 594       // The identifier is found in ordinary lookup. If correction to colon is
 595       // allowed, suggest replacement to ':'.
 596       if (IsCorrectedToColon) {
 597         *IsCorrectedToColon = true;
 598         Diag(IdInfo.CCLoc, diag::err_nested_name_spec_is_not_class)
 599             << IdInfo.Identifier << getLangOpts().CPlusPlus
 600             << FixItHint::CreateReplacement(IdInfo.CCLoc, ":");
 601         if (NamedDecl *ND = R.getAsSingle<NamedDecl>())
 602           Diag(ND->getLocation(), diag::note_declared_at);
 603         return true;
 604       }
 605       // Replacement '::' -> ':' is not allowed, just issue respective error.
 606       Diag(R.getNameLoc(), OnlyNamespace
 607                                ? unsigned(diag::err_expected_namespace_name)
 608                                : unsigned(diag::err_expected_class_or_namespace))
 609           << IdInfo.Identifier << getLangOpts().CPlusPlus;
 610       if (NamedDecl *ND = R.getAsSingle<NamedDecl>())
 611         Diag(ND->getLocation(), diag::note_entity_declared_at)
 612             << IdInfo.Identifier;
 613       return true;
 614     }
 615   }
 616
 617   if (Found.empty() && !ErrorRecoveryLookup && !getLangOpts().MSVCCompat) {
 618     // We haven't found anything, and we're not recovering from a
 619     // different kind of error, so look for typos.
 620     DeclarationName Name = Found.getLookupName();
 621     Found.clear();
 622     NestedNameSpecifierValidatorCCC CCC(*this);
 623     if (TypoCorrection Corrected = CorrectTypo(
 624             Found.getLookupNameInfo(), Found.getLookupKind(), S, &SS, CCC,
 625             CTK_ErrorRecovery, LookupCtx, EnteringContext)) {
 626       if (LookupCtx) {
 627         bool DroppedSpecifier =
 628             Corrected.WillReplaceSpecifier() &&
 629             Name.getAsString() == Corrected.getAsString(getLangOpts());
 630         if (DroppedSpecifier)
 631           SS.clear();
 632         diagnoseTypo(Corrected, PDiag(diag::err_no_member_suggest)
 633                                   << Name << LookupCtx << DroppedSpecifier
 634                                   << SS.getRange());
 635       } else
 636         diagnoseTypo(Corrected, PDiag(diag::err_undeclared_var_use_suggest)
 637                                   << Name);
 638
 639       if (Corrected.getCorrectionSpecifier())
 640         SS.MakeTrivial(Context, Corrected.getCorrectionSpecifier(),
 641                        SourceRange(Found.getNameLoc()));
 642
 643       if (NamedDecl *ND = Corrected.getFoundDecl())
 644         Found.addDecl(ND);
 645       Found.setLookupName(Corrected.getCorrection());
 646     } else {
 647       Found.setLookupName(IdInfo.Identifier);
 648     }
 649   }
 650
 651   NamedDecl *SD =
 652       Found.isSingleResult() ? Found.getRepresentativeDecl() : nullptr;
 653   bool IsExtension = false;
 654   bool AcceptSpec = isAcceptableNestedNameSpecifier(SD, &IsExtension);
 655   if (!AcceptSpec && IsExtension) {
 656     AcceptSpec = true;
 657     Diag(IdInfo.IdentifierLoc, diag::ext_nested_name_spec_is_enum);
 658   }
 659   if (AcceptSpec) {
 660     if (!ObjectType.isNull() && !ObjectTypeSearchedInScope &&
 661         !getLangOpts().CPlusPlus11) {
 662       // C++03 [basic.lookup.classref]p4:
 663       //   [...] If the name is found in both contexts, the
 664       //   class-name-or-namespace-name shall refer to the same entity.
 665       //
 666       // We already found the name in the scope of the object. Now, look
 667       // into the current scope (the scope of the postfix-expression) to
 668       // see if we can find the same name there. As above, if there is no
 669       // scope, reconstruct the result from the template instantiation itself.
 670       //
 671       // Note that C++11 does *not* perform this redundant lookup.
 672       NamedDecl *OuterDecl;
 673       if (S) {
 674         LookupResult FoundOuter(*this, IdInfo.Identifier, IdInfo.IdentifierLoc,
 675                                 LookupNestedNameSpecifierName);
 676         LookupName(FoundOuter, S);
 677         OuterDecl = FoundOuter.getAsSingle<NamedDecl>();
 678       } else
 679         OuterDecl = ScopeLookupResult;
 680
 681       if (isAcceptableNestedNameSpecifier(OuterDecl) &&
 682           OuterDecl->getCanonicalDecl() != SD->getCanonicalDecl() &&
 683           (!isa<TypeDecl>(OuterDecl) || !isa<TypeDecl>(SD) ||
 684            !Context.hasSameType(
 685                             Context.getTypeDeclType(cast<TypeDecl>(OuterDecl)),
 686                                Context.getTypeDeclType(cast<TypeDecl>(SD))))) {
 687         if (ErrorRecoveryLookup)
 688           return true;
 689
 690          Diag(IdInfo.IdentifierLoc,
 691               diag::err_nested_name_member_ref_lookup_ambiguous)
 692            << IdInfo.Identifier;
 693          Diag(SD->getLocation(), diag::note_ambig_member_ref_object_type)
 694            << ObjectType;
 695          Diag(OuterDecl->getLocation(), diag::note_ambig_member_ref_scope);
 696
 697          // Fall through so that we'll pick the name we found in the object
 698          // type, since that's probably what the user wanted anyway.
 699        }
 700     }
 701
 702     if (auto *TD = dyn_cast_or_null<TypedefNameDecl>(SD))
 703       MarkAnyDeclReferenced(TD->getLocation(), TD, /*OdrUse=*/false);
 704
 705     // If we're just performing this lookup for error-recovery purposes,
 706     // don't extend the nested-name-specifier. Just return now.
 707     if (ErrorRecoveryLookup)
 708       return false;
 709
 710     // The use of a nested name specifier may trigger deprecation warnings.
 711     DiagnoseUseOfDecl(SD, IdInfo.CCLoc);
 712
 713     if (NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(SD)) {
 714       SS.Extend(Context, Namespace, IdInfo.IdentifierLoc, IdInfo.CCLoc);
 715       return false;
 716     }
 717
 718     if (NamespaceAliasDecl *Alias = dyn_cast<NamespaceAliasDecl>(SD)) {
 719       SS.Extend(Context, Alias, IdInfo.IdentifierLoc, IdInfo.CCLoc);
 720       return false;
 721     }
 722
 723     QualType T =
 724         Context.getTypeDeclType(cast<TypeDecl>(SD->getUnderlyingDecl()));
 725     TypeLocBuilder TLB;
 726     if (isa<InjectedClassNameType>(T)) {
 727       InjectedClassNameTypeLoc InjectedTL
 728         = TLB.push<InjectedClassNameTypeLoc>(T);
 729       InjectedTL.setNameLoc(IdInfo.IdentifierLoc);
 730     } else if (isa<RecordType>(T)) {
 731       RecordTypeLoc RecordTL = TLB.push<RecordTypeLoc>(T);
 732       RecordTL.setNameLoc(IdInfo.IdentifierLoc);
 733     } else if (isa<TypedefType>(T)) {
 734       TypedefTypeLoc TypedefTL = TLB.push<TypedefTypeLoc>(T);
 735       TypedefTL.setNameLoc(IdInfo.IdentifierLoc);
 736     } else if (isa<EnumType>(T)) {
 737       EnumTypeLoc EnumTL = TLB.push<EnumTypeLoc>(T);
 738       EnumTL.setNameLoc(IdInfo.IdentifierLoc);
 739     } else if (isa<TemplateTypeParmType>(T)) {
 740       TemplateTypeParmTypeLoc TemplateTypeTL
 741         = TLB.push<TemplateTypeParmTypeLoc>(T);
 742       TemplateTypeTL.setNameLoc(IdInfo.IdentifierLoc);
 743     } else if (isa<UnresolvedUsingType>(T)) {
 744       UnresolvedUsingTypeLoc UnresolvedTL
 745         = TLB.push<UnresolvedUsingTypeLoc>(T);
 746       UnresolvedTL.setNameLoc(IdInfo.IdentifierLoc);
 747     } else if (isa<SubstTemplateTypeParmType>(T)) {
 748       SubstTemplateTypeParmTypeLoc TL
 749         = TLB.push<SubstTemplateTypeParmTypeLoc>(T);
 750       TL.setNameLoc(IdInfo.IdentifierLoc);
 751     } else if (isa<SubstTemplateTypeParmPackType>(T)) {
 752       SubstTemplateTypeParmPackTypeLoc TL
 753         = TLB.push<SubstTemplateTypeParmPackTypeLoc>(T);
 754       TL.setNameLoc(IdInfo.IdentifierLoc);
 755     } else {
 756       llvm_unreachable("Unhandled TypeDecl node in nested-name-specifier");
 757     }
 758
 759     if (T->isEnumeralType())
 760       Diag(IdInfo.IdentifierLoc, diag::warn_cxx98_compat_enum_nested_name_spec);
 761
 762     SS.Extend(Context, SourceLocation(), TLB.getTypeLocInContext(Context, T),
 763               IdInfo.CCLoc);
 764     return false;
 765   }
 766
 767   // Otherwise, we have an error case.  If we don't want diagnostics, just
 768   // return an error now.
 769   if (ErrorRecoveryLookup)
 770     return true;
 771
 772   // If we didn't find anything during our lookup, try again with
 773   // ordinary name lookup, which can help us produce better error
 774   // messages.
 775   if (Found.empty()) {
 776     Found.clear(LookupOrdinaryName);
 777     LookupName(Found, S);
 778   }
 779
 780   // In Microsoft mode, if we are within a templated function and we can't
 781   // resolve Identifier, then extend the SS with Identifier. This will have
 782   // the effect of resolving Identifier during template instantiation.
 783   // The goal is to be able to resolve a function call whose
 784   // nested-name-specifier is located inside a dependent base class.
 785   // Example:
 786   //
 787   // class C {
 788   // public:
 789   //    static void foo2() {  }
 790   // };
 791   // template <class T> class A { public: typedef C D; };
 792   //
 793   // template <class T> class B : public A<T> {
 794   // public:
 795   //   void foo() { D::foo2(); }
 796   // };
 797   if (getLangOpts().MSVCCompat) {
 798     DeclContext *DC = LookupCtx ? LookupCtx : CurContext;
 799     if (DC->isDependentContext() && DC->isFunctionOrMethod()) {
 800       CXXRecordDecl *ContainingClass = dyn_cast<CXXRecordDecl>(DC->getParent());
 801       if (ContainingClass && ContainingClass->hasAnyDependentBases()) {
 802         Diag(IdInfo.IdentifierLoc,
 803              diag::ext_undeclared_unqual_id_with_dependent_base)
 804             << IdInfo.Identifier << ContainingClass;
 805         SS.Extend(Context, IdInfo.Identifier, IdInfo.IdentifierLoc,
 806                   IdInfo.CCLoc);
 807         return false;
 808       }
 809     }
 810   }
 811
 812   if (!Found.empty()) {
 813     if (TypeDecl *TD = Found.getAsSingle<TypeDecl>())
 814       Diag(IdInfo.IdentifierLoc, diag::err_expected_class_or_namespace)
 815           << Context.getTypeDeclType(TD) << getLangOpts().CPlusPlus;
 816     else {
 817       Diag(IdInfo.IdentifierLoc, diag::err_expected_class_or_namespace)
 818           << IdInfo.Identifier << getLangOpts().CPlusPlus;
 819       if (NamedDecl *ND = Found.getAsSingle<NamedDecl>())
 820         Diag(ND->getLocation(), diag::note_entity_declared_at)
 821             << IdInfo.Identifier;
 822     }
 823   } else if (SS.isSet())
 824     Diag(IdInfo.IdentifierLoc, diag::err_no_member) << IdInfo.Identifier
 825         << LookupCtx << SS.getRange();
 826   else
 827     Diag(IdInfo.IdentifierLoc, diag::err_undeclared_var_use)
 828         << IdInfo.Identifier;
 829
 830   return true;
 831 }
 832
 833 bool Sema::ActOnCXXNestedNameSpecifier(Scope *S, NestedNameSpecInfo &IdInfo,
 834                                        bool EnteringContext, CXXScopeSpec &SS,
 835                                        bool ErrorRecoveryLookup,
 836                                        bool *IsCorrectedToColon,
 837                                        bool OnlyNamespace) {
 838   if (SS.isInvalid())
 839     return true;
 840
 841   return BuildCXXNestedNameSpecifier(S, IdInfo, EnteringContext, SS,
 842                                      /*ScopeLookupResult=*/nullptr, false,
 843                                      IsCorrectedToColon, OnlyNamespace);
 844 }
 845
 846 bool Sema::ActOnCXXNestedNameSpecifierDecltype(CXXScopeSpec &SS,
 847                                                const DeclSpec &DS,
 848                                                SourceLocation ColonColonLoc) {
 849   if (SS.isInvalid() || DS.getTypeSpecType() == DeclSpec::TST_error)
 850     return true;
 851
 852   assert(DS.getTypeSpecType() == DeclSpec::TST_decltype);
 853
 854   QualType T = BuildDecltypeType(DS.getRepAsExpr(), DS.getTypeSpecTypeLoc());
 855   if (T.isNull())
 856     return true;
 857
 858   if (!T->isDependentType() && !T->getAs<TagType>()) {
 859     Diag(DS.getTypeSpecTypeLoc(), diag::err_expected_class_or_namespace)
 860       << T << getLangOpts().CPlusPlus;
 861     return true;
 862   }
 863
 864   TypeLocBuilder TLB;
 865   DecltypeTypeLoc DecltypeTL = TLB.push<DecltypeTypeLoc>(T);
 866   DecltypeTL.setNameLoc(DS.getTypeSpecTypeLoc());
 867   SS.Extend(Context, SourceLocation(), TLB.getTypeLocInContext(Context, T),
 868             ColonColonLoc);
 869   return false;
 870 }
 871
 872 /// IsInvalidUnlessNestedName - This method is used for error recovery
 873 /// purposes to determine whether the specified identifier is only valid as
 874 /// a nested name specifier, for example a namespace name.  It is
 875 /// conservatively correct to always return false from this method.
 876 ///
 877 /// The arguments are the same as those passed to ActOnCXXNestedNameSpecifier.
 878 bool Sema::IsInvalidUnlessNestedName(Scope *S, CXXScopeSpec &SS,
 879                                      NestedNameSpecInfo &IdInfo,
 880                                      bool EnteringContext) {
 881   if (SS.isInvalid())
 882     return false;
 883
 884   return !BuildCXXNestedNameSpecifier(S, IdInfo, EnteringContext, SS,
 885                                       /*ScopeLookupResult=*/nullptr, true);
 886 }
 887
 888 bool Sema::ActOnCXXNestedNameSpecifier(Scope *S,
 889                                        CXXScopeSpec &SS,
 890                                        SourceLocation TemplateKWLoc,
 891                                        TemplateTy OpaqueTemplate,
 892                                        SourceLocation TemplateNameLoc,
 893                                        SourceLocation LAngleLoc,
 894                                        ASTTemplateArgsPtr TemplateArgsIn,
 895                                        SourceLocation RAngleLoc,
 896                                        SourceLocation CCLoc,
 897                                        bool EnteringContext) {
 898   if (SS.isInvalid())
 899     return true;
 900
 901   TemplateName Template = OpaqueTemplate.get();
 902
 903   // Translate the parser's template argument list in our AST format.
 904   TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc);
 905   translateTemplateArguments(TemplateArgsIn, TemplateArgs);
 906
 907   DependentTemplateName *DTN = Template.getAsDependentTemplateName();
 908   if (DTN && DTN->isIdentifier()) {
 909     // Handle a dependent template specialization for which we cannot resolve
 910     // the template name.
 911     assert(DTN->getQualifier() == SS.getScopeRep());
 912     QualType T = Context.getDependentTemplateSpecializationType(ETK_None,
 913                                                           DTN->getQualifier(),
 914                                                           DTN->getIdentifier(),
 915                                                                 TemplateArgs);
 916
 917     // Create source-location information for this type.
 918     TypeLocBuilder Builder;
 919     DependentTemplateSpecializationTypeLoc SpecTL
 920       = Builder.push<DependentTemplateSpecializationTypeLoc>(T);
 921     SpecTL.setElaboratedKeywordLoc(SourceLocation());
 922     SpecTL.setQualifierLoc(SS.getWithLocInContext(Context));
 923     SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
 924     SpecTL.setTemplateNameLoc(TemplateNameLoc);
 925     SpecTL.setLAngleLoc(LAngleLoc);
 926     SpecTL.setRAngleLoc(RAngleLoc);
 927     for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
 928       SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
 929
 930     SS.Extend(Context, TemplateKWLoc, Builder.getTypeLocInContext(Context, T),
 931               CCLoc);
 932     return false;
 933   }
 934
 935   // If we assumed an undeclared identifier was a template name, try to
 936   // typo-correct it now.
 937   if (Template.getAsAssumedTemplateName() &&
 938       resolveAssumedTemplateNameAsType(S, Template, TemplateNameLoc))
 939     return true;
 940
 941   TemplateDecl *TD = Template.getAsTemplateDecl();
 942   if (Template.getAsOverloadedTemplate() || DTN ||
 943       isa<FunctionTemplateDecl>(TD) || isa<VarTemplateDecl>(TD)) {
 944     SourceRange R(TemplateNameLoc, RAngleLoc);
 945     if (SS.getRange().isValid())
 946       R.setBegin(SS.getRange().getBegin());
 947
 948     Diag(CCLoc, diag::err_non_type_template_in_nested_name_specifier)
 949       << (TD && isa<VarTemplateDecl>(TD)) << Template << R;
 950     NoteAllFoundTemplates(Template);
 951     return true;
 952   }
 953
 954   // We were able to resolve the template name to an actual template.
 955   // Build an appropriate nested-name-specifier.
 956   QualType T = CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs);
 957   if (T.isNull())
 958     return true;
 959
 960   // Alias template specializations can produce types which are not valid
 961   // nested name specifiers.
 962   if (!T->isDependentType() && !T->getAs<TagType>()) {
 963     Diag(TemplateNameLoc, diag::err_nested_name_spec_non_tag) << T;
 964     NoteAllFoundTemplates(Template);
 965     return true;
 966   }
 967
 968   // Provide source-location information for the template specialization type.
 969   TypeLocBuilder Builder;
 970   TemplateSpecializationTypeLoc SpecTL
 971     = Builder.push<TemplateSpecializationTypeLoc>(T);
 972   SpecTL.setTemplateKeywordLoc(TemplateKWLoc);
 973   SpecTL.setTemplateNameLoc(TemplateNameLoc);
 974   SpecTL.setLAngleLoc(LAngleLoc);
 975   SpecTL.setRAngleLoc(RAngleLoc);
 976   for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I)
 977     SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo());
 978
 979
 980   SS.Extend(Context, TemplateKWLoc, Builder.getTypeLocInContext(Context, T),
 981             CCLoc);
 982   return false;
 983 }
 984
 985 namespace {
 986   /// A structure that stores a nested-name-specifier annotation,
 987   /// including both the nested-name-specifier
 988   struct NestedNameSpecifierAnnotation {
 989     NestedNameSpecifier *NNS;
 990   };
 991 }
 992
 993 void *Sema::SaveNestedNameSpecifierAnnotation(CXXScopeSpec &SS) {
 994   if (SS.isEmpty() || SS.isInvalid())
 995     return nullptr;
 996
 997   void *Mem = Context.Allocate(
 998       (sizeof(NestedNameSpecifierAnnotation) + SS.location_size()),
 999       alignof(NestedNameSpecifierAnnotation));
1000   NestedNameSpecifierAnnotation *Annotation
1001     = new (Mem) NestedNameSpecifierAnnotation;
1002   Annotation->NNS = SS.getScopeRep();
1003   memcpy(Annotation + 1, SS.location_data(), SS.location_size());
1004   return Annotation;
1005 }
1006
1007 void Sema::RestoreNestedNameSpecifierAnnotation(void *AnnotationPtr,
1008                                                 SourceRange AnnotationRange,
1009                                                 CXXScopeSpec &SS) {
1010   if (!AnnotationPtr) {
1011     SS.SetInvalid(AnnotationRange);
1012     return;
1013   }
1014
1015   NestedNameSpecifierAnnotation *Annotation
1016     = static_cast<NestedNameSpecifierAnnotation *>(AnnotationPtr);
1017   SS.Adopt(NestedNameSpecifierLoc(Annotation->NNS, Annotation + 1));
1018 }
1019
1020 bool Sema::ShouldEnterDeclaratorScope(Scope *S, const CXXScopeSpec &SS) {
1021   assert(SS.isSet() && "Parser passed invalid CXXScopeSpec.");
1022
1023   // Don't enter a declarator context when the current context is an Objective-C
1024   // declaration.
1025   if (isa<ObjCContainerDecl>(CurContext) || isa<ObjCMethodDecl>(CurContext))
1026     return false;
1027
1028   NestedNameSpecifier *Qualifier = SS.getScopeRep();
1029
1030   // There are only two places a well-formed program may qualify a
1031   // declarator: first, when defining a namespace or class member
1032   // out-of-line, and second, when naming an explicitly-qualified
1033   // friend function.  The latter case is governed by
1034   // C++03 [basic.lookup.unqual]p10:
1035   //   In a friend declaration naming a member function, a name used
1036   //   in the function declarator and not part of a template-argument
1037   //   in a template-id is first looked up in the scope of the member
1038   //   function's class. If it is not found, or if the name is part of
1039   //   a template-argument in a template-id, the look up is as
1040   //   described for unqualified names in the definition of the class
1041   //   granting friendship.
1042   // i.e. we don't push a scope unless it's a class member.
1043
1044   switch (Qualifier->getKind()) {
1045   case NestedNameSpecifier::Global:
1046   case NestedNameSpecifier::Namespace:
1047   case NestedNameSpecifier::NamespaceAlias:
1048     // These are always namespace scopes.  We never want to enter a
1049     // namespace scope from anything but a file context.
1050     return CurContext->getRedeclContext()->isFileContext();
1051
1052   case NestedNameSpecifier::Identifier:
1053   case NestedNameSpecifier::TypeSpec:
1054   case NestedNameSpecifier::TypeSpecWithTemplate:
1055   case NestedNameSpecifier::Super:
1056     // These are never namespace scopes.
1057     return true;
1058   }
1059
1060   llvm_unreachable("Invalid NestedNameSpecifier::Kind!");
1061 }
1062
1063 /// ActOnCXXEnterDeclaratorScope - Called when a C++ scope specifier (global
1064 /// scope or nested-name-specifier) is parsed, part of a declarator-id.
1065 /// After this method is called, according to [C++ 3.4.3p3], names should be
1066 /// looked up in the declarator-id's scope, until the declarator is parsed and
1067 /// ActOnCXXExitDeclaratorScope is called.
1068 /// The 'SS' should be a non-empty valid CXXScopeSpec.
1069 bool Sema::ActOnCXXEnterDeclaratorScope(Scope *S, CXXScopeSpec &SS) {
1070   assert(SS.isSet() && "Parser passed invalid CXXScopeSpec.");
1071
1072   if (SS.isInvalid()) return true;
1073
1074   DeclContext *DC = computeDeclContext(SS, true);
1075   if (!DC) return true;
1076
1077   // Before we enter a declarator's context, we need to make sure that
1078   // it is a complete declaration context.
1079   if (!DC->isDependentContext() && RequireCompleteDeclContext(SS, DC))
1080     return true;
1081
1082   EnterDeclaratorContext(S, DC);
1083
1084   // Rebuild the nested name specifier for the new scope.
1085   if (DC->isDependentContext())
1086     RebuildNestedNameSpecifierInCurrentInstantiation(SS);
1087
1088   return false;
1089 }
1090
1091 /// ActOnCXXExitDeclaratorScope - Called when a declarator that previously
1092 /// invoked ActOnCXXEnterDeclaratorScope(), is finished. 'SS' is the same
1093 /// CXXScopeSpec that was passed to ActOnCXXEnterDeclaratorScope as well.
1094 /// Used to indicate that names should revert to being looked up in the
1095 /// defining scope.
1096 void Sema::ActOnCXXExitDeclaratorScope(Scope *S, const CXXScopeSpec &SS) {
1097   assert(SS.isSet() && "Parser passed invalid CXXScopeSpec.");
1098   if (SS.isInvalid())
1099     return;
1100   assert(!SS.isInvalid() && computeDeclContext(SS, true) &&
1101          "exiting declarator scope we never really entered");
1102   ExitDeclaratorContext(S);
1103 }