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