Decl.cpp revision 45975531e3e93033b41e04974340e4e8f7481d61
1//===--- Decl.cpp - Declaration AST Node Implementation -------------------===// 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 the Decl subclasses. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/AST/Decl.h" 15#include "clang/AST/DeclCXX.h" 16#include "clang/AST/DeclObjC.h" 17#include "clang/AST/DeclTemplate.h" 18#include "clang/AST/ASTContext.h" 19#include "clang/AST/TypeLoc.h" 20#include "clang/AST/Stmt.h" 21#include "clang/AST/Expr.h" 22#include "clang/AST/ExprCXX.h" 23#include "clang/AST/PrettyPrinter.h" 24#include "clang/Basic/Builtins.h" 25#include "clang/Basic/IdentifierTable.h" 26#include "clang/Basic/Specifiers.h" 27#include "llvm/Support/ErrorHandling.h" 28 29using namespace clang; 30 31//===----------------------------------------------------------------------===// 32// NamedDecl Implementation 33//===----------------------------------------------------------------------===// 34 35/// \brief Get the most restrictive linkage for the types in the given 36/// template parameter list. 37static Linkage 38getLinkageForTemplateParameterList(const TemplateParameterList *Params) { 39 Linkage L = ExternalLinkage; 40 for (TemplateParameterList::const_iterator P = Params->begin(), 41 PEnd = Params->end(); 42 P != PEnd; ++P) { 43 if (NonTypeTemplateParmDecl *NTTP = dyn_cast<NonTypeTemplateParmDecl>(*P)) 44 if (!NTTP->getType()->isDependentType()) { 45 L = minLinkage(L, NTTP->getType()->getLinkage()); 46 continue; 47 } 48 49 if (TemplateTemplateParmDecl *TTP 50 = dyn_cast<TemplateTemplateParmDecl>(*P)) { 51 L = minLinkage(L, 52 getLinkageForTemplateParameterList(TTP->getTemplateParameters())); 53 } 54 } 55 56 return L; 57} 58 59/// \brief Get the most restrictive linkage for the types and 60/// declarations in the given template argument list. 61static Linkage getLinkageForTemplateArgumentList(const TemplateArgument *Args, 62 unsigned NumArgs) { 63 Linkage L = ExternalLinkage; 64 65 for (unsigned I = 0; I != NumArgs; ++I) { 66 switch (Args[I].getKind()) { 67 case TemplateArgument::Null: 68 case TemplateArgument::Integral: 69 case TemplateArgument::Expression: 70 break; 71 72 case TemplateArgument::Type: 73 L = minLinkage(L, Args[I].getAsType()->getLinkage()); 74 break; 75 76 case TemplateArgument::Declaration: 77 if (NamedDecl *ND = dyn_cast<NamedDecl>(Args[I].getAsDecl())) 78 L = minLinkage(L, ND->getLinkage()); 79 if (ValueDecl *VD = dyn_cast<ValueDecl>(Args[I].getAsDecl())) 80 L = minLinkage(L, VD->getType()->getLinkage()); 81 break; 82 83 case TemplateArgument::Template: 84 if (TemplateDecl *Template 85 = Args[I].getAsTemplate().getAsTemplateDecl()) 86 L = minLinkage(L, Template->getLinkage()); 87 break; 88 89 case TemplateArgument::Pack: 90 L = minLinkage(L, 91 getLinkageForTemplateArgumentList(Args[I].pack_begin(), 92 Args[I].pack_size())); 93 break; 94 } 95 } 96 97 return L; 98} 99 100static Linkage 101getLinkageForTemplateArgumentList(const TemplateArgumentList &TArgs) { 102 return getLinkageForTemplateArgumentList(TArgs.getFlatArgumentList(), 103 TArgs.flat_size()); 104} 105 106static Linkage getLinkageForNamespaceScopeDecl(const NamedDecl *D) { 107 assert(D->getDeclContext()->getLookupContext()->isFileContext() && 108 "Not a name having namespace scope"); 109 ASTContext &Context = D->getASTContext(); 110 111 // C++ [basic.link]p3: 112 // A name having namespace scope (3.3.6) has internal linkage if it 113 // is the name of 114 // - an object, reference, function or function template that is 115 // explicitly declared static; or, 116 // (This bullet corresponds to C99 6.2.2p3.) 117 if (const VarDecl *Var = dyn_cast<VarDecl>(D)) { 118 // Explicitly declared static. 119 if (Var->getStorageClass() == VarDecl::Static) 120 return InternalLinkage; 121 122 // - an object or reference that is explicitly declared const 123 // and neither explicitly declared extern nor previously 124 // declared to have external linkage; or 125 // (there is no equivalent in C99) 126 if (Context.getLangOptions().CPlusPlus && 127 Var->getType().isConstant(Context) && 128 Var->getStorageClass() != VarDecl::Extern && 129 Var->getStorageClass() != VarDecl::PrivateExtern) { 130 bool FoundExtern = false; 131 for (const VarDecl *PrevVar = Var->getPreviousDeclaration(); 132 PrevVar && !FoundExtern; 133 PrevVar = PrevVar->getPreviousDeclaration()) 134 if (isExternalLinkage(PrevVar->getLinkage())) 135 FoundExtern = true; 136 137 if (!FoundExtern) 138 return InternalLinkage; 139 } 140 } else if (isa<FunctionDecl>(D) || isa<FunctionTemplateDecl>(D)) { 141 // C++ [temp]p4: 142 // A non-member function template can have internal linkage; any 143 // other template name shall have external linkage. 144 const FunctionDecl *Function = 0; 145 if (const FunctionTemplateDecl *FunTmpl 146 = dyn_cast<FunctionTemplateDecl>(D)) 147 Function = FunTmpl->getTemplatedDecl(); 148 else 149 Function = cast<FunctionDecl>(D); 150 151 // Explicitly declared static. 152 if (Function->getStorageClass() == FunctionDecl::Static) 153 return InternalLinkage; 154 } else if (const FieldDecl *Field = dyn_cast<FieldDecl>(D)) { 155 // - a data member of an anonymous union. 156 if (cast<RecordDecl>(Field->getDeclContext())->isAnonymousStructOrUnion()) 157 return InternalLinkage; 158 } 159 160 // C++ [basic.link]p4: 161 162 // A name having namespace scope has external linkage if it is the 163 // name of 164 // 165 // - an object or reference, unless it has internal linkage; or 166 if (const VarDecl *Var = dyn_cast<VarDecl>(D)) { 167 if (!Context.getLangOptions().CPlusPlus && 168 (Var->getStorageClass() == VarDecl::Extern || 169 Var->getStorageClass() == VarDecl::PrivateExtern)) { 170 // C99 6.2.2p4: 171 // For an identifier declared with the storage-class specifier 172 // extern in a scope in which a prior declaration of that 173 // identifier is visible, if the prior declaration specifies 174 // internal or external linkage, the linkage of the identifier 175 // at the later declaration is the same as the linkage 176 // specified at the prior declaration. If no prior declaration 177 // is visible, or if the prior declaration specifies no 178 // linkage, then the identifier has external linkage. 179 if (const VarDecl *PrevVar = Var->getPreviousDeclaration()) { 180 if (Linkage L = PrevVar->getLinkage()) 181 return L; 182 } 183 } 184 185 // C99 6.2.2p5: 186 // If the declaration of an identifier for an object has file 187 // scope and no storage-class specifier, its linkage is 188 // external. 189 if (Var->isInAnonymousNamespace()) 190 return UniqueExternalLinkage; 191 192 return ExternalLinkage; 193 } 194 195 // - a function, unless it has internal linkage; or 196 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(D)) { 197 // C99 6.2.2p5: 198 // If the declaration of an identifier for a function has no 199 // storage-class specifier, its linkage is determined exactly 200 // as if it were declared with the storage-class specifier 201 // extern. 202 if (!Context.getLangOptions().CPlusPlus && 203 (Function->getStorageClass() == FunctionDecl::Extern || 204 Function->getStorageClass() == FunctionDecl::PrivateExtern || 205 Function->getStorageClass() == FunctionDecl::None)) { 206 // C99 6.2.2p4: 207 // For an identifier declared with the storage-class specifier 208 // extern in a scope in which a prior declaration of that 209 // identifier is visible, if the prior declaration specifies 210 // internal or external linkage, the linkage of the identifier 211 // at the later declaration is the same as the linkage 212 // specified at the prior declaration. If no prior declaration 213 // is visible, or if the prior declaration specifies no 214 // linkage, then the identifier has external linkage. 215 if (const FunctionDecl *PrevFunc = Function->getPreviousDeclaration()) { 216 if (Linkage L = PrevFunc->getLinkage()) 217 return L; 218 } 219 } 220 221 if (Function->isInAnonymousNamespace()) 222 return UniqueExternalLinkage; 223 224 if (FunctionTemplateSpecializationInfo *SpecInfo 225 = Function->getTemplateSpecializationInfo()) { 226 Linkage L = SpecInfo->getTemplate()->getLinkage(); 227 const TemplateArgumentList &TemplateArgs = *SpecInfo->TemplateArguments; 228 L = minLinkage(L, getLinkageForTemplateArgumentList(TemplateArgs)); 229 return L; 230 } 231 232 return ExternalLinkage; 233 } 234 235 // - a named class (Clause 9), or an unnamed class defined in a 236 // typedef declaration in which the class has the typedef name 237 // for linkage purposes (7.1.3); or 238 // - a named enumeration (7.2), or an unnamed enumeration 239 // defined in a typedef declaration in which the enumeration 240 // has the typedef name for linkage purposes (7.1.3); or 241 if (const TagDecl *Tag = dyn_cast<TagDecl>(D)) 242 if (Tag->getDeclName() || Tag->getTypedefForAnonDecl()) { 243 if (Tag->isInAnonymousNamespace()) 244 return UniqueExternalLinkage; 245 246 // If this is a class template specialization, consider the 247 // linkage of the template and template arguments. 248 if (const ClassTemplateSpecializationDecl *Spec 249 = dyn_cast<ClassTemplateSpecializationDecl>(Tag)) { 250 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs(); 251 Linkage L = getLinkageForTemplateArgumentList(TemplateArgs); 252 return minLinkage(L, Spec->getSpecializedTemplate()->getLinkage()); 253 } 254 255 return ExternalLinkage; 256 } 257 258 // - an enumerator belonging to an enumeration with external linkage; 259 if (isa<EnumConstantDecl>(D)) { 260 Linkage L = cast<NamedDecl>(D->getDeclContext())->getLinkage(); 261 if (isExternalLinkage(L)) 262 return L; 263 } 264 265 // - a template, unless it is a function template that has 266 // internal linkage (Clause 14); 267 if (const TemplateDecl *Template = dyn_cast<TemplateDecl>(D)) { 268 if (D->isInAnonymousNamespace()) 269 return UniqueExternalLinkage; 270 271 return getLinkageForTemplateParameterList( 272 Template->getTemplateParameters()); 273 } 274 275 // - a namespace (7.3), unless it is declared within an unnamed 276 // namespace. 277 if (isa<NamespaceDecl>(D) && !D->isInAnonymousNamespace()) 278 return ExternalLinkage; 279 280 return NoLinkage; 281} 282 283static Linkage getLinkageForClassMember(const NamedDecl *D) { 284 if (!(isa<CXXMethodDecl>(D) || 285 isa<VarDecl>(D) || 286 (isa<TagDecl>(D) && 287 (D->getDeclName() || cast<TagDecl>(D)->getTypedefForAnonDecl())))) 288 return NoLinkage; 289 290 // Class members only have linkage if their class has external linkage. 291 Linkage L = cast<RecordDecl>(D->getDeclContext())->getLinkage(); 292 if (!isExternalLinkage(L)) return NoLinkage; 293 294 // If the class already has unique-external linkage, we can't improve. 295 if (L == UniqueExternalLinkage) return UniqueExternalLinkage; 296 297 // If this is a method template specialization, use the linkage for 298 // the template parameters and arguments. 299 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) { 300 if (FunctionTemplateSpecializationInfo *SpecInfo 301 = MD->getTemplateSpecializationInfo()) { 302 Linkage ArgLinkage = 303 getLinkageForTemplateArgumentList(*SpecInfo->TemplateArguments); 304 Linkage ParamLinkage = 305 getLinkageForTemplateParameterList( 306 SpecInfo->getTemplate()->getTemplateParameters()); 307 return minLinkage(ArgLinkage, ParamLinkage); 308 } 309 310 // Similarly for member class template specializations. 311 } else if (const ClassTemplateSpecializationDecl *Spec 312 = dyn_cast<ClassTemplateSpecializationDecl>(D)) { 313 Linkage ArgLinkage = 314 getLinkageForTemplateArgumentList(Spec->getTemplateArgs()); 315 Linkage ParamLinkage = 316 getLinkageForTemplateParameterList( 317 Spec->getSpecializedTemplate()->getTemplateParameters()); 318 return minLinkage(ArgLinkage, ParamLinkage); 319 } 320 321 return ExternalLinkage; 322} 323 324Linkage NamedDecl::getLinkage() const { 325 326 // Objective-C: treat all Objective-C declarations as having external 327 // linkage. 328 switch (getKind()) { 329 default: 330 break; 331 case Decl::ObjCAtDefsField: 332 case Decl::ObjCCategory: 333 case Decl::ObjCCategoryImpl: 334 case Decl::ObjCClass: 335 case Decl::ObjCCompatibleAlias: 336 case Decl::ObjCForwardProtocol: 337 case Decl::ObjCImplementation: 338 case Decl::ObjCInterface: 339 case Decl::ObjCIvar: 340 case Decl::ObjCMethod: 341 case Decl::ObjCProperty: 342 case Decl::ObjCPropertyImpl: 343 case Decl::ObjCProtocol: 344 return ExternalLinkage; 345 } 346 347 // Handle linkage for namespace-scope names. 348 if (getDeclContext()->getLookupContext()->isFileContext()) 349 if (Linkage L = getLinkageForNamespaceScopeDecl(this)) 350 return L; 351 352 // C++ [basic.link]p5: 353 // In addition, a member function, static data member, a named 354 // class or enumeration of class scope, or an unnamed class or 355 // enumeration defined in a class-scope typedef declaration such 356 // that the class or enumeration has the typedef name for linkage 357 // purposes (7.1.3), has external linkage if the name of the class 358 // has external linkage. 359 if (getDeclContext()->isRecord()) 360 return getLinkageForClassMember(this); 361 362 // C++ [basic.link]p6: 363 // The name of a function declared in block scope and the name of 364 // an object declared by a block scope extern declaration have 365 // linkage. If there is a visible declaration of an entity with 366 // linkage having the same name and type, ignoring entities 367 // declared outside the innermost enclosing namespace scope, the 368 // block scope declaration declares that same entity and receives 369 // the linkage of the previous declaration. If there is more than 370 // one such matching entity, the program is ill-formed. Otherwise, 371 // if no matching entity is found, the block scope entity receives 372 // external linkage. 373 if (getLexicalDeclContext()->isFunctionOrMethod()) { 374 if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(this)) { 375 if (Function->getPreviousDeclaration()) 376 if (Linkage L = Function->getPreviousDeclaration()->getLinkage()) 377 return L; 378 379 if (Function->isInAnonymousNamespace()) 380 return UniqueExternalLinkage; 381 382 return ExternalLinkage; 383 } 384 385 if (const VarDecl *Var = dyn_cast<VarDecl>(this)) 386 if (Var->getStorageClass() == VarDecl::Extern || 387 Var->getStorageClass() == VarDecl::PrivateExtern) { 388 if (Var->getPreviousDeclaration()) 389 if (Linkage L = Var->getPreviousDeclaration()->getLinkage()) 390 return L; 391 392 if (Var->isInAnonymousNamespace()) 393 return UniqueExternalLinkage; 394 395 return ExternalLinkage; 396 } 397 } 398 399 // C++ [basic.link]p6: 400 // Names not covered by these rules have no linkage. 401 return NoLinkage; 402 } 403 404std::string NamedDecl::getQualifiedNameAsString() const { 405 return getQualifiedNameAsString(getASTContext().getLangOptions()); 406} 407 408std::string NamedDecl::getQualifiedNameAsString(const PrintingPolicy &P) const { 409 const DeclContext *Ctx = getDeclContext(); 410 411 if (Ctx->isFunctionOrMethod()) 412 return getNameAsString(); 413 414 typedef llvm::SmallVector<const DeclContext *, 8> ContextsTy; 415 ContextsTy Contexts; 416 417 // Collect contexts. 418 while (Ctx && isa<NamedDecl>(Ctx)) { 419 Contexts.push_back(Ctx); 420 Ctx = Ctx->getParent(); 421 }; 422 423 std::string QualName; 424 llvm::raw_string_ostream OS(QualName); 425 426 for (ContextsTy::reverse_iterator I = Contexts.rbegin(), E = Contexts.rend(); 427 I != E; ++I) { 428 if (const ClassTemplateSpecializationDecl *Spec 429 = dyn_cast<ClassTemplateSpecializationDecl>(*I)) { 430 const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs(); 431 std::string TemplateArgsStr 432 = TemplateSpecializationType::PrintTemplateArgumentList( 433 TemplateArgs.getFlatArgumentList(), 434 TemplateArgs.flat_size(), 435 P); 436 OS << Spec->getName() << TemplateArgsStr; 437 } else if (const NamespaceDecl *ND = dyn_cast<NamespaceDecl>(*I)) { 438 if (ND->isAnonymousNamespace()) 439 OS << "<anonymous namespace>"; 440 else 441 OS << ND; 442 } else if (const RecordDecl *RD = dyn_cast<RecordDecl>(*I)) { 443 if (!RD->getIdentifier()) 444 OS << "<anonymous " << RD->getKindName() << '>'; 445 else 446 OS << RD; 447 } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) { 448 const FunctionProtoType *FT = 0; 449 if (FD->hasWrittenPrototype()) 450 FT = dyn_cast<FunctionProtoType>(FD->getType()->getAs<FunctionType>()); 451 452 OS << FD << '('; 453 if (FT) { 454 unsigned NumParams = FD->getNumParams(); 455 for (unsigned i = 0; i < NumParams; ++i) { 456 if (i) 457 OS << ", "; 458 std::string Param; 459 FD->getParamDecl(i)->getType().getAsStringInternal(Param, P); 460 OS << Param; 461 } 462 463 if (FT->isVariadic()) { 464 if (NumParams > 0) 465 OS << ", "; 466 OS << "..."; 467 } 468 } 469 OS << ')'; 470 } else { 471 OS << cast<NamedDecl>(*I); 472 } 473 OS << "::"; 474 } 475 476 if (getDeclName()) 477 OS << this; 478 else 479 OS << "<anonymous>"; 480 481 return OS.str(); 482} 483 484bool NamedDecl::declarationReplaces(NamedDecl *OldD) const { 485 assert(getDeclName() == OldD->getDeclName() && "Declaration name mismatch"); 486 487 // UsingDirectiveDecl's are not really NamedDecl's, and all have same name. 488 // We want to keep it, unless it nominates same namespace. 489 if (getKind() == Decl::UsingDirective) { 490 return cast<UsingDirectiveDecl>(this)->getNominatedNamespace() == 491 cast<UsingDirectiveDecl>(OldD)->getNominatedNamespace(); 492 } 493 494 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(this)) 495 // For function declarations, we keep track of redeclarations. 496 return FD->getPreviousDeclaration() == OldD; 497 498 // For function templates, the underlying function declarations are linked. 499 if (const FunctionTemplateDecl *FunctionTemplate 500 = dyn_cast<FunctionTemplateDecl>(this)) 501 if (const FunctionTemplateDecl *OldFunctionTemplate 502 = dyn_cast<FunctionTemplateDecl>(OldD)) 503 return FunctionTemplate->getTemplatedDecl() 504 ->declarationReplaces(OldFunctionTemplate->getTemplatedDecl()); 505 506 // For method declarations, we keep track of redeclarations. 507 if (isa<ObjCMethodDecl>(this)) 508 return false; 509 510 if (isa<ObjCInterfaceDecl>(this) && isa<ObjCCompatibleAliasDecl>(OldD)) 511 return true; 512 513 if (isa<UsingShadowDecl>(this) && isa<UsingShadowDecl>(OldD)) 514 return cast<UsingShadowDecl>(this)->getTargetDecl() == 515 cast<UsingShadowDecl>(OldD)->getTargetDecl(); 516 517 // For non-function declarations, if the declarations are of the 518 // same kind then this must be a redeclaration, or semantic analysis 519 // would not have given us the new declaration. 520 return this->getKind() == OldD->getKind(); 521} 522 523bool NamedDecl::hasLinkage() const { 524 return getLinkage() != NoLinkage; 525} 526 527NamedDecl *NamedDecl::getUnderlyingDecl() { 528 NamedDecl *ND = this; 529 while (true) { 530 if (UsingShadowDecl *UD = dyn_cast<UsingShadowDecl>(ND)) 531 ND = UD->getTargetDecl(); 532 else if (ObjCCompatibleAliasDecl *AD 533 = dyn_cast<ObjCCompatibleAliasDecl>(ND)) 534 return AD->getClassInterface(); 535 else 536 return ND; 537 } 538} 539 540bool NamedDecl::isCXXInstanceMember() const { 541 assert(isCXXClassMember() && 542 "checking whether non-member is instance member"); 543 544 const NamedDecl *D = this; 545 if (isa<UsingShadowDecl>(D)) 546 D = cast<UsingShadowDecl>(D)->getTargetDecl(); 547 548 if (isa<FieldDecl>(D)) 549 return true; 550 if (isa<CXXMethodDecl>(D)) 551 return cast<CXXMethodDecl>(D)->isInstance(); 552 if (isa<FunctionTemplateDecl>(D)) 553 return cast<CXXMethodDecl>(cast<FunctionTemplateDecl>(D) 554 ->getTemplatedDecl())->isInstance(); 555 return false; 556} 557 558//===----------------------------------------------------------------------===// 559// DeclaratorDecl Implementation 560//===----------------------------------------------------------------------===// 561 562template <typename DeclT> 563static SourceLocation getTemplateOrInnerLocStart(const DeclT *decl) { 564 if (decl->getNumTemplateParameterLists() > 0) 565 return decl->getTemplateParameterList(0)->getTemplateLoc(); 566 else 567 return decl->getInnerLocStart(); 568} 569 570SourceLocation DeclaratorDecl::getTypeSpecStartLoc() const { 571 TypeSourceInfo *TSI = getTypeSourceInfo(); 572 if (TSI) return TSI->getTypeLoc().getBeginLoc(); 573 return SourceLocation(); 574} 575 576void DeclaratorDecl::setQualifierInfo(NestedNameSpecifier *Qualifier, 577 SourceRange QualifierRange) { 578 if (Qualifier) { 579 // Make sure the extended decl info is allocated. 580 if (!hasExtInfo()) { 581 // Save (non-extended) type source info pointer. 582 TypeSourceInfo *savedTInfo = DeclInfo.get<TypeSourceInfo*>(); 583 // Allocate external info struct. 584 DeclInfo = new (getASTContext()) ExtInfo; 585 // Restore savedTInfo into (extended) decl info. 586 getExtInfo()->TInfo = savedTInfo; 587 } 588 // Set qualifier info. 589 getExtInfo()->NNS = Qualifier; 590 getExtInfo()->NNSRange = QualifierRange; 591 } 592 else { 593 // Here Qualifier == 0, i.e., we are removing the qualifier (if any). 594 assert(QualifierRange.isInvalid()); 595 if (hasExtInfo()) { 596 // Save type source info pointer. 597 TypeSourceInfo *savedTInfo = getExtInfo()->TInfo; 598 // Deallocate the extended decl info. 599 getASTContext().Deallocate(getExtInfo()); 600 // Restore savedTInfo into (non-extended) decl info. 601 DeclInfo = savedTInfo; 602 } 603 } 604} 605 606SourceLocation DeclaratorDecl::getOuterLocStart() const { 607 return getTemplateOrInnerLocStart(this); 608} 609 610void 611QualifierInfo::setTemplateParameterListsInfo(ASTContext &Context, 612 unsigned NumTPLists, 613 TemplateParameterList **TPLists) { 614 assert((NumTPLists == 0 || TPLists != 0) && 615 "Empty array of template parameters with positive size!"); 616 assert((NumTPLists == 0 || NNS) && 617 "Nonempty array of template parameters with no qualifier!"); 618 619 // Free previous template parameters (if any). 620 if (NumTemplParamLists > 0) { 621 Context.Deallocate(TemplParamLists); 622 TemplParamLists = 0; 623 NumTemplParamLists = 0; 624 } 625 // Set info on matched template parameter lists (if any). 626 if (NumTPLists > 0) { 627 TemplParamLists = new (Context) TemplateParameterList*[NumTPLists]; 628 NumTemplParamLists = NumTPLists; 629 for (unsigned i = NumTPLists; i-- > 0; ) 630 TemplParamLists[i] = TPLists[i]; 631 } 632} 633 634//===----------------------------------------------------------------------===// 635// VarDecl Implementation 636//===----------------------------------------------------------------------===// 637 638const char *VarDecl::getStorageClassSpecifierString(StorageClass SC) { 639 switch (SC) { 640 case VarDecl::None: break; 641 case VarDecl::Auto: return "auto"; break; 642 case VarDecl::Extern: return "extern"; break; 643 case VarDecl::PrivateExtern: return "__private_extern__"; break; 644 case VarDecl::Register: return "register"; break; 645 case VarDecl::Static: return "static"; break; 646 } 647 648 assert(0 && "Invalid storage class"); 649 return 0; 650} 651 652VarDecl *VarDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L, 653 IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, 654 StorageClass S, StorageClass SCAsWritten) { 655 return new (C) VarDecl(Var, DC, L, Id, T, TInfo, S, SCAsWritten); 656} 657 658SourceLocation VarDecl::getInnerLocStart() const { 659 SourceLocation Start = getTypeSpecStartLoc(); 660 if (Start.isInvalid()) 661 Start = getLocation(); 662 return Start; 663} 664 665SourceRange VarDecl::getSourceRange() const { 666 if (getInit()) 667 return SourceRange(getOuterLocStart(), getInit()->getLocEnd()); 668 return SourceRange(getOuterLocStart(), getLocation()); 669} 670 671bool VarDecl::isExternC() const { 672 ASTContext &Context = getASTContext(); 673 if (!Context.getLangOptions().CPlusPlus) 674 return (getDeclContext()->isTranslationUnit() && 675 getStorageClass() != Static) || 676 (getDeclContext()->isFunctionOrMethod() && hasExternalStorage()); 677 678 for (const DeclContext *DC = getDeclContext(); !DC->isTranslationUnit(); 679 DC = DC->getParent()) { 680 if (const LinkageSpecDecl *Linkage = dyn_cast<LinkageSpecDecl>(DC)) { 681 if (Linkage->getLanguage() == LinkageSpecDecl::lang_c) 682 return getStorageClass() != Static; 683 684 break; 685 } 686 687 if (DC->isFunctionOrMethod()) 688 return false; 689 } 690 691 return false; 692} 693 694VarDecl *VarDecl::getCanonicalDecl() { 695 return getFirstDeclaration(); 696} 697 698VarDecl::DefinitionKind VarDecl::isThisDeclarationADefinition() const { 699 // C++ [basic.def]p2: 700 // A declaration is a definition unless [...] it contains the 'extern' 701 // specifier or a linkage-specification and neither an initializer [...], 702 // it declares a static data member in a class declaration [...]. 703 // C++ [temp.expl.spec]p15: 704 // An explicit specialization of a static data member of a template is a 705 // definition if the declaration includes an initializer; otherwise, it is 706 // a declaration. 707 if (isStaticDataMember()) { 708 if (isOutOfLine() && (hasInit() || 709 getTemplateSpecializationKind() != TSK_ExplicitSpecialization)) 710 return Definition; 711 else 712 return DeclarationOnly; 713 } 714 // C99 6.7p5: 715 // A definition of an identifier is a declaration for that identifier that 716 // [...] causes storage to be reserved for that object. 717 // Note: that applies for all non-file-scope objects. 718 // C99 6.9.2p1: 719 // If the declaration of an identifier for an object has file scope and an 720 // initializer, the declaration is an external definition for the identifier 721 if (hasInit()) 722 return Definition; 723 // AST for 'extern "C" int foo;' is annotated with 'extern'. 724 if (hasExternalStorage()) 725 return DeclarationOnly; 726 727 if (getStorageClassAsWritten() == Extern || 728 getStorageClassAsWritten() == PrivateExtern) { 729 for (const VarDecl *PrevVar = getPreviousDeclaration(); 730 PrevVar; PrevVar = PrevVar->getPreviousDeclaration()) { 731 if (PrevVar->getLinkage() == InternalLinkage && PrevVar->hasInit()) 732 return DeclarationOnly; 733 } 734 } 735 // C99 6.9.2p2: 736 // A declaration of an object that has file scope without an initializer, 737 // and without a storage class specifier or the scs 'static', constitutes 738 // a tentative definition. 739 // No such thing in C++. 740 if (!getASTContext().getLangOptions().CPlusPlus && isFileVarDecl()) 741 return TentativeDefinition; 742 743 // What's left is (in C, block-scope) declarations without initializers or 744 // external storage. These are definitions. 745 return Definition; 746} 747 748VarDecl *VarDecl::getActingDefinition() { 749 DefinitionKind Kind = isThisDeclarationADefinition(); 750 if (Kind != TentativeDefinition) 751 return 0; 752 753 VarDecl *LastTentative = 0; 754 VarDecl *First = getFirstDeclaration(); 755 for (redecl_iterator I = First->redecls_begin(), E = First->redecls_end(); 756 I != E; ++I) { 757 Kind = (*I)->isThisDeclarationADefinition(); 758 if (Kind == Definition) 759 return 0; 760 else if (Kind == TentativeDefinition) 761 LastTentative = *I; 762 } 763 return LastTentative; 764} 765 766bool VarDecl::isTentativeDefinitionNow() const { 767 DefinitionKind Kind = isThisDeclarationADefinition(); 768 if (Kind != TentativeDefinition) 769 return false; 770 771 for (redecl_iterator I = redecls_begin(), E = redecls_end(); I != E; ++I) { 772 if ((*I)->isThisDeclarationADefinition() == Definition) 773 return false; 774 } 775 return true; 776} 777 778VarDecl *VarDecl::getDefinition() { 779 VarDecl *First = getFirstDeclaration(); 780 for (redecl_iterator I = First->redecls_begin(), E = First->redecls_end(); 781 I != E; ++I) { 782 if ((*I)->isThisDeclarationADefinition() == Definition) 783 return *I; 784 } 785 return 0; 786} 787 788const Expr *VarDecl::getAnyInitializer(const VarDecl *&D) const { 789 redecl_iterator I = redecls_begin(), E = redecls_end(); 790 while (I != E && !I->getInit()) 791 ++I; 792 793 if (I != E) { 794 D = *I; 795 return I->getInit(); 796 } 797 return 0; 798} 799 800bool VarDecl::isOutOfLine() const { 801 if (Decl::isOutOfLine()) 802 return true; 803 804 if (!isStaticDataMember()) 805 return false; 806 807 // If this static data member was instantiated from a static data member of 808 // a class template, check whether that static data member was defined 809 // out-of-line. 810 if (VarDecl *VD = getInstantiatedFromStaticDataMember()) 811 return VD->isOutOfLine(); 812 813 return false; 814} 815 816VarDecl *VarDecl::getOutOfLineDefinition() { 817 if (!isStaticDataMember()) 818 return 0; 819 820 for (VarDecl::redecl_iterator RD = redecls_begin(), RDEnd = redecls_end(); 821 RD != RDEnd; ++RD) { 822 if (RD->getLexicalDeclContext()->isFileContext()) 823 return *RD; 824 } 825 826 return 0; 827} 828 829void VarDecl::setInit(Expr *I) { 830 if (EvaluatedStmt *Eval = Init.dyn_cast<EvaluatedStmt *>()) { 831 Eval->~EvaluatedStmt(); 832 getASTContext().Deallocate(Eval); 833 } 834 835 Init = I; 836} 837 838VarDecl *VarDecl::getInstantiatedFromStaticDataMember() const { 839 if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo()) 840 return cast<VarDecl>(MSI->getInstantiatedFrom()); 841 842 return 0; 843} 844 845TemplateSpecializationKind VarDecl::getTemplateSpecializationKind() const { 846 if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo()) 847 return MSI->getTemplateSpecializationKind(); 848 849 return TSK_Undeclared; 850} 851 852MemberSpecializationInfo *VarDecl::getMemberSpecializationInfo() const { 853 return getASTContext().getInstantiatedFromStaticDataMember(this); 854} 855 856void VarDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK, 857 SourceLocation PointOfInstantiation) { 858 MemberSpecializationInfo *MSI = getMemberSpecializationInfo(); 859 assert(MSI && "Not an instantiated static data member?"); 860 MSI->setTemplateSpecializationKind(TSK); 861 if (TSK != TSK_ExplicitSpecialization && 862 PointOfInstantiation.isValid() && 863 MSI->getPointOfInstantiation().isInvalid()) 864 MSI->setPointOfInstantiation(PointOfInstantiation); 865} 866 867//===----------------------------------------------------------------------===// 868// ParmVarDecl Implementation 869//===----------------------------------------------------------------------===// 870 871ParmVarDecl *ParmVarDecl::Create(ASTContext &C, DeclContext *DC, 872 SourceLocation L, IdentifierInfo *Id, 873 QualType T, TypeSourceInfo *TInfo, 874 StorageClass S, StorageClass SCAsWritten, 875 Expr *DefArg) { 876 return new (C) ParmVarDecl(ParmVar, DC, L, Id, T, TInfo, 877 S, SCAsWritten, DefArg); 878} 879 880Expr *ParmVarDecl::getDefaultArg() { 881 assert(!hasUnparsedDefaultArg() && "Default argument is not yet parsed!"); 882 assert(!hasUninstantiatedDefaultArg() && 883 "Default argument is not yet instantiated!"); 884 885 Expr *Arg = getInit(); 886 if (CXXExprWithTemporaries *E = dyn_cast_or_null<CXXExprWithTemporaries>(Arg)) 887 return E->getSubExpr(); 888 889 return Arg; 890} 891 892unsigned ParmVarDecl::getNumDefaultArgTemporaries() const { 893 if (const CXXExprWithTemporaries *E = 894 dyn_cast<CXXExprWithTemporaries>(getInit())) 895 return E->getNumTemporaries(); 896 897 return 0; 898} 899 900CXXTemporary *ParmVarDecl::getDefaultArgTemporary(unsigned i) { 901 assert(getNumDefaultArgTemporaries() && 902 "Default arguments does not have any temporaries!"); 903 904 CXXExprWithTemporaries *E = cast<CXXExprWithTemporaries>(getInit()); 905 return E->getTemporary(i); 906} 907 908SourceRange ParmVarDecl::getDefaultArgRange() const { 909 if (const Expr *E = getInit()) 910 return E->getSourceRange(); 911 912 if (hasUninstantiatedDefaultArg()) 913 return getUninstantiatedDefaultArg()->getSourceRange(); 914 915 return SourceRange(); 916} 917 918//===----------------------------------------------------------------------===// 919// FunctionDecl Implementation 920//===----------------------------------------------------------------------===// 921 922void FunctionDecl::getNameForDiagnostic(std::string &S, 923 const PrintingPolicy &Policy, 924 bool Qualified) const { 925 NamedDecl::getNameForDiagnostic(S, Policy, Qualified); 926 const TemplateArgumentList *TemplateArgs = getTemplateSpecializationArgs(); 927 if (TemplateArgs) 928 S += TemplateSpecializationType::PrintTemplateArgumentList( 929 TemplateArgs->getFlatArgumentList(), 930 TemplateArgs->flat_size(), 931 Policy); 932 933} 934 935bool FunctionDecl::isVariadic() const { 936 if (const FunctionProtoType *FT = getType()->getAs<FunctionProtoType>()) 937 return FT->isVariadic(); 938 return false; 939} 940 941bool FunctionDecl::hasBody(const FunctionDecl *&Definition) const { 942 for (redecl_iterator I = redecls_begin(), E = redecls_end(); I != E; ++I) { 943 if (I->Body) { 944 Definition = *I; 945 return true; 946 } 947 } 948 949 return false; 950} 951 952Stmt *FunctionDecl::getBody(const FunctionDecl *&Definition) const { 953 for (redecl_iterator I = redecls_begin(), E = redecls_end(); I != E; ++I) { 954 if (I->Body) { 955 Definition = *I; 956 return I->Body.get(getASTContext().getExternalSource()); 957 } 958 } 959 960 return 0; 961} 962 963void FunctionDecl::setBody(Stmt *B) { 964 Body = B; 965 if (B) 966 EndRangeLoc = B->getLocEnd(); 967} 968 969bool FunctionDecl::isMain() const { 970 ASTContext &Context = getASTContext(); 971 return !Context.getLangOptions().Freestanding && 972 getDeclContext()->getLookupContext()->isTranslationUnit() && 973 getIdentifier() && getIdentifier()->isStr("main"); 974} 975 976bool FunctionDecl::isExternC() const { 977 ASTContext &Context = getASTContext(); 978 // In C, any non-static, non-overloadable function has external 979 // linkage. 980 if (!Context.getLangOptions().CPlusPlus) 981 return getStorageClass() != Static && !getAttr<OverloadableAttr>(); 982 983 for (const DeclContext *DC = getDeclContext(); !DC->isTranslationUnit(); 984 DC = DC->getParent()) { 985 if (const LinkageSpecDecl *Linkage = dyn_cast<LinkageSpecDecl>(DC)) { 986 if (Linkage->getLanguage() == LinkageSpecDecl::lang_c) 987 return getStorageClass() != Static && 988 !getAttr<OverloadableAttr>(); 989 990 break; 991 } 992 993 if (DC->isRecord()) 994 break; 995 } 996 997 return false; 998} 999 1000bool FunctionDecl::isGlobal() const { 1001 if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(this)) 1002 return Method->isStatic(); 1003 1004 if (getStorageClass() == Static) 1005 return false; 1006 1007 for (const DeclContext *DC = getDeclContext(); 1008 DC->isNamespace(); 1009 DC = DC->getParent()) { 1010 if (const NamespaceDecl *Namespace = cast<NamespaceDecl>(DC)) { 1011 if (!Namespace->getDeclName()) 1012 return false; 1013 break; 1014 } 1015 } 1016 1017 return true; 1018} 1019 1020void 1021FunctionDecl::setPreviousDeclaration(FunctionDecl *PrevDecl) { 1022 redeclarable_base::setPreviousDeclaration(PrevDecl); 1023 1024 if (FunctionTemplateDecl *FunTmpl = getDescribedFunctionTemplate()) { 1025 FunctionTemplateDecl *PrevFunTmpl 1026 = PrevDecl? PrevDecl->getDescribedFunctionTemplate() : 0; 1027 assert((!PrevDecl || PrevFunTmpl) && "Function/function template mismatch"); 1028 FunTmpl->setPreviousDeclaration(PrevFunTmpl); 1029 } 1030} 1031 1032const FunctionDecl *FunctionDecl::getCanonicalDecl() const { 1033 return getFirstDeclaration(); 1034} 1035 1036FunctionDecl *FunctionDecl::getCanonicalDecl() { 1037 return getFirstDeclaration(); 1038} 1039 1040/// \brief Returns a value indicating whether this function 1041/// corresponds to a builtin function. 1042/// 1043/// The function corresponds to a built-in function if it is 1044/// declared at translation scope or within an extern "C" block and 1045/// its name matches with the name of a builtin. The returned value 1046/// will be 0 for functions that do not correspond to a builtin, a 1047/// value of type \c Builtin::ID if in the target-independent range 1048/// \c [1,Builtin::First), or a target-specific builtin value. 1049unsigned FunctionDecl::getBuiltinID() const { 1050 ASTContext &Context = getASTContext(); 1051 if (!getIdentifier() || !getIdentifier()->getBuiltinID()) 1052 return 0; 1053 1054 unsigned BuiltinID = getIdentifier()->getBuiltinID(); 1055 if (!Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) 1056 return BuiltinID; 1057 1058 // This function has the name of a known C library 1059 // function. Determine whether it actually refers to the C library 1060 // function or whether it just has the same name. 1061 1062 // If this is a static function, it's not a builtin. 1063 if (getStorageClass() == Static) 1064 return 0; 1065 1066 // If this function is at translation-unit scope and we're not in 1067 // C++, it refers to the C library function. 1068 if (!Context.getLangOptions().CPlusPlus && 1069 getDeclContext()->isTranslationUnit()) 1070 return BuiltinID; 1071 1072 // If the function is in an extern "C" linkage specification and is 1073 // not marked "overloadable", it's the real function. 1074 if (isa<LinkageSpecDecl>(getDeclContext()) && 1075 cast<LinkageSpecDecl>(getDeclContext())->getLanguage() 1076 == LinkageSpecDecl::lang_c && 1077 !getAttr<OverloadableAttr>()) 1078 return BuiltinID; 1079 1080 // Not a builtin 1081 return 0; 1082} 1083 1084 1085/// getNumParams - Return the number of parameters this function must have 1086/// based on its FunctionType. This is the length of the PararmInfo array 1087/// after it has been created. 1088unsigned FunctionDecl::getNumParams() const { 1089 const FunctionType *FT = getType()->getAs<FunctionType>(); 1090 if (isa<FunctionNoProtoType>(FT)) 1091 return 0; 1092 return cast<FunctionProtoType>(FT)->getNumArgs(); 1093 1094} 1095 1096void FunctionDecl::setParams(ParmVarDecl **NewParamInfo, unsigned NumParams) { 1097 assert(ParamInfo == 0 && "Already has param info!"); 1098 assert(NumParams == getNumParams() && "Parameter count mismatch!"); 1099 1100 // Zero params -> null pointer. 1101 if (NumParams) { 1102 void *Mem = getASTContext().Allocate(sizeof(ParmVarDecl*)*NumParams); 1103 ParamInfo = new (Mem) ParmVarDecl*[NumParams]; 1104 memcpy(ParamInfo, NewParamInfo, sizeof(ParmVarDecl*)*NumParams); 1105 1106 // Update source range. The check below allows us to set EndRangeLoc before 1107 // setting the parameters. 1108 if (EndRangeLoc.isInvalid() || EndRangeLoc == getLocation()) 1109 EndRangeLoc = NewParamInfo[NumParams-1]->getLocEnd(); 1110 } 1111} 1112 1113/// getMinRequiredArguments - Returns the minimum number of arguments 1114/// needed to call this function. This may be fewer than the number of 1115/// function parameters, if some of the parameters have default 1116/// arguments (in C++). 1117unsigned FunctionDecl::getMinRequiredArguments() const { 1118 unsigned NumRequiredArgs = getNumParams(); 1119 while (NumRequiredArgs > 0 1120 && getParamDecl(NumRequiredArgs-1)->hasDefaultArg()) 1121 --NumRequiredArgs; 1122 1123 return NumRequiredArgs; 1124} 1125 1126bool FunctionDecl::isInlined() const { 1127 // FIXME: This is not enough. Consider: 1128 // 1129 // inline void f(); 1130 // void f() { } 1131 // 1132 // f is inlined, but does not have inline specified. 1133 // To fix this we should add an 'inline' flag to FunctionDecl. 1134 if (isInlineSpecified()) 1135 return true; 1136 1137 if (isa<CXXMethodDecl>(this)) { 1138 if (!isOutOfLine() || getCanonicalDecl()->isInlineSpecified()) 1139 return true; 1140 } 1141 1142 switch (getTemplateSpecializationKind()) { 1143 case TSK_Undeclared: 1144 case TSK_ExplicitSpecialization: 1145 return false; 1146 1147 case TSK_ImplicitInstantiation: 1148 case TSK_ExplicitInstantiationDeclaration: 1149 case TSK_ExplicitInstantiationDefinition: 1150 // Handle below. 1151 break; 1152 } 1153 1154 const FunctionDecl *PatternDecl = getTemplateInstantiationPattern(); 1155 bool HasPattern = false; 1156 if (PatternDecl) 1157 HasPattern = PatternDecl->hasBody(PatternDecl); 1158 1159 if (HasPattern && PatternDecl) 1160 return PatternDecl->isInlined(); 1161 1162 return false; 1163} 1164 1165/// \brief For an inline function definition in C or C++, determine whether the 1166/// definition will be externally visible. 1167/// 1168/// Inline function definitions are always available for inlining optimizations. 1169/// However, depending on the language dialect, declaration specifiers, and 1170/// attributes, the definition of an inline function may or may not be 1171/// "externally" visible to other translation units in the program. 1172/// 1173/// In C99, inline definitions are not externally visible by default. However, 1174/// if even one of the global-scope declarations is marked "extern inline", the 1175/// inline definition becomes externally visible (C99 6.7.4p6). 1176/// 1177/// In GNU89 mode, or if the gnu_inline attribute is attached to the function 1178/// definition, we use the GNU semantics for inline, which are nearly the 1179/// opposite of C99 semantics. In particular, "inline" by itself will create 1180/// an externally visible symbol, but "extern inline" will not create an 1181/// externally visible symbol. 1182bool FunctionDecl::isInlineDefinitionExternallyVisible() const { 1183 assert(isThisDeclarationADefinition() && "Must have the function definition"); 1184 assert(isInlined() && "Function must be inline"); 1185 ASTContext &Context = getASTContext(); 1186 1187 if (!Context.getLangOptions().C99 || hasAttr<GNUInlineAttr>()) { 1188 // GNU inline semantics. Based on a number of examples, we came up with the 1189 // following heuristic: if the "inline" keyword is present on a 1190 // declaration of the function but "extern" is not present on that 1191 // declaration, then the symbol is externally visible. Otherwise, the GNU 1192 // "extern inline" semantics applies and the symbol is not externally 1193 // visible. 1194 for (redecl_iterator Redecl = redecls_begin(), RedeclEnd = redecls_end(); 1195 Redecl != RedeclEnd; 1196 ++Redecl) { 1197 if (Redecl->isInlineSpecified() && Redecl->getStorageClass() != Extern) 1198 return true; 1199 } 1200 1201 // GNU "extern inline" semantics; no externally visible symbol. 1202 return false; 1203 } 1204 1205 // C99 6.7.4p6: 1206 // [...] If all of the file scope declarations for a function in a 1207 // translation unit include the inline function specifier without extern, 1208 // then the definition in that translation unit is an inline definition. 1209 for (redecl_iterator Redecl = redecls_begin(), RedeclEnd = redecls_end(); 1210 Redecl != RedeclEnd; 1211 ++Redecl) { 1212 // Only consider file-scope declarations in this test. 1213 if (!Redecl->getLexicalDeclContext()->isTranslationUnit()) 1214 continue; 1215 1216 if (!Redecl->isInlineSpecified() || Redecl->getStorageClass() == Extern) 1217 return true; // Not an inline definition 1218 } 1219 1220 // C99 6.7.4p6: 1221 // An inline definition does not provide an external definition for the 1222 // function, and does not forbid an external definition in another 1223 // translation unit. 1224 return false; 1225} 1226 1227/// getOverloadedOperator - Which C++ overloaded operator this 1228/// function represents, if any. 1229OverloadedOperatorKind FunctionDecl::getOverloadedOperator() const { 1230 if (getDeclName().getNameKind() == DeclarationName::CXXOperatorName) 1231 return getDeclName().getCXXOverloadedOperator(); 1232 else 1233 return OO_None; 1234} 1235 1236/// getLiteralIdentifier - The literal suffix identifier this function 1237/// represents, if any. 1238const IdentifierInfo *FunctionDecl::getLiteralIdentifier() const { 1239 if (getDeclName().getNameKind() == DeclarationName::CXXLiteralOperatorName) 1240 return getDeclName().getCXXLiteralIdentifier(); 1241 else 1242 return 0; 1243} 1244 1245FunctionDecl::TemplatedKind FunctionDecl::getTemplatedKind() const { 1246 if (TemplateOrSpecialization.isNull()) 1247 return TK_NonTemplate; 1248 if (TemplateOrSpecialization.is<FunctionTemplateDecl *>()) 1249 return TK_FunctionTemplate; 1250 if (TemplateOrSpecialization.is<MemberSpecializationInfo *>()) 1251 return TK_MemberSpecialization; 1252 if (TemplateOrSpecialization.is<FunctionTemplateSpecializationInfo *>()) 1253 return TK_FunctionTemplateSpecialization; 1254 if (TemplateOrSpecialization.is 1255 <DependentFunctionTemplateSpecializationInfo*>()) 1256 return TK_DependentFunctionTemplateSpecialization; 1257 1258 assert(false && "Did we miss a TemplateOrSpecialization type?"); 1259 return TK_NonTemplate; 1260} 1261 1262FunctionDecl *FunctionDecl::getInstantiatedFromMemberFunction() const { 1263 if (MemberSpecializationInfo *Info = getMemberSpecializationInfo()) 1264 return cast<FunctionDecl>(Info->getInstantiatedFrom()); 1265 1266 return 0; 1267} 1268 1269MemberSpecializationInfo *FunctionDecl::getMemberSpecializationInfo() const { 1270 return TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo*>(); 1271} 1272 1273void 1274FunctionDecl::setInstantiationOfMemberFunction(FunctionDecl *FD, 1275 TemplateSpecializationKind TSK) { 1276 assert(TemplateOrSpecialization.isNull() && 1277 "Member function is already a specialization"); 1278 MemberSpecializationInfo *Info 1279 = new (getASTContext()) MemberSpecializationInfo(FD, TSK); 1280 TemplateOrSpecialization = Info; 1281} 1282 1283bool FunctionDecl::isImplicitlyInstantiable() const { 1284 // If the function is invalid, it can't be implicitly instantiated. 1285 if (isInvalidDecl()) 1286 return false; 1287 1288 switch (getTemplateSpecializationKind()) { 1289 case TSK_Undeclared: 1290 case TSK_ExplicitSpecialization: 1291 case TSK_ExplicitInstantiationDefinition: 1292 return false; 1293 1294 case TSK_ImplicitInstantiation: 1295 return true; 1296 1297 case TSK_ExplicitInstantiationDeclaration: 1298 // Handled below. 1299 break; 1300 } 1301 1302 // Find the actual template from which we will instantiate. 1303 const FunctionDecl *PatternDecl = getTemplateInstantiationPattern(); 1304 bool HasPattern = false; 1305 if (PatternDecl) 1306 HasPattern = PatternDecl->hasBody(PatternDecl); 1307 1308 // C++0x [temp.explicit]p9: 1309 // Except for inline functions, other explicit instantiation declarations 1310 // have the effect of suppressing the implicit instantiation of the entity 1311 // to which they refer. 1312 if (!HasPattern || !PatternDecl) 1313 return true; 1314 1315 return PatternDecl->isInlined(); 1316} 1317 1318FunctionDecl *FunctionDecl::getTemplateInstantiationPattern() const { 1319 if (FunctionTemplateDecl *Primary = getPrimaryTemplate()) { 1320 while (Primary->getInstantiatedFromMemberTemplate()) { 1321 // If we have hit a point where the user provided a specialization of 1322 // this template, we're done looking. 1323 if (Primary->isMemberSpecialization()) 1324 break; 1325 1326 Primary = Primary->getInstantiatedFromMemberTemplate(); 1327 } 1328 1329 return Primary->getTemplatedDecl(); 1330 } 1331 1332 return getInstantiatedFromMemberFunction(); 1333} 1334 1335FunctionTemplateDecl *FunctionDecl::getPrimaryTemplate() const { 1336 if (FunctionTemplateSpecializationInfo *Info 1337 = TemplateOrSpecialization 1338 .dyn_cast<FunctionTemplateSpecializationInfo*>()) { 1339 return Info->Template.getPointer(); 1340 } 1341 return 0; 1342} 1343 1344const TemplateArgumentList * 1345FunctionDecl::getTemplateSpecializationArgs() const { 1346 if (FunctionTemplateSpecializationInfo *Info 1347 = TemplateOrSpecialization 1348 .dyn_cast<FunctionTemplateSpecializationInfo*>()) { 1349 return Info->TemplateArguments; 1350 } 1351 return 0; 1352} 1353 1354const TemplateArgumentListInfo * 1355FunctionDecl::getTemplateSpecializationArgsAsWritten() const { 1356 if (FunctionTemplateSpecializationInfo *Info 1357 = TemplateOrSpecialization 1358 .dyn_cast<FunctionTemplateSpecializationInfo*>()) { 1359 return Info->TemplateArgumentsAsWritten; 1360 } 1361 return 0; 1362} 1363 1364void 1365FunctionDecl::setFunctionTemplateSpecialization(FunctionTemplateDecl *Template, 1366 const TemplateArgumentList *TemplateArgs, 1367 void *InsertPos, 1368 TemplateSpecializationKind TSK, 1369 const TemplateArgumentListInfo *TemplateArgsAsWritten, 1370 SourceLocation PointOfInstantiation) { 1371 assert(TSK != TSK_Undeclared && 1372 "Must specify the type of function template specialization"); 1373 FunctionTemplateSpecializationInfo *Info 1374 = TemplateOrSpecialization.dyn_cast<FunctionTemplateSpecializationInfo*>(); 1375 if (!Info) 1376 Info = new (getASTContext()) FunctionTemplateSpecializationInfo; 1377 1378 Info->Function = this; 1379 Info->Template.setPointer(Template); 1380 Info->Template.setInt(TSK - 1); 1381 Info->TemplateArguments = TemplateArgs; 1382 Info->TemplateArgumentsAsWritten = TemplateArgsAsWritten; 1383 Info->PointOfInstantiation = PointOfInstantiation; 1384 TemplateOrSpecialization = Info; 1385 1386 // Insert this function template specialization into the set of known 1387 // function template specializations. 1388 if (InsertPos) 1389 Template->getSpecializations().InsertNode(Info, InsertPos); 1390 else { 1391 // Try to insert the new node. If there is an existing node, leave it, the 1392 // set will contain the canonical decls while 1393 // FunctionTemplateDecl::findSpecialization will return 1394 // the most recent redeclarations. 1395 FunctionTemplateSpecializationInfo *Existing 1396 = Template->getSpecializations().GetOrInsertNode(Info); 1397 (void)Existing; 1398 assert((!Existing || Existing->Function->isCanonicalDecl()) && 1399 "Set is supposed to only contain canonical decls"); 1400 } 1401} 1402 1403void 1404FunctionDecl::setFunctionTemplateSpecialization(FunctionTemplateDecl *Template, 1405 unsigned NumTemplateArgs, 1406 const TemplateArgument *TemplateArgs, 1407 TemplateSpecializationKind TSK, 1408 unsigned NumTemplateArgsAsWritten, 1409 TemplateArgumentLoc *TemplateArgsAsWritten, 1410 SourceLocation LAngleLoc, 1411 SourceLocation RAngleLoc, 1412 SourceLocation PointOfInstantiation) { 1413 ASTContext &Ctx = getASTContext(); 1414 TemplateArgumentList *TemplArgs 1415 = new (Ctx) TemplateArgumentList(Ctx, TemplateArgs, NumTemplateArgs); 1416 TemplateArgumentListInfo *TemplArgsInfo 1417 = new (Ctx) TemplateArgumentListInfo(LAngleLoc, RAngleLoc); 1418 for (unsigned i=0; i != NumTemplateArgsAsWritten; ++i) 1419 TemplArgsInfo->addArgument(TemplateArgsAsWritten[i]); 1420 1421 setFunctionTemplateSpecialization(Template, TemplArgs, /*InsertPos=*/0, TSK, 1422 TemplArgsInfo, PointOfInstantiation); 1423} 1424 1425void 1426FunctionDecl::setDependentTemplateSpecialization(ASTContext &Context, 1427 const UnresolvedSetImpl &Templates, 1428 const TemplateArgumentListInfo &TemplateArgs) { 1429 assert(TemplateOrSpecialization.isNull()); 1430 size_t Size = sizeof(DependentFunctionTemplateSpecializationInfo); 1431 Size += Templates.size() * sizeof(FunctionTemplateDecl*); 1432 Size += TemplateArgs.size() * sizeof(TemplateArgumentLoc); 1433 void *Buffer = Context.Allocate(Size); 1434 DependentFunctionTemplateSpecializationInfo *Info = 1435 new (Buffer) DependentFunctionTemplateSpecializationInfo(Templates, 1436 TemplateArgs); 1437 TemplateOrSpecialization = Info; 1438} 1439 1440DependentFunctionTemplateSpecializationInfo:: 1441DependentFunctionTemplateSpecializationInfo(const UnresolvedSetImpl &Ts, 1442 const TemplateArgumentListInfo &TArgs) 1443 : AngleLocs(TArgs.getLAngleLoc(), TArgs.getRAngleLoc()) { 1444 1445 d.NumTemplates = Ts.size(); 1446 d.NumArgs = TArgs.size(); 1447 1448 FunctionTemplateDecl **TsArray = 1449 const_cast<FunctionTemplateDecl**>(getTemplates()); 1450 for (unsigned I = 0, E = Ts.size(); I != E; ++I) 1451 TsArray[I] = cast<FunctionTemplateDecl>(Ts[I]->getUnderlyingDecl()); 1452 1453 TemplateArgumentLoc *ArgsArray = 1454 const_cast<TemplateArgumentLoc*>(getTemplateArgs()); 1455 for (unsigned I = 0, E = TArgs.size(); I != E; ++I) 1456 new (&ArgsArray[I]) TemplateArgumentLoc(TArgs[I]); 1457} 1458 1459TemplateSpecializationKind FunctionDecl::getTemplateSpecializationKind() const { 1460 // For a function template specialization, query the specialization 1461 // information object. 1462 FunctionTemplateSpecializationInfo *FTSInfo 1463 = TemplateOrSpecialization.dyn_cast<FunctionTemplateSpecializationInfo*>(); 1464 if (FTSInfo) 1465 return FTSInfo->getTemplateSpecializationKind(); 1466 1467 MemberSpecializationInfo *MSInfo 1468 = TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo*>(); 1469 if (MSInfo) 1470 return MSInfo->getTemplateSpecializationKind(); 1471 1472 return TSK_Undeclared; 1473} 1474 1475void 1476FunctionDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK, 1477 SourceLocation PointOfInstantiation) { 1478 if (FunctionTemplateSpecializationInfo *FTSInfo 1479 = TemplateOrSpecialization.dyn_cast< 1480 FunctionTemplateSpecializationInfo*>()) { 1481 FTSInfo->setTemplateSpecializationKind(TSK); 1482 if (TSK != TSK_ExplicitSpecialization && 1483 PointOfInstantiation.isValid() && 1484 FTSInfo->getPointOfInstantiation().isInvalid()) 1485 FTSInfo->setPointOfInstantiation(PointOfInstantiation); 1486 } else if (MemberSpecializationInfo *MSInfo 1487 = TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo*>()) { 1488 MSInfo->setTemplateSpecializationKind(TSK); 1489 if (TSK != TSK_ExplicitSpecialization && 1490 PointOfInstantiation.isValid() && 1491 MSInfo->getPointOfInstantiation().isInvalid()) 1492 MSInfo->setPointOfInstantiation(PointOfInstantiation); 1493 } else 1494 assert(false && "Function cannot have a template specialization kind"); 1495} 1496 1497SourceLocation FunctionDecl::getPointOfInstantiation() const { 1498 if (FunctionTemplateSpecializationInfo *FTSInfo 1499 = TemplateOrSpecialization.dyn_cast< 1500 FunctionTemplateSpecializationInfo*>()) 1501 return FTSInfo->getPointOfInstantiation(); 1502 else if (MemberSpecializationInfo *MSInfo 1503 = TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo*>()) 1504 return MSInfo->getPointOfInstantiation(); 1505 1506 return SourceLocation(); 1507} 1508 1509bool FunctionDecl::isOutOfLine() const { 1510 if (Decl::isOutOfLine()) 1511 return true; 1512 1513 // If this function was instantiated from a member function of a 1514 // class template, check whether that member function was defined out-of-line. 1515 if (FunctionDecl *FD = getInstantiatedFromMemberFunction()) { 1516 const FunctionDecl *Definition; 1517 if (FD->hasBody(Definition)) 1518 return Definition->isOutOfLine(); 1519 } 1520 1521 // If this function was instantiated from a function template, 1522 // check whether that function template was defined out-of-line. 1523 if (FunctionTemplateDecl *FunTmpl = getPrimaryTemplate()) { 1524 const FunctionDecl *Definition; 1525 if (FunTmpl->getTemplatedDecl()->hasBody(Definition)) 1526 return Definition->isOutOfLine(); 1527 } 1528 1529 return false; 1530} 1531 1532//===----------------------------------------------------------------------===// 1533// FieldDecl Implementation 1534//===----------------------------------------------------------------------===// 1535 1536FieldDecl *FieldDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L, 1537 IdentifierInfo *Id, QualType T, 1538 TypeSourceInfo *TInfo, Expr *BW, bool Mutable) { 1539 return new (C) FieldDecl(Decl::Field, DC, L, Id, T, TInfo, BW, Mutable); 1540} 1541 1542bool FieldDecl::isAnonymousStructOrUnion() const { 1543 if (!isImplicit() || getDeclName()) 1544 return false; 1545 1546 if (const RecordType *Record = getType()->getAs<RecordType>()) 1547 return Record->getDecl()->isAnonymousStructOrUnion(); 1548 1549 return false; 1550} 1551 1552//===----------------------------------------------------------------------===// 1553// TagDecl Implementation 1554//===----------------------------------------------------------------------===// 1555 1556SourceLocation TagDecl::getOuterLocStart() const { 1557 return getTemplateOrInnerLocStart(this); 1558} 1559 1560SourceRange TagDecl::getSourceRange() const { 1561 SourceLocation E = RBraceLoc.isValid() ? RBraceLoc : getLocation(); 1562 return SourceRange(getOuterLocStart(), E); 1563} 1564 1565TagDecl* TagDecl::getCanonicalDecl() { 1566 return getFirstDeclaration(); 1567} 1568 1569void TagDecl::setTypedefForAnonDecl(TypedefDecl *TDD) { 1570 TypedefDeclOrQualifier = TDD; 1571 if (TypeForDecl) 1572 TypeForDecl->ClearLinkageCache(); 1573} 1574 1575void TagDecl::startDefinition() { 1576 IsBeingDefined = true; 1577 1578 if (isa<CXXRecordDecl>(this)) { 1579 CXXRecordDecl *D = cast<CXXRecordDecl>(this); 1580 struct CXXRecordDecl::DefinitionData *Data = 1581 new (getASTContext()) struct CXXRecordDecl::DefinitionData(D); 1582 for (redecl_iterator I = redecls_begin(), E = redecls_end(); I != E; ++I) 1583 cast<CXXRecordDecl>(*I)->DefinitionData = Data; 1584 } 1585} 1586 1587void TagDecl::completeDefinition() { 1588 assert((!isa<CXXRecordDecl>(this) || 1589 cast<CXXRecordDecl>(this)->hasDefinition()) && 1590 "definition completed but not started"); 1591 1592 IsDefinition = true; 1593 IsBeingDefined = false; 1594} 1595 1596TagDecl* TagDecl::getDefinition() const { 1597 if (isDefinition()) 1598 return const_cast<TagDecl *>(this); 1599 1600 for (redecl_iterator R = redecls_begin(), REnd = redecls_end(); 1601 R != REnd; ++R) 1602 if (R->isDefinition()) 1603 return *R; 1604 1605 return 0; 1606} 1607 1608void TagDecl::setQualifierInfo(NestedNameSpecifier *Qualifier, 1609 SourceRange QualifierRange) { 1610 if (Qualifier) { 1611 // Make sure the extended qualifier info is allocated. 1612 if (!hasExtInfo()) 1613 TypedefDeclOrQualifier = new (getASTContext()) ExtInfo; 1614 // Set qualifier info. 1615 getExtInfo()->NNS = Qualifier; 1616 getExtInfo()->NNSRange = QualifierRange; 1617 } 1618 else { 1619 // Here Qualifier == 0, i.e., we are removing the qualifier (if any). 1620 assert(QualifierRange.isInvalid()); 1621 if (hasExtInfo()) { 1622 getASTContext().Deallocate(getExtInfo()); 1623 TypedefDeclOrQualifier = (TypedefDecl*) 0; 1624 } 1625 } 1626} 1627 1628//===----------------------------------------------------------------------===// 1629// EnumDecl Implementation 1630//===----------------------------------------------------------------------===// 1631 1632EnumDecl *EnumDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L, 1633 IdentifierInfo *Id, SourceLocation TKL, 1634 EnumDecl *PrevDecl) { 1635 EnumDecl *Enum = new (C) EnumDecl(DC, L, Id, PrevDecl, TKL); 1636 C.getTypeDeclType(Enum, PrevDecl); 1637 return Enum; 1638} 1639 1640EnumDecl *EnumDecl::Create(ASTContext &C, EmptyShell Empty) { 1641 return new (C) EnumDecl(0, SourceLocation(), 0, 0, SourceLocation()); 1642} 1643 1644void EnumDecl::completeDefinition(QualType NewType, 1645 QualType NewPromotionType, 1646 unsigned NumPositiveBits, 1647 unsigned NumNegativeBits) { 1648 assert(!isDefinition() && "Cannot redefine enums!"); 1649 IntegerType = NewType; 1650 PromotionType = NewPromotionType; 1651 setNumPositiveBits(NumPositiveBits); 1652 setNumNegativeBits(NumNegativeBits); 1653 TagDecl::completeDefinition(); 1654} 1655 1656//===----------------------------------------------------------------------===// 1657// RecordDecl Implementation 1658//===----------------------------------------------------------------------===// 1659 1660RecordDecl::RecordDecl(Kind DK, TagKind TK, DeclContext *DC, SourceLocation L, 1661 IdentifierInfo *Id, RecordDecl *PrevDecl, 1662 SourceLocation TKL) 1663 : TagDecl(DK, TK, DC, L, Id, PrevDecl, TKL) { 1664 HasFlexibleArrayMember = false; 1665 AnonymousStructOrUnion = false; 1666 HasObjectMember = false; 1667 assert(classof(static_cast<Decl*>(this)) && "Invalid Kind!"); 1668} 1669 1670RecordDecl *RecordDecl::Create(ASTContext &C, TagKind TK, DeclContext *DC, 1671 SourceLocation L, IdentifierInfo *Id, 1672 SourceLocation TKL, RecordDecl* PrevDecl) { 1673 1674 RecordDecl* R = new (C) RecordDecl(Record, TK, DC, L, Id, PrevDecl, TKL); 1675 C.getTypeDeclType(R, PrevDecl); 1676 return R; 1677} 1678 1679RecordDecl *RecordDecl::Create(ASTContext &C, EmptyShell Empty) { 1680 return new (C) RecordDecl(Record, TTK_Struct, 0, SourceLocation(), 0, 0, 1681 SourceLocation()); 1682} 1683 1684bool RecordDecl::isInjectedClassName() const { 1685 return isImplicit() && getDeclName() && getDeclContext()->isRecord() && 1686 cast<RecordDecl>(getDeclContext())->getDeclName() == getDeclName(); 1687} 1688 1689/// completeDefinition - Notes that the definition of this type is now 1690/// complete. 1691void RecordDecl::completeDefinition() { 1692 assert(!isDefinition() && "Cannot redefine record!"); 1693 TagDecl::completeDefinition(); 1694} 1695 1696ValueDecl *RecordDecl::getAnonymousStructOrUnionObject() { 1697 // Force the decl chain to come into existence properly. 1698 if (!getNextDeclInContext()) getParent()->decls_begin(); 1699 1700 assert(isAnonymousStructOrUnion()); 1701 ValueDecl *D = cast<ValueDecl>(getNextDeclInContext()); 1702 assert(D->getType()->isRecordType()); 1703 assert(D->getType()->getAs<RecordType>()->getDecl() == this); 1704 return D; 1705} 1706 1707//===----------------------------------------------------------------------===// 1708// BlockDecl Implementation 1709//===----------------------------------------------------------------------===// 1710 1711void BlockDecl::setParams(ParmVarDecl **NewParamInfo, 1712 unsigned NParms) { 1713 assert(ParamInfo == 0 && "Already has param info!"); 1714 1715 // Zero params -> null pointer. 1716 if (NParms) { 1717 NumParams = NParms; 1718 void *Mem = getASTContext().Allocate(sizeof(ParmVarDecl*)*NumParams); 1719 ParamInfo = new (Mem) ParmVarDecl*[NumParams]; 1720 memcpy(ParamInfo, NewParamInfo, sizeof(ParmVarDecl*)*NumParams); 1721 } 1722} 1723 1724unsigned BlockDecl::getNumParams() const { 1725 return NumParams; 1726} 1727 1728 1729//===----------------------------------------------------------------------===// 1730// Other Decl Allocation/Deallocation Method Implementations 1731//===----------------------------------------------------------------------===// 1732 1733TranslationUnitDecl *TranslationUnitDecl::Create(ASTContext &C) { 1734 return new (C) TranslationUnitDecl(C); 1735} 1736 1737NamespaceDecl *NamespaceDecl::Create(ASTContext &C, DeclContext *DC, 1738 SourceLocation L, IdentifierInfo *Id) { 1739 return new (C) NamespaceDecl(DC, L, Id); 1740} 1741 1742ImplicitParamDecl *ImplicitParamDecl::Create(ASTContext &C, DeclContext *DC, 1743 SourceLocation L, IdentifierInfo *Id, QualType T) { 1744 return new (C) ImplicitParamDecl(ImplicitParam, DC, L, Id, T); 1745} 1746 1747FunctionDecl *FunctionDecl::Create(ASTContext &C, DeclContext *DC, 1748 const DeclarationNameInfo &NameInfo, 1749 QualType T, TypeSourceInfo *TInfo, 1750 StorageClass S, StorageClass SCAsWritten, 1751 bool isInline, bool hasWrittenPrototype) { 1752 FunctionDecl *New = new (C) FunctionDecl(Function, DC, NameInfo, T, TInfo, 1753 S, SCAsWritten, isInline); 1754 New->HasWrittenPrototype = hasWrittenPrototype; 1755 return New; 1756} 1757 1758BlockDecl *BlockDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L) { 1759 return new (C) BlockDecl(DC, L); 1760} 1761 1762EnumConstantDecl *EnumConstantDecl::Create(ASTContext &C, EnumDecl *CD, 1763 SourceLocation L, 1764 IdentifierInfo *Id, QualType T, 1765 Expr *E, const llvm::APSInt &V) { 1766 return new (C) EnumConstantDecl(CD, L, Id, T, E, V); 1767} 1768 1769TypedefDecl *TypedefDecl::Create(ASTContext &C, DeclContext *DC, 1770 SourceLocation L, IdentifierInfo *Id, 1771 TypeSourceInfo *TInfo) { 1772 return new (C) TypedefDecl(DC, L, Id, TInfo); 1773} 1774 1775FileScopeAsmDecl *FileScopeAsmDecl::Create(ASTContext &C, DeclContext *DC, 1776 SourceLocation L, 1777 StringLiteral *Str) { 1778 return new (C) FileScopeAsmDecl(DC, L, Str); 1779} 1780