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 diagnoseTypo(Corrected, PDiag(diag::err_no_member_suggest) 501 << Name << LookupCtx << DroppedSpecifier 502 << SS.getRange()); 503 } else 504 diagnoseTypo(Corrected, PDiag(diag::err_undeclared_var_use_suggest) 505 << Name); 506 507 if (NamedDecl *ND = Corrected.getCorrectionDecl()) 508 Found.addDecl(ND); 509 Found.setLookupName(Corrected.getCorrection()); 510 } else { 511 Found.setLookupName(&Identifier); 512 } 513 } 514 515 NamedDecl *SD = Found.getAsSingle<NamedDecl>(); 516 if (isAcceptableNestedNameSpecifier(SD)) { 517 if (!ObjectType.isNull() && !ObjectTypeSearchedInScope && 518 !getLangOpts().CPlusPlus11) { 519 // C++03 [basic.lookup.classref]p4: 520 // [...] If the name is found in both contexts, the 521 // class-name-or-namespace-name shall refer to the same entity. 522 // 523 // We already found the name in the scope of the object. Now, look 524 // into the current scope (the scope of the postfix-expression) to 525 // see if we can find the same name there. As above, if there is no 526 // scope, reconstruct the result from the template instantiation itself. 527 // 528 // Note that C++11 does *not* perform this redundant lookup. 529 NamedDecl *OuterDecl; 530 if (S) { 531 LookupResult FoundOuter(*this, &Identifier, IdentifierLoc, 532 LookupNestedNameSpecifierName); 533 LookupName(FoundOuter, S); 534 OuterDecl = FoundOuter.getAsSingle<NamedDecl>(); 535 } else 536 OuterDecl = ScopeLookupResult; 537 538 if (isAcceptableNestedNameSpecifier(OuterDecl) && 539 OuterDecl->getCanonicalDecl() != SD->getCanonicalDecl() && 540 (!isa<TypeDecl>(OuterDecl) || !isa<TypeDecl>(SD) || 541 !Context.hasSameType( 542 Context.getTypeDeclType(cast<TypeDecl>(OuterDecl)), 543 Context.getTypeDeclType(cast<TypeDecl>(SD))))) { 544 if (ErrorRecoveryLookup) 545 return true; 546 547 Diag(IdentifierLoc, 548 diag::err_nested_name_member_ref_lookup_ambiguous) 549 << &Identifier; 550 Diag(SD->getLocation(), diag::note_ambig_member_ref_object_type) 551 << ObjectType; 552 Diag(OuterDecl->getLocation(), diag::note_ambig_member_ref_scope); 553 554 // Fall through so that we'll pick the name we found in the object 555 // type, since that's probably what the user wanted anyway. 556 } 557 } 558 559 // If we're just performing this lookup for error-recovery purposes, 560 // don't extend the nested-name-specifier. Just return now. 561 if (ErrorRecoveryLookup) 562 return false; 563 564 if (NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(SD)) { 565 SS.Extend(Context, Namespace, IdentifierLoc, CCLoc); 566 return false; 567 } 568 569 if (NamespaceAliasDecl *Alias = dyn_cast<NamespaceAliasDecl>(SD)) { 570 SS.Extend(Context, Alias, IdentifierLoc, CCLoc); 571 return false; 572 } 573 574 QualType T = Context.getTypeDeclType(cast<TypeDecl>(SD)); 575 TypeLocBuilder TLB; 576 if (isa<InjectedClassNameType>(T)) { 577 InjectedClassNameTypeLoc InjectedTL 578 = TLB.push<InjectedClassNameTypeLoc>(T); 579 InjectedTL.setNameLoc(IdentifierLoc); 580 } else if (isa<RecordType>(T)) { 581 RecordTypeLoc RecordTL = TLB.push<RecordTypeLoc>(T); 582 RecordTL.setNameLoc(IdentifierLoc); 583 } else if (isa<TypedefType>(T)) { 584 TypedefTypeLoc TypedefTL = TLB.push<TypedefTypeLoc>(T); 585 TypedefTL.setNameLoc(IdentifierLoc); 586 } else if (isa<EnumType>(T)) { 587 EnumTypeLoc EnumTL = TLB.push<EnumTypeLoc>(T); 588 EnumTL.setNameLoc(IdentifierLoc); 589 } else if (isa<TemplateTypeParmType>(T)) { 590 TemplateTypeParmTypeLoc TemplateTypeTL 591 = TLB.push<TemplateTypeParmTypeLoc>(T); 592 TemplateTypeTL.setNameLoc(IdentifierLoc); 593 } else if (isa<UnresolvedUsingType>(T)) { 594 UnresolvedUsingTypeLoc UnresolvedTL 595 = TLB.push<UnresolvedUsingTypeLoc>(T); 596 UnresolvedTL.setNameLoc(IdentifierLoc); 597 } else if (isa<SubstTemplateTypeParmType>(T)) { 598 SubstTemplateTypeParmTypeLoc TL 599 = TLB.push<SubstTemplateTypeParmTypeLoc>(T); 600 TL.setNameLoc(IdentifierLoc); 601 } else if (isa<SubstTemplateTypeParmPackType>(T)) { 602 SubstTemplateTypeParmPackTypeLoc TL 603 = TLB.push<SubstTemplateTypeParmPackTypeLoc>(T); 604 TL.setNameLoc(IdentifierLoc); 605 } else { 606 llvm_unreachable("Unhandled TypeDecl node in nested-name-specifier"); 607 } 608 609 if (T->isEnumeralType()) 610 Diag(IdentifierLoc, diag::warn_cxx98_compat_enum_nested_name_spec); 611 612 SS.Extend(Context, SourceLocation(), TLB.getTypeLocInContext(Context, T), 613 CCLoc); 614 return false; 615 } 616 617 // Otherwise, we have an error case. If we don't want diagnostics, just 618 // return an error now. 619 if (ErrorRecoveryLookup) 620 return true; 621 622 // If we didn't find anything during our lookup, try again with 623 // ordinary name lookup, which can help us produce better error 624 // messages. 625 if (Found.empty()) { 626 Found.clear(LookupOrdinaryName); 627 LookupName(Found, S); 628 } 629 630 // In Microsoft mode, if we are within a templated function and we can't 631 // resolve Identifier, then extend the SS with Identifier. This will have 632 // the effect of resolving Identifier during template instantiation. 633 // The goal is to be able to resolve a function call whose 634 // nested-name-specifier is located inside a dependent base class. 635 // Example: 636 // 637 // class C { 638 // public: 639 // static void foo2() { } 640 // }; 641 // template <class T> class A { public: typedef C D; }; 642 // 643 // template <class T> class B : public A<T> { 644 // public: 645 // void foo() { D::foo2(); } 646 // }; 647 if (getLangOpts().MicrosoftMode) { 648 DeclContext *DC = LookupCtx ? LookupCtx : CurContext; 649 if (DC->isDependentContext() && DC->isFunctionOrMethod()) { 650 SS.Extend(Context, &Identifier, IdentifierLoc, CCLoc); 651 return false; 652 } 653 } 654 655 unsigned DiagID; 656 if (!Found.empty()) 657 DiagID = diag::err_expected_class_or_namespace; 658 else if (SS.isSet()) { 659 Diag(IdentifierLoc, diag::err_no_member) 660 << &Identifier << LookupCtx << SS.getRange(); 661 return true; 662 } else 663 DiagID = diag::err_undeclared_var_use; 664 665 if (SS.isSet()) 666 Diag(IdentifierLoc, DiagID) << &Identifier << SS.getRange(); 667 else 668 Diag(IdentifierLoc, DiagID) << &Identifier; 669 670 return true; 671 } 672 673 bool Sema::ActOnCXXNestedNameSpecifier(Scope *S, 674 IdentifierInfo &Identifier, 675 SourceLocation IdentifierLoc, 676 SourceLocation CCLoc, 677 ParsedType ObjectType, 678 bool EnteringContext, 679 CXXScopeSpec &SS) { 680 if (SS.isInvalid()) 681 return true; 682 683 return BuildCXXNestedNameSpecifier(S, Identifier, IdentifierLoc, CCLoc, 684 GetTypeFromParser(ObjectType), 685 EnteringContext, SS, 686 /*ScopeLookupResult=*/0, false); 687 } 688 689 bool Sema::ActOnCXXNestedNameSpecifierDecltype(CXXScopeSpec &SS, 690 const DeclSpec &DS, 691 SourceLocation ColonColonLoc) { 692 if (SS.isInvalid() || DS.getTypeSpecType() == DeclSpec::TST_error) 693 return true; 694 695 assert(DS.getTypeSpecType() == DeclSpec::TST_decltype); 696 697 QualType T = BuildDecltypeType(DS.getRepAsExpr(), DS.getTypeSpecTypeLoc()); 698 if (!T->isDependentType() && !T->getAs<TagType>()) { 699 Diag(DS.getTypeSpecTypeLoc(), diag::err_expected_class) 700 << T << getLangOpts().CPlusPlus; 701 return true; 702 } 703 704 TypeLocBuilder TLB; 705 DecltypeTypeLoc DecltypeTL = TLB.push<DecltypeTypeLoc>(T); 706 DecltypeTL.setNameLoc(DS.getTypeSpecTypeLoc()); 707 SS.Extend(Context, SourceLocation(), TLB.getTypeLocInContext(Context, T), 708 ColonColonLoc); 709 return false; 710 } 711 712 /// IsInvalidUnlessNestedName - This method is used for error recovery 713 /// purposes to determine whether the specified identifier is only valid as 714 /// a nested name specifier, for example a namespace name. It is 715 /// conservatively correct to always return false from this method. 716 /// 717 /// The arguments are the same as those passed to ActOnCXXNestedNameSpecifier. 718 bool Sema::IsInvalidUnlessNestedName(Scope *S, CXXScopeSpec &SS, 719 IdentifierInfo &Identifier, 720 SourceLocation IdentifierLoc, 721 SourceLocation ColonLoc, 722 ParsedType ObjectType, 723 bool EnteringContext) { 724 if (SS.isInvalid()) 725 return false; 726 727 return !BuildCXXNestedNameSpecifier(S, Identifier, IdentifierLoc, ColonLoc, 728 GetTypeFromParser(ObjectType), 729 EnteringContext, SS, 730 /*ScopeLookupResult=*/0, true); 731 } 732 733 bool Sema::ActOnCXXNestedNameSpecifier(Scope *S, 734 CXXScopeSpec &SS, 735 SourceLocation TemplateKWLoc, 736 TemplateTy Template, 737 SourceLocation TemplateNameLoc, 738 SourceLocation LAngleLoc, 739 ASTTemplateArgsPtr TemplateArgsIn, 740 SourceLocation RAngleLoc, 741 SourceLocation CCLoc, 742 bool EnteringContext) { 743 if (SS.isInvalid()) 744 return true; 745 746 // Translate the parser's template argument list in our AST format. 747 TemplateArgumentListInfo TemplateArgs(LAngleLoc, RAngleLoc); 748 translateTemplateArguments(TemplateArgsIn, TemplateArgs); 749 750 if (DependentTemplateName *DTN = Template.get().getAsDependentTemplateName()){ 751 // Handle a dependent template specialization for which we cannot resolve 752 // the template name. 753 assert(DTN->getQualifier() == SS.getScopeRep()); 754 QualType T = Context.getDependentTemplateSpecializationType(ETK_None, 755 DTN->getQualifier(), 756 DTN->getIdentifier(), 757 TemplateArgs); 758 759 // Create source-location information for this type. 760 TypeLocBuilder Builder; 761 DependentTemplateSpecializationTypeLoc SpecTL 762 = Builder.push<DependentTemplateSpecializationTypeLoc>(T); 763 SpecTL.setElaboratedKeywordLoc(SourceLocation()); 764 SpecTL.setQualifierLoc(SS.getWithLocInContext(Context)); 765 SpecTL.setTemplateKeywordLoc(TemplateKWLoc); 766 SpecTL.setTemplateNameLoc(TemplateNameLoc); 767 SpecTL.setLAngleLoc(LAngleLoc); 768 SpecTL.setRAngleLoc(RAngleLoc); 769 for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I) 770 SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo()); 771 772 SS.Extend(Context, TemplateKWLoc, Builder.getTypeLocInContext(Context, T), 773 CCLoc); 774 return false; 775 } 776 777 778 if (Template.get().getAsOverloadedTemplate() || 779 isa<FunctionTemplateDecl>(Template.get().getAsTemplateDecl())) { 780 SourceRange R(TemplateNameLoc, RAngleLoc); 781 if (SS.getRange().isValid()) 782 R.setBegin(SS.getRange().getBegin()); 783 784 Diag(CCLoc, diag::err_non_type_template_in_nested_name_specifier) 785 << Template.get() << R; 786 NoteAllFoundTemplates(Template.get()); 787 return true; 788 } 789 790 // We were able to resolve the template name to an actual template. 791 // Build an appropriate nested-name-specifier. 792 QualType T = CheckTemplateIdType(Template.get(), TemplateNameLoc, 793 TemplateArgs); 794 if (T.isNull()) 795 return true; 796 797 // Alias template specializations can produce types which are not valid 798 // nested name specifiers. 799 if (!T->isDependentType() && !T->getAs<TagType>()) { 800 Diag(TemplateNameLoc, diag::err_nested_name_spec_non_tag) << T; 801 NoteAllFoundTemplates(Template.get()); 802 return true; 803 } 804 805 // Provide source-location information for the template specialization type. 806 TypeLocBuilder Builder; 807 TemplateSpecializationTypeLoc SpecTL 808 = Builder.push<TemplateSpecializationTypeLoc>(T); 809 SpecTL.setTemplateKeywordLoc(TemplateKWLoc); 810 SpecTL.setTemplateNameLoc(TemplateNameLoc); 811 SpecTL.setLAngleLoc(LAngleLoc); 812 SpecTL.setRAngleLoc(RAngleLoc); 813 for (unsigned I = 0, N = TemplateArgs.size(); I != N; ++I) 814 SpecTL.setArgLocInfo(I, TemplateArgs[I].getLocInfo()); 815 816 817 SS.Extend(Context, TemplateKWLoc, Builder.getTypeLocInContext(Context, T), 818 CCLoc); 819 return false; 820 } 821 822 namespace { 823 /// \brief A structure that stores a nested-name-specifier annotation, 824 /// including both the nested-name-specifier 825 struct NestedNameSpecifierAnnotation { 826 NestedNameSpecifier *NNS; 827 }; 828 } 829 830 void *Sema::SaveNestedNameSpecifierAnnotation(CXXScopeSpec &SS) { 831 if (SS.isEmpty() || SS.isInvalid()) 832 return 0; 833 834 void *Mem = Context.Allocate((sizeof(NestedNameSpecifierAnnotation) + 835 SS.location_size()), 836 llvm::alignOf<NestedNameSpecifierAnnotation>()); 837 NestedNameSpecifierAnnotation *Annotation 838 = new (Mem) NestedNameSpecifierAnnotation; 839 Annotation->NNS = SS.getScopeRep(); 840 memcpy(Annotation + 1, SS.location_data(), SS.location_size()); 841 return Annotation; 842 } 843 844 void Sema::RestoreNestedNameSpecifierAnnotation(void *AnnotationPtr, 845 SourceRange AnnotationRange, 846 CXXScopeSpec &SS) { 847 if (!AnnotationPtr) { 848 SS.SetInvalid(AnnotationRange); 849 return; 850 } 851 852 NestedNameSpecifierAnnotation *Annotation 853 = static_cast<NestedNameSpecifierAnnotation *>(AnnotationPtr); 854 SS.Adopt(NestedNameSpecifierLoc(Annotation->NNS, Annotation + 1)); 855 } 856 857 bool Sema::ShouldEnterDeclaratorScope(Scope *S, const CXXScopeSpec &SS) { 858 assert(SS.isSet() && "Parser passed invalid CXXScopeSpec."); 859 860 NestedNameSpecifier *Qualifier = SS.getScopeRep(); 861 862 // There are only two places a well-formed program may qualify a 863 // declarator: first, when defining a namespace or class member 864 // out-of-line, and second, when naming an explicitly-qualified 865 // friend function. The latter case is governed by 866 // C++03 [basic.lookup.unqual]p10: 867 // In a friend declaration naming a member function, a name used 868 // in the function declarator and not part of a template-argument 869 // in a template-id is first looked up in the scope of the member 870 // function's class. If it is not found, or if the name is part of 871 // a template-argument in a template-id, the look up is as 872 // described for unqualified names in the definition of the class 873 // granting friendship. 874 // i.e. we don't push a scope unless it's a class member. 875 876 switch (Qualifier->getKind()) { 877 case NestedNameSpecifier::Global: 878 case NestedNameSpecifier::Namespace: 879 case NestedNameSpecifier::NamespaceAlias: 880 // These are always namespace scopes. We never want to enter a 881 // namespace scope from anything but a file context. 882 return CurContext->getRedeclContext()->isFileContext(); 883 884 case NestedNameSpecifier::Identifier: 885 case NestedNameSpecifier::TypeSpec: 886 case NestedNameSpecifier::TypeSpecWithTemplate: 887 // These are never namespace scopes. 888 return true; 889 } 890 891 llvm_unreachable("Invalid NestedNameSpecifier::Kind!"); 892 } 893 894 /// ActOnCXXEnterDeclaratorScope - Called when a C++ scope specifier (global 895 /// scope or nested-name-specifier) is parsed, part of a declarator-id. 896 /// After this method is called, according to [C++ 3.4.3p3], names should be 897 /// looked up in the declarator-id's scope, until the declarator is parsed and 898 /// ActOnCXXExitDeclaratorScope is called. 899 /// The 'SS' should be a non-empty valid CXXScopeSpec. 900 bool Sema::ActOnCXXEnterDeclaratorScope(Scope *S, CXXScopeSpec &SS) { 901 assert(SS.isSet() && "Parser passed invalid CXXScopeSpec."); 902 903 if (SS.isInvalid()) return true; 904 905 DeclContext *DC = computeDeclContext(SS, true); 906 if (!DC) return true; 907 908 // Before we enter a declarator's context, we need to make sure that 909 // it is a complete declaration context. 910 if (!DC->isDependentContext() && RequireCompleteDeclContext(SS, DC)) 911 return true; 912 913 EnterDeclaratorContext(S, DC); 914 915 // Rebuild the nested name specifier for the new scope. 916 if (DC->isDependentContext()) 917 RebuildNestedNameSpecifierInCurrentInstantiation(SS); 918 919 return false; 920 } 921 922 /// ActOnCXXExitDeclaratorScope - Called when a declarator that previously 923 /// invoked ActOnCXXEnterDeclaratorScope(), is finished. 'SS' is the same 924 /// CXXScopeSpec that was passed to ActOnCXXEnterDeclaratorScope as well. 925 /// Used to indicate that names should revert to being looked up in the 926 /// defining scope. 927 void Sema::ActOnCXXExitDeclaratorScope(Scope *S, const CXXScopeSpec &SS) { 928 assert(SS.isSet() && "Parser passed invalid CXXScopeSpec."); 929 if (SS.isInvalid()) 930 return; 931 assert(!SS.isInvalid() && computeDeclContext(SS, true) && 932 "exiting declarator scope we never really entered"); 933 ExitDeclaratorContext(S); 934 } 935