DeclBase.cpp revision 204643
165942Sgibbs//===--- DeclBase.cpp - Declaration AST Node Implementation ---------------===// 265942Sgibbs// 365942Sgibbs// The LLVM Compiler Infrastructure 465942Sgibbs// 565942Sgibbs// This file is distributed under the University of Illinois Open Source 665942Sgibbs// License. See LICENSE.TXT for details. 765942Sgibbs// 865942Sgibbs//===----------------------------------------------------------------------===// 965942Sgibbs// 1065942Sgibbs// This file implements the Decl and DeclContext classes. 1165942Sgibbs// 1265942Sgibbs//===----------------------------------------------------------------------===// 1365942Sgibbs 1465942Sgibbs#include "clang/AST/DeclBase.h" 1565942Sgibbs#include "clang/AST/Decl.h" 1665942Sgibbs#include "clang/AST/DeclContextInternals.h" 1765942Sgibbs#include "clang/AST/DeclCXX.h" 1865942Sgibbs#include "clang/AST/DeclObjC.h" 1965942Sgibbs#include "clang/AST/DeclTemplate.h" 2065942Sgibbs#include "clang/AST/ExternalASTSource.h" 2165942Sgibbs#include "clang/AST/ASTContext.h" 2265942Sgibbs#include "clang/AST/Type.h" 2365942Sgibbs#include "clang/AST/Stmt.h" 2465942Sgibbs#include "clang/AST/StmtCXX.h" 2565942Sgibbs#include "llvm/ADT/DenseMap.h" 2665942Sgibbs#include "llvm/Support/raw_ostream.h" 2765942Sgibbs#include <algorithm> 2865942Sgibbs#include <cstdio> 2965942Sgibbs#include <vector> 3065942Sgibbsusing namespace clang; 3165942Sgibbs 3265942Sgibbs//===----------------------------------------------------------------------===// 3365942Sgibbs// Statistics 3465942Sgibbs//===----------------------------------------------------------------------===// 3565942Sgibbs 3665942Sgibbs#define DECL(Derived, Base) static int n##Derived##s = 0; 3765942Sgibbs#include "clang/AST/DeclNodes.def" 3865942Sgibbs 3965942Sgibbsstatic bool StatSwitch = false; 4065942Sgibbs 4165942Sgibbsconst char *Decl::getDeclKindName() const { 4265942Sgibbs switch (DeclKind) { 4365942Sgibbs default: assert(0 && "Declaration not in DeclNodes.def!"); 4465942Sgibbs#define DECL(Derived, Base) case Derived: return #Derived; 4565942Sgibbs#include "clang/AST/DeclNodes.def" 4665942Sgibbs } 4765942Sgibbs} 4865942Sgibbs 4965942Sgibbsconst char *DeclContext::getDeclKindName() const { 5065942Sgibbs switch (DeclKind) { 5165942Sgibbs default: assert(0 && "Declaration context not in DeclNodes.def!"); 5265942Sgibbs#define DECL(Derived, Base) case Decl::Derived: return #Derived; 5365942Sgibbs#include "clang/AST/DeclNodes.def" 5465942Sgibbs } 5565942Sgibbs} 5665942Sgibbs 5765942Sgibbsbool Decl::CollectingStats(bool Enable) { 5865942Sgibbs if (Enable) StatSwitch = true; 5965942Sgibbs return StatSwitch; 6065942Sgibbs} 6165942Sgibbs 6265942Sgibbsvoid Decl::PrintStats() { 6365942Sgibbs fprintf(stderr, "*** Decl Stats:\n"); 6465942Sgibbs 6565942Sgibbs int totalDecls = 0; 6665942Sgibbs#define DECL(Derived, Base) totalDecls += n##Derived##s; 6765942Sgibbs#include "clang/AST/DeclNodes.def" 6865942Sgibbs fprintf(stderr, " %d decls total.\n", totalDecls); 6965942Sgibbs 7065942Sgibbs int totalBytes = 0; 7166269Sgibbs#define DECL(Derived, Base) \ 7265942Sgibbs if (n##Derived##s > 0) { \ 7365942Sgibbs totalBytes += (int)(n##Derived##s * sizeof(Derived##Decl)); \ 7465942Sgibbs fprintf(stderr, " %d " #Derived " decls, %d each (%d bytes)\n", \ 7565942Sgibbs n##Derived##s, (int)sizeof(Derived##Decl), \ 7665942Sgibbs (int)(n##Derived##s * sizeof(Derived##Decl))); \ 7766269Sgibbs } 7866269Sgibbs#include "clang/AST/DeclNodes.def" 7965942Sgibbs 8065942Sgibbs fprintf(stderr, "Total bytes = %d\n", totalBytes); 8165942Sgibbs} 8266269Sgibbs 8365942Sgibbsvoid Decl::addDeclKind(Kind k) { 8465942Sgibbs switch (k) { 8565942Sgibbs default: assert(0 && "Declaration not in DeclNodes.def!"); 8665942Sgibbs#define DECL(Derived, Base) case Derived: ++n##Derived##s; break; 8765942Sgibbs#include "clang/AST/DeclNodes.def" 8866269Sgibbs } 8965942Sgibbs} 9065942Sgibbs 9165942Sgibbsbool Decl::isTemplateParameterPack() const { 9265942Sgibbs if (const TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(this)) 9365942Sgibbs return TTP->isParameterPack(); 9465942Sgibbs 9565942Sgibbs return false; 9665942Sgibbs} 9765942Sgibbs 9865942Sgibbsbool Decl::isFunctionOrFunctionTemplate() const { 9965942Sgibbs if (const UsingShadowDecl *UD = dyn_cast<UsingShadowDecl>(this)) 10065942Sgibbs return UD->getTargetDecl()->isFunctionOrFunctionTemplate(); 10165942Sgibbs 10265942Sgibbs return isa<FunctionDecl>(this) || isa<FunctionTemplateDecl>(this); 10365942Sgibbs} 10465942Sgibbs 10565942Sgibbsbool Decl::isDefinedOutsideFunctionOrMethod() const { 10665942Sgibbs for (const DeclContext *DC = getDeclContext(); 10765942Sgibbs DC && !DC->isTranslationUnit(); 10865942Sgibbs DC = DC->getParent()) 10965942Sgibbs if (DC->isFunctionOrMethod()) 11065942Sgibbs return false; 11165942Sgibbs 11265942Sgibbs return true; 11365942Sgibbs} 11465942Sgibbs 11565942Sgibbs 11665942Sgibbs//===----------------------------------------------------------------------===// 11765942Sgibbs// PrettyStackTraceDecl Implementation 11865942Sgibbs//===----------------------------------------------------------------------===// 11965942Sgibbs 12065942Sgibbsvoid PrettyStackTraceDecl::print(llvm::raw_ostream &OS) const { 12165942Sgibbs SourceLocation TheLoc = Loc; 12265942Sgibbs if (TheLoc.isInvalid() && TheDecl) 12365942Sgibbs TheLoc = TheDecl->getLocation(); 12465942Sgibbs 12565942Sgibbs if (TheLoc.isValid()) { 12665942Sgibbs TheLoc.print(OS, SM); 12765942Sgibbs OS << ": "; 12865942Sgibbs } 12965942Sgibbs 13065942Sgibbs OS << Message; 13165942Sgibbs 13265942Sgibbs if (const NamedDecl *DN = dyn_cast_or_null<NamedDecl>(TheDecl)) 13365942Sgibbs OS << " '" << DN->getQualifiedNameAsString() << '\''; 13465942Sgibbs OS << '\n'; 13565942Sgibbs} 13665942Sgibbs 13765942Sgibbs//===----------------------------------------------------------------------===// 13865942Sgibbs// Decl Implementation 13965942Sgibbs//===----------------------------------------------------------------------===// 14065942Sgibbs 14166647Sgibbs// Out-of-line virtual method providing a home for Decl. 14265942SgibbsDecl::~Decl() { 14365942Sgibbs assert(!HasAttrs && "attributes should have been freed by Destroy"); 14465942Sgibbs} 14565942Sgibbs 14665942Sgibbsvoid Decl::setDeclContext(DeclContext *DC) { 14765942Sgibbs if (isOutOfSemaDC()) 14866104Sgibbs delete getMultipleDC(); 14966104Sgibbs 15066647Sgibbs DeclCtx = DC; 15165942Sgibbs} 15265942Sgibbs 15365942Sgibbsvoid Decl::setLexicalDeclContext(DeclContext *DC) { 15465942Sgibbs if (DC == getLexicalDeclContext()) 15565942Sgibbs return; 15665942Sgibbs 15765942Sgibbs if (isInSemaDC()) { 15865942Sgibbs MultipleDC *MDC = new (getASTContext()) MultipleDC(); 15965942Sgibbs MDC->SemanticDC = getDeclContext(); 16065942Sgibbs MDC->LexicalDC = DC; 16165942Sgibbs DeclCtx = MDC; 16265942Sgibbs } else { 16365942Sgibbs getMultipleDC()->LexicalDC = DC; 16465942Sgibbs } 16565942Sgibbs} 16665942Sgibbs 16765942Sgibbsbool Decl::isInAnonymousNamespace() const { 16865942Sgibbs const DeclContext *DC = getDeclContext(); 16965942Sgibbs do { 17065942Sgibbs if (const NamespaceDecl *ND = dyn_cast<NamespaceDecl>(DC)) 17165942Sgibbs if (ND->isAnonymousNamespace()) 17265942Sgibbs return true; 17365942Sgibbs } while ((DC = DC->getParent())); 17465942Sgibbs 17565942Sgibbs return false; 17665942Sgibbs} 17765942Sgibbs 17865942SgibbsTranslationUnitDecl *Decl::getTranslationUnitDecl() { 17965942Sgibbs if (TranslationUnitDecl *TUD = dyn_cast<TranslationUnitDecl>(this)) 18065942Sgibbs return TUD; 18166104Sgibbs 18266647Sgibbs DeclContext *DC = getDeclContext(); 18365942Sgibbs assert(DC && "This decl is not contained in a translation unit!"); 18465942Sgibbs 18565942Sgibbs while (!DC->isTranslationUnit()) { 18665942Sgibbs DC = DC->getParent(); 18765942Sgibbs assert(DC && "This decl is not contained in a translation unit!"); 18865942Sgibbs } 18965942Sgibbs 19065942Sgibbs return cast<TranslationUnitDecl>(DC); 19165942Sgibbs} 19265942Sgibbs 19365942SgibbsASTContext &Decl::getASTContext() const { 19465942Sgibbs return getTranslationUnitDecl()->getASTContext(); 19565942Sgibbs} 19665942Sgibbs 19765942Sgibbsbool Decl::isUsed() const { 19865942Sgibbs if (Used) 19965942Sgibbs return true; 20065942Sgibbs 20165942Sgibbs // Check for used attribute. 20265942Sgibbs if (hasAttr<UsedAttr>()) 20365942Sgibbs return true; 20465942Sgibbs 20565942Sgibbs // Check redeclarations for used attribute. 20665942Sgibbs for (redecl_iterator I = redecls_begin(), E = redecls_end(); I != E; ++I) { 20765942Sgibbs if (I->hasAttr<UsedAttr>() || I->Used) 20865942Sgibbs return true; 20965942Sgibbs } 21065942Sgibbs 21165942Sgibbs return false; 21265942Sgibbs} 21365942Sgibbs 21465942Sgibbs 21565942Sgibbsunsigned Decl::getIdentifierNamespaceForKind(Kind DeclKind) { 21665942Sgibbs switch (DeclKind) { 21765942Sgibbs case Function: 21865942Sgibbs case CXXMethod: 21965942Sgibbs case CXXConstructor: 22065942Sgibbs case CXXDestructor: 22165942Sgibbs case CXXConversion: 22265942Sgibbs case Typedef: 22365942Sgibbs case EnumConstant: 22465942Sgibbs case Var: 22565942Sgibbs case ImplicitParam: 22665942Sgibbs case ParmVar: 22765942Sgibbs case NonTypeTemplateParm: 22865942Sgibbs case ObjCMethod: 22965942Sgibbs case ObjCContainer: 23065942Sgibbs case ObjCInterface: 23165942Sgibbs case ObjCProperty: 23265942Sgibbs case ObjCCompatibleAlias: 23365942Sgibbs return IDNS_Ordinary; 23465942Sgibbs 23565942Sgibbs case UsingShadow: 23665942Sgibbs return 0; // we'll actually overwrite this later 23765942Sgibbs 23865942Sgibbs case UnresolvedUsingValue: 23965942Sgibbs case UnresolvedUsingTypename: 24065942Sgibbs return IDNS_Ordinary | IDNS_Using; 24165942Sgibbs 24265942Sgibbs case Using: 24365942Sgibbs return IDNS_Using; 24465942Sgibbs 24565942Sgibbs case ObjCProtocol: 24665942Sgibbs return IDNS_ObjCProtocol; 24765942Sgibbs 24865942Sgibbs case ObjCImplementation: 24965942Sgibbs return IDNS_ObjCImplementation; 25065942Sgibbs 25165942Sgibbs case ObjCCategory: 25265942Sgibbs case ObjCCategoryImpl: 25365942Sgibbs return IDNS_ObjCCategoryName; 25465942Sgibbs 25565942Sgibbs case Field: 25665942Sgibbs case ObjCAtDefsField: 25765942Sgibbs case ObjCIvar: 25865942Sgibbs return IDNS_Member; 25965942Sgibbs 26065942Sgibbs case Record: 26165942Sgibbs case CXXRecord: 26265942Sgibbs case Enum: 26365942Sgibbs case TemplateTypeParm: 26465942Sgibbs return IDNS_Tag; 26565942Sgibbs 26665942Sgibbs case Namespace: 26765942Sgibbs case Template: 26865942Sgibbs case FunctionTemplate: 26965942Sgibbs case ClassTemplate: 27065942Sgibbs case TemplateTemplateParm: 27165942Sgibbs case NamespaceAlias: 27265942Sgibbs return IDNS_Tag | IDNS_Ordinary; 27365942Sgibbs 27465942Sgibbs // Never have names. 27565942Sgibbs case Friend: 27665942Sgibbs case FriendTemplate: 27765942Sgibbs case LinkageSpec: 27865942Sgibbs case FileScopeAsm: 27965942Sgibbs case StaticAssert: 28065942Sgibbs case ObjCClass: 28165942Sgibbs case ObjCPropertyImpl: 28265942Sgibbs case ObjCForwardProtocol: 28365942Sgibbs case Block: 28465942Sgibbs case TranslationUnit: 28565942Sgibbs 28665942Sgibbs // Aren't looked up? 28765942Sgibbs case UsingDirective: 28865942Sgibbs case ClassTemplateSpecialization: 28965942Sgibbs case ClassTemplatePartialSpecialization: 29065942Sgibbs return 0; 29165942Sgibbs } 29265942Sgibbs 29365942Sgibbs return 0; 29465942Sgibbs} 29565942Sgibbs 29665942Sgibbsvoid Decl::addAttr(Attr *NewAttr) { 29765942Sgibbs Attr *&ExistingAttr = getASTContext().getDeclAttrs(this); 29865942Sgibbs 29965942Sgibbs NewAttr->setNext(ExistingAttr); 30065942Sgibbs ExistingAttr = NewAttr; 30165942Sgibbs 30265942Sgibbs HasAttrs = true; 30365942Sgibbs} 30465942Sgibbs 30565942Sgibbsvoid Decl::invalidateAttrs() { 30665942Sgibbs if (!HasAttrs) return; 30765942Sgibbs 30865942Sgibbs HasAttrs = false; 30965942Sgibbs getASTContext().eraseDeclAttrs(this); 31065942Sgibbs} 31165942Sgibbs 31265942Sgibbsconst Attr *Decl::getAttrsImpl() const { 31365942Sgibbs assert(HasAttrs && "getAttrs() should verify this!"); 31465942Sgibbs return getASTContext().getDeclAttrs(this); 31565942Sgibbs} 31665942Sgibbs 31765942Sgibbsvoid Decl::swapAttrs(Decl *RHS) { 31865942Sgibbs bool HasLHSAttr = this->HasAttrs; 31965942Sgibbs bool HasRHSAttr = RHS->HasAttrs; 32065942Sgibbs 32165942Sgibbs // Usually, neither decl has attrs, nothing to do. 32265942Sgibbs if (!HasLHSAttr && !HasRHSAttr) return; 32365942Sgibbs 32465942Sgibbs // If 'this' has no attrs, swap the other way. 32565942Sgibbs if (!HasLHSAttr) 32665942Sgibbs return RHS->swapAttrs(this); 32765942Sgibbs 32865942Sgibbs ASTContext &Context = getASTContext(); 32965942Sgibbs 33065942Sgibbs // Handle the case when both decls have attrs. 33165942Sgibbs if (HasRHSAttr) { 33265942Sgibbs std::swap(Context.getDeclAttrs(this), Context.getDeclAttrs(RHS)); 33365942Sgibbs return; 33465942Sgibbs } 33565942Sgibbs 33665942Sgibbs // Otherwise, LHS has an attr and RHS doesn't. 33765942Sgibbs Context.getDeclAttrs(RHS) = Context.getDeclAttrs(this); 33865942Sgibbs Context.eraseDeclAttrs(this); 33965942Sgibbs this->HasAttrs = false; 34065942Sgibbs RHS->HasAttrs = true; 34165942Sgibbs} 34265942Sgibbs 34365942Sgibbs 34465942Sgibbsvoid Decl::Destroy(ASTContext &C) { 34565942Sgibbs // Free attributes for this decl. 34665942Sgibbs if (HasAttrs) { 34765942Sgibbs C.getDeclAttrs(this)->Destroy(C); 34865942Sgibbs invalidateAttrs(); 34965942Sgibbs HasAttrs = false; 35065942Sgibbs } 35165942Sgibbs 35265942Sgibbs#if 0 35365942Sgibbs // FIXME: Once ownership is fully understood, we can enable this code 35465942Sgibbs if (DeclContext *DC = dyn_cast<DeclContext>(this)) 35565942Sgibbs DC->decls_begin()->Destroy(C); 35665942Sgibbs 35765942Sgibbs // Observe the unrolled recursion. By setting N->NextDeclInContext = 0x0 35865942Sgibbs // within the loop, only the Destroy method for the first Decl 35965942Sgibbs // will deallocate all of the Decls in a chain. 36065942Sgibbs 36165942Sgibbs Decl* N = getNextDeclInContext(); 36265942Sgibbs 36365942Sgibbs while (N) { 36465942Sgibbs Decl* Tmp = N->getNextDeclInContext(); 36565942Sgibbs N->NextDeclInContext = 0; 36665942Sgibbs N->Destroy(C); 36765942Sgibbs N = Tmp; 36865942Sgibbs } 36965942Sgibbs 37065942Sgibbs if (isOutOfSemaDC()) 37165942Sgibbs delete (C) getMultipleDC(); 37265942Sgibbs 37365942Sgibbs this->~Decl(); 37465942Sgibbs C.Deallocate((void *)this); 37565942Sgibbs#endif 37665942Sgibbs} 37765942Sgibbs 37865942SgibbsDecl *Decl::castFromDeclContext (const DeclContext *D) { 37965942Sgibbs Decl::Kind DK = D->getDeclKind(); 38065942Sgibbs switch(DK) { 38165942Sgibbs#define DECL_CONTEXT(Name) \ 38265942Sgibbs case Decl::Name: \ 38365942Sgibbs return static_cast<Name##Decl*>(const_cast<DeclContext*>(D)); 38465942Sgibbs#define DECL_CONTEXT_BASE(Name) 38565942Sgibbs#include "clang/AST/DeclNodes.def" 38665942Sgibbs default: 38765942Sgibbs#define DECL_CONTEXT_BASE(Name) \ 38865942Sgibbs if (DK >= Decl::Name##First && DK <= Decl::Name##Last) \ 38965942Sgibbs return static_cast<Name##Decl*>(const_cast<DeclContext*>(D)); 39065942Sgibbs#include "clang/AST/DeclNodes.def" 39165942Sgibbs assert(false && "a decl that inherits DeclContext isn't handled"); 39265942Sgibbs return 0; 39365942Sgibbs } 39465942Sgibbs} 39565942Sgibbs 39665942SgibbsDeclContext *Decl::castToDeclContext(const Decl *D) { 39765942Sgibbs Decl::Kind DK = D->getKind(); 39865942Sgibbs switch(DK) { 39965942Sgibbs#define DECL_CONTEXT(Name) \ 40065942Sgibbs case Decl::Name: \ 40165942Sgibbs return static_cast<Name##Decl*>(const_cast<Decl*>(D)); 40265942Sgibbs#define DECL_CONTEXT_BASE(Name) 40365942Sgibbs#include "clang/AST/DeclNodes.def" 40465942Sgibbs default: 40565942Sgibbs#define DECL_CONTEXT_BASE(Name) \ 40665942Sgibbs if (DK >= Decl::Name##First && DK <= Decl::Name##Last) \ 40765942Sgibbs return static_cast<Name##Decl*>(const_cast<Decl*>(D)); 40865942Sgibbs#include "clang/AST/DeclNodes.def" 40965942Sgibbs assert(false && "a decl that inherits DeclContext isn't handled"); 41065942Sgibbs return 0; 41165942Sgibbs } 41265942Sgibbs} 41365942Sgibbs 41465942SgibbsCompoundStmt* Decl::getCompoundBody() const { 41565942Sgibbs return dyn_cast_or_null<CompoundStmt>(getBody()); 41665942Sgibbs} 41765942Sgibbs 41865942SgibbsSourceLocation Decl::getBodyRBrace() const { 41965942Sgibbs Stmt *Body = getBody(); 42065942Sgibbs if (!Body) 42165942Sgibbs return SourceLocation(); 42265942Sgibbs if (CompoundStmt *CS = dyn_cast<CompoundStmt>(Body)) 42365942Sgibbs return CS->getRBracLoc(); 42465942Sgibbs assert(isa<CXXTryStmt>(Body) && 42565942Sgibbs "Body can only be CompoundStmt or CXXTryStmt"); 42665942Sgibbs return cast<CXXTryStmt>(Body)->getSourceRange().getEnd(); 42766717Sgibbs} 42866717Sgibbs 42965942Sgibbs#ifndef NDEBUG 43065942Sgibbsvoid Decl::CheckAccessDeclContext() const { 43165942Sgibbs // Suppress this check if any of the following hold: 43265942Sgibbs // 1. this is the translation unit (and thus has no parent) 43366717Sgibbs // 2. this is a template parameter (and thus doesn't belong to its context) 43465942Sgibbs // 3. this is a ParmVarDecl (which can be in a record context during 43565942Sgibbs // the brief period between its creation and the creation of the 43665942Sgibbs // FunctionDecl) 43765942Sgibbs // 4. the context is not a record 43865942Sgibbs if (isa<TranslationUnitDecl>(this) || 43966510Sgibbs !isa<CXXRecordDecl>(getDeclContext()) || 44065942Sgibbs isInvalidDecl()) 44165942Sgibbs return; 44265942Sgibbs 44366717Sgibbs assert(Access != AS_none && 44465942Sgibbs "Access specifier is AS_none inside a record decl"); 44565942Sgibbs} 44665942Sgibbs 44765942Sgibbs#endif 44865942Sgibbs 44965942Sgibbs//===----------------------------------------------------------------------===// 45065942Sgibbs// DeclContext Implementation 45165942Sgibbs//===----------------------------------------------------------------------===// 45265942Sgibbs 45365942Sgibbsbool DeclContext::classof(const Decl *D) { 45465942Sgibbs switch (D->getKind()) { 45565942Sgibbs#define DECL_CONTEXT(Name) case Decl::Name: 45665942Sgibbs#define DECL_CONTEXT_BASE(Name) 45765942Sgibbs#include "clang/AST/DeclNodes.def" 45865942Sgibbs return true; 45965942Sgibbs default: 46065942Sgibbs#define DECL_CONTEXT_BASE(Name) \ 46165942Sgibbs if (D->getKind() >= Decl::Name##First && \ 46265942Sgibbs D->getKind() <= Decl::Name##Last) \ 46365942Sgibbs return true; 46465942Sgibbs#include "clang/AST/DeclNodes.def" 46565942Sgibbs return false; 46665942Sgibbs } 46765942Sgibbs} 46865942Sgibbs 46965942SgibbsDeclContext::~DeclContext() { 47065942Sgibbs // FIXME: Currently ~ASTContext will delete the StoredDeclsMaps because 47165942Sgibbs // ~DeclContext() is not guaranteed to be called when ASTContext uses 47265942Sgibbs // a BumpPtrAllocator. 47365942Sgibbs // delete static_cast<StoredDeclsMap*>(LookupPtr); 47465942Sgibbs} 47565942Sgibbs 47665942Sgibbsvoid DeclContext::DestroyDecls(ASTContext &C) { 47765942Sgibbs for (decl_iterator D = decls_begin(); D != decls_end(); ) 47865942Sgibbs (*D++)->Destroy(C); 47965942Sgibbs} 48065942Sgibbs 48165942Sgibbs/// \brief Find the parent context of this context that will be 48265942Sgibbs/// used for unqualified name lookup. 48365942Sgibbs/// 48465942Sgibbs/// Generally, the parent lookup context is the semantic context. However, for 48565942Sgibbs/// a friend function the parent lookup context is the lexical context, which 48665942Sgibbs/// is the class in which the friend is declared. 48765942SgibbsDeclContext *DeclContext::getLookupParent() { 48865942Sgibbs // FIXME: Find a better way to identify friends 48965942Sgibbs if (isa<FunctionDecl>(this)) 49065942Sgibbs if (getParent()->getLookupContext()->isFileContext() && 49165942Sgibbs getLexicalParent()->getLookupContext()->isRecord()) 49265942Sgibbs return getLexicalParent(); 49365942Sgibbs 49465942Sgibbs return getParent(); 49565942Sgibbs} 49665942Sgibbs 49765942Sgibbsbool DeclContext::isDependentContext() const { 49865942Sgibbs if (isFileContext()) 49965942Sgibbs return false; 50065942Sgibbs 50165942Sgibbs if (isa<ClassTemplatePartialSpecializationDecl>(this)) 50265942Sgibbs return true; 50365942Sgibbs 50465942Sgibbs if (const CXXRecordDecl *Record = dyn_cast<CXXRecordDecl>(this)) 50565942Sgibbs if (Record->getDescribedClassTemplate()) 50665942Sgibbs return true; 50765942Sgibbs 50865942Sgibbs if (const FunctionDecl *Function = dyn_cast<FunctionDecl>(this)) 50965942Sgibbs if (Function->getDescribedFunctionTemplate()) 51065942Sgibbs return true; 51165942Sgibbs 51265942Sgibbs return getParent() && getParent()->isDependentContext(); 51365942Sgibbs} 51465942Sgibbs 51565942Sgibbsbool DeclContext::isTransparentContext() const { 51665942Sgibbs if (DeclKind == Decl::Enum) 51765942Sgibbs return true; // FIXME: Check for C++0x scoped enums 51865942Sgibbs else if (DeclKind == Decl::LinkageSpec) 51965942Sgibbs return true; 52065942Sgibbs else if (DeclKind >= Decl::RecordFirst && DeclKind <= Decl::RecordLast) 52165942Sgibbs return cast<RecordDecl>(this)->isAnonymousStructOrUnion(); 52265942Sgibbs else if (DeclKind == Decl::Namespace) 52365942Sgibbs return false; // FIXME: Check for C++0x inline namespaces 52465942Sgibbs 52565942Sgibbs return false; 52665942Sgibbs} 52765942Sgibbs 52865942Sgibbsbool DeclContext::Encloses(DeclContext *DC) { 52965942Sgibbs if (getPrimaryContext() != this) 53065942Sgibbs return getPrimaryContext()->Encloses(DC); 53165942Sgibbs 53265942Sgibbs for (; DC; DC = DC->getParent()) 53365942Sgibbs if (DC->getPrimaryContext() == this) 53465942Sgibbs return true; 53565942Sgibbs return false; 53665942Sgibbs} 53765942Sgibbs 53865942SgibbsDeclContext *DeclContext::getPrimaryContext() { 53965942Sgibbs switch (DeclKind) { 54065942Sgibbs case Decl::TranslationUnit: 54165942Sgibbs case Decl::LinkageSpec: 54265942Sgibbs case Decl::Block: 54365942Sgibbs // There is only one DeclContext for these entities. 54465942Sgibbs return this; 54565942Sgibbs 54665942Sgibbs case Decl::Namespace: 54765942Sgibbs // The original namespace is our primary context. 54865942Sgibbs return static_cast<NamespaceDecl*>(this)->getOriginalNamespace(); 54965942Sgibbs 55065942Sgibbs case Decl::ObjCMethod: 55165942Sgibbs return this; 55265942Sgibbs 55365942Sgibbs case Decl::ObjCInterface: 55465942Sgibbs case Decl::ObjCProtocol: 55565942Sgibbs case Decl::ObjCCategory: 55665942Sgibbs // FIXME: Can Objective-C interfaces be forward-declared? 55765942Sgibbs return this; 55865942Sgibbs 55965942Sgibbs case Decl::ObjCImplementation: 56065942Sgibbs case Decl::ObjCCategoryImpl: 56165942Sgibbs return this; 56265942Sgibbs 56365942Sgibbs default: 56465942Sgibbs if (DeclKind >= Decl::TagFirst && DeclKind <= Decl::TagLast) { 56565942Sgibbs // If this is a tag type that has a definition or is currently 56665942Sgibbs // being defined, that definition is our primary context. 56765942Sgibbs if (const TagType *TagT =cast<TagDecl>(this)->TypeForDecl->getAs<TagType>()) 56865942Sgibbs if (TagT->isBeingDefined() || 56965942Sgibbs (TagT->getDecl() && TagT->getDecl()->isDefinition())) 57065942Sgibbs return TagT->getDecl(); 57165942Sgibbs return this; 57265942Sgibbs } 57365942Sgibbs 57465942Sgibbs assert(DeclKind >= Decl::FunctionFirst && DeclKind <= Decl::FunctionLast && 57565942Sgibbs "Unknown DeclContext kind"); 57665942Sgibbs return this; 57765942Sgibbs } 57865942Sgibbs} 57965942Sgibbs 58065942SgibbsDeclContext *DeclContext::getNextContext() { 58165942Sgibbs switch (DeclKind) { 58265942Sgibbs case Decl::Namespace: 58365942Sgibbs // Return the next namespace 58465942Sgibbs return static_cast<NamespaceDecl*>(this)->getNextNamespace(); 58565942Sgibbs 58665942Sgibbs default: 58765942Sgibbs return 0; 58865942Sgibbs } 58965942Sgibbs} 59065942Sgibbs 59165942Sgibbs/// \brief Load the declarations within this lexical storage from an 59265942Sgibbs/// external source. 59365942Sgibbsvoid 59465942SgibbsDeclContext::LoadLexicalDeclsFromExternalStorage() const { 59565942Sgibbs ExternalASTSource *Source = getParentASTContext().getExternalSource(); 59665942Sgibbs assert(hasExternalLexicalStorage() && Source && "No external storage?"); 59765942Sgibbs 59865942Sgibbs llvm::SmallVector<uint32_t, 64> Decls; 59965942Sgibbs if (Source->ReadDeclsLexicallyInContext(const_cast<DeclContext *>(this), 60065942Sgibbs Decls)) 60165942Sgibbs return; 60265942Sgibbs 60365942Sgibbs // There is no longer any lexical storage in this context 60465942Sgibbs ExternalLexicalStorage = false; 60565942Sgibbs 60665942Sgibbs if (Decls.empty()) 60765942Sgibbs return; 60865942Sgibbs 60965942Sgibbs // Resolve all of the declaration IDs into declarations, building up 61065942Sgibbs // a chain of declarations via the Decl::NextDeclInContext field. 61165942Sgibbs Decl *FirstNewDecl = 0; 61265942Sgibbs Decl *PrevDecl = 0; 61365942Sgibbs for (unsigned I = 0, N = Decls.size(); I != N; ++I) { 61465942Sgibbs Decl *D = Source->GetDecl(Decls[I]); 61565942Sgibbs if (PrevDecl) 61665942Sgibbs PrevDecl->NextDeclInContext = D; 61765942Sgibbs else 61865942Sgibbs FirstNewDecl = D; 61965942Sgibbs 62065942Sgibbs PrevDecl = D; 62165942Sgibbs } 62265942Sgibbs 62365942Sgibbs // Splice the newly-read declarations into the beginning of the list 62465942Sgibbs // of declarations. 62565942Sgibbs PrevDecl->NextDeclInContext = FirstDecl; 62665942Sgibbs FirstDecl = FirstNewDecl; 62765942Sgibbs if (!LastDecl) 62865942Sgibbs LastDecl = PrevDecl; 62965942Sgibbs} 63065942Sgibbs 63165942Sgibbsvoid 63265942SgibbsDeclContext::LoadVisibleDeclsFromExternalStorage() const { 63365942Sgibbs DeclContext *This = const_cast<DeclContext *>(this); 63465942Sgibbs ExternalASTSource *Source = getParentASTContext().getExternalSource(); 63565942Sgibbs assert(hasExternalVisibleStorage() && Source && "No external storage?"); 63665942Sgibbs 63765942Sgibbs llvm::SmallVector<VisibleDeclaration, 64> Decls; 63865942Sgibbs if (Source->ReadDeclsVisibleInContext(This, Decls)) 63965942Sgibbs return; 64065942Sgibbs 64165942Sgibbs // There is no longer any visible storage in this context 64265942Sgibbs ExternalVisibleStorage = false; 64365942Sgibbs 64465942Sgibbs // Load the declaration IDs for all of the names visible in this 64565942Sgibbs // context. 64665942Sgibbs assert(!LookupPtr && "Have a lookup map before de-serialization?"); 64765942Sgibbs StoredDeclsMap *Map = 64865942Sgibbs (StoredDeclsMap*) getParentASTContext().CreateStoredDeclsMap(); 64965942Sgibbs LookupPtr = Map; 65065942Sgibbs for (unsigned I = 0, N = Decls.size(); I != N; ++I) { 65165942Sgibbs (*Map)[Decls[I].Name].setFromDeclIDs(Decls[I].Declarations); 65265942Sgibbs } 65365942Sgibbs} 65465942Sgibbs 65565942SgibbsDeclContext::decl_iterator DeclContext::decls_begin() const { 65665942Sgibbs if (hasExternalLexicalStorage()) 65765942Sgibbs LoadLexicalDeclsFromExternalStorage(); 65865942Sgibbs 65965942Sgibbs // FIXME: Check whether we need to load some declarations from 66065942Sgibbs // external storage. 66165942Sgibbs return decl_iterator(FirstDecl); 66265942Sgibbs} 66365942Sgibbs 66465942SgibbsDeclContext::decl_iterator DeclContext::decls_end() const { 66565942Sgibbs if (hasExternalLexicalStorage()) 66665942Sgibbs LoadLexicalDeclsFromExternalStorage(); 66765942Sgibbs 66865942Sgibbs return decl_iterator(); 66965942Sgibbs} 67065942Sgibbs 67165942Sgibbsbool DeclContext::decls_empty() const { 67265942Sgibbs if (hasExternalLexicalStorage()) 67365942Sgibbs LoadLexicalDeclsFromExternalStorage(); 67465942Sgibbs 67565942Sgibbs return !FirstDecl; 67665942Sgibbs} 67765942Sgibbs 67865942Sgibbsvoid DeclContext::removeDecl(Decl *D) { 67965942Sgibbs assert(D->getLexicalDeclContext() == this && 68065942Sgibbs "decl being removed from non-lexical context"); 68165942Sgibbs assert((D->NextDeclInContext || D == LastDecl) && 68265942Sgibbs "decl is not in decls list"); 68365942Sgibbs 68465942Sgibbs // Remove D from the decl chain. This is O(n) but hopefully rare. 68565942Sgibbs if (D == FirstDecl) { 68665942Sgibbs if (D == LastDecl) 68765942Sgibbs FirstDecl = LastDecl = 0; 68865942Sgibbs else 68965942Sgibbs FirstDecl = D->NextDeclInContext; 69065942Sgibbs } else { 69165942Sgibbs for (Decl *I = FirstDecl; true; I = I->NextDeclInContext) { 69265942Sgibbs assert(I && "decl not found in linked list"); 69365942Sgibbs if (I->NextDeclInContext == D) { 69465942Sgibbs I->NextDeclInContext = D->NextDeclInContext; 69565942Sgibbs if (D == LastDecl) LastDecl = I; 69665942Sgibbs break; 69765942Sgibbs } 69865942Sgibbs } 69965942Sgibbs } 70065942Sgibbs 70165942Sgibbs // Mark that D is no longer in the decl chain. 70265942Sgibbs D->NextDeclInContext = 0; 70365942Sgibbs 70465942Sgibbs // Remove D from the lookup table if necessary. 70565942Sgibbs if (isa<NamedDecl>(D)) { 70665942Sgibbs NamedDecl *ND = cast<NamedDecl>(D); 70765942Sgibbs 70865942Sgibbs void *OpaqueMap = getPrimaryContext()->LookupPtr; 70965942Sgibbs if (!OpaqueMap) return; 71065942Sgibbs 71165942Sgibbs StoredDeclsMap *Map = static_cast<StoredDeclsMap*>(OpaqueMap); 71265942Sgibbs StoredDeclsMap::iterator Pos = Map->find(ND->getDeclName()); 71365942Sgibbs assert(Pos != Map->end() && "no lookup entry for decl"); 71465942Sgibbs Pos->second.remove(ND); 71565942Sgibbs } 71665942Sgibbs} 71765942Sgibbs 71865942Sgibbsvoid DeclContext::addHiddenDecl(Decl *D) { 71965942Sgibbs assert(D->getLexicalDeclContext() == this && 72065942Sgibbs "Decl inserted into wrong lexical context"); 72165942Sgibbs assert(!D->getNextDeclInContext() && D != LastDecl && 72265942Sgibbs "Decl already inserted into a DeclContext"); 72365942Sgibbs 72465942Sgibbs if (FirstDecl) { 72565942Sgibbs LastDecl->NextDeclInContext = D; 72665942Sgibbs LastDecl = D; 72765942Sgibbs } else { 72865942Sgibbs FirstDecl = LastDecl = D; 72965942Sgibbs } 73065942Sgibbs} 73165942Sgibbs 73265942Sgibbsvoid DeclContext::addDecl(Decl *D) { 73365942Sgibbs addHiddenDecl(D); 73465942Sgibbs 73565942Sgibbs if (NamedDecl *ND = dyn_cast<NamedDecl>(D)) 73665942Sgibbs ND->getDeclContext()->makeDeclVisibleInContext(ND); 73765942Sgibbs} 73865942Sgibbs 73965942Sgibbs/// buildLookup - Build the lookup data structure with all of the 74065942Sgibbs/// declarations in DCtx (and any other contexts linked to it or 74165942Sgibbs/// transparent contexts nested within it). 74265942Sgibbsvoid DeclContext::buildLookup(DeclContext *DCtx) { 74365942Sgibbs for (; DCtx; DCtx = DCtx->getNextContext()) { 74465942Sgibbs for (decl_iterator D = DCtx->decls_begin(), 74565942Sgibbs DEnd = DCtx->decls_end(); 74665942Sgibbs D != DEnd; ++D) { 74765942Sgibbs // Insert this declaration into the lookup structure, but only 74865942Sgibbs // if it's semantically in its decl context. During non-lazy 74965942Sgibbs // lookup building, this is implicitly enforced by addDecl. 75065942Sgibbs if (NamedDecl *ND = dyn_cast<NamedDecl>(*D)) 75165942Sgibbs if (D->getDeclContext() == DCtx) 75265942Sgibbs makeDeclVisibleInContextImpl(ND); 75365942Sgibbs 75465942Sgibbs // Insert any forward-declared Objective-C interfaces into the lookup 75565942Sgibbs // data structure. 75665942Sgibbs if (ObjCClassDecl *Class = dyn_cast<ObjCClassDecl>(*D)) 75765942Sgibbs for (ObjCClassDecl::iterator I = Class->begin(), IEnd = Class->end(); 75865942Sgibbs I != IEnd; ++I) 75965942Sgibbs makeDeclVisibleInContextImpl(I->getInterface()); 76065942Sgibbs 76165942Sgibbs // If this declaration is itself a transparent declaration context, 76265942Sgibbs // add its members (recursively). 76365942Sgibbs if (DeclContext *InnerCtx = dyn_cast<DeclContext>(*D)) 76465942Sgibbs if (InnerCtx->isTransparentContext()) 76565942Sgibbs buildLookup(InnerCtx->getPrimaryContext()); 76665942Sgibbs } 76765942Sgibbs } 76865942Sgibbs} 76965942Sgibbs 77065942SgibbsDeclContext::lookup_result 77165942SgibbsDeclContext::lookup(DeclarationName Name) { 77265942Sgibbs DeclContext *PrimaryContext = getPrimaryContext(); 77365942Sgibbs if (PrimaryContext != this) 77465942Sgibbs return PrimaryContext->lookup(Name); 77565942Sgibbs 77665942Sgibbs if (hasExternalVisibleStorage()) 77765942Sgibbs LoadVisibleDeclsFromExternalStorage(); 77865942Sgibbs 77965942Sgibbs /// If there is no lookup data structure, build one now by walking 78065942Sgibbs /// all of the linked DeclContexts (in declaration order!) and 78165942Sgibbs /// inserting their values. 78265942Sgibbs if (!LookupPtr) { 78365942Sgibbs buildLookup(this); 78465942Sgibbs 78565942Sgibbs if (!LookupPtr) 78665942Sgibbs return lookup_result(0, 0); 78765942Sgibbs } 78865942Sgibbs 78965942Sgibbs StoredDeclsMap *Map = static_cast<StoredDeclsMap*>(LookupPtr); 79065942Sgibbs StoredDeclsMap::iterator Pos = Map->find(Name); 79165942Sgibbs if (Pos == Map->end()) 79265942Sgibbs return lookup_result(0, 0); 79365942Sgibbs return Pos->second.getLookupResult(getParentASTContext()); 79465942Sgibbs} 79565942Sgibbs 79665942SgibbsDeclContext::lookup_const_result 79765942SgibbsDeclContext::lookup(DeclarationName Name) const { 79865942Sgibbs return const_cast<DeclContext*>(this)->lookup(Name); 79965942Sgibbs} 80065942Sgibbs 80165942SgibbsDeclContext *DeclContext::getLookupContext() { 80265942Sgibbs DeclContext *Ctx = this; 80365942Sgibbs // Skip through transparent contexts. 80465942Sgibbs while (Ctx->isTransparentContext()) 80565942Sgibbs Ctx = Ctx->getParent(); 80665942Sgibbs return Ctx; 80765942Sgibbs} 80865942Sgibbs 80965942SgibbsDeclContext *DeclContext::getEnclosingNamespaceContext() { 81065942Sgibbs DeclContext *Ctx = this; 81165942Sgibbs // Skip through non-namespace, non-translation-unit contexts. 81265942Sgibbs while (!Ctx->isFileContext() || Ctx->isTransparentContext()) 81365942Sgibbs Ctx = Ctx->getParent(); 81465942Sgibbs return Ctx->getPrimaryContext(); 81565942Sgibbs} 81665942Sgibbs 81765942Sgibbsvoid DeclContext::makeDeclVisibleInContext(NamedDecl *D, bool Recoverable) { 81865942Sgibbs // FIXME: This feels like a hack. Should DeclarationName support 81965942Sgibbs // template-ids, or is there a better way to keep specializations 82065942Sgibbs // from being visible? 82165942Sgibbs if (isa<ClassTemplateSpecializationDecl>(D)) 82265942Sgibbs return; 82365942Sgibbs if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) 82465942Sgibbs if (FD->isFunctionTemplateSpecialization()) 82565942Sgibbs return; 82665942Sgibbs 82765942Sgibbs DeclContext *PrimaryContext = getPrimaryContext(); 82865942Sgibbs if (PrimaryContext != this) { 82965942Sgibbs PrimaryContext->makeDeclVisibleInContext(D, Recoverable); 83065942Sgibbs return; 83165942Sgibbs } 83265942Sgibbs 83365942Sgibbs // If we already have a lookup data structure, perform the insertion 83465942Sgibbs // into it. Otherwise, be lazy and don't build that structure until 83565942Sgibbs // someone asks for it. 83665942Sgibbs if (LookupPtr || !Recoverable) 83765942Sgibbs makeDeclVisibleInContextImpl(D); 83865942Sgibbs 83965942Sgibbs // If we are a transparent context, insert into our parent context, 84065942Sgibbs // too. This operation is recursive. 84165942Sgibbs if (isTransparentContext()) 84265942Sgibbs getParent()->makeDeclVisibleInContext(D, Recoverable); 84365942Sgibbs} 84465942Sgibbs 84565942Sgibbsvoid DeclContext::makeDeclVisibleInContextImpl(NamedDecl *D) { 84665942Sgibbs // Skip unnamed declarations. 84765942Sgibbs if (!D->getDeclName()) 84865942Sgibbs return; 84965942Sgibbs 85065942Sgibbs // FIXME: This feels like a hack. Should DeclarationName support 85165942Sgibbs // template-ids, or is there a better way to keep specializations 85265942Sgibbs // from being visible? 85365942Sgibbs if (isa<ClassTemplateSpecializationDecl>(D)) 85465942Sgibbs return; 85565942Sgibbs 85665942Sgibbs ASTContext *C = 0; 85765942Sgibbs if (!LookupPtr) { 85865942Sgibbs C = &getParentASTContext(); 85965942Sgibbs LookupPtr = (StoredDeclsMap*) C->CreateStoredDeclsMap(); 86065942Sgibbs } 86165942Sgibbs 86265942Sgibbs // Insert this declaration into the map. 86365942Sgibbs StoredDeclsMap &Map = *static_cast<StoredDeclsMap*>(LookupPtr); 86465942Sgibbs StoredDeclsList &DeclNameEntries = Map[D->getDeclName()]; 86565942Sgibbs if (DeclNameEntries.isNull()) { 86665942Sgibbs DeclNameEntries.setOnlyValue(D); 86765942Sgibbs return; 86865942Sgibbs } 86965942Sgibbs 87065942Sgibbs // If it is possible that this is a redeclaration, check to see if there is 87165942Sgibbs // already a decl for which declarationReplaces returns true. If there is 87265942Sgibbs // one, just replace it and return. 87365942Sgibbs if (!C) 87465942Sgibbs C = &getParentASTContext(); 87565942Sgibbs 87665942Sgibbs if (DeclNameEntries.HandleRedeclaration(*C, D)) 87765942Sgibbs return; 87865942Sgibbs 87965942Sgibbs // Put this declaration into the appropriate slot. 88065942Sgibbs DeclNameEntries.AddSubsequentDecl(D); 88165942Sgibbs} 88265942Sgibbs 88365942Sgibbs/// Returns iterator range [First, Last) of UsingDirectiveDecls stored within 88465942Sgibbs/// this context. 88565942SgibbsDeclContext::udir_iterator_range 88665942SgibbsDeclContext::getUsingDirectives() const { 88765942Sgibbs lookup_const_result Result = lookup(UsingDirectiveDecl::getName()); 88865942Sgibbs return udir_iterator_range(reinterpret_cast<udir_iterator>(Result.first), 88965942Sgibbs reinterpret_cast<udir_iterator>(Result.second)); 89065942Sgibbs} 89165942Sgibbs 89265942Sgibbsvoid StoredDeclsList::materializeDecls(ASTContext &Context) { 89365942Sgibbs if (isNull()) 89465942Sgibbs return; 89565942Sgibbs 89665942Sgibbs switch ((DataKind)(Data & 0x03)) { 89765942Sgibbs case DK_Decl: 89865942Sgibbs case DK_Decl_Vector: 89965942Sgibbs break; 90065942Sgibbs 90165942Sgibbs case DK_DeclID: { 90265942Sgibbs // Resolve this declaration ID to an actual declaration by 90365942Sgibbs // querying the external AST source. 90465942Sgibbs unsigned DeclID = Data >> 2; 90565942Sgibbs 90665942Sgibbs ExternalASTSource *Source = Context.getExternalSource(); 90765942Sgibbs assert(Source && "No external AST source available!"); 90865942Sgibbs 90965942Sgibbs Data = reinterpret_cast<uintptr_t>(Source->GetDecl(DeclID)); 91065942Sgibbs break; 91165942Sgibbs } 91265942Sgibbs 91365942Sgibbs case DK_ID_Vector: { 91465942Sgibbs // We have a vector of declaration IDs. Resolve all of them to 91565942Sgibbs // actual declarations. 91665942Sgibbs VectorTy &Vector = *getAsVector(); 91765942Sgibbs ExternalASTSource *Source = Context.getExternalSource(); 91865942Sgibbs assert(Source && "No external AST source available!"); 91965942Sgibbs 92065942Sgibbs for (unsigned I = 0, N = Vector.size(); I != N; ++I) 92165942Sgibbs Vector[I] = reinterpret_cast<uintptr_t>(Source->GetDecl(Vector[I])); 92265942Sgibbs 92365942Sgibbs Data = (Data & ~0x03) | DK_Decl_Vector; 92465942Sgibbs break; 92565942Sgibbs } 92665942Sgibbs } 92765942Sgibbs} 92865942Sgibbs 92965942Sgibbs//===----------------------------------------------------------------------===// 93065942Sgibbs// Creation and Destruction of StoredDeclsMaps. // 93165942Sgibbs//===----------------------------------------------------------------------===// 93265942Sgibbs 93365942Sgibbsvoid *ASTContext::CreateStoredDeclsMap() { 93465942Sgibbs StoredDeclsMap *M = new StoredDeclsMap(); 93565942Sgibbs SDMs.push_back(M); 93665942Sgibbs return M; 93765942Sgibbs} 93865942Sgibbs 93965942Sgibbsvoid ASTContext::ReleaseDeclContextMaps() { 94065942Sgibbs for (std::vector<void*>::iterator I = SDMs.begin(), E = SDMs.end(); I!=E; ++I) 94166717Sgibbs delete (StoredDeclsMap*) *I; 94266717Sgibbs} 94366717Sgibbs