SemaCXXScopeSpec.cpp revision 198954
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 "Sema.h" 15#include "clang/AST/ASTContext.h" 16#include "clang/AST/DeclTemplate.h" 17#include "clang/AST/ExprCXX.h" 18#include "clang/AST/NestedNameSpecifier.h" 19#include "clang/Basic/PartialDiagnostic.h" 20#include "clang/Parse/DeclSpec.h" 21#include "llvm/ADT/STLExtras.h" 22#include "llvm/Support/raw_ostream.h" 23using namespace clang; 24 25/// \brief Find the current instantiation that associated with the given type. 26static CXXRecordDecl * 27getCurrentInstantiationOf(ASTContext &Context, DeclContext *CurContext, 28 QualType T) { 29 if (T.isNull()) 30 return 0; 31 32 T = Context.getCanonicalType(T); 33 34 for (DeclContext *Ctx = CurContext; Ctx; Ctx = Ctx->getParent()) { 35 // If we've hit a namespace or the global scope, then the 36 // nested-name-specifier can't refer to the current instantiation. 37 if (Ctx->isFileContext()) 38 return 0; 39 40 // Skip non-class contexts. 41 CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(Ctx); 42 if (!Record) 43 continue; 44 45 // If this record type is not dependent, 46 if (!Record->isDependentType()) 47 return 0; 48 49 // C++ [temp.dep.type]p1: 50 // 51 // In the definition of a class template, a nested class of a 52 // class template, a member of a class template, or a member of a 53 // nested class of a class template, a name refers to the current 54 // instantiation if it is 55 // -- the injected-class-name (9) of the class template or 56 // nested class, 57 // -- in the definition of a primary class template, the name 58 // of the class template followed by the template argument 59 // list of the primary template (as described below) 60 // enclosed in <>, 61 // -- in the definition of a nested class of a class template, 62 // the name of the nested class referenced as a member of 63 // the current instantiation, or 64 // -- in the definition of a partial specialization, the name 65 // of the class template followed by the template argument 66 // list of the partial specialization enclosed in <>. If 67 // the nth template parameter is a parameter pack, the nth 68 // template argument is a pack expansion (14.6.3) whose 69 // pattern is the name of the parameter pack. 70 // (FIXME: parameter packs) 71 // 72 // All of these options come down to having the 73 // nested-name-specifier type that is equivalent to the 74 // injected-class-name of one of the types that is currently in 75 // our context. 76 if (Context.getCanonicalType(Context.getTypeDeclType(Record)) == T) 77 return Record; 78 79 if (ClassTemplateDecl *Template = Record->getDescribedClassTemplate()) { 80 QualType InjectedClassName 81 = Template->getInjectedClassNameType(Context); 82 if (T == Context.getCanonicalType(InjectedClassName)) 83 return Template->getTemplatedDecl(); 84 } 85 // FIXME: check for class template partial specializations 86 } 87 88 return 0; 89} 90 91/// \brief Compute the DeclContext that is associated with the given type. 92/// 93/// \param T the type for which we are attempting to find a DeclContext. 94/// 95/// \returns the declaration context represented by the type T, 96/// or NULL if the declaration context cannot be computed (e.g., because it is 97/// dependent and not the current instantiation). 98DeclContext *Sema::computeDeclContext(QualType T) { 99 if (const TagType *Tag = T->getAs<TagType>()) 100 return Tag->getDecl(); 101 102 return ::getCurrentInstantiationOf(Context, CurContext, T); 103} 104 105/// \brief Compute the DeclContext that is associated with the given 106/// scope specifier. 107/// 108/// \param SS the C++ scope specifier as it appears in the source 109/// 110/// \param EnteringContext when true, we will be entering the context of 111/// this scope specifier, so we can retrieve the declaration context of a 112/// class template or class template partial specialization even if it is 113/// not the current instantiation. 114/// 115/// \returns the declaration context represented by the scope specifier @p SS, 116/// or NULL if the declaration context cannot be computed (e.g., because it is 117/// dependent and not the current instantiation). 118DeclContext *Sema::computeDeclContext(const CXXScopeSpec &SS, 119 bool EnteringContext) { 120 if (!SS.isSet() || SS.isInvalid()) 121 return 0; 122 123 NestedNameSpecifier *NNS 124 = static_cast<NestedNameSpecifier *>(SS.getScopeRep()); 125 if (NNS->isDependent()) { 126 // If this nested-name-specifier refers to the current 127 // instantiation, return its DeclContext. 128 if (CXXRecordDecl *Record = getCurrentInstantiationOf(NNS)) 129 return Record; 130 131 if (EnteringContext) { 132 if (const TemplateSpecializationType *SpecType 133 = dyn_cast_or_null<TemplateSpecializationType>(NNS->getAsType())) { 134 // We are entering the context of the nested name specifier, so try to 135 // match the nested name specifier to either a primary class template 136 // or a class template partial specialization. 137 if (ClassTemplateDecl *ClassTemplate 138 = dyn_cast_or_null<ClassTemplateDecl>( 139 SpecType->getTemplateName().getAsTemplateDecl())) { 140 QualType ContextType 141 = Context.getCanonicalType(QualType(SpecType, 0)); 142 143 // If the type of the nested name specifier is the same as the 144 // injected class name of the named class template, we're entering 145 // into that class template definition. 146 QualType Injected = ClassTemplate->getInjectedClassNameType(Context); 147 if (Context.hasSameType(Injected, ContextType)) 148 return ClassTemplate->getTemplatedDecl(); 149 150 // If the type of the nested name specifier is the same as the 151 // type of one of the class template's class template partial 152 // specializations, we're entering into the definition of that 153 // class template partial specialization. 154 if (ClassTemplatePartialSpecializationDecl *PartialSpec 155 = ClassTemplate->findPartialSpecialization(ContextType)) 156 return PartialSpec; 157 } 158 } else if (const RecordType *RecordT 159 = dyn_cast_or_null<RecordType>(NNS->getAsType())) { 160 // The nested name specifier refers to a member of a class template. 161 return RecordT->getDecl(); 162 } 163 } 164 165 return 0; 166 } 167 168 switch (NNS->getKind()) { 169 case NestedNameSpecifier::Identifier: 170 assert(false && "Dependent nested-name-specifier has no DeclContext"); 171 break; 172 173 case NestedNameSpecifier::Namespace: 174 return NNS->getAsNamespace(); 175 176 case NestedNameSpecifier::TypeSpec: 177 case NestedNameSpecifier::TypeSpecWithTemplate: { 178 const TagType *Tag = NNS->getAsType()->getAs<TagType>(); 179 assert(Tag && "Non-tag type in nested-name-specifier"); 180 return Tag->getDecl(); 181 } break; 182 183 case NestedNameSpecifier::Global: 184 return Context.getTranslationUnitDecl(); 185 } 186 187 // Required to silence a GCC warning. 188 return 0; 189} 190 191bool Sema::isDependentScopeSpecifier(const CXXScopeSpec &SS) { 192 if (!SS.isSet() || SS.isInvalid()) 193 return false; 194 195 NestedNameSpecifier *NNS 196 = static_cast<NestedNameSpecifier *>(SS.getScopeRep()); 197 return NNS->isDependent(); 198} 199 200// \brief Determine whether this C++ scope specifier refers to an 201// unknown specialization, i.e., a dependent type that is not the 202// current instantiation. 203bool Sema::isUnknownSpecialization(const CXXScopeSpec &SS) { 204 if (!isDependentScopeSpecifier(SS)) 205 return false; 206 207 NestedNameSpecifier *NNS 208 = static_cast<NestedNameSpecifier *>(SS.getScopeRep()); 209 return getCurrentInstantiationOf(NNS) == 0; 210} 211 212/// \brief If the given nested name specifier refers to the current 213/// instantiation, return the declaration that corresponds to that 214/// current instantiation (C++0x [temp.dep.type]p1). 215/// 216/// \param NNS a dependent nested name specifier. 217CXXRecordDecl *Sema::getCurrentInstantiationOf(NestedNameSpecifier *NNS) { 218 assert(getLangOptions().CPlusPlus && "Only callable in C++"); 219 assert(NNS->isDependent() && "Only dependent nested-name-specifier allowed"); 220 221 if (!NNS->getAsType()) 222 return 0; 223 224 QualType T = QualType(NNS->getAsType(), 0); 225 return ::getCurrentInstantiationOf(Context, CurContext, T); 226} 227 228/// \brief Require that the context specified by SS be complete. 229/// 230/// If SS refers to a type, this routine checks whether the type is 231/// complete enough (or can be made complete enough) for name lookup 232/// into the DeclContext. A type that is not yet completed can be 233/// considered "complete enough" if it is a class/struct/union/enum 234/// that is currently being defined. Or, if we have a type that names 235/// a class template specialization that is not a complete type, we 236/// will attempt to instantiate that class template. 237bool Sema::RequireCompleteDeclContext(const CXXScopeSpec &SS) { 238 if (!SS.isSet() || SS.isInvalid()) 239 return false; 240 241 DeclContext *DC = computeDeclContext(SS, true); 242 if (TagDecl *Tag = dyn_cast<TagDecl>(DC)) { 243 // If we're currently defining this type, then lookup into the 244 // type is okay: don't complain that it isn't complete yet. 245 const TagType *TagT = Context.getTypeDeclType(Tag)->getAs<TagType>(); 246 if (TagT->isBeingDefined()) 247 return false; 248 249 // The type must be complete. 250 return RequireCompleteType(SS.getRange().getBegin(), 251 Context.getTypeDeclType(Tag), 252 PDiag(diag::err_incomplete_nested_name_spec) 253 << SS.getRange()); 254 } 255 256 return false; 257} 258 259/// ActOnCXXGlobalScopeSpecifier - Return the object that represents the 260/// global scope ('::'). 261Sema::CXXScopeTy *Sema::ActOnCXXGlobalScopeSpecifier(Scope *S, 262 SourceLocation CCLoc) { 263 return NestedNameSpecifier::GlobalSpecifier(Context); 264} 265 266/// \brief Determines whether the given declaration is an valid acceptable 267/// result for name lookup of a nested-name-specifier. 268bool Sema::isAcceptableNestedNameSpecifier(NamedDecl *SD) { 269 if (!SD) 270 return false; 271 272 // Namespace and namespace aliases are fine. 273 if (isa<NamespaceDecl>(SD) || isa<NamespaceAliasDecl>(SD)) 274 return true; 275 276 if (!isa<TypeDecl>(SD)) 277 return false; 278 279 // Determine whether we have a class (or, in C++0x, an enum) or 280 // a typedef thereof. If so, build the nested-name-specifier. 281 QualType T = Context.getTypeDeclType(cast<TypeDecl>(SD)); 282 if (T->isDependentType()) 283 return true; 284 else if (TypedefDecl *TD = dyn_cast<TypedefDecl>(SD)) { 285 if (TD->getUnderlyingType()->isRecordType() || 286 (Context.getLangOptions().CPlusPlus0x && 287 TD->getUnderlyingType()->isEnumeralType())) 288 return true; 289 } else if (isa<RecordDecl>(SD) || 290 (Context.getLangOptions().CPlusPlus0x && isa<EnumDecl>(SD))) 291 return true; 292 293 return false; 294} 295 296/// \brief If the given nested-name-specifier begins with a bare identifier 297/// (e.g., Base::), perform name lookup for that identifier as a 298/// nested-name-specifier within the given scope, and return the result of that 299/// name lookup. 300NamedDecl *Sema::FindFirstQualifierInScope(Scope *S, NestedNameSpecifier *NNS) { 301 if (!S || !NNS) 302 return 0; 303 304 while (NNS->getPrefix()) 305 NNS = NNS->getPrefix(); 306 307 if (NNS->getKind() != NestedNameSpecifier::Identifier) 308 return 0; 309 310 LookupResult Found; 311 LookupName(Found, S, NNS->getAsIdentifier(), LookupNestedNameSpecifierName); 312 assert(!Found.isAmbiguous() && "Cannot handle ambiguities here yet"); 313 314 NamedDecl *Result = Found.getAsSingleDecl(Context); 315 if (isAcceptableNestedNameSpecifier(Result)) 316 return Result; 317 318 return 0; 319} 320 321/// \brief Build a new nested-name-specifier for "identifier::", as described 322/// by ActOnCXXNestedNameSpecifier. 323/// 324/// This routine differs only slightly from ActOnCXXNestedNameSpecifier, in 325/// that it contains an extra parameter \p ScopeLookupResult, which provides 326/// the result of name lookup within the scope of the nested-name-specifier 327/// that was computed at template definitino time. 328Sema::CXXScopeTy *Sema::BuildCXXNestedNameSpecifier(Scope *S, 329 const CXXScopeSpec &SS, 330 SourceLocation IdLoc, 331 SourceLocation CCLoc, 332 IdentifierInfo &II, 333 QualType ObjectType, 334 NamedDecl *ScopeLookupResult, 335 bool EnteringContext) { 336 NestedNameSpecifier *Prefix 337 = static_cast<NestedNameSpecifier *>(SS.getScopeRep()); 338 339 // Determine where to perform name lookup 340 DeclContext *LookupCtx = 0; 341 bool isDependent = false; 342 if (!ObjectType.isNull()) { 343 // This nested-name-specifier occurs in a member access expression, e.g., 344 // x->B::f, and we are looking into the type of the object. 345 assert(!SS.isSet() && "ObjectType and scope specifier cannot coexist"); 346 LookupCtx = computeDeclContext(ObjectType); 347 isDependent = ObjectType->isDependentType(); 348 } else if (SS.isSet()) { 349 // This nested-name-specifier occurs after another nested-name-specifier, 350 // so long into the context associated with the prior nested-name-specifier. 351 LookupCtx = computeDeclContext(SS, EnteringContext); 352 isDependent = isDependentScopeSpecifier(SS); 353 } 354 355 LookupResult Found; 356 bool ObjectTypeSearchedInScope = false; 357 if (LookupCtx) { 358 // Perform "qualified" name lookup into the declaration context we 359 // computed, which is either the type of the base of a member access 360 // expression or the declaration context associated with a prior 361 // nested-name-specifier. 362 363 // The declaration context must be complete. 364 if (!LookupCtx->isDependentContext() && RequireCompleteDeclContext(SS)) 365 return 0; 366 367 LookupQualifiedName(Found, LookupCtx, &II, LookupNestedNameSpecifierName, 368 false); 369 370 if (!ObjectType.isNull() && Found.getKind() == LookupResult::NotFound) { 371 // C++ [basic.lookup.classref]p4: 372 // If the id-expression in a class member access is a qualified-id of 373 // the form 374 // 375 // class-name-or-namespace-name::... 376 // 377 // the class-name-or-namespace-name following the . or -> operator is 378 // looked up both in the context of the entire postfix-expression and in 379 // the scope of the class of the object expression. If the name is found 380 // only in the scope of the class of the object expression, the name 381 // shall refer to a class-name. If the name is found only in the 382 // context of the entire postfix-expression, the name shall refer to a 383 // class-name or namespace-name. [...] 384 // 385 // Qualified name lookup into a class will not find a namespace-name, 386 // so we do not need to diagnoste that case specifically. However, 387 // this qualified name lookup may find nothing. In that case, perform 388 // unqualified name lookup in the given scope (if available) or 389 // reconstruct the result from when name lookup was performed at template 390 // definition time. 391 if (S) 392 LookupName(Found, S, &II, LookupNestedNameSpecifierName); 393 else if (ScopeLookupResult) 394 Found.addDecl(ScopeLookupResult); 395 396 ObjectTypeSearchedInScope = true; 397 } 398 } else if (isDependent) { 399 // We were not able to compute the declaration context for a dependent 400 // base object type or prior nested-name-specifier, so this 401 // nested-name-specifier refers to an unknown specialization. Just build 402 // a dependent nested-name-specifier. 403 if (!Prefix) 404 return NestedNameSpecifier::Create(Context, &II); 405 406 return NestedNameSpecifier::Create(Context, Prefix, &II); 407 } else { 408 // Perform unqualified name lookup in the current scope. 409 LookupName(Found, S, &II, LookupNestedNameSpecifierName); 410 } 411 412 // FIXME: Deal with ambiguities cleanly. 413 NamedDecl *SD = Found.getAsSingleDecl(Context); 414 if (isAcceptableNestedNameSpecifier(SD)) { 415 if (!ObjectType.isNull() && !ObjectTypeSearchedInScope) { 416 // C++ [basic.lookup.classref]p4: 417 // [...] If the name is found in both contexts, the 418 // class-name-or-namespace-name shall refer to the same entity. 419 // 420 // We already found the name in the scope of the object. Now, look 421 // into the current scope (the scope of the postfix-expression) to 422 // see if we can find the same name there. As above, if there is no 423 // scope, reconstruct the result from the template instantiation itself. 424 NamedDecl *OuterDecl; 425 if (S) { 426 LookupResult FoundOuter; 427 LookupName(FoundOuter, S, &II, LookupNestedNameSpecifierName); 428 // FIXME: Handle ambiguities! 429 OuterDecl = FoundOuter.getAsSingleDecl(Context); 430 } else 431 OuterDecl = ScopeLookupResult; 432 433 if (isAcceptableNestedNameSpecifier(OuterDecl) && 434 OuterDecl->getCanonicalDecl() != SD->getCanonicalDecl() && 435 (!isa<TypeDecl>(OuterDecl) || !isa<TypeDecl>(SD) || 436 !Context.hasSameType( 437 Context.getTypeDeclType(cast<TypeDecl>(OuterDecl)), 438 Context.getTypeDeclType(cast<TypeDecl>(SD))))) { 439 Diag(IdLoc, diag::err_nested_name_member_ref_lookup_ambiguous) 440 << &II; 441 Diag(SD->getLocation(), diag::note_ambig_member_ref_object_type) 442 << ObjectType; 443 Diag(OuterDecl->getLocation(), diag::note_ambig_member_ref_scope); 444 445 // Fall through so that we'll pick the name we found in the object type, 446 // since that's probably what the user wanted anyway. 447 } 448 } 449 450 if (NamespaceDecl *Namespace = dyn_cast<NamespaceDecl>(SD)) 451 return NestedNameSpecifier::Create(Context, Prefix, Namespace); 452 453 // FIXME: It would be nice to maintain the namespace alias name, then 454 // see through that alias when resolving the nested-name-specifier down to 455 // a declaration context. 456 if (NamespaceAliasDecl *Alias = dyn_cast<NamespaceAliasDecl>(SD)) 457 return NestedNameSpecifier::Create(Context, Prefix, 458 459 Alias->getNamespace()); 460 461 QualType T = Context.getTypeDeclType(cast<TypeDecl>(SD)); 462 return NestedNameSpecifier::Create(Context, Prefix, false, 463 T.getTypePtr()); 464 } 465 466 // If we didn't find anything during our lookup, try again with 467 // ordinary name lookup, which can help us produce better error 468 // messages. 469 if (!SD) { 470 Found.clear(); 471 LookupName(Found, S, &II, LookupOrdinaryName); 472 SD = Found.getAsSingleDecl(Context); 473 } 474 475 unsigned DiagID; 476 if (SD) 477 DiagID = diag::err_expected_class_or_namespace; 478 else if (SS.isSet()) { 479 Diag(IdLoc, diag::err_no_member) << &II << LookupCtx << SS.getRange(); 480 return 0; 481 } else 482 DiagID = diag::err_undeclared_var_use; 483 484 if (SS.isSet()) 485 Diag(IdLoc, DiagID) << &II << SS.getRange(); 486 else 487 Diag(IdLoc, DiagID) << &II; 488 489 return 0; 490} 491 492/// ActOnCXXNestedNameSpecifier - Called during parsing of a 493/// nested-name-specifier. e.g. for "foo::bar::" we parsed "foo::" and now 494/// we want to resolve "bar::". 'SS' is empty or the previously parsed 495/// nested-name part ("foo::"), 'IdLoc' is the source location of 'bar', 496/// 'CCLoc' is the location of '::' and 'II' is the identifier for 'bar'. 497/// Returns a CXXScopeTy* object representing the C++ scope. 498Sema::CXXScopeTy *Sema::ActOnCXXNestedNameSpecifier(Scope *S, 499 const CXXScopeSpec &SS, 500 SourceLocation IdLoc, 501 SourceLocation CCLoc, 502 IdentifierInfo &II, 503 TypeTy *ObjectTypePtr, 504 bool EnteringContext) { 505 return BuildCXXNestedNameSpecifier(S, SS, IdLoc, CCLoc, II, 506 QualType::getFromOpaquePtr(ObjectTypePtr), 507 /*ScopeLookupResult=*/0, EnteringContext); 508} 509 510Sema::CXXScopeTy *Sema::ActOnCXXNestedNameSpecifier(Scope *S, 511 const CXXScopeSpec &SS, 512 TypeTy *Ty, 513 SourceRange TypeRange, 514 SourceLocation CCLoc) { 515 NestedNameSpecifier *Prefix 516 = static_cast<NestedNameSpecifier *>(SS.getScopeRep()); 517 QualType T = GetTypeFromParser(Ty); 518 return NestedNameSpecifier::Create(Context, Prefix, /*FIXME:*/false, 519 T.getTypePtr()); 520} 521 522/// ActOnCXXEnterDeclaratorScope - Called when a C++ scope specifier (global 523/// scope or nested-name-specifier) is parsed, part of a declarator-id. 524/// After this method is called, according to [C++ 3.4.3p3], names should be 525/// looked up in the declarator-id's scope, until the declarator is parsed and 526/// ActOnCXXExitDeclaratorScope is called. 527/// The 'SS' should be a non-empty valid CXXScopeSpec. 528bool Sema::ActOnCXXEnterDeclaratorScope(Scope *S, const CXXScopeSpec &SS) { 529 assert(SS.isSet() && "Parser passed invalid CXXScopeSpec."); 530 if (DeclContext *DC = computeDeclContext(SS, true)) { 531 // Before we enter a declarator's context, we need to make sure that 532 // it is a complete declaration context. 533 if (!DC->isDependentContext() && RequireCompleteDeclContext(SS)) 534 return true; 535 536 EnterDeclaratorContext(S, DC); 537 } 538 539 return false; 540} 541 542/// ActOnCXXExitDeclaratorScope - Called when a declarator that previously 543/// invoked ActOnCXXEnterDeclaratorScope(), is finished. 'SS' is the same 544/// CXXScopeSpec that was passed to ActOnCXXEnterDeclaratorScope as well. 545/// Used to indicate that names should revert to being looked up in the 546/// defining scope. 547void Sema::ActOnCXXExitDeclaratorScope(Scope *S, const CXXScopeSpec &SS) { 548 assert(SS.isSet() && "Parser passed invalid CXXScopeSpec."); 549 if (SS.isInvalid()) 550 return; 551 if (computeDeclContext(SS, true)) 552 ExitDeclaratorContext(S); 553} 554