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