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

   1 //===--- DeclBase.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 and DeclContext classes.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/AST/DeclBase.h"
  15 #include "clang/AST/ASTContext.h"
  16 #include "clang/AST/ASTMutationListener.h"
  17 #include "clang/AST/Attr.h"
  18 #include "clang/AST/Decl.h"
  19 #include "clang/AST/DeclCXX.h"
  20 #include "clang/AST/DeclContextInternals.h"
  21 #include "clang/AST/DeclFriend.h"
  22 #include "clang/AST/DeclObjC.h"
  23 #include "clang/AST/DeclOpenMP.h"
  24 #include "clang/AST/DeclTemplate.h"
  25 #include "clang/AST/DependentDiagnostic.h"
  26 #include "clang/AST/ExternalASTSource.h"
  27 #include "clang/AST/Stmt.h"
  28 #include "clang/AST/StmtCXX.h"
  29 #include "clang/AST/Type.h"
  30 #include "clang/Basic/TargetInfo.h"
  31 #include "llvm/ADT/DenseMap.h"
  32 #include "llvm/Support/raw_ostream.h"
  33 #include <algorithm>
  34 using namespace clang;
  35
  36 //===----------------------------------------------------------------------===//
  37 //  Statistics
  38 //===----------------------------------------------------------------------===//
  39
  40 #define DECL(DERIVED, BASE) static int n##DERIVED##s = 0;
  41 #define ABSTRACT_DECL(DECL)
  42 #include "clang/AST/DeclNodes.inc"
  43
  44 void Decl::updateOutOfDate(IdentifierInfo &II) const {
  45   getASTContext().getExternalSource()->updateOutOfDateIdentifier(II);
  46 }
  47
  48 void *Decl::AllocateDeserializedDecl(const ASTContext &Context,
  49                                      unsigned ID,
  50                                      unsigned Size) {
  51   // Allocate an extra 8 bytes worth of storage, which ensures that the
  52   // resulting pointer will still be 8-byte aligned.
  53   void *Start = Context.Allocate(Size + 8);
  54   void *Result = (char*)Start + 8;
  55
  56   unsigned *PrefixPtr = (unsigned *)Result - 2;
  57
  58   // Zero out the first 4 bytes; this is used to store the owning module ID.
  59   PrefixPtr[0] = 0;
  60
  61   // Store the global declaration ID in the second 4 bytes.
  62   PrefixPtr[1] = ID;
  63
  64   return Result;
  65 }
  66
  67 Module *Decl::getOwningModuleSlow() const {
  68   assert(isFromASTFile() && "Not from AST file?");
  69   return getASTContext().getExternalSource()->getModule(getOwningModuleID());
  70 }
  71
  72 const char *Decl::getDeclKindName() const {
  73   switch (DeclKind) {
  74   default: llvm_unreachable("Declaration not in DeclNodes.inc!");
  75 #define DECL(DERIVED, BASE) case DERIVED: return #DERIVED;
  76 #define ABSTRACT_DECL(DECL)
  77 #include "clang/AST/DeclNodes.inc"
  78   }
  79 }
  80
  81 void Decl::setInvalidDecl(bool Invalid) {
  82   InvalidDecl = Invalid;
  83   if (Invalid && !isa<ParmVarDecl>(this)) {
  84     // Defensive maneuver for ill-formed code: we're likely not to make it to
  85     // a point where we set the access specifier, so default it to "public"
  86     // to avoid triggering asserts elsewhere in the front end.
  87     setAccess(AS_public);
  88   }
  89 }
  90
  91 const char *DeclContext::getDeclKindName() const {
  92   switch (DeclKind) {
  93   default: llvm_unreachable("Declaration context not in DeclNodes.inc!");
  94 #define DECL(DERIVED, BASE) case Decl::DERIVED: return #DERIVED;
  95 #define ABSTRACT_DECL(DECL)
  96 #include "clang/AST/DeclNodes.inc"
  97   }
  98 }
  99
 100 bool Decl::StatisticsEnabled = false;
 101 void Decl::EnableStatistics() {
 102   StatisticsEnabled = true;
 103 }
 104
 105 void Decl::PrintStats() {
 106   llvm::errs() << "\n*** Decl Stats:\n";
 107
 108   int totalDecls = 0;
 109 #define DECL(DERIVED, BASE) totalDecls += n##DERIVED##s;
 110 #define ABSTRACT_DECL(DECL)
 111 #include "clang/AST/DeclNodes.inc"
 112   llvm::errs() << "  " << totalDecls << " decls total.\n";
 113
 114   int totalBytes = 0;
 115 #define DECL(DERIVED, BASE)                                             \
 116   if (n##DERIVED##s > 0) {                                              \
 117     totalBytes += (int)(n##DERIVED##s * sizeof(DERIVED##Decl));         \
 118     llvm::errs() << "    " << n##DERIVED##s << " " #DERIVED " decls, "  \
 119                  << sizeof(DERIVED##Decl) << " each ("                  \
 120                  << n##DERIVED##s * sizeof(DERIVED##Decl)               \
 121                  << " bytes)\n";                                        \
 122   }
 123 #define ABSTRACT_DECL(DECL)
 124 #include "clang/AST/DeclNodes.inc"
 125
 126   llvm::errs() << "Total bytes = " << totalBytes << "\n";
 127 }
 128
 129 void Decl::add(Kind k) {
 130   switch (k) {
 131 #define DECL(DERIVED, BASE) case DERIVED: ++n##DERIVED##s; break;
 132 #define ABSTRACT_DECL(DECL)
 133 #include "clang/AST/DeclNodes.inc"
 134   }
 135 }
 136
 137 bool Decl::isTemplateParameterPack() const {
 138   if (const TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(this))
 139     return TTP->isParameterPack();
 140   if (const NonTypeTemplateParmDecl *NTTP
 141                                 = dyn_cast<NonTypeTemplateParmDecl>(this))
 142     return NTTP->isParameterPack();
 143   if (const TemplateTemplateParmDecl *TTP
 144                                     = dyn_cast<TemplateTemplateParmDecl>(this))
 145     return TTP->isParameterPack();
 146   return false;
 147 }
 148
 149 bool Decl::isParameterPack() const {
 150   if (const ParmVarDecl *Parm = dyn_cast<ParmVarDecl>(this))
 151     return Parm->isParameterPack();
 152
 153   return isTemplateParameterPack();
 154 }
 155
 156 bool Decl::isFunctionOrFunctionTemplate() const {
 157   if (const UsingShadowDecl *UD = dyn_cast<UsingShadowDecl>(this))
 158     return UD->getTargetDecl()->isFunctionOrFunctionTemplate();
 159
 160   return isa<FunctionDecl>(this) || isa<FunctionTemplateDecl>(this);
 161 }
 162
 163 bool Decl::isTemplateDecl() const {
 164   return isa<TemplateDecl>(this);
 165 }
 166
 167 const DeclContext *Decl::getParentFunctionOrMethod() const {
 168   for (const DeclContext *DC = getDeclContext();
 169        DC && !DC->isTranslationUnit() && !DC->isNamespace();
 170        DC = DC->getParent())
 171     if (DC->isFunctionOrMethod())
 172       return DC;
 173
 174   return 0;
 175 }
 176
 177
 178 //===----------------------------------------------------------------------===//
 179 // PrettyStackTraceDecl Implementation
 180 //===----------------------------------------------------------------------===//
 181
 182 void PrettyStackTraceDecl::print(raw_ostream &OS) const {
 183   SourceLocation TheLoc = Loc;
 184   if (TheLoc.isInvalid() && TheDecl)
 185     TheLoc = TheDecl->getLocation();
 186
 187   if (TheLoc.isValid()) {
 188     TheLoc.print(OS, SM);
 189     OS << ": ";
 190   }
 191
 192   OS << Message;
 193
 194   if (const NamedDecl *DN = dyn_cast_or_null<NamedDecl>(TheDecl)) {
 195     OS << " '";
 196     DN->printQualifiedName(OS);
 197     OS << '\'';
 198   }
 199   OS << '\n';
 200 }
 201
 202 //===----------------------------------------------------------------------===//
 203 // Decl Implementation
 204 //===----------------------------------------------------------------------===//
 205
 206 // Out-of-line virtual method providing a home for Decl.
 207 Decl::~Decl() { }
 208
 209 void Decl::setDeclContext(DeclContext *DC) {
 210   DeclCtx = DC;
 211 }
 212
 213 void Decl::setLexicalDeclContext(DeclContext *DC) {
 214   if (DC == getLexicalDeclContext())
 215     return;
 216
 217   if (isInSemaDC()) {
 218     setDeclContextsImpl(getDeclContext(), DC, getASTContext());
 219   } else {
 220     getMultipleDC()->LexicalDC = DC;
 221   }
 222 }
 223
 224 void Decl::setDeclContextsImpl(DeclContext *SemaDC, DeclContext *LexicalDC,
 225                                ASTContext &Ctx) {
 226   if (SemaDC == LexicalDC) {
 227     DeclCtx = SemaDC;
 228   } else {
 229     Decl::MultipleDC *MDC = new (Ctx) Decl::MultipleDC();
 230     MDC->SemanticDC = SemaDC;
 231     MDC->LexicalDC = LexicalDC;
 232     DeclCtx = MDC;
 233   }
 234 }
 235
 236 bool Decl::isInAnonymousNamespace() const {
 237   const DeclContext *DC = getDeclContext();
 238   do {
 239     if (const NamespaceDecl *ND = dyn_cast<NamespaceDecl>(DC))
 240       if (ND->isAnonymousNamespace())
 241         return true;
 242   } while ((DC = DC->getParent()));
 243
 244   return false;
 245 }
 246
 247 TranslationUnitDecl *Decl::getTranslationUnitDecl() {
 248   if (TranslationUnitDecl *TUD = dyn_cast<TranslationUnitDecl>(this))
 249     return TUD;
 250
 251   DeclContext *DC = getDeclContext();
 252   assert(DC && "This decl is not contained in a translation unit!");
 253
 254   while (!DC->isTranslationUnit()) {
 255     DC = DC->getParent();
 256     assert(DC && "This decl is not contained in a translation unit!");
 257   }
 258
 259   return cast<TranslationUnitDecl>(DC);
 260 }
 261
 262 ASTContext &Decl::getASTContext() const {
 263   return getTranslationUnitDecl()->getASTContext();
 264 }
 265
 266 ASTMutationListener *Decl::getASTMutationListener() const {
 267   return getASTContext().getASTMutationListener();
 268 }
 269
 270 unsigned Decl::getMaxAlignment() const {
 271   if (!hasAttrs())
 272     return 0;
 273
 274   unsigned Align = 0;
 275   const AttrVec &V = getAttrs();
 276   ASTContext &Ctx = getASTContext();
 277   specific_attr_iterator<AlignedAttr> I(V.begin()), E(V.end());
 278   for (; I != E; ++I)
 279     Align = std::max(Align, I->getAlignment(Ctx));
 280   return Align;
 281 }
 282
 283 bool Decl::isUsed(bool CheckUsedAttr) const {
 284   if (Used)
 285     return true;
 286
 287   // Check for used attribute.
 288   if (CheckUsedAttr && hasAttr<UsedAttr>())
 289     return true;
 290
 291   return false;
 292 }
 293
 294 void Decl::markUsed(ASTContext &C) {
 295   if (Used)
 296     return;
 297
 298   if (C.getASTMutationListener())
 299     C.getASTMutationListener()->DeclarationMarkedUsed(this);
 300
 301   Used = true;
 302 }
 303
 304 bool Decl::isReferenced() const {
 305   if (Referenced)
 306     return true;
 307
 308   // Check redeclarations.
 309   for (redecl_iterator I = redecls_begin(), E = redecls_end(); I != E; ++I)
 310     if (I->Referenced)
 311       return true;
 312
 313   return false;
 314 }
 315
 316 /// \brief Determine the availability of the given declaration based on
 317 /// the target platform.
 318 ///
 319 /// When it returns an availability result other than \c AR_Available,
 320 /// if the \p Message parameter is non-NULL, it will be set to a
 321 /// string describing why the entity is unavailable.
 322 ///
 323 /// FIXME: Make these strings localizable, since they end up in
 324 /// diagnostics.
 325 static AvailabilityResult CheckAvailability(ASTContext &Context,
 326                                             const AvailabilityAttr *A,
 327                                             std::string *Message) {
 328   StringRef TargetPlatform = Context.getTargetInfo().getPlatformName();
 329   StringRef PrettyPlatformName
 330     = AvailabilityAttr::getPrettyPlatformName(TargetPlatform);
 331   if (PrettyPlatformName.empty())
 332     PrettyPlatformName = TargetPlatform;
 333
 334   VersionTuple TargetMinVersion = Context.getTargetInfo().getPlatformMinVersion();
 335   if (TargetMinVersion.empty())
 336     return AR_Available;
 337
 338   // Match the platform name.
 339   if (A->getPlatform()->getName() != TargetPlatform)
 340     return AR_Available;
 341
 342   std::string HintMessage;
 343   if (!A->getMessage().empty()) {
 344     HintMessage = " - ";
 345     HintMessage += A->getMessage();
 346   }
 347
 348   // Make sure that this declaration has not been marked 'unavailable'.
 349   if (A->getUnavailable()) {
 350     if (Message) {
 351       Message->clear();
 352       llvm::raw_string_ostream Out(*Message);
 353       Out << "not available on " << PrettyPlatformName
 354           << HintMessage;
 355     }
 356
 357     return AR_Unavailable;
 358   }
 359
 360   // Make sure that this declaration has already been introduced.
 361   if (!A->getIntroduced().empty() &&
 362       TargetMinVersion < A->getIntroduced()) {
 363     if (Message) {
 364       Message->clear();
 365       llvm::raw_string_ostream Out(*Message);
 366       Out << "introduced in " << PrettyPlatformName << ' '
 367           << A->getIntroduced() << HintMessage;
 368     }
 369
 370     return AR_NotYetIntroduced;
 371   }
 372
 373   // Make sure that this declaration hasn't been obsoleted.
 374   if (!A->getObsoleted().empty() && TargetMinVersion >= A->getObsoleted()) {
 375     if (Message) {
 376       Message->clear();
 377       llvm::raw_string_ostream Out(*Message);
 378       Out << "obsoleted in " << PrettyPlatformName << ' '
 379           << A->getObsoleted() << HintMessage;
 380     }
 381
 382     return AR_Unavailable;
 383   }
 384
 385   // Make sure that this declaration hasn't been deprecated.
 386   if (!A->getDeprecated().empty() && TargetMinVersion >= A->getDeprecated()) {
 387     if (Message) {
 388       Message->clear();
 389       llvm::raw_string_ostream Out(*Message);
 390       Out << "first deprecated in " << PrettyPlatformName << ' '
 391           << A->getDeprecated() << HintMessage;
 392     }
 393
 394     return AR_Deprecated;
 395   }
 396
 397   return AR_Available;
 398 }
 399
 400 AvailabilityResult Decl::getAvailability(std::string *Message) const {
 401   AvailabilityResult Result = AR_Available;
 402   std::string ResultMessage;
 403
 404   for (attr_iterator A = attr_begin(), AEnd = attr_end(); A != AEnd; ++A) {
 405     if (DeprecatedAttr *Deprecated = dyn_cast<DeprecatedAttr>(*A)) {
 406       if (Result >= AR_Deprecated)
 407         continue;
 408
 409       if (Message)
 410         ResultMessage = Deprecated->getMessage();
 411
 412       Result = AR_Deprecated;
 413       continue;
 414     }
 415
 416     if (UnavailableAttr *Unavailable = dyn_cast<UnavailableAttr>(*A)) {
 417       if (Message)
 418         *Message = Unavailable->getMessage();
 419       return AR_Unavailable;
 420     }
 421
 422     if (AvailabilityAttr *Availability = dyn_cast<AvailabilityAttr>(*A)) {
 423       AvailabilityResult AR = CheckAvailability(getASTContext(), Availability,
 424                                                 Message);
 425
 426       if (AR == AR_Unavailable)
 427         return AR_Unavailable;
 428
 429       if (AR > Result) {
 430         Result = AR;
 431         if (Message)
 432           ResultMessage.swap(*Message);
 433       }
 434       continue;
 435     }
 436   }
 437
 438   if (Message)
 439     Message->swap(ResultMessage);
 440   return Result;
 441 }
 442
 443 bool Decl::canBeWeakImported(bool &IsDefinition) const {
 444   IsDefinition = false;
 445
 446   // Variables, if they aren't definitions.
 447   if (const VarDecl *Var = dyn_cast<VarDecl>(this)) {
 448     if (Var->isThisDeclarationADefinition()) {
 449       IsDefinition = true;
 450       return false;
 451     }
 452     return true;
 453
 454   // Functions, if they aren't definitions.
 455   } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(this)) {
 456     if (FD->hasBody()) {
 457       IsDefinition = true;
 458       return false;
 459     }
 460     return true;
 461
 462   // Objective-C classes, if this is the non-fragile runtime.
 463   } else if (isa<ObjCInterfaceDecl>(this) &&
 464              getASTContext().getLangOpts().ObjCRuntime.hasWeakClassImport()) {
 465     return true;
 466
 467   // Nothing else.
 468   } else {
 469     return false;
 470   }
 471 }
 472
 473 bool Decl::isWeakImported() const {
 474   bool IsDefinition;
 475   if (!canBeWeakImported(IsDefinition))
 476     return false;
 477
 478   for (attr_iterator A = attr_begin(), AEnd = attr_end(); A != AEnd; ++A) {
 479     if (isa<WeakImportAttr>(*A))
 480       return true;
 481
 482     if (AvailabilityAttr *Availability = dyn_cast<AvailabilityAttr>(*A)) {
 483       if (CheckAvailability(getASTContext(), Availability, 0)
 484                                                          == AR_NotYetIntroduced)
 485         return true;
 486     }
 487   }
 488
 489   return false;
 490 }
 491
 492 unsigned Decl::getIdentifierNamespaceForKind(Kind DeclKind) {
 493   switch (DeclKind) {
 494     case Function:
 495     case CXXMethod:
 496     case CXXConstructor:
 497     case CXXDestructor:
 498     case CXXConversion:
 499     case EnumConstant:
 500     case Var:
 501     case ImplicitParam:
 502     case ParmVar:
 503     case NonTypeTemplateParm:
 504     case ObjCMethod:
 505     case ObjCProperty:
 506     case MSProperty:
 507       return IDNS_Ordinary;
 508     case Label:
 509       return IDNS_Label;
 510     case IndirectField:
 511       return IDNS_Ordinary | IDNS_Member;
 512
 513     case ObjCCompatibleAlias:
 514     case ObjCInterface:
 515       return IDNS_Ordinary | IDNS_Type;
 516
 517     case Typedef:
 518     case TypeAlias:
 519     case TypeAliasTemplate:
 520     case UnresolvedUsingTypename:
 521     case TemplateTypeParm:
 522       return IDNS_Ordinary | IDNS_Type;
 523
 524     case UsingShadow:
 525       return 0; // we'll actually overwrite this later
 526
 527     case UnresolvedUsingValue:
 528       return IDNS_Ordinary | IDNS_Using;
 529
 530     case Using:
 531       return IDNS_Using;
 532
 533     case ObjCProtocol:
 534       return IDNS_ObjCProtocol;
 535
 536     case Field:
 537     case ObjCAtDefsField:
 538     case ObjCIvar:
 539       return IDNS_Member;
 540
 541     case Record:
 542     case CXXRecord:
 543     case Enum:
 544       return IDNS_Tag | IDNS_Type;
 545
 546     case Namespace:
 547     case NamespaceAlias:
 548       return IDNS_Namespace;
 549
 550     case FunctionTemplate:
 551     case VarTemplate:
 552       return IDNS_Ordinary;
 553
 554     case ClassTemplate:
 555     case TemplateTemplateParm:
 556       return IDNS_Ordinary | IDNS_Tag | IDNS_Type;
 557
 558     // Never have names.
 559     case Friend:
 560     case FriendTemplate:
 561     case AccessSpec:
 562     case LinkageSpec:
 563     case FileScopeAsm:
 564     case StaticAssert:
 565     case ObjCPropertyImpl:
 566     case Block:
 567     case Captured:
 568     case TranslationUnit:
 569
 570     case UsingDirective:
 571     case ClassTemplateSpecialization:
 572     case ClassTemplatePartialSpecialization:
 573     case ClassScopeFunctionSpecialization:
 574     case VarTemplateSpecialization:
 575     case VarTemplatePartialSpecialization:
 576     case ObjCImplementation:
 577     case ObjCCategory:
 578     case ObjCCategoryImpl:
 579     case Import:
 580     case OMPThreadPrivate:
 581     case Empty:
 582       // Never looked up by name.
 583       return 0;
 584   }
 585
 586   llvm_unreachable("Invalid DeclKind!");
 587 }
 588
 589 void Decl::setAttrsImpl(const AttrVec &attrs, ASTContext &Ctx) {
 590   assert(!HasAttrs && "Decl already contains attrs.");
 591
 592   AttrVec &AttrBlank = Ctx.getDeclAttrs(this);
 593   assert(AttrBlank.empty() && "HasAttrs was wrong?");
 594
 595   AttrBlank = attrs;
 596   HasAttrs = true;
 597 }
 598
 599 void Decl::dropAttrs() {
 600   if (!HasAttrs) return;
 601
 602   HasAttrs = false;
 603   getASTContext().eraseDeclAttrs(this);
 604 }
 605
 606 const AttrVec &Decl::getAttrs() const {
 607   assert(HasAttrs && "No attrs to get!");
 608   return getASTContext().getDeclAttrs(this);
 609 }
 610
 611 Decl *Decl::castFromDeclContext (const DeclContext *D) {
 612   Decl::Kind DK = D->getDeclKind();
 613   switch(DK) {
 614 #define DECL(NAME, BASE)
 615 #define DECL_CONTEXT(NAME) \
 616     case Decl::NAME:       \
 617       return static_cast<NAME##Decl*>(const_cast<DeclContext*>(D));
 618 #define DECL_CONTEXT_BASE(NAME)
 619 #include "clang/AST/DeclNodes.inc"
 620     default:
 621 #define DECL(NAME, BASE)
 622 #define DECL_CONTEXT_BASE(NAME)                  \
 623       if (DK >= first##NAME && DK <= last##NAME) \
 624         return static_cast<NAME##Decl*>(const_cast<DeclContext*>(D));
 625 #include "clang/AST/DeclNodes.inc"
 626       llvm_unreachable("a decl that inherits DeclContext isn't handled");
 627   }
 628 }
 629
 630 DeclContext *Decl::castToDeclContext(const Decl *D) {
 631   Decl::Kind DK = D->getKind();
 632   switch(DK) {
 633 #define DECL(NAME, BASE)
 634 #define DECL_CONTEXT(NAME) \
 635     case Decl::NAME:       \
 636       return static_cast<NAME##Decl*>(const_cast<Decl*>(D));
 637 #define DECL_CONTEXT_BASE(NAME)
 638 #include "clang/AST/DeclNodes.inc"
 639     default:
 640 #define DECL(NAME, BASE)
 641 #define DECL_CONTEXT_BASE(NAME)                                   \
 642       if (DK >= first##NAME && DK <= last##NAME)                  \
 643         return static_cast<NAME##Decl*>(const_cast<Decl*>(D));
 644 #include "clang/AST/DeclNodes.inc"
 645       llvm_unreachable("a decl that inherits DeclContext isn't handled");
 646   }
 647 }
 648
 649 SourceLocation Decl::getBodyRBrace() const {
 650   // Special handling of FunctionDecl to avoid de-serializing the body from PCH.
 651   // FunctionDecl stores EndRangeLoc for this purpose.
 652   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(this)) {
 653     const FunctionDecl *Definition;
 654     if (FD->hasBody(Definition))
 655       return Definition->getSourceRange().getEnd();
 656     return SourceLocation();
 657   }
 658
 659   if (Stmt *Body = getBody())
 660     return Body->getSourceRange().getEnd();
 661
 662   return SourceLocation();
 663 }
 664
 665 void Decl::CheckAccessDeclContext() const {
 666 #ifndef NDEBUG
 667   // Suppress this check if any of the following hold:
 668   // 1. this is the translation unit (and thus has no parent)
 669   // 2. this is a template parameter (and thus doesn't belong to its context)
 670   // 3. this is a non-type template parameter
 671   // 4. the context is not a record
 672   // 5. it's invalid
 673   // 6. it's a C++0x static_assert.
 674   if (isa<TranslationUnitDecl>(this) ||
 675       isa<TemplateTypeParmDecl>(this) ||
 676       isa<NonTypeTemplateParmDecl>(this) ||
 677       !isa<CXXRecordDecl>(getDeclContext()) ||
 678       isInvalidDecl() ||
 679       isa<StaticAssertDecl>(this) ||
 680       // FIXME: a ParmVarDecl can have ClassTemplateSpecialization
 681       // as DeclContext (?).
 682       isa<ParmVarDecl>(this) ||
 683       // FIXME: a ClassTemplateSpecialization or CXXRecordDecl can have
 684       // AS_none as access specifier.
 685       isa<CXXRecordDecl>(this) ||
 686       isa<ClassScopeFunctionSpecializationDecl>(this))
 687     return;
 688
 689   assert(Access != AS_none &&
 690          "Access specifier is AS_none inside a record decl");
 691 #endif
 692 }
 693
 694 static Decl::Kind getKind(const Decl *D) { return D->getKind(); }
 695 static Decl::Kind getKind(const DeclContext *DC) { return DC->getDeclKind(); }
 696
 697 /// Starting at a given context (a Decl or DeclContext), look for a
 698 /// code context that is not a closure (a lambda, block, etc.).
 699 template <class T> static Decl *getNonClosureContext(T *D) {
 700   if (getKind(D) == Decl::CXXMethod) {
 701     CXXMethodDecl *MD = cast<CXXMethodDecl>(D);
 702     if (MD->getOverloadedOperator() == OO_Call &&
 703         MD->getParent()->isLambda())
 704       return getNonClosureContext(MD->getParent()->getParent());
 705     return MD;
 706   } else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
 707     return FD;
 708   } else if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
 709     return MD;
 710   } else if (BlockDecl *BD = dyn_cast<BlockDecl>(D)) {
 711     return getNonClosureContext(BD->getParent());
 712   } else if (CapturedDecl *CD = dyn_cast<CapturedDecl>(D)) {
 713     return getNonClosureContext(CD->getParent());
 714   } else {
 715     return 0;
 716   }
 717 }
 718
 719 Decl *Decl::getNonClosureContext() {
 720   return ::getNonClosureContext(this);
 721 }
 722
 723 Decl *DeclContext::getNonClosureAncestor() {
 724   return ::getNonClosureContext(this);
 725 }
 726
 727 //===----------------------------------------------------------------------===//
 728 // DeclContext Implementation
 729 //===----------------------------------------------------------------------===//
 730
 731 bool DeclContext::classof(const Decl *D) {
 732   switch (D->getKind()) {
 733 #define DECL(NAME, BASE)
 734 #define DECL_CONTEXT(NAME) case Decl::NAME:
 735 #define DECL_CONTEXT_BASE(NAME)
 736 #include "clang/AST/DeclNodes.inc"
 737       return true;
 738     default:
 739 #define DECL(NAME, BASE)
 740 #define DECL_CONTEXT_BASE(NAME)                 \
 741       if (D->getKind() >= Decl::first##NAME &&  \
 742           D->getKind() <= Decl::last##NAME)     \
 743         return true;
 744 #include "clang/AST/DeclNodes.inc"
 745       return false;
 746   }
 747 }
 748
 749 DeclContext::~DeclContext() { }
 750
 751 /// \brief Find the parent context of this context that will be
 752 /// used for unqualified name lookup.
 753 ///
 754 /// Generally, the parent lookup context is the semantic context. However, for
 755 /// a friend function the parent lookup context is the lexical context, which
 756 /// is the class in which the friend is declared.
 757 DeclContext *DeclContext::getLookupParent() {
 758   // FIXME: Find a better way to identify friends
 759   if (isa<FunctionDecl>(this))
 760     if (getParent()->getRedeclContext()->isFileContext() &&
 761         getLexicalParent()->getRedeclContext()->isRecord())
 762       return getLexicalParent();
 763
 764   return getParent();
 765 }
 766
 767 bool DeclContext::isInlineNamespace() const {
 768   return isNamespace() &&
 769          cast<NamespaceDecl>(this)->isInline();
 770 }
 771
 772 bool DeclContext::isDependentContext() const {
 773   if (isFileContext())
 774     return false;
 775
 776   if (isa<ClassTemplatePartialSpecializationDecl>(this))
 777     return true;
 778
 779   if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(this)) {
 780     if (Record->getDescribedClassTemplate())
 781       return true;
 782
 783     if (Record->isDependentLambda())
 784       return true;
 785   }
 786
 787   if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(this)) {
 788     if (Function->getDescribedFunctionTemplate())
 789       return true;
 790
 791     // Friend function declarations are dependent if their *lexical*
 792     // context is dependent.
 793     if (cast<Decl>(this)->getFriendObjectKind())
 794       return getLexicalParent()->isDependentContext();
 795   }
 796
 797   return getParent() && getParent()->isDependentContext();
 798 }
 799
 800 bool DeclContext::isTransparentContext() const {
 801   if (DeclKind == Decl::Enum)
 802     return !cast<EnumDecl>(this)->isScoped();
 803   else if (DeclKind == Decl::LinkageSpec)
 804     return true;
 805
 806   return false;
 807 }
 808
 809 static bool isLinkageSpecContext(const DeclContext *DC,
 810                                  LinkageSpecDecl::LanguageIDs ID) {
 811   while (DC->getDeclKind() != Decl::TranslationUnit) {
 812     if (DC->getDeclKind() == Decl::LinkageSpec)
 813       return cast<LinkageSpecDecl>(DC)->getLanguage() == ID;
 814     DC = DC->getParent();
 815   }
 816   return false;
 817 }
 818
 819 bool DeclContext::isExternCContext() const {
 820   return isLinkageSpecContext(this, clang::LinkageSpecDecl::lang_c);
 821 }
 822
 823 bool DeclContext::isExternCXXContext() const {
 824   return isLinkageSpecContext(this, clang::LinkageSpecDecl::lang_cxx);
 825 }
 826
 827 bool DeclContext::Encloses(const DeclContext *DC) const {
 828   if (getPrimaryContext() != this)
 829     return getPrimaryContext()->Encloses(DC);
 830
 831   for (; DC; DC = DC->getParent())
 832     if (DC->getPrimaryContext() == this)
 833       return true;
 834   return false;
 835 }
 836
 837 DeclContext *DeclContext::getPrimaryContext() {
 838   switch (DeclKind) {
 839   case Decl::TranslationUnit:
 840   case Decl::LinkageSpec:
 841   case Decl::Block:
 842   case Decl::Captured:
 843     // There is only one DeclContext for these entities.
 844     return this;
 845
 846   case Decl::Namespace:
 847     // The original namespace is our primary context.
 848     return static_cast<NamespaceDecl*>(this)->getOriginalNamespace();
 849
 850   case Decl::ObjCMethod:
 851     return this;
 852
 853   case Decl::ObjCInterface:
 854     if (ObjCInterfaceDecl *Def = cast<ObjCInterfaceDecl>(this)->getDefinition())
 855       return Def;
 856
 857     return this;
 858
 859   case Decl::ObjCProtocol:
 860     if (ObjCProtocolDecl *Def = cast<ObjCProtocolDecl>(this)->getDefinition())
 861       return Def;
 862
 863     return this;
 864
 865   case Decl::ObjCCategory:
 866     return this;
 867
 868   case Decl::ObjCImplementation:
 869   case Decl::ObjCCategoryImpl:
 870     return this;
 871
 872   default:
 873     if (DeclKind >= Decl::firstTag && DeclKind <= Decl::lastTag) {
 874       // If this is a tag type that has a definition or is currently
 875       // being defined, that definition is our primary context.
 876       TagDecl *Tag = cast<TagDecl>(this);
 877       assert(isa<TagType>(Tag->TypeForDecl) ||
 878              isa<InjectedClassNameType>(Tag->TypeForDecl));
 879
 880       if (TagDecl *Def = Tag->getDefinition())
 881         return Def;
 882
 883       if (!isa<InjectedClassNameType>(Tag->TypeForDecl)) {
 884         const TagType *TagTy = cast<TagType>(Tag->TypeForDecl);
 885         if (TagTy->isBeingDefined())
 886           // FIXME: is it necessarily being defined in the decl
 887           // that owns the type?
 888           return TagTy->getDecl();
 889       }
 890
 891       return Tag;
 892     }
 893
 894     assert(DeclKind >= Decl::firstFunction && DeclKind <= Decl::lastFunction &&
 895           "Unknown DeclContext kind");
 896     return this;
 897   }
 898 }
 899
 900 void
 901 DeclContext::collectAllContexts(SmallVectorImpl<DeclContext *> &Contexts){
 902   Contexts.clear();
 903
 904   if (DeclKind != Decl::Namespace) {
 905     Contexts.push_back(this);
 906     return;
 907   }
 908
 909   NamespaceDecl *Self = static_cast<NamespaceDecl *>(this);
 910   for (NamespaceDecl *N = Self->getMostRecentDecl(); N;
 911        N = N->getPreviousDecl())
 912     Contexts.push_back(N);
 913
 914   std::reverse(Contexts.begin(), Contexts.end());
 915 }
 916
 917 std::pair<Decl *, Decl *>
 918 DeclContext::BuildDeclChain(ArrayRef<Decl*> Decls,
 919                             bool FieldsAlreadyLoaded) {
 920   // Build up a chain of declarations via the Decl::NextInContextAndBits field.
 921   Decl *FirstNewDecl = 0;
 922   Decl *PrevDecl = 0;
 923   for (unsigned I = 0, N = Decls.size(); I != N; ++I) {
 924     if (FieldsAlreadyLoaded && isa<FieldDecl>(Decls[I]))
 925       continue;
 926
 927     Decl *D = Decls[I];
 928     if (PrevDecl)
 929       PrevDecl->NextInContextAndBits.setPointer(D);
 930     else
 931       FirstNewDecl = D;
 932
 933     PrevDecl = D;
 934   }
 935
 936   return std::make_pair(FirstNewDecl, PrevDecl);
 937 }
 938
 939 /// \brief We have just acquired external visible storage, and we already have
 940 /// built a lookup map. For every name in the map, pull in the new names from
 941 /// the external storage.
 942 void DeclContext::reconcileExternalVisibleStorage() {
 943   assert(NeedToReconcileExternalVisibleStorage && LookupPtr.getPointer());
 944   NeedToReconcileExternalVisibleStorage = false;
 945
 946   StoredDeclsMap &Map = *LookupPtr.getPointer();
 947   for (StoredDeclsMap::iterator I = Map.begin(); I != Map.end(); ++I)
 948     I->second.setHasExternalDecls();
 949 }
 950
 951 /// \brief Load the declarations within this lexical storage from an
 952 /// external source.
 953 void
 954 DeclContext::LoadLexicalDeclsFromExternalStorage() const {
 955   ExternalASTSource *Source = getParentASTContext().getExternalSource();
 956   assert(hasExternalLexicalStorage() && Source && "No external storage?");
 957
 958   // Notify that we have a DeclContext that is initializing.
 959   ExternalASTSource::Deserializing ADeclContext(Source);
 960
 961   // Load the external declarations, if any.
 962   SmallVector<Decl*, 64> Decls;
 963   ExternalLexicalStorage = false;
 964   switch (Source->FindExternalLexicalDecls(this, Decls)) {
 965   case ELR_Success:
 966     break;
 967
 968   case ELR_Failure:
 969   case ELR_AlreadyLoaded:
 970     return;
 971   }
 972
 973   if (Decls.empty())
 974     return;
 975
 976   // We may have already loaded just the fields of this record, in which case
 977   // we need to ignore them.
 978   bool FieldsAlreadyLoaded = false;
 979   if (const RecordDecl *RD = dyn_cast<RecordDecl>(this))
 980     FieldsAlreadyLoaded = RD->LoadedFieldsFromExternalStorage;
 981
 982   // Splice the newly-read declarations into the beginning of the list
 983   // of declarations.
 984   Decl *ExternalFirst, *ExternalLast;
 985   llvm::tie(ExternalFirst, ExternalLast) = BuildDeclChain(Decls,
 986                                                           FieldsAlreadyLoaded);
 987   ExternalLast->NextInContextAndBits.setPointer(FirstDecl);
 988   FirstDecl = ExternalFirst;
 989   if (!LastDecl)
 990     LastDecl = ExternalLast;
 991 }
 992
 993 DeclContext::lookup_result
 994 ExternalASTSource::SetNoExternalVisibleDeclsForName(const DeclContext *DC,
 995                                                     DeclarationName Name) {
 996   ASTContext &Context = DC->getParentASTContext();
 997   StoredDeclsMap *Map;
 998   if (!(Map = DC->LookupPtr.getPointer()))
 999     Map = DC->CreateStoredDeclsMap(Context);
1000
1001   (*Map)[Name].removeExternalDecls();
1002
1003   return DeclContext::lookup_result();
1004 }
1005
1006 DeclContext::lookup_result
1007 ExternalASTSource::SetExternalVisibleDeclsForName(const DeclContext *DC,
1008                                                   DeclarationName Name,
1009                                                   ArrayRef<NamedDecl*> Decls) {
1010   ASTContext &Context = DC->getParentASTContext();
1011   StoredDeclsMap *Map;
1012   if (!(Map = DC->LookupPtr.getPointer()))
1013     Map = DC->CreateStoredDeclsMap(Context);
1014
1015   StoredDeclsList &List = (*Map)[Name];
1016
1017   // Clear out any old external visible declarations, to avoid quadratic
1018   // performance in the redeclaration checks below.
1019   List.removeExternalDecls();
1020
1021   if (!List.isNull()) {
1022     // We have both existing declarations and new declarations for this name.
1023     // Some of the declarations may simply replace existing ones. Handle those
1024     // first.
1025     llvm::SmallVector<unsigned, 8> Skip;
1026     for (unsigned I = 0, N = Decls.size(); I != N; ++I)
1027       if (List.HandleRedeclaration(Decls[I]))
1028         Skip.push_back(I);
1029     Skip.push_back(Decls.size());
1030
1031     // Add in any new declarations.
1032     unsigned SkipPos = 0;
1033     for (unsigned I = 0, N = Decls.size(); I != N; ++I) {
1034       if (I == Skip[SkipPos])
1035         ++SkipPos;
1036       else
1037         List.AddSubsequentDecl(Decls[I]);
1038     }
1039   } else {
1040     // Convert the array to a StoredDeclsList.
1041     for (ArrayRef<NamedDecl*>::iterator
1042            I = Decls.begin(), E = Decls.end(); I != E; ++I) {
1043       if (List.isNull())
1044         List.setOnlyValue(*I);
1045       else
1046         List.AddSubsequentDecl(*I);
1047     }
1048   }
1049
1050   return List.getLookupResult();
1051 }
1052
1053 DeclContext::decl_iterator DeclContext::noload_decls_begin() const {
1054   return decl_iterator(FirstDecl);
1055 }
1056
1057 DeclContext::decl_iterator DeclContext::decls_begin() const {
1058   if (hasExternalLexicalStorage())
1059     LoadLexicalDeclsFromExternalStorage();
1060
1061   return decl_iterator(FirstDecl);
1062 }
1063
1064 bool DeclContext::decls_empty() const {
1065   if (hasExternalLexicalStorage())
1066     LoadLexicalDeclsFromExternalStorage();
1067
1068   return !FirstDecl;
1069 }
1070
1071 bool DeclContext::containsDecl(Decl *D) const {
1072   return (D->getLexicalDeclContext() == this &&
1073           (D->NextInContextAndBits.getPointer() || D == LastDecl));
1074 }
1075
1076 void DeclContext::removeDecl(Decl *D) {
1077   assert(D->getLexicalDeclContext() == this &&
1078          "decl being removed from non-lexical context");
1079   assert((D->NextInContextAndBits.getPointer() || D == LastDecl) &&
1080          "decl is not in decls list");
1081
1082   // Remove D from the decl chain.  This is O(n) but hopefully rare.
1083   if (D == FirstDecl) {
1084     if (D == LastDecl)
1085       FirstDecl = LastDecl = 0;
1086     else
1087       FirstDecl = D->NextInContextAndBits.getPointer();
1088   } else {
1089     for (Decl *I = FirstDecl; true; I = I->NextInContextAndBits.getPointer()) {
1090       assert(I && "decl not found in linked list");
1091       if (I->NextInContextAndBits.getPointer() == D) {
1092         I->NextInContextAndBits.setPointer(D->NextInContextAndBits.getPointer());
1093         if (D == LastDecl) LastDecl = I;
1094         break;
1095       }
1096     }
1097   }
1098
1099   // Mark that D is no longer in the decl chain.
1100   D->NextInContextAndBits.setPointer(0);
1101
1102   // Remove D from the lookup table if necessary.
1103   if (isa<NamedDecl>(D)) {
1104     NamedDecl *ND = cast<NamedDecl>(D);
1105
1106     // Remove only decls that have a name
1107     if (!ND->getDeclName()) return;
1108
1109     StoredDeclsMap *Map = getPrimaryContext()->LookupPtr.getPointer();
1110     if (!Map) return;
1111
1112     StoredDeclsMap::iterator Pos = Map->find(ND->getDeclName());
1113     assert(Pos != Map->end() && "no lookup entry for decl");
1114     if (Pos->second.getAsVector() || Pos->second.getAsDecl() == ND)
1115       Pos->second.remove(ND);
1116   }
1117 }
1118
1119 void DeclContext::addHiddenDecl(Decl *D) {
1120   assert(D->getLexicalDeclContext() == this &&
1121          "Decl inserted into wrong lexical context");
1122   assert(!D->getNextDeclInContext() && D != LastDecl &&
1123          "Decl already inserted into a DeclContext");
1124
1125   if (FirstDecl) {
1126     LastDecl->NextInContextAndBits.setPointer(D);
1127     LastDecl = D;
1128   } else {
1129     FirstDecl = LastDecl = D;
1130   }
1131
1132   // Notify a C++ record declaration that we've added a member, so it can
1133   // update it's class-specific state.
1134   if (CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(this))
1135     Record->addedMember(D);
1136
1137   // If this is a newly-created (not de-serialized) import declaration, wire
1138   // it in to the list of local import declarations.
1139   if (!D->isFromASTFile()) {
1140     if (ImportDecl *Import = dyn_cast<ImportDecl>(D))
1141       D->getASTContext().addedLocalImportDecl(Import);
1142   }
1143 }
1144
1145 void DeclContext::addDecl(Decl *D) {
1146   addHiddenDecl(D);
1147
1148   if (NamedDecl *ND = dyn_cast<NamedDecl>(D))
1149     ND->getDeclContext()->getPrimaryContext()->
1150         makeDeclVisibleInContextWithFlags(ND, false, true);
1151 }
1152
1153 void DeclContext::addDeclInternal(Decl *D) {
1154   addHiddenDecl(D);
1155
1156   if (NamedDecl *ND = dyn_cast<NamedDecl>(D))
1157     ND->getDeclContext()->getPrimaryContext()->
1158         makeDeclVisibleInContextWithFlags(ND, true, true);
1159 }
1160
1161 /// shouldBeHidden - Determine whether a declaration which was declared
1162 /// within its semantic context should be invisible to qualified name lookup.
1163 static bool shouldBeHidden(NamedDecl *D) {
1164   // Skip unnamed declarations.
1165   if (!D->getDeclName())
1166     return true;
1167
1168   // Skip entities that can't be found by name lookup into a particular
1169   // context.
1170   if ((D->getIdentifierNamespace() == 0 && !isa<UsingDirectiveDecl>(D)) ||
1171       D->isTemplateParameter())
1172     return true;
1173
1174   // Skip template specializations.
1175   // FIXME: This feels like a hack. Should DeclarationName support
1176   // template-ids, or is there a better way to keep specializations
1177   // from being visible?
1178   if (isa<ClassTemplateSpecializationDecl>(D))
1179     return true;
1180   if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D))
1181     if (FD->isFunctionTemplateSpecialization())
1182       return true;
1183
1184   return false;
1185 }
1186
1187 /// buildLookup - Build the lookup data structure with all of the
1188 /// declarations in this DeclContext (and any other contexts linked
1189 /// to it or transparent contexts nested within it) and return it.
1190 StoredDeclsMap *DeclContext::buildLookup() {
1191   assert(this == getPrimaryContext() && "buildLookup called on non-primary DC");
1192
1193   // FIXME: Should we keep going if hasExternalVisibleStorage?
1194   if (!LookupPtr.getInt())
1195     return LookupPtr.getPointer();
1196
1197   SmallVector<DeclContext *, 2> Contexts;
1198   collectAllContexts(Contexts);
1199   for (unsigned I = 0, N = Contexts.size(); I != N; ++I)
1200     buildLookupImpl<&DeclContext::decls_begin,
1201                     &DeclContext::decls_end>(Contexts[I]);
1202
1203   // We no longer have any lazy decls.
1204   LookupPtr.setInt(false);
1205   NeedToReconcileExternalVisibleStorage = false;
1206   return LookupPtr.getPointer();
1207 }
1208
1209 /// buildLookupImpl - Build part of the lookup data structure for the
1210 /// declarations contained within DCtx, which will either be this
1211 /// DeclContext, a DeclContext linked to it, or a transparent context
1212 /// nested within it.
1213 template<DeclContext::decl_iterator (DeclContext::*Begin)() const,
1214          DeclContext::decl_iterator (DeclContext::*End)() const>
1215 void DeclContext::buildLookupImpl(DeclContext *DCtx) {
1216   for (decl_iterator I = (DCtx->*Begin)(), E = (DCtx->*End)();
1217        I != E; ++I) {
1218     Decl *D = *I;
1219
1220     // Insert this declaration into the lookup structure, but only if
1221     // it's semantically within its decl context. Any other decls which
1222     // should be found in this context are added eagerly.
1223     //
1224     // If it's from an AST file, don't add it now. It'll get handled by
1225     // FindExternalVisibleDeclsByName if needed. Exception: if we're not
1226     // in C++, we do not track external visible decls for the TU, so in
1227     // that case we need to collect them all here.
1228     if (NamedDecl *ND = dyn_cast<NamedDecl>(D))
1229       if (ND->getDeclContext() == DCtx && !shouldBeHidden(ND) &&
1230           (!ND->isFromASTFile() ||
1231            (isTranslationUnit() &&
1232             !getParentASTContext().getLangOpts().CPlusPlus)))
1233         makeDeclVisibleInContextImpl(ND, false);
1234
1235     // If this declaration is itself a transparent declaration context
1236     // or inline namespace, add the members of this declaration of that
1237     // context (recursively).
1238     if (DeclContext *InnerCtx = dyn_cast<DeclContext>(D))
1239       if (InnerCtx->isTransparentContext() || InnerCtx->isInlineNamespace())
1240         buildLookupImpl<Begin, End>(InnerCtx);
1241   }
1242 }
1243
1244 DeclContext::lookup_result
1245 DeclContext::lookup(DeclarationName Name) {
1246   assert(DeclKind != Decl::LinkageSpec &&
1247          "Should not perform lookups into linkage specs!");
1248
1249   DeclContext *PrimaryContext = getPrimaryContext();
1250   if (PrimaryContext != this)
1251     return PrimaryContext->lookup(Name);
1252
1253   if (hasExternalVisibleStorage()) {
1254     StoredDeclsMap *Map = LookupPtr.getPointer();
1255     if (LookupPtr.getInt())
1256       Map = buildLookup();
1257     else if (NeedToReconcileExternalVisibleStorage)
1258       reconcileExternalVisibleStorage();
1259
1260     if (!Map)
1261       Map = CreateStoredDeclsMap(getParentASTContext());
1262
1263     // If we have a lookup result with no external decls, we are done.
1264     std::pair<StoredDeclsMap::iterator, bool> R =
1265         Map->insert(std::make_pair(Name, StoredDeclsList()));
1266     if (!R.second && !R.first->second.hasExternalDecls())
1267       return R.first->second.getLookupResult();
1268
1269     ExternalASTSource *Source = getParentASTContext().getExternalSource();
1270     if (Source->FindExternalVisibleDeclsByName(this, Name) || R.second) {
1271       if (StoredDeclsMap *Map = LookupPtr.getPointer()) {
1272         StoredDeclsMap::iterator I = Map->find(Name);
1273         if (I != Map->end())
1274           return I->second.getLookupResult();
1275       }
1276     }
1277
1278     return lookup_result(lookup_iterator(0), lookup_iterator(0));
1279   }
1280
1281   StoredDeclsMap *Map = LookupPtr.getPointer();
1282   if (LookupPtr.getInt())
1283     Map = buildLookup();
1284
1285   if (!Map)
1286     return lookup_result(lookup_iterator(0), lookup_iterator(0));
1287
1288   StoredDeclsMap::iterator I = Map->find(Name);
1289   if (I == Map->end())
1290     return lookup_result(lookup_iterator(0), lookup_iterator(0));
1291
1292   return I->second.getLookupResult();
1293 }
1294
1295 DeclContext::lookup_result
1296 DeclContext::noload_lookup(DeclarationName Name) {
1297   assert(DeclKind != Decl::LinkageSpec &&
1298          "Should not perform lookups into linkage specs!");
1299   if (!hasExternalVisibleStorage())
1300     return lookup(Name);
1301
1302   DeclContext *PrimaryContext = getPrimaryContext();
1303   if (PrimaryContext != this)
1304     return PrimaryContext->noload_lookup(Name);
1305
1306   StoredDeclsMap *Map = LookupPtr.getPointer();
1307   if (LookupPtr.getInt()) {
1308     // Carefully build the lookup map, without deserializing anything.
1309     SmallVector<DeclContext *, 2> Contexts;
1310     collectAllContexts(Contexts);
1311     for (unsigned I = 0, N = Contexts.size(); I != N; ++I)
1312       buildLookupImpl<&DeclContext::noload_decls_begin,
1313                       &DeclContext::noload_decls_end>(Contexts[I]);
1314
1315     // We no longer have any lazy decls.
1316     LookupPtr.setInt(false);
1317
1318     // There may now be names for which we have local decls but are
1319     // missing the external decls. FIXME: Just set the hasExternalDecls
1320     // flag on those names that have external decls.
1321     NeedToReconcileExternalVisibleStorage = true;
1322
1323     Map = LookupPtr.getPointer();
1324   }
1325
1326   if (!Map)
1327     return lookup_result(lookup_iterator(0), lookup_iterator(0));
1328
1329   StoredDeclsMap::iterator I = Map->find(Name);
1330   return I != Map->end()
1331              ? I->second.getLookupResult()
1332              : lookup_result(lookup_iterator(0), lookup_iterator(0));
1333 }
1334
1335 void DeclContext::localUncachedLookup(DeclarationName Name,
1336                                       SmallVectorImpl<NamedDecl *> &Results) {
1337   Results.clear();
1338
1339   // If there's no external storage, just perform a normal lookup and copy
1340   // the results.
1341   if (!hasExternalVisibleStorage() && !hasExternalLexicalStorage() && Name) {
1342     lookup_result LookupResults = lookup(Name);
1343     Results.insert(Results.end(), LookupResults.begin(), LookupResults.end());
1344     return;
1345   }
1346
1347   // If we have a lookup table, check there first. Maybe we'll get lucky.
1348   if (Name && !LookupPtr.getInt()) {
1349     if (StoredDeclsMap *Map = LookupPtr.getPointer()) {
1350       StoredDeclsMap::iterator Pos = Map->find(Name);
1351       if (Pos != Map->end()) {
1352         Results.insert(Results.end(),
1353                        Pos->second.getLookupResult().begin(),
1354                        Pos->second.getLookupResult().end());
1355         return;
1356       }
1357     }
1358   }
1359
1360   // Slow case: grovel through the declarations in our chain looking for
1361   // matches.
1362   for (Decl *D = FirstDecl; D; D = D->getNextDeclInContext()) {
1363     if (NamedDecl *ND = dyn_cast<NamedDecl>(D))
1364       if (ND->getDeclName() == Name)
1365         Results.push_back(ND);
1366   }
1367 }
1368
1369 DeclContext *DeclContext::getRedeclContext() {
1370   DeclContext *Ctx = this;
1371   // Skip through transparent contexts.
1372   while (Ctx->isTransparentContext())
1373     Ctx = Ctx->getParent();
1374   return Ctx;
1375 }
1376
1377 DeclContext *DeclContext::getEnclosingNamespaceContext() {
1378   DeclContext *Ctx = this;
1379   // Skip through non-namespace, non-translation-unit contexts.
1380   while (!Ctx->isFileContext())
1381     Ctx = Ctx->getParent();
1382   return Ctx->getPrimaryContext();
1383 }
1384
1385 bool DeclContext::InEnclosingNamespaceSetOf(const DeclContext *O) const {
1386   // For non-file contexts, this is equivalent to Equals.
1387   if (!isFileContext())
1388     return O->Equals(this);
1389
1390   do {
1391     if (O->Equals(this))
1392       return true;
1393
1394     const NamespaceDecl *NS = dyn_cast<NamespaceDecl>(O);
1395     if (!NS || !NS->isInline())
1396       break;
1397     O = NS->getParent();
1398   } while (O);
1399
1400   return false;
1401 }
1402
1403 void DeclContext::makeDeclVisibleInContext(NamedDecl *D) {
1404   DeclContext *PrimaryDC = this->getPrimaryContext();
1405   DeclContext *DeclDC = D->getDeclContext()->getPrimaryContext();
1406   // If the decl is being added outside of its semantic decl context, we
1407   // need to ensure that we eagerly build the lookup information for it.
1408   PrimaryDC->makeDeclVisibleInContextWithFlags(D, false, PrimaryDC == DeclDC);
1409 }
1410
1411 void DeclContext::makeDeclVisibleInContextWithFlags(NamedDecl *D, bool Internal,
1412                                                     bool Recoverable) {
1413   assert(this == getPrimaryContext() && "expected a primary DC");
1414
1415   // Skip declarations within functions.
1416   if (isFunctionOrMethod())
1417     return;
1418
1419   // Skip declarations which should be invisible to name lookup.
1420   if (shouldBeHidden(D))
1421     return;
1422
1423   // If we already have a lookup data structure, perform the insertion into
1424   // it. If we might have externally-stored decls with this name, look them
1425   // up and perform the insertion. If this decl was declared outside its
1426   // semantic context, buildLookup won't add it, so add it now.
1427   //
1428   // FIXME: As a performance hack, don't add such decls into the translation
1429   // unit unless we're in C++, since qualified lookup into the TU is never
1430   // performed.
1431   if (LookupPtr.getPointer() || hasExternalVisibleStorage() ||
1432       ((!Recoverable || D->getDeclContext() != D->getLexicalDeclContext()) &&
1433        (getParentASTContext().getLangOpts().CPlusPlus ||
1434         !isTranslationUnit()))) {
1435     // If we have lazily omitted any decls, they might have the same name as
1436     // the decl which we are adding, so build a full lookup table before adding
1437     // this decl.
1438     buildLookup();
1439     makeDeclVisibleInContextImpl(D, Internal);
1440   } else {
1441     LookupPtr.setInt(true);
1442   }
1443
1444   // If we are a transparent context or inline namespace, insert into our
1445   // parent context, too. This operation is recursive.
1446   if (isTransparentContext() || isInlineNamespace())
1447     getParent()->getPrimaryContext()->
1448         makeDeclVisibleInContextWithFlags(D, Internal, Recoverable);
1449
1450   Decl *DCAsDecl = cast<Decl>(this);
1451   // Notify that a decl was made visible unless we are a Tag being defined.
1452   if (!(isa<TagDecl>(DCAsDecl) && cast<TagDecl>(DCAsDecl)->isBeingDefined()))
1453     if (ASTMutationListener *L = DCAsDecl->getASTMutationListener())
1454       L->AddedVisibleDecl(this, D);
1455 }
1456
1457 void DeclContext::makeDeclVisibleInContextImpl(NamedDecl *D, bool Internal) {
1458   // Find or create the stored declaration map.
1459   StoredDeclsMap *Map = LookupPtr.getPointer();
1460   if (!Map) {
1461     ASTContext *C = &getParentASTContext();
1462     Map = CreateStoredDeclsMap(*C);
1463   }
1464
1465   // If there is an external AST source, load any declarations it knows about
1466   // with this declaration's name.
1467   // If the lookup table contains an entry about this name it means that we
1468   // have already checked the external source.
1469   if (!Internal)
1470     if (ExternalASTSource *Source = getParentASTContext().getExternalSource())
1471       if (hasExternalVisibleStorage() &&
1472           Map->find(D->getDeclName()) == Map->end())
1473         Source->FindExternalVisibleDeclsByName(this, D->getDeclName());
1474
1475   // Insert this declaration into the map.
1476   StoredDeclsList &DeclNameEntries = (*Map)[D->getDeclName()];
1477
1478   if (Internal) {
1479     // If this is being added as part of loading an external declaration,
1480     // this may not be the only external declaration with this name.
1481     // In this case, we never try to replace an existing declaration; we'll
1482     // handle that when we finalize the list of declarations for this name.
1483     DeclNameEntries.setHasExternalDecls();
1484     DeclNameEntries.AddSubsequentDecl(D);
1485     return;
1486   }
1487
1488   else if (DeclNameEntries.isNull()) {
1489     DeclNameEntries.setOnlyValue(D);
1490     return;
1491   }
1492
1493   if (DeclNameEntries.HandleRedeclaration(D)) {
1494     // This declaration has replaced an existing one for which
1495     // declarationReplaces returns true.
1496     return;
1497   }
1498
1499   // Put this declaration into the appropriate slot.
1500   DeclNameEntries.AddSubsequentDecl(D);
1501 }
1502
1503 /// Returns iterator range [First, Last) of UsingDirectiveDecls stored within
1504 /// this context.
1505 DeclContext::udir_iterator_range
1506 DeclContext::getUsingDirectives() const {
1507   // FIXME: Use something more efficient than normal lookup for using
1508   // directives. In C++, using directives are looked up more than anything else.
1509   lookup_const_result Result = lookup(UsingDirectiveDecl::getName());
1510   return udir_iterator_range(reinterpret_cast<udir_iterator>(Result.begin()),
1511                              reinterpret_cast<udir_iterator>(Result.end()));
1512 }
1513
1514 //===----------------------------------------------------------------------===//
1515 // Creation and Destruction of StoredDeclsMaps.                               //
1516 //===----------------------------------------------------------------------===//
1517
1518 StoredDeclsMap *DeclContext::CreateStoredDeclsMap(ASTContext &C) const {
1519   assert(!LookupPtr.getPointer() && "context already has a decls map");
1520   assert(getPrimaryContext() == this &&
1521          "creating decls map on non-primary context");
1522
1523   StoredDeclsMap *M;
1524   bool Dependent = isDependentContext();
1525   if (Dependent)
1526     M = new DependentStoredDeclsMap();
1527   else
1528     M = new StoredDeclsMap();
1529   M->Previous = C.LastSDM;
1530   C.LastSDM = llvm::PointerIntPair<StoredDeclsMap*,1>(M, Dependent);
1531   LookupPtr.setPointer(M);
1532   return M;
1533 }
1534
1535 void ASTContext::ReleaseDeclContextMaps() {
1536   // It's okay to delete DependentStoredDeclsMaps via a StoredDeclsMap
1537   // pointer because the subclass doesn't add anything that needs to
1538   // be deleted.
1539   StoredDeclsMap::DestroyAll(LastSDM.getPointer(), LastSDM.getInt());
1540 }
1541
1542 void StoredDeclsMap::DestroyAll(StoredDeclsMap *Map, bool Dependent) {
1543   while (Map) {
1544     // Advance the iteration before we invalidate memory.
1545     llvm::PointerIntPair<StoredDeclsMap*,1> Next = Map->Previous;
1546
1547     if (Dependent)
1548       delete static_cast<DependentStoredDeclsMap*>(Map);
1549     else
1550       delete Map;
1551
1552     Map = Next.getPointer();
1553     Dependent = Next.getInt();
1554   }
1555 }
1556
1557 DependentDiagnostic *DependentDiagnostic::Create(ASTContext &C,
1558                                                  DeclContext *Parent,
1559                                            const PartialDiagnostic &PDiag) {
1560   assert(Parent->isDependentContext()
1561          && "cannot iterate dependent diagnostics of non-dependent context");
1562   Parent = Parent->getPrimaryContext();
1563   if (!Parent->LookupPtr.getPointer())
1564     Parent->CreateStoredDeclsMap(C);
1565
1566   DependentStoredDeclsMap *Map
1567     = static_cast<DependentStoredDeclsMap*>(Parent->LookupPtr.getPointer());
1568
1569   // Allocate the copy of the PartialDiagnostic via the ASTContext's
1570   // BumpPtrAllocator, rather than the ASTContext itself.
1571   PartialDiagnostic::Storage *DiagStorage = 0;
1572   if (PDiag.hasStorage())
1573     DiagStorage = new (C) PartialDiagnostic::Storage;
1574
1575   DependentDiagnostic *DD = new (C) DependentDiagnostic(PDiag, DiagStorage);
1576
1577   // TODO: Maybe we shouldn't reverse the order during insertion.
1578   DD->NextDiagnostic = Map->FirstDiagnostic;
1579   Map->FirstDiagnostic = DD;
1580
1581   return DD;
1582 }