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