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