contrib/llvm/tools/clang/lib/AST/Decl.cpp

   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
  29 using 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.
  37 static Linkage
  38 getLinkageForTemplateParameterList(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.
  61 static 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
 100 static Linkage
 101 getLinkageForTemplateArgumentList(const TemplateArgumentList &TArgs) {
 102   return getLinkageForTemplateArgumentList(TArgs.getFlatArgumentList(),
 103                                            TArgs.flat_size());
 104 }
 105
 106 static Linkage getLinkageForNamespaceScopeDecl(const NamedDecl *D) {
 107   assert(D->getDeclContext()->getRedeclContext()->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() == SC_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() != SC_Extern &&
 129         Var->getStorageClass() != SC_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() == SC_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() == SC_Extern ||
 169          Var->getStorageClass() == SC_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() == SC_Extern ||
 204          Function->getStorageClass() == SC_PrivateExtern ||
 205          Function->getStorageClass() == SC_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
 283 static 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
 324 Linkage 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()->getRedeclContext()->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() == SC_Extern ||
 387           Var->getStorageClass() == SC_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
 404 std::string NamedDecl::getQualifiedNameAsString() const {
 405   return getQualifiedNameAsString(getASTContext().getLangOptions());
 406 }
 407
 408 std::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
 484 bool 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
 523 bool NamedDecl::hasLinkage() const {
 524   return getLinkage() != NoLinkage;
 525 }
 526
 527 NamedDecl *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
 540 bool 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
 562 template <typename DeclT>
 563 static SourceLocation getTemplateOrInnerLocStart(const DeclT *decl) {
 564   if (decl->getNumTemplateParameterLists() > 0)
 565     return decl->getTemplateParameterList(0)->getTemplateLoc();
 566   else
 567     return decl->getInnerLocStart();
 568 }
 569
 570 SourceLocation DeclaratorDecl::getTypeSpecStartLoc() const {
 571   TypeSourceInfo *TSI = getTypeSourceInfo();
 572   if (TSI) return TSI->getTypeLoc().getBeginLoc();
 573   return SourceLocation();
 574 }
 575
 576 void 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
 606 SourceLocation DeclaratorDecl::getOuterLocStart() const {
 607   return getTemplateOrInnerLocStart(this);
 608 }
 609
 610 void
 611 QualifierInfo::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
 638 const char *VarDecl::getStorageClassSpecifierString(StorageClass SC) {
 639   switch (SC) {
 640   case SC_None:          break;
 641   case SC_Auto:          return "auto"; break;
 642   case SC_Extern:        return "extern"; break;
 643   case SC_PrivateExtern: return "__private_extern__"; break;
 644   case SC_Register:      return "register"; break;
 645   case SC_Static:        return "static"; break;
 646   }
 647
 648   assert(0 && "Invalid storage class");
 649   return 0;
 650 }
 651
 652 VarDecl *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
 658 SourceLocation VarDecl::getInnerLocStart() const {
 659   SourceLocation Start = getTypeSpecStartLoc();
 660   if (Start.isInvalid())
 661     Start = getLocation();
 662   return Start;
 663 }
 664
 665 SourceRange VarDecl::getSourceRange() const {
 666   if (getInit())
 667     return SourceRange(getOuterLocStart(), getInit()->getLocEnd());
 668   return SourceRange(getOuterLocStart(), getLocation());
 669 }
 670
 671 bool VarDecl::isExternC() const {
 672   ASTContext &Context = getASTContext();
 673   if (!Context.getLangOptions().CPlusPlus)
 674     return (getDeclContext()->isTranslationUnit() &&
 675             getStorageClass() != SC_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() != SC_Static;
 683
 684       break;
 685     }
 686
 687     if (DC->isFunctionOrMethod())
 688       return false;
 689   }
 690
 691   return false;
 692 }
 693
 694 VarDecl *VarDecl::getCanonicalDecl() {
 695   return getFirstDeclaration();
 696 }
 697
 698 VarDecl::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() == SC_Extern ||
 728        getStorageClassAsWritten() == SC_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
 748 VarDecl *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
 766 bool 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
 778 VarDecl *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
 788 const 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
 800 bool 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
 816 VarDecl *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
 829 void 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
 838 VarDecl *VarDecl::getInstantiatedFromStaticDataMember() const {
 839   if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo())
 840     return cast<VarDecl>(MSI->getInstantiatedFrom());
 841
 842   return 0;
 843 }
 844
 845 TemplateSpecializationKind VarDecl::getTemplateSpecializationKind() const {
 846   if (MemberSpecializationInfo *MSI = getMemberSpecializationInfo())
 847     return MSI->getTemplateSpecializationKind();
 848
 849   return TSK_Undeclared;
 850 }
 851
 852 MemberSpecializationInfo *VarDecl::getMemberSpecializationInfo() const {
 853   return getASTContext().getInstantiatedFromStaticDataMember(this);
 854 }
 855
 856 void 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
 871 ParmVarDecl *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
 880 Expr *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
 892 unsigned ParmVarDecl::getNumDefaultArgTemporaries() const {
 893   if (const CXXExprWithTemporaries *E =
 894         dyn_cast<CXXExprWithTemporaries>(getInit()))
 895     return E->getNumTemporaries();
 896
 897   return 0;
 898 }
 899
 900 CXXTemporary *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
 908 SourceRange 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
 922 void 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
 935 bool FunctionDecl::isVariadic() const {
 936   if (const FunctionProtoType *FT = getType()->getAs<FunctionProtoType>())
 937     return FT->isVariadic();
 938   return false;
 939 }
 940
 941 bool 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
 952 Stmt *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
 963 void FunctionDecl::setBody(Stmt *B) {
 964   Body = B;
 965   if (B)
 966     EndRangeLoc = B->getLocEnd();
 967 }
 968
 969 bool FunctionDecl::isMain() const {
 970   ASTContext &Context = getASTContext();
 971   return !Context.getLangOptions().Freestanding &&
 972     getDeclContext()->getRedeclContext()->isTranslationUnit() &&
 973     getIdentifier() && getIdentifier()->isStr("main");
 974 }
 975
 976 bool 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() != SC_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() != SC_Static &&
 988                !getAttr<OverloadableAttr>();
 989
 990       break;
 991     }
 992
 993     if (DC->isRecord())
 994       break;
 995   }
 996
 997   return false;
 998 }
 999
1000 bool FunctionDecl::isGlobal() const {
1001   if (const CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(this))
1002     return Method->isStatic();
1003
1004   if (getStorageClass() == SC_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
1020 void
1021 FunctionDecl::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
1032 const FunctionDecl *FunctionDecl::getCanonicalDecl() const {
1033   return getFirstDeclaration();
1034 }
1035
1036 FunctionDecl *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.
1049 unsigned 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() == SC_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.
1088 unsigned 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
1096 void 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++).
1117 unsigned FunctionDecl::getMinRequiredArguments() const {
1118   unsigned NumRequiredArgs = getNumParams();
1119   while (NumRequiredArgs > 0
1120          && getParamDecl(NumRequiredArgs-1)->hasDefaultArg())
1121     --NumRequiredArgs;
1122
1123   return NumRequiredArgs;
1124 }
1125
1126 bool 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.
1182 bool 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() != SC_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() == SC_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.
1229 OverloadedOperatorKind 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.
1238 const IdentifierInfo *FunctionDecl::getLiteralIdentifier() const {
1239   if (getDeclName().getNameKind() == DeclarationName::CXXLiteralOperatorName)
1240     return getDeclName().getCXXLiteralIdentifier();
1241   else
1242     return 0;
1243 }
1244
1245 FunctionDecl::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
1262 FunctionDecl *FunctionDecl::getInstantiatedFromMemberFunction() const {
1263   if (MemberSpecializationInfo *Info = getMemberSpecializationInfo())
1264     return cast<FunctionDecl>(Info->getInstantiatedFrom());
1265
1266   return 0;
1267 }
1268
1269 MemberSpecializationInfo *FunctionDecl::getMemberSpecializationInfo() const {
1270   return TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo*>();
1271 }
1272
1273 void
1274 FunctionDecl::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
1283 bool 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
1318 FunctionDecl *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
1335 FunctionTemplateDecl *FunctionDecl::getPrimaryTemplate() const {
1336   if (FunctionTemplateSpecializationInfo *Info
1337         = TemplateOrSpecialization
1338             .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
1339     return Info->Template.getPointer();
1340   }
1341   return 0;
1342 }
1343
1344 const TemplateArgumentList *
1345 FunctionDecl::getTemplateSpecializationArgs() const {
1346   if (FunctionTemplateSpecializationInfo *Info
1347         = TemplateOrSpecialization
1348             .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
1349     return Info->TemplateArguments;
1350   }
1351   return 0;
1352 }
1353
1354 const TemplateArgumentListInfo *
1355 FunctionDecl::getTemplateSpecializationArgsAsWritten() const {
1356   if (FunctionTemplateSpecializationInfo *Info
1357         = TemplateOrSpecialization
1358             .dyn_cast<FunctionTemplateSpecializationInfo*>()) {
1359     return Info->TemplateArgumentsAsWritten;
1360   }
1361   return 0;
1362 }
1363
1364 void
1365 FunctionDecl::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
1403 void
1404 FunctionDecl::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
1425 void
1426 FunctionDecl::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
1440 DependentFunctionTemplateSpecializationInfo::
1441 DependentFunctionTemplateSpecializationInfo(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
1459 TemplateSpecializationKind 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
1475 void
1476 FunctionDecl::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
1497 SourceLocation 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
1509 bool 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
1536 FieldDecl *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
1542 bool 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
1556 SourceLocation TagDecl::getOuterLocStart() const {
1557   return getTemplateOrInnerLocStart(this);
1558 }
1559
1560 SourceRange TagDecl::getSourceRange() const {
1561   SourceLocation E = RBraceLoc.isValid() ? RBraceLoc : getLocation();
1562   return SourceRange(getOuterLocStart(), E);
1563 }
1564
1565 TagDecl* TagDecl::getCanonicalDecl() {
1566   return getFirstDeclaration();
1567 }
1568
1569 void TagDecl::setTypedefForAnonDecl(TypedefDecl *TDD) {
1570   TypedefDeclOrQualifier = TDD;
1571   if (TypeForDecl)
1572     TypeForDecl->ClearLinkageCache();
1573 }
1574
1575 void 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
1587 void 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
1596 TagDecl* 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
1608 void 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
1632 EnumDecl *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
1640 EnumDecl *EnumDecl::Create(ASTContext &C, EmptyShell Empty) {
1641   return new (C) EnumDecl(0, SourceLocation(), 0, 0, SourceLocation());
1642 }
1643
1644 void 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
1660 RecordDecl::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
1670 RecordDecl *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
1679 RecordDecl *RecordDecl::Create(ASTContext &C, EmptyShell Empty) {
1680   return new (C) RecordDecl(Record, TTK_Struct, 0, SourceLocation(), 0, 0,
1681                             SourceLocation());
1682 }
1683
1684 bool 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.
1691 void RecordDecl::completeDefinition() {
1692   assert(!isDefinition() && "Cannot redefine record!");
1693   TagDecl::completeDefinition();
1694 }
1695
1696 ValueDecl *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
1711 void 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
1724 unsigned BlockDecl::getNumParams() const {
1725   return NumParams;
1726 }
1727
1728
1729 //===----------------------------------------------------------------------===//
1730 // Other Decl Allocation/Deallocation Method Implementations
1731 //===----------------------------------------------------------------------===//
1732
1733 TranslationUnitDecl *TranslationUnitDecl::Create(ASTContext &C) {
1734   return new (C) TranslationUnitDecl(C);
1735 }
1736
1737 NamespaceDecl *NamespaceDecl::Create(ASTContext &C, DeclContext *DC,
1738                                      SourceLocation L, IdentifierInfo *Id) {
1739   return new (C) NamespaceDecl(DC, L, Id);
1740 }
1741
1742 ImplicitParamDecl *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
1747 FunctionDecl *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
1758 BlockDecl *BlockDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation L) {
1759   return new (C) BlockDecl(DC, L);
1760 }
1761
1762 EnumConstantDecl *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
1769 SourceRange EnumConstantDecl::getSourceRange() const {
1770   SourceLocation End = getLocation();
1771   if (Init)
1772     End = Init->getLocEnd();
1773   return SourceRange(getLocation(), End);
1774 }
1775
1776 TypedefDecl *TypedefDecl::Create(ASTContext &C, DeclContext *DC,
1777                                  SourceLocation L, IdentifierInfo *Id,
1778                                  TypeSourceInfo *TInfo) {
1779   return new (C) TypedefDecl(DC, L, Id, TInfo);
1780 }
1781
1782 FileScopeAsmDecl *FileScopeAsmDecl::Create(ASTContext &C, DeclContext *DC,
1783                                            SourceLocation L,
1784                                            StringLiteral *Str) {
1785   return new (C) FileScopeAsmDecl(DC, L, Str);
1786 }