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