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