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

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