clang  8.0.0svn
DeclBase.h
Go to the documentation of this file.
1 //===- DeclBase.h - Base Classes for representing declarations --*- C++ -*-===//
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 defines the Decl and DeclContext interfaces.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_AST_DECLBASE_H
15 #define LLVM_CLANG_AST_DECLBASE_H
16 
17 #include "clang/AST/AttrIterator.h"
19 #include "clang/Basic/LLVM.h"
21 #include "clang/Basic/Specifiers.h"
22 #include "llvm/ADT/ArrayRef.h"
23 #include "llvm/ADT/PointerIntPair.h"
24 #include "llvm/ADT/PointerUnion.h"
25 #include "llvm/ADT/iterator.h"
26 #include "llvm/ADT/iterator_range.h"
27 #include "llvm/Support/Casting.h"
28 #include "llvm/Support/Compiler.h"
29 #include "llvm/Support/PrettyStackTrace.h"
30 #include "llvm/Support/VersionTuple.h"
31 #include <algorithm>
32 #include <cassert>
33 #include <cstddef>
34 #include <iterator>
35 #include <string>
36 #include <type_traits>
37 #include <utility>
38 
39 namespace clang {
40 
41 class ASTContext;
42 class ASTMutationListener;
43 class Attr;
44 class DeclContext;
45 class ExternalSourceSymbolAttr;
46 class FunctionDecl;
47 class FunctionType;
48 class IdentifierInfo;
49 enum Linkage : unsigned char;
50 class LinkageSpecDecl;
51 class Module;
52 class NamedDecl;
53 class ObjCCategoryDecl;
54 class ObjCCategoryImplDecl;
55 class ObjCContainerDecl;
56 class ObjCImplDecl;
57 class ObjCImplementationDecl;
58 class ObjCInterfaceDecl;
59 class ObjCMethodDecl;
60 class ObjCProtocolDecl;
61 struct PrintingPolicy;
62 class RecordDecl;
63 class SourceManager;
64 class Stmt;
65 class StoredDeclsMap;
66 class TemplateDecl;
67 class TranslationUnitDecl;
68 class UsingDirectiveDecl;
69 
70 /// Captures the result of checking the availability of a
71 /// declaration.
77 };
78 
79 /// Decl - This represents one declaration (or definition), e.g. a variable,
80 /// typedef, function, struct, etc.
81 ///
82 /// Note: There are objects tacked on before the *beginning* of Decl
83 /// (and its subclasses) in its Decl::operator new(). Proper alignment
84 /// of all subclasses (not requiring more than the alignment of Decl) is
85 /// asserted in DeclBase.cpp.
86 class alignas(8) Decl {
87 public:
88  /// Lists the kind of concrete classes of Decl.
89  enum Kind {
90 #define DECL(DERIVED, BASE) DERIVED,
91 #define ABSTRACT_DECL(DECL)
92 #define DECL_RANGE(BASE, START, END) \
93  first##BASE = START, last##BASE = END,
94 #define LAST_DECL_RANGE(BASE, START, END) \
95  first##BASE = START, last##BASE = END
96 #include "clang/AST/DeclNodes.inc"
97  };
98 
99  /// A placeholder type used to construct an empty shell of a
100  /// decl-derived type that will be filled in later (e.g., by some
101  /// deserialization method).
102  struct EmptyShell {};
103 
104  /// IdentifierNamespace - The different namespaces in which
105  /// declarations may appear. According to C99 6.2.3, there are
106  /// four namespaces, labels, tags, members and ordinary
107  /// identifiers. C++ describes lookup completely differently:
108  /// certain lookups merely "ignore" certain kinds of declarations,
109  /// usually based on whether the declaration is of a type, etc.
110  ///
111  /// These are meant as bitmasks, so that searches in
112  /// C++ can look into the "tag" namespace during ordinary lookup.
113  ///
114  /// Decl currently provides 15 bits of IDNS bits.
116  /// Labels, declared with 'x:' and referenced with 'goto x'.
117  IDNS_Label = 0x0001,
118 
119  /// Tags, declared with 'struct foo;' and referenced with
120  /// 'struct foo'. All tags are also types. This is what
121  /// elaborated-type-specifiers look for in C.
122  /// This also contains names that conflict with tags in the
123  /// same scope but that are otherwise ordinary names (non-type
124  /// template parameters and indirect field declarations).
125  IDNS_Tag = 0x0002,
126 
127  /// Types, declared with 'struct foo', typedefs, etc.
128  /// This is what elaborated-type-specifiers look for in C++,
129  /// but note that it's ill-formed to find a non-tag.
130  IDNS_Type = 0x0004,
131 
132  /// Members, declared with object declarations within tag
133  /// definitions. In C, these can only be found by "qualified"
134  /// lookup in member expressions. In C++, they're found by
135  /// normal lookup.
136  IDNS_Member = 0x0008,
137 
138  /// Namespaces, declared with 'namespace foo {}'.
139  /// Lookup for nested-name-specifiers find these.
140  IDNS_Namespace = 0x0010,
141 
142  /// Ordinary names. In C, everything that's not a label, tag,
143  /// member, or function-local extern ends up here.
144  IDNS_Ordinary = 0x0020,
145 
146  /// Objective C \@protocol.
148 
149  /// This declaration is a friend function. A friend function
150  /// declaration is always in this namespace but may also be in
151  /// IDNS_Ordinary if it was previously declared.
153 
154  /// This declaration is a friend class. A friend class
155  /// declaration is always in this namespace but may also be in
156  /// IDNS_Tag|IDNS_Type if it was previously declared.
157  IDNS_TagFriend = 0x0100,
158 
159  /// This declaration is a using declaration. A using declaration
160  /// *introduces* a number of other declarations into the current
161  /// scope, and those declarations use the IDNS of their targets,
162  /// but the actual using declarations go in this namespace.
163  IDNS_Using = 0x0200,
164 
165  /// This declaration is a C++ operator declared in a non-class
166  /// context. All such operators are also in IDNS_Ordinary.
167  /// C++ lexical operator lookup looks for these.
169 
170  /// This declaration is a function-local extern declaration of a
171  /// variable or function. This may also be IDNS_Ordinary if it
172  /// has been declared outside any function. These act mostly like
173  /// invisible friend declarations, but are also visible to unqualified
174  /// lookup within the scope of the declaring function.
176 
177  /// This declaration is an OpenMP user defined reduction construction.
179  };
180 
181  /// ObjCDeclQualifier - 'Qualifiers' written next to the return and
182  /// parameter types in method declarations. Other than remembering
183  /// them and mangling them into the method's signature string, these
184  /// are ignored by the compiler; they are consumed by certain
185  /// remote-messaging frameworks.
186  ///
187  /// in, inout, and out are mutually exclusive and apply only to
188  /// method parameters. bycopy and byref are mutually exclusive and
189  /// apply only to method parameters (?). oneway applies only to
190  /// results. All of these expect their corresponding parameter to
191  /// have a particular type. None of this is currently enforced by
192  /// clang.
193  ///
194  /// This should be kept in sync with ObjCDeclSpec::ObjCDeclQualifier.
197  OBJC_TQ_In = 0x1,
199  OBJC_TQ_Out = 0x4,
203 
204  /// The nullability qualifier is set when the nullability of the
205  /// result or parameter was expressed via a context-sensitive
206  /// keyword.
208  };
209 
210  /// The kind of ownership a declaration has, for visibility purposes.
211  /// This enumeration is designed such that higher values represent higher
212  /// levels of name hiding.
213  enum class ModuleOwnershipKind : unsigned {
214  /// This declaration is not owned by a module.
215  Unowned,
216 
217  /// This declaration has an owning module, but is globally visible
218  /// (typically because its owning module is visible and we know that
219  /// modules cannot later become hidden in this compilation).
220  /// After serialization and deserialization, this will be converted
221  /// to VisibleWhenImported.
222  Visible,
223 
224  /// This declaration has an owning module, and is visible when that
225  /// module is imported.
226  VisibleWhenImported,
227 
228  /// This declaration has an owning module, but is only visible to
229  /// lookups that occur within that module.
230  ModulePrivate
231  };
232 
233 protected:
234  /// The next declaration within the same lexical
235  /// DeclContext. These pointers form the linked list that is
236  /// traversed via DeclContext's decls_begin()/decls_end().
237  ///
238  /// The extra two bits are used for the ModuleOwnershipKind.
239  llvm::PointerIntPair<Decl *, 2, ModuleOwnershipKind> NextInContextAndBits;
240 
241 private:
242  friend class DeclContext;
243 
244  struct MultipleDC {
245  DeclContext *SemanticDC;
246  DeclContext *LexicalDC;
247  };
248 
249  /// DeclCtx - Holds either a DeclContext* or a MultipleDC*.
250  /// For declarations that don't contain C++ scope specifiers, it contains
251  /// the DeclContext where the Decl was declared.
252  /// For declarations with C++ scope specifiers, it contains a MultipleDC*
253  /// with the context where it semantically belongs (SemanticDC) and the
254  /// context where it was lexically declared (LexicalDC).
255  /// e.g.:
256  ///
257  /// namespace A {
258  /// void f(); // SemanticDC == LexicalDC == 'namespace A'
259  /// }
260  /// void A::f(); // SemanticDC == namespace 'A'
261  /// // LexicalDC == global namespace
262  llvm::PointerUnion<DeclContext*, MultipleDC*> DeclCtx;
263 
264  bool isInSemaDC() const { return DeclCtx.is<DeclContext*>(); }
265  bool isOutOfSemaDC() const { return DeclCtx.is<MultipleDC*>(); }
266 
267  MultipleDC *getMultipleDC() const {
268  return DeclCtx.get<MultipleDC*>();
269  }
270 
271  DeclContext *getSemanticDC() const {
272  return DeclCtx.get<DeclContext*>();
273  }
274 
275  /// Loc - The location of this decl.
276  SourceLocation Loc;
277 
278  /// DeclKind - This indicates which class this is.
279  unsigned DeclKind : 7;
280 
281  /// InvalidDecl - This indicates a semantic error occurred.
282  unsigned InvalidDecl : 1;
283 
284  /// HasAttrs - This indicates whether the decl has attributes or not.
285  unsigned HasAttrs : 1;
286 
287  /// Implicit - Whether this declaration was implicitly generated by
288  /// the implementation rather than explicitly written by the user.
289  unsigned Implicit : 1;
290 
291  /// Whether this declaration was "used", meaning that a definition is
292  /// required.
293  unsigned Used : 1;
294 
295  /// Whether this declaration was "referenced".
296  /// The difference with 'Used' is whether the reference appears in a
297  /// evaluated context or not, e.g. functions used in uninstantiated templates
298  /// are regarded as "referenced" but not "used".
299  unsigned Referenced : 1;
300 
301  /// Whether this declaration is a top-level declaration (function,
302  /// global variable, etc.) that is lexically inside an objc container
303  /// definition.
304  unsigned TopLevelDeclInObjCContainer : 1;
305 
306  /// Whether statistic collection is enabled.
307  static bool StatisticsEnabled;
308 
309 protected:
310  friend class ASTDeclReader;
311  friend class ASTDeclWriter;
312  friend class ASTNodeImporter;
313  friend class ASTReader;
314  friend class CXXClassMemberWrapper;
315  friend class LinkageComputer;
316  template<typename decl_type> friend class Redeclarable;
317 
318  /// Access - Used by C++ decls for the access specifier.
319  // NOTE: VC++ treats enums as signed, avoid using the AccessSpecifier enum
320  unsigned Access : 2;
321 
322  /// Whether this declaration was loaded from an AST file.
323  unsigned FromASTFile : 1;
324 
325  /// IdentifierNamespace - This specifies what IDNS_* namespace this lives in.
326  unsigned IdentifierNamespace : 13;
327 
328  /// If 0, we have not computed the linkage of this declaration.
329  /// Otherwise, it is the linkage + 1.
330  mutable unsigned CacheValidAndLinkage : 3;
331 
332  /// Allocate memory for a deserialized declaration.
333  ///
334  /// This routine must be used to allocate memory for any declaration that is
335  /// deserialized from a module file.
336  ///
337  /// \param Size The size of the allocated object.
338  /// \param Ctx The context in which we will allocate memory.
339  /// \param ID The global ID of the deserialized declaration.
340  /// \param Extra The amount of extra space to allocate after the object.
341  void *operator new(std::size_t Size, const ASTContext &Ctx, unsigned ID,
342  std::size_t Extra = 0);
343 
344  /// Allocate memory for a non-deserialized declaration.
345  void *operator new(std::size_t Size, const ASTContext &Ctx,
346  DeclContext *Parent, std::size_t Extra = 0);
347 
348 private:
349  bool AccessDeclContextSanity() const;
350 
351  /// Get the module ownership kind to use for a local lexical child of \p DC,
352  /// which may be either a local or (rarely) an imported declaration.
353  static ModuleOwnershipKind getModuleOwnershipKindForChildOf(DeclContext *DC) {
354  if (DC) {
355  auto *D = cast<Decl>(DC);
356  auto MOK = D->getModuleOwnershipKind();
357  if (MOK != ModuleOwnershipKind::Unowned &&
358  (!D->isFromASTFile() || D->hasLocalOwningModuleStorage()))
359  return MOK;
360  // If D is not local and we have no local module storage, then we don't
361  // need to track module ownership at all.
362  }
364  }
365 
366 protected:
368  : NextInContextAndBits(nullptr, getModuleOwnershipKindForChildOf(DC)),
369  DeclCtx(DC), Loc(L), DeclKind(DK), InvalidDecl(false), HasAttrs(false),
370  Implicit(false), Used(false), Referenced(false),
371  TopLevelDeclInObjCContainer(false), Access(AS_none), FromASTFile(0),
374  if (StatisticsEnabled) add(DK);
375  }
376 
377  Decl(Kind DK, EmptyShell Empty)
378  : DeclKind(DK), InvalidDecl(false), HasAttrs(false), Implicit(false),
379  Used(false), Referenced(false), TopLevelDeclInObjCContainer(false),
383  if (StatisticsEnabled) add(DK);
384  }
385 
386  virtual ~Decl();
387 
388  /// Update a potentially out-of-date declaration.
389  void updateOutOfDate(IdentifierInfo &II) const;
390 
392  return Linkage(CacheValidAndLinkage - 1);
393  }
394 
395  void setCachedLinkage(Linkage L) const {
396  CacheValidAndLinkage = L + 1;
397  }
398 
399  bool hasCachedLinkage() const {
400  return CacheValidAndLinkage;
401  }
402 
403 public:
404  /// Source range that this declaration covers.
405  virtual SourceRange getSourceRange() const LLVM_READONLY {
406  return SourceRange(getLocation(), getLocation());
407  }
408 
409  LLVM_ATTRIBUTE_DEPRECATED(SourceLocation getLocStart() const LLVM_READONLY,
410  "Use getBeginLoc instead") {
411  return getBeginLoc();
412  }
413  SourceLocation getBeginLoc() const LLVM_READONLY {
414  return getSourceRange().getBegin();
415  }
416 
417  LLVM_ATTRIBUTE_DEPRECATED(SourceLocation getLocEnd() const LLVM_READONLY,
418  "Use getEndLoc instead") {
419  return getEndLoc();
420  }
421  SourceLocation getEndLoc() const LLVM_READONLY {
422  return getSourceRange().getEnd();
423  }
424 
425  SourceLocation getLocation() const { return Loc; }
426  void setLocation(SourceLocation L) { Loc = L; }
427 
428  Kind getKind() const { return static_cast<Kind>(DeclKind); }
429  const char *getDeclKindName() const;
430 
431  Decl *getNextDeclInContext() { return NextInContextAndBits.getPointer(); }
432  const Decl *getNextDeclInContext() const {return NextInContextAndBits.getPointer();}
433 
435  if (isInSemaDC())
436  return getSemanticDC();
437  return getMultipleDC()->SemanticDC;
438  }
439  const DeclContext *getDeclContext() const {
440  return const_cast<Decl*>(this)->getDeclContext();
441  }
442 
443  /// Find the innermost non-closure ancestor of this declaration,
444  /// walking up through blocks, lambdas, etc. If that ancestor is
445  /// not a code context (!isFunctionOrMethod()), returns null.
446  ///
447  /// A declaration may be its own non-closure context.
449  const Decl *getNonClosureContext() const {
450  return const_cast<Decl*>(this)->getNonClosureContext();
451  }
452 
455  return const_cast<Decl*>(this)->getTranslationUnitDecl();
456  }
457 
458  bool isInAnonymousNamespace() const;
459 
460  bool isInStdNamespace() const;
461 
462  ASTContext &getASTContext() const LLVM_READONLY;
463 
465  Access = AS;
466  assert(AccessDeclContextSanity());
467  }
468 
470  assert(AccessDeclContextSanity());
471  return AccessSpecifier(Access);
472  }
473 
474  /// Retrieve the access specifier for this declaration, even though
475  /// it may not yet have been properly set.
477  return AccessSpecifier(Access);
478  }
479 
480  bool hasAttrs() const { return HasAttrs; }
481 
482  void setAttrs(const AttrVec& Attrs) {
483  return setAttrsImpl(Attrs, getASTContext());
484  }
485 
487  return const_cast<AttrVec&>(const_cast<const Decl*>(this)->getAttrs());
488  }
489 
490  const AttrVec &getAttrs() const;
491  void dropAttrs();
492 
493  void addAttr(Attr *A) {
494  if (hasAttrs())
495  getAttrs().push_back(A);
496  else
497  setAttrs(AttrVec(1, A));
498  }
499 
500  using attr_iterator = AttrVec::const_iterator;
501  using attr_range = llvm::iterator_range<attr_iterator>;
502 
503  attr_range attrs() const {
504  return attr_range(attr_begin(), attr_end());
505  }
506 
508  return hasAttrs() ? getAttrs().begin() : nullptr;
509  }
511  return hasAttrs() ? getAttrs().end() : nullptr;
512  }
513 
514  template <typename T>
515  void dropAttr() {
516  if (!HasAttrs) return;
517 
518  AttrVec &Vec = getAttrs();
519  Vec.erase(std::remove_if(Vec.begin(), Vec.end(), isa<T, Attr*>), Vec.end());
520 
521  if (Vec.empty())
522  HasAttrs = false;
523  }
524 
525  template <typename T>
526  llvm::iterator_range<specific_attr_iterator<T>> specific_attrs() const {
527  return llvm::make_range(specific_attr_begin<T>(), specific_attr_end<T>());
528  }
529 
530  template <typename T>
533  }
534 
535  template <typename T>
538  }
539 
540  template<typename T> T *getAttr() const {
541  return hasAttrs() ? getSpecificAttr<T>(getAttrs()) : nullptr;
542  }
543 
544  template<typename T> bool hasAttr() const {
545  return hasAttrs() && hasSpecificAttr<T>(getAttrs());
546  }
547 
548  /// getMaxAlignment - return the maximum alignment specified by attributes
549  /// on this decl, 0 if there are none.
550  unsigned getMaxAlignment() const;
551 
552  /// setInvalidDecl - Indicates the Decl had a semantic error. This
553  /// allows for graceful error recovery.
554  void setInvalidDecl(bool Invalid = true);
555  bool isInvalidDecl() const { return (bool) InvalidDecl; }
556 
557  /// isImplicit - Indicates whether the declaration was implicitly
558  /// generated by the implementation. If false, this declaration
559  /// was written explicitly in the source code.
560  bool isImplicit() const { return Implicit; }
561  void setImplicit(bool I = true) { Implicit = I; }
562 
563  /// Whether *any* (re-)declaration of the entity was used, meaning that
564  /// a definition is required.
565  ///
566  /// \param CheckUsedAttr When true, also consider the "used" attribute
567  /// (in addition to the "used" bit set by \c setUsed()) when determining
568  /// whether the function is used.
569  bool isUsed(bool CheckUsedAttr = true) const;
570 
571  /// Set whether the declaration is used, in the sense of odr-use.
572  ///
573  /// This should only be used immediately after creating a declaration.
574  /// It intentionally doesn't notify any listeners.
575  void setIsUsed() { getCanonicalDecl()->Used = true; }
576 
577  /// Mark the declaration used, in the sense of odr-use.
578  ///
579  /// This notifies any mutation listeners in addition to setting a bit
580  /// indicating the declaration is used.
581  void markUsed(ASTContext &C);
582 
583  /// Whether any declaration of this entity was referenced.
584  bool isReferenced() const;
585 
586  /// Whether this declaration was referenced. This should not be relied
587  /// upon for anything other than debugging.
588  bool isThisDeclarationReferenced() const { return Referenced; }
589 
590  void setReferenced(bool R = true) { Referenced = R; }
591 
592  /// Whether this declaration is a top-level declaration (function,
593  /// global variable, etc.) that is lexically inside an objc container
594  /// definition.
596  return TopLevelDeclInObjCContainer;
597  }
598 
599  void setTopLevelDeclInObjCContainer(bool V = true) {
600  TopLevelDeclInObjCContainer = V;
601  }
602 
603  /// Looks on this and related declarations for an applicable
604  /// external source symbol attribute.
605  ExternalSourceSymbolAttr *getExternalSourceSymbolAttr() const;
606 
607  /// Whether this declaration was marked as being private to the
608  /// module in which it was defined.
609  bool isModulePrivate() const {
611  }
612 
613  /// Whether this declaration is exported (by virtue of being lexically
614  /// within an ExportDecl or by being a NamespaceDecl).
615  bool isExported() const;
616 
617  /// Return true if this declaration has an attribute which acts as
618  /// definition of the entity, such as 'alias' or 'ifunc'.
619  bool hasDefiningAttr() const;
620 
621  /// Return this declaration's defining attribute if it has one.
622  const Attr *getDefiningAttr() const;
623 
624 protected:
625  /// Specify that this declaration was marked as being private
626  /// to the module in which it was defined.
628  // The module-private specifier has no effect on unowned declarations.
629  // FIXME: We should track this in some way for source fidelity.
631  return;
633  }
634 
635  /// Set the owning module ID.
636  void setOwningModuleID(unsigned ID) {
637  assert(isFromASTFile() && "Only works on a deserialized declaration");
638  *((unsigned*)this - 2) = ID;
639  }
640 
641 public:
642  /// Determine the availability of the given declaration.
643  ///
644  /// This routine will determine the most restrictive availability of
645  /// the given declaration (e.g., preferring 'unavailable' to
646  /// 'deprecated').
647  ///
648  /// \param Message If non-NULL and the result is not \c
649  /// AR_Available, will be set to a (possibly empty) message
650  /// describing why the declaration has not been introduced, is
651  /// deprecated, or is unavailable.
652  ///
653  /// \param EnclosingVersion The version to compare with. If empty, assume the
654  /// deployment target version.
655  ///
656  /// \param RealizedPlatform If non-NULL and the availability result is found
657  /// in an available attribute it will set to the platform which is written in
658  /// the available attribute.
660  getAvailability(std::string *Message = nullptr,
661  VersionTuple EnclosingVersion = VersionTuple(),
662  StringRef *RealizedPlatform = nullptr) const;
663 
664  /// Retrieve the version of the target platform in which this
665  /// declaration was introduced.
666  ///
667  /// \returns An empty version tuple if this declaration has no 'introduced'
668  /// availability attributes, or the version tuple that's specified in the
669  /// attribute otherwise.
670  VersionTuple getVersionIntroduced() const;
671 
672  /// Determine whether this declaration is marked 'deprecated'.
673  ///
674  /// \param Message If non-NULL and the declaration is deprecated,
675  /// this will be set to the message describing why the declaration
676  /// was deprecated (which may be empty).
677  bool isDeprecated(std::string *Message = nullptr) const {
678  return getAvailability(Message) == AR_Deprecated;
679  }
680 
681  /// Determine whether this declaration is marked 'unavailable'.
682  ///
683  /// \param Message If non-NULL and the declaration is unavailable,
684  /// this will be set to the message describing why the declaration
685  /// was made unavailable (which may be empty).
686  bool isUnavailable(std::string *Message = nullptr) const {
687  return getAvailability(Message) == AR_Unavailable;
688  }
689 
690  /// Determine whether this is a weak-imported symbol.
691  ///
692  /// Weak-imported symbols are typically marked with the
693  /// 'weak_import' attribute, but may also be marked with an
694  /// 'availability' attribute where we're targing a platform prior to
695  /// the introduction of this feature.
696  bool isWeakImported() const;
697 
698  /// Determines whether this symbol can be weak-imported,
699  /// e.g., whether it would be well-formed to add the weak_import
700  /// attribute.
701  ///
702  /// \param IsDefinition Set to \c true to indicate that this
703  /// declaration cannot be weak-imported because it has a definition.
704  bool canBeWeakImported(bool &IsDefinition) const;
705 
706  /// Determine whether this declaration came from an AST file (such as
707  /// a precompiled header or module) rather than having been parsed.
708  bool isFromASTFile() const { return FromASTFile; }
709 
710  /// Retrieve the global declaration ID associated with this
711  /// declaration, which specifies where this Decl was loaded from.
712  unsigned getGlobalID() const {
713  if (isFromASTFile())
714  return *((const unsigned*)this - 1);
715  return 0;
716  }
717 
718  /// Retrieve the global ID of the module that owns this particular
719  /// declaration.
720  unsigned getOwningModuleID() const {
721  if (isFromASTFile())
722  return *((const unsigned*)this - 2);
723  return 0;
724  }
725 
726 private:
727  Module *getOwningModuleSlow() const;
728 
729 protected:
730  bool hasLocalOwningModuleStorage() const;
731 
732 public:
733  /// Get the imported owning module, if this decl is from an imported
734  /// (non-local) module.
736  if (!isFromASTFile() || !hasOwningModule())
737  return nullptr;
738 
739  return getOwningModuleSlow();
740  }
741 
742  /// Get the local owning module, if known. Returns nullptr if owner is
743  /// not yet known or declaration is not from a module.
745  if (isFromASTFile() || !hasOwningModule())
746  return nullptr;
747 
748  assert(hasLocalOwningModuleStorage() &&
749  "owned local decl but no local module storage");
750  return reinterpret_cast<Module *const *>(this)[-1];
751  }
753  assert(!isFromASTFile() && hasOwningModule() &&
755  "should not have a cached owning module");
756  reinterpret_cast<Module **>(this)[-1] = M;
757  }
758 
759  /// Is this declaration owned by some module?
760  bool hasOwningModule() const {
762  }
763 
764  /// Get the module that owns this declaration (for visibility purposes).
767  }
768 
769  /// Get the module that owns this declaration for linkage purposes.
770  /// There only ever is such a module under the C++ Modules TS.
771  ///
772  /// \param IgnoreLinkage Ignore the linkage of the entity; assume that
773  /// all declarations in a global module fragment are unowned.
774  Module *getOwningModuleForLinkage(bool IgnoreLinkage = false) const;
775 
776  /// Determine whether this declaration might be hidden from name
777  /// lookup. Note that the declaration might be visible even if this returns
778  /// \c false, if the owning module is visible within the query context.
779  // FIXME: Rename this to make it clearer what it does.
780  bool isHidden() const {
782  }
783 
784  /// Set that this declaration is globally visible, even if it came from a
785  /// module that is not visible.
787  if (isHidden())
789  }
790 
791  /// Get the kind of module ownership for this declaration.
793  return NextInContextAndBits.getInt();
794  }
795 
796  /// Set whether this declaration is hidden from name lookup.
801  "no storage available for owning module for this declaration");
802  NextInContextAndBits.setInt(MOK);
803  }
804 
805  unsigned getIdentifierNamespace() const {
806  return IdentifierNamespace;
807  }
808 
809  bool isInIdentifierNamespace(unsigned NS) const {
810  return getIdentifierNamespace() & NS;
811  }
812 
813  static unsigned getIdentifierNamespaceForKind(Kind DK);
814 
817  }
818 
819  static bool isTagIdentifierNamespace(unsigned NS) {
820  // TagDecls have Tag and Type set and may also have TagFriend.
821  return (NS & ~IDNS_TagFriend) == (IDNS_Tag | IDNS_Type);
822  }
823 
824  /// getLexicalDeclContext - The declaration context where this Decl was
825  /// lexically declared (LexicalDC). May be different from
826  /// getDeclContext() (SemanticDC).
827  /// e.g.:
828  ///
829  /// namespace A {
830  /// void f(); // SemanticDC == LexicalDC == 'namespace A'
831  /// }
832  /// void A::f(); // SemanticDC == namespace 'A'
833  /// // LexicalDC == global namespace
835  if (isInSemaDC())
836  return getSemanticDC();
837  return getMultipleDC()->LexicalDC;
838  }
840  return const_cast<Decl*>(this)->getLexicalDeclContext();
841  }
842 
843  /// Determine whether this declaration is declared out of line (outside its
844  /// semantic context).
845  virtual bool isOutOfLine() const;
846 
847  /// setDeclContext - Set both the semantic and lexical DeclContext
848  /// to DC.
849  void setDeclContext(DeclContext *DC);
850 
852 
853  /// Determine whether this declaration is a templated entity (whether it is
854  // within the scope of a template parameter).
855  bool isTemplated() const;
856 
857  /// isDefinedOutsideFunctionOrMethod - This predicate returns true if this
858  /// scoped decl is defined outside the current function or method. This is
859  /// roughly global variables and functions, but also handles enums (which
860  /// could be defined inside or outside a function etc).
862  return getParentFunctionOrMethod() == nullptr;
863  }
864 
865  /// Returns true if this declaration lexically is inside a function.
866  /// It recognizes non-defining declarations as well as members of local
867  /// classes:
868  /// \code
869  /// void foo() { void bar(); }
870  /// void foo2() { class ABC { void bar(); }; }
871  /// \endcode
873 
874  /// If this decl is defined inside a function/method/block it returns
875  /// the corresponding DeclContext, otherwise it returns null.
876  const DeclContext *getParentFunctionOrMethod() const;
878  return const_cast<DeclContext*>(
879  const_cast<const Decl*>(this)->getParentFunctionOrMethod());
880  }
881 
882  /// Retrieves the "canonical" declaration of the given declaration.
883  virtual Decl *getCanonicalDecl() { return this; }
884  const Decl *getCanonicalDecl() const {
885  return const_cast<Decl*>(this)->getCanonicalDecl();
886  }
887 
888  /// Whether this particular Decl is a canonical one.
889  bool isCanonicalDecl() const { return getCanonicalDecl() == this; }
890 
891 protected:
892  /// Returns the next redeclaration or itself if this is the only decl.
893  ///
894  /// Decl subclasses that can be redeclared should override this method so that
895  /// Decl::redecl_iterator can iterate over them.
896  virtual Decl *getNextRedeclarationImpl() { return this; }
897 
898  /// Implementation of getPreviousDecl(), to be overridden by any
899  /// subclass that has a redeclaration chain.
900  virtual Decl *getPreviousDeclImpl() { return nullptr; }
901 
902  /// Implementation of getMostRecentDecl(), to be overridden by any
903  /// subclass that has a redeclaration chain.
904  virtual Decl *getMostRecentDeclImpl() { return this; }
905 
906 public:
907  /// Iterates through all the redeclarations of the same decl.
909  /// Current - The current declaration.
910  Decl *Current = nullptr;
911  Decl *Starter;
912 
913  public:
914  using value_type = Decl *;
915  using reference = const value_type &;
916  using pointer = const value_type *;
917  using iterator_category = std::forward_iterator_tag;
919 
920  redecl_iterator() = default;
921  explicit redecl_iterator(Decl *C) : Current(C), Starter(C) {}
922 
923  reference operator*() const { return Current; }
924  value_type operator->() const { return Current; }
925 
927  assert(Current && "Advancing while iterator has reached end");
928  // Get either previous decl or latest decl.
929  Decl *Next = Current->getNextRedeclarationImpl();
930  assert(Next && "Should return next redeclaration or itself, never null!");
931  Current = (Next != Starter) ? Next : nullptr;
932  return *this;
933  }
934 
936  redecl_iterator tmp(*this);
937  ++(*this);
938  return tmp;
939  }
940 
942  return x.Current == y.Current;
943  }
944 
946  return x.Current != y.Current;
947  }
948  };
949 
950  using redecl_range = llvm::iterator_range<redecl_iterator>;
951 
952  /// Returns an iterator range for all the redeclarations of the same
953  /// decl. It will iterate at least once (when this decl is the only one).
956  }
957 
959  return redecl_iterator(const_cast<Decl *>(this));
960  }
961 
963 
964  /// Retrieve the previous declaration that declares the same entity
965  /// as this declaration, or NULL if there is no previous declaration.
967 
968  /// Retrieve the most recent declaration that declares the same entity
969  /// as this declaration, or NULL if there is no previous declaration.
970  const Decl *getPreviousDecl() const {
971  return const_cast<Decl *>(this)->getPreviousDeclImpl();
972  }
973 
974  /// True if this is the first declaration in its redeclaration chain.
975  bool isFirstDecl() const {
976  return getPreviousDecl() == nullptr;
977  }
978 
979  /// Retrieve the most recent declaration that declares the same entity
980  /// as this declaration (which may be this declaration).
982 
983  /// Retrieve the most recent declaration that declares the same entity
984  /// as this declaration (which may be this declaration).
985  const Decl *getMostRecentDecl() const {
986  return const_cast<Decl *>(this)->getMostRecentDeclImpl();
987  }
988 
989  /// getBody - If this Decl represents a declaration for a body of code,
990  /// such as a function or method definition, this method returns the
991  /// top-level Stmt* of that body. Otherwise this method returns null.
992  virtual Stmt* getBody() const { return nullptr; }
993 
994  /// Returns true if this \c Decl represents a declaration for a body of
995  /// code, such as a function or method definition.
996  /// Note that \c hasBody can also return true if any redeclaration of this
997  /// \c Decl represents a declaration for a body of code.
998  virtual bool hasBody() const { return getBody() != nullptr; }
999 
1000  /// getBodyRBrace - Gets the right brace of the body, if a body exists.
1001  /// This works whether the body is a CompoundStmt or a CXXTryStmt.
1002  SourceLocation getBodyRBrace() const;
1003 
1004  // global temp stats (until we have a per-module visitor)
1005  static void add(Kind k);
1006  static void EnableStatistics();
1007  static void PrintStats();
1008 
1009  /// isTemplateParameter - Determines whether this declaration is a
1010  /// template parameter.
1011  bool isTemplateParameter() const;
1012 
1013  /// isTemplateParameter - Determines whether this declaration is a
1014  /// template parameter pack.
1015  bool isTemplateParameterPack() const;
1016 
1017  /// Whether this declaration is a parameter pack.
1018  bool isParameterPack() const;
1019 
1020  /// returns true if this declaration is a template
1021  bool isTemplateDecl() const;
1022 
1023  /// Whether this declaration is a function or function template.
1025  return (DeclKind >= Decl::firstFunction &&
1026  DeclKind <= Decl::lastFunction) ||
1027  DeclKind == FunctionTemplate;
1028  }
1029 
1030  /// If this is a declaration that describes some template, this
1031  /// method returns that template declaration.
1033 
1034  /// Returns the function itself, or the templated function if this is a
1035  /// function template.
1036  FunctionDecl *getAsFunction() LLVM_READONLY;
1037 
1038  const FunctionDecl *getAsFunction() const {
1039  return const_cast<Decl *>(this)->getAsFunction();
1040  }
1041 
1042  /// Changes the namespace of this declaration to reflect that it's
1043  /// a function-local extern declaration.
1044  ///
1045  /// These declarations appear in the lexical context of the extern
1046  /// declaration, but in the semantic context of the enclosing namespace
1047  /// scope.
1049  Decl *Prev = getPreviousDecl();
1051 
1052  // It's OK for the declaration to still have the "invisible friend" flag or
1053  // the "conflicts with tag declarations in this scope" flag for the outer
1054  // scope.
1055  assert((IdentifierNamespace & ~(IDNS_OrdinaryFriend | IDNS_Tag)) == 0 &&
1056  "namespace is not ordinary");
1057 
1059  if (Prev && Prev->getIdentifierNamespace() & IDNS_Ordinary)
1061  }
1062 
1063  /// Determine whether this is a block-scope declaration with linkage.
1064  /// This will either be a local variable declaration declared 'extern', or a
1065  /// local function declaration.
1068  }
1069 
1070  /// Changes the namespace of this declaration to reflect that it's
1071  /// the object of a friend declaration.
1072  ///
1073  /// These declarations appear in the lexical context of the friending
1074  /// class, but in the semantic context of the actual entity. This property
1075  /// applies only to a specific decl object; other redeclarations of the
1076  /// same entity may not (and probably don't) share this property.
1077  void setObjectOfFriendDecl(bool PerformFriendInjection = false) {
1078  unsigned OldNS = IdentifierNamespace;
1079  assert((OldNS & (IDNS_Tag | IDNS_Ordinary |
1081  IDNS_LocalExtern)) &&
1082  "namespace includes neither ordinary nor tag");
1083  assert(!(OldNS & ~(IDNS_Tag | IDNS_Ordinary | IDNS_Type |
1085  IDNS_LocalExtern)) &&
1086  "namespace includes other than ordinary or tag");
1087 
1088  Decl *Prev = getPreviousDecl();
1090 
1091  if (OldNS & (IDNS_Tag | IDNS_TagFriend)) {
1093  if (PerformFriendInjection ||
1094  (Prev && Prev->getIdentifierNamespace() & IDNS_Tag))
1096  }
1097 
1100  if (PerformFriendInjection ||
1101  (Prev && Prev->getIdentifierNamespace() & IDNS_Ordinary))
1103  }
1104  }
1105 
1107  FOK_None, ///< Not a friend object.
1108  FOK_Declared, ///< A friend of a previously-declared entity.
1109  FOK_Undeclared ///< A friend of a previously-undeclared entity.
1110  };
1111 
1112  /// Determines whether this declaration is the object of a
1113  /// friend declaration and, if so, what kind.
1114  ///
1115  /// There is currently no direct way to find the associated FriendDecl.
1117  unsigned mask =
1119  if (!mask) return FOK_None;
1121  : FOK_Undeclared);
1122  }
1123 
1124  /// Specifies that this declaration is a C++ overloaded non-member.
1126  assert(getKind() == Function || getKind() == FunctionTemplate);
1127  assert((IdentifierNamespace & IDNS_Ordinary) &&
1128  "visible non-member operators should be in ordinary namespace");
1130  }
1131 
1132  static bool classofKind(Kind K) { return true; }
1133  static DeclContext *castToDeclContext(const Decl *);
1134  static Decl *castFromDeclContext(const DeclContext *);
1135 
1136  void print(raw_ostream &Out, unsigned Indentation = 0,
1137  bool PrintInstantiation = false) const;
1138  void print(raw_ostream &Out, const PrintingPolicy &Policy,
1139  unsigned Indentation = 0, bool PrintInstantiation = false) const;
1140  static void printGroup(Decl** Begin, unsigned NumDecls,
1141  raw_ostream &Out, const PrintingPolicy &Policy,
1142  unsigned Indentation = 0);
1143 
1144  // Debuggers don't usually respect default arguments.
1145  void dump() const;
1146 
1147  // Same as dump(), but forces color printing.
1148  void dumpColor() const;
1149 
1150  void dump(raw_ostream &Out, bool Deserialize = false) const;
1151 
1152  /// Looks through the Decl's underlying type to extract a FunctionType
1153  /// when possible. Will return null if the type underlying the Decl does not
1154  /// have a FunctionType.
1155  const FunctionType *getFunctionType(bool BlocksToo = true) const;
1156 
1157 private:
1158  void setAttrsImpl(const AttrVec& Attrs, ASTContext &Ctx);
1159  void setDeclContextsImpl(DeclContext *SemaDC, DeclContext *LexicalDC,
1160  ASTContext &Ctx);
1161 
1162 protected:
1164 };
1165 
1166 /// Determine whether two declarations declare the same entity.
1167 inline bool declaresSameEntity(const Decl *D1, const Decl *D2) {
1168  if (!D1 || !D2)
1169  return false;
1170 
1171  if (D1 == D2)
1172  return true;
1173 
1174  return D1->getCanonicalDecl() == D2->getCanonicalDecl();
1175 }
1176 
1177 /// PrettyStackTraceDecl - If a crash occurs, indicate that it happened when
1178 /// doing something to a specific decl.
1179 class PrettyStackTraceDecl : public llvm::PrettyStackTraceEntry {
1180  const Decl *TheDecl;
1181  SourceLocation Loc;
1182  SourceManager &SM;
1183  const char *Message;
1184 
1185 public:
1187  SourceManager &sm, const char *Msg)
1188  : TheDecl(theDecl), Loc(L), SM(sm), Message(Msg) {}
1189 
1190  void print(raw_ostream &OS) const override;
1191 };
1192 
1193 /// The results of name lookup within a DeclContext. This is either a
1194 /// single result (with no stable storage) or a collection of results (with
1195 /// stable storage provided by the lookup table).
1198 
1199  ResultTy Result;
1200 
1201  // If there is only one lookup result, it would be invalidated by
1202  // reallocations of the name table, so store it separately.
1203  NamedDecl *Single = nullptr;
1204 
1205  static NamedDecl *const SingleElementDummyList;
1206 
1207 public:
1208  DeclContextLookupResult() = default;
1210  : Result(Result) {}
1212  : Result(SingleElementDummyList), Single(Single) {}
1213 
1214  class iterator;
1215 
1216  using IteratorBase =
1217  llvm::iterator_adaptor_base<iterator, ResultTy::iterator,
1218  std::random_access_iterator_tag,
1219  NamedDecl *const>;
1220 
1221  class iterator : public IteratorBase {
1222  value_type SingleElement;
1223 
1224  public:
1225  iterator() = default;
1226  explicit iterator(pointer Pos, value_type Single = nullptr)
1227  : IteratorBase(Pos), SingleElement(Single) {}
1228 
1230  return SingleElement ? SingleElement : IteratorBase::operator*();
1231  }
1232  };
1233 
1234  using const_iterator = iterator;
1235  using pointer = iterator::pointer;
1236  using reference = iterator::reference;
1237 
1238  iterator begin() const { return iterator(Result.begin(), Single); }
1239  iterator end() const { return iterator(Result.end(), Single); }
1240 
1241  bool empty() const { return Result.empty(); }
1242  pointer data() const { return Single ? &Single : Result.data(); }
1243  size_t size() const { return Single ? 1 : Result.size(); }
1244  reference front() const { return Single ? Single : Result.front(); }
1245  reference back() const { return Single ? Single : Result.back(); }
1246  reference operator[](size_t N) const { return Single ? Single : Result[N]; }
1247 
1248  // FIXME: Remove this from the interface
1249  DeclContextLookupResult slice(size_t N) const {
1250  DeclContextLookupResult Sliced = Result.slice(N);
1251  Sliced.Single = Single;
1252  return Sliced;
1253  }
1254 };
1255 
1256 /// DeclContext - This is used only as base class of specific decl types that
1257 /// can act as declaration contexts. These decls are (only the top classes
1258 /// that directly derive from DeclContext are mentioned, not their subclasses):
1259 ///
1260 /// TranslationUnitDecl
1261 /// ExternCContext
1262 /// NamespaceDecl
1263 /// TagDecl
1264 /// OMPDeclareReductionDecl
1265 /// FunctionDecl
1266 /// ObjCMethodDecl
1267 /// ObjCContainerDecl
1268 /// LinkageSpecDecl
1269 /// ExportDecl
1270 /// BlockDecl
1271 /// CapturedDecl
1273  /// For makeDeclVisibleInContextImpl
1274  friend class ASTDeclReader;
1275  /// For reconcileExternalVisibleStorage, CreateStoredDeclsMap,
1276  /// hasNeedToReconcileExternalVisibleStorage
1277  friend class ExternalASTSource;
1278  /// For CreateStoredDeclsMap
1279  friend class DependentDiagnostic;
1280  /// For hasNeedToReconcileExternalVisibleStorage,
1281  /// hasLazyLocalLexicalLookups, hasLazyExternalLexicalLookups
1282  friend class ASTWriter;
1283 
1284  // We use uint64_t in the bit-fields below since some bit-fields
1285  // cross the unsigned boundary and this breaks the packing.
1286 
1287  /// Stores the bits used by DeclContext.
1288  /// If modified NumDeclContextBit, the ctor of DeclContext and the accessor
1289  /// methods in DeclContext should be updated appropriately.
1290  class DeclContextBitfields {
1291  friend class DeclContext;
1292  /// DeclKind - This indicates which class this is.
1293  uint64_t DeclKind : 7;
1294 
1295  /// Whether this declaration context also has some external
1296  /// storage that contains additional declarations that are lexically
1297  /// part of this context.
1298  mutable uint64_t ExternalLexicalStorage : 1;
1299 
1300  /// Whether this declaration context also has some external
1301  /// storage that contains additional declarations that are visible
1302  /// in this context.
1303  mutable uint64_t ExternalVisibleStorage : 1;
1304 
1305  /// Whether this declaration context has had externally visible
1306  /// storage added since the last lookup. In this case, \c LookupPtr's
1307  /// invariant may not hold and needs to be fixed before we perform
1308  /// another lookup.
1309  mutable uint64_t NeedToReconcileExternalVisibleStorage : 1;
1310 
1311  /// If \c true, this context may have local lexical declarations
1312  /// that are missing from the lookup table.
1313  mutable uint64_t HasLazyLocalLexicalLookups : 1;
1314 
1315  /// If \c true, the external source may have lexical declarations
1316  /// that are missing from the lookup table.
1317  mutable uint64_t HasLazyExternalLexicalLookups : 1;
1318 
1319  /// If \c true, lookups should only return identifier from
1320  /// DeclContext scope (for example TranslationUnit). Used in
1321  /// LookupQualifiedName()
1322  mutable uint64_t UseQualifiedLookup : 1;
1323  };
1324 
1325  /// Number of bits in DeclContextBitfields.
1326  enum { NumDeclContextBits = 13 };
1327 
1328  /// Stores the bits used by TagDecl.
1329  /// If modified NumTagDeclBits and the accessor
1330  /// methods in TagDecl should be updated appropriately.
1331  class TagDeclBitfields {
1332  friend class TagDecl;
1333  /// For the bits in DeclContextBitfields
1334  uint64_t : NumDeclContextBits;
1335 
1336  /// The TagKind enum.
1337  uint64_t TagDeclKind : 3;
1338 
1339  /// True if this is a definition ("struct foo {};"), false if it is a
1340  /// declaration ("struct foo;"). It is not considered a definition
1341  /// until the definition has been fully processed.
1342  uint64_t IsCompleteDefinition : 1;
1343 
1344  /// True if this is currently being defined.
1345  uint64_t IsBeingDefined : 1;
1346 
1347  /// True if this tag declaration is "embedded" (i.e., defined or declared
1348  /// for the very first time) in the syntax of a declarator.
1349  uint64_t IsEmbeddedInDeclarator : 1;
1350 
1351  /// True if this tag is free standing, e.g. "struct foo;".
1352  uint64_t IsFreeStanding : 1;
1353 
1354  /// Indicates whether it is possible for declarations of this kind
1355  /// to have an out-of-date definition.
1356  ///
1357  /// This option is only enabled when modules are enabled.
1358  uint64_t MayHaveOutOfDateDef : 1;
1359 
1360  /// Has the full definition of this type been required by a use somewhere in
1361  /// the TU.
1362  uint64_t IsCompleteDefinitionRequired : 1;
1363  };
1364 
1365  /// Number of non-inherited bits in TagDeclBitfields.
1366  enum { NumTagDeclBits = 9 };
1367 
1368  /// Stores the bits used by EnumDecl.
1369  /// If modified NumEnumDeclBit and the accessor
1370  /// methods in EnumDecl should be updated appropriately.
1371  class EnumDeclBitfields {
1372  friend class EnumDecl;
1373  /// For the bits in DeclContextBitfields.
1374  uint64_t : NumDeclContextBits;
1375  /// For the bits in TagDeclBitfields.
1376  uint64_t : NumTagDeclBits;
1377 
1378  /// Width in bits required to store all the non-negative
1379  /// enumerators of this enum.
1380  uint64_t NumPositiveBits : 8;
1381 
1382  /// Width in bits required to store all the negative
1383  /// enumerators of this enum.
1384  uint64_t NumNegativeBits : 8;
1385 
1386  /// True if this tag declaration is a scoped enumeration. Only
1387  /// possible in C++11 mode.
1388  uint64_t IsScoped : 1;
1389 
1390  /// If this tag declaration is a scoped enum,
1391  /// then this is true if the scoped enum was declared using the class
1392  /// tag, false if it was declared with the struct tag. No meaning is
1393  /// associated if this tag declaration is not a scoped enum.
1394  uint64_t IsScopedUsingClassTag : 1;
1395 
1396  /// True if this is an enumeration with fixed underlying type. Only
1397  /// possible in C++11, Microsoft extensions, or Objective C mode.
1398  uint64_t IsFixed : 1;
1399 
1400  /// True if a valid hash is stored in ODRHash.
1401  uint64_t HasODRHash : 1;
1402  };
1403 
1404  /// Number of non-inherited bits in EnumDeclBitfields.
1405  enum { NumEnumDeclBits = 20 };
1406 
1407  /// Stores the bits used by RecordDecl.
1408  /// If modified NumRecordDeclBits and the accessor
1409  /// methods in RecordDecl should be updated appropriately.
1410  class RecordDeclBitfields {
1411  friend class RecordDecl;
1412  /// For the bits in DeclContextBitfields.
1413  uint64_t : NumDeclContextBits;
1414  /// For the bits in TagDeclBitfields.
1415  uint64_t : NumTagDeclBits;
1416 
1417  /// This is true if this struct ends with a flexible
1418  /// array member (e.g. int X[]) or if this union contains a struct that does.
1419  /// If so, this cannot be contained in arrays or other structs as a member.
1420  uint64_t HasFlexibleArrayMember : 1;
1421 
1422  /// Whether this is the type of an anonymous struct or union.
1423  uint64_t AnonymousStructOrUnion : 1;
1424 
1425  /// This is true if this struct has at least one member
1426  /// containing an Objective-C object pointer type.
1427  uint64_t HasObjectMember : 1;
1428 
1429  /// This is true if struct has at least one member of
1430  /// 'volatile' type.
1431  uint64_t HasVolatileMember : 1;
1432 
1433  /// Whether the field declarations of this record have been loaded
1434  /// from external storage. To avoid unnecessary deserialization of
1435  /// methods/nested types we allow deserialization of just the fields
1436  /// when needed.
1437  mutable uint64_t LoadedFieldsFromExternalStorage : 1;
1438 
1439  /// Basic properties of non-trivial C structs.
1440  uint64_t NonTrivialToPrimitiveDefaultInitialize : 1;
1441  uint64_t NonTrivialToPrimitiveCopy : 1;
1442  uint64_t NonTrivialToPrimitiveDestroy : 1;
1443 
1444  /// Indicates whether this struct is destroyed in the callee.
1445  uint64_t ParamDestroyedInCallee : 1;
1446 
1447  /// Represents the way this type is passed to a function.
1448  uint64_t ArgPassingRestrictions : 2;
1449  };
1450 
1451  /// Number of non-inherited bits in RecordDeclBitfields.
1452  enum { NumRecordDeclBits = 11 };
1453 
1454  /// Stores the bits used by OMPDeclareReductionDecl.
1455  /// If modified NumOMPDeclareReductionDeclBits and the accessor
1456  /// methods in OMPDeclareReductionDecl should be updated appropriately.
1457  class OMPDeclareReductionDeclBitfields {
1458  friend class OMPDeclareReductionDecl;
1459  /// For the bits in DeclContextBitfields
1460  uint64_t : NumDeclContextBits;
1461 
1462  /// Kind of initializer,
1463  /// function call or omp_priv<init_expr> initializtion.
1464  uint64_t InitializerKind : 2;
1465  };
1466 
1467  /// Number of non-inherited bits in OMPDeclareReductionDeclBitfields.
1468  enum { NumOMPDeclareReductionDeclBits = 2 };
1469 
1470  /// Stores the bits used by FunctionDecl.
1471  /// If modified NumFunctionDeclBits and the accessor
1472  /// methods in FunctionDecl and CXXDeductionGuideDecl
1473  /// (for IsCopyDeductionCandidate) should be updated appropriately.
1474  class FunctionDeclBitfields {
1475  friend class FunctionDecl;
1476  /// For IsCopyDeductionCandidate
1477  friend class CXXDeductionGuideDecl;
1478  /// For the bits in DeclContextBitfields.
1479  uint64_t : NumDeclContextBits;
1480 
1481  uint64_t SClass : 3;
1482  uint64_t IsInline : 1;
1483  uint64_t IsInlineSpecified : 1;
1484 
1485  /// This is shared by CXXConstructorDecl,
1486  /// CXXConversionDecl, and CXXDeductionGuideDecl.
1487  uint64_t IsExplicitSpecified : 1;
1488 
1489  uint64_t IsVirtualAsWritten : 1;
1490  uint64_t IsPure : 1;
1491  uint64_t HasInheritedPrototype : 1;
1492  uint64_t HasWrittenPrototype : 1;
1493  uint64_t IsDeleted : 1;
1494  /// Used by CXXMethodDecl
1495  uint64_t IsTrivial : 1;
1496 
1497  /// This flag indicates whether this function is trivial for the purpose of
1498  /// calls. This is meaningful only when this function is a copy/move
1499  /// constructor or a destructor.
1500  uint64_t IsTrivialForCall : 1;
1501 
1502  /// Used by CXXMethodDecl
1503  uint64_t IsDefaulted : 1;
1504  /// Used by CXXMethodDecl
1505  uint64_t IsExplicitlyDefaulted : 1;
1506  uint64_t HasImplicitReturnZero : 1;
1507  uint64_t IsLateTemplateParsed : 1;
1508  uint64_t IsConstexpr : 1;
1509  uint64_t InstantiationIsPending : 1;
1510 
1511  /// Indicates if the function uses __try.
1512  uint64_t UsesSEHTry : 1;
1513 
1514  /// Indicates if the function was a definition
1515  /// but its body was skipped.
1516  uint64_t HasSkippedBody : 1;
1517 
1518  /// Indicates if the function declaration will
1519  /// have a body, once we're done parsing it.
1520  uint64_t WillHaveBody : 1;
1521 
1522  /// Indicates that this function is a multiversioned
1523  /// function using attribute 'target'.
1524  uint64_t IsMultiVersion : 1;
1525 
1526  /// [C++17] Only used by CXXDeductionGuideDecl. Indicates that
1527  /// the Deduction Guide is the implicitly generated 'copy
1528  /// deduction candidate' (is used during overload resolution).
1529  uint64_t IsCopyDeductionCandidate : 1;
1530 
1531  /// Store the ODRHash after first calculation.
1532  uint64_t HasODRHash : 1;
1533  };
1534 
1535  /// Number of non-inherited bits in FunctionDeclBitfields.
1536  enum { NumFunctionDeclBits = 25 };
1537 
1538  /// Stores the bits used by CXXConstructorDecl. If modified
1539  /// NumCXXConstructorDeclBits and the accessor
1540  /// methods in CXXConstructorDecl should be updated appropriately.
1541  class CXXConstructorDeclBitfields {
1542  friend class CXXConstructorDecl;
1543  /// For the bits in DeclContextBitfields.
1544  uint64_t : NumDeclContextBits;
1545  /// For the bits in FunctionDeclBitfields.
1546  uint64_t : NumFunctionDeclBits;
1547 
1548  /// 25 bits to fit in the remaining availible space.
1549  /// Note that this makes CXXConstructorDeclBitfields take
1550  /// exactly 64 bits and thus the width of NumCtorInitializers
1551  /// will need to be shrunk if some bit is added to NumDeclContextBitfields,
1552  /// NumFunctionDeclBitfields or CXXConstructorDeclBitfields.
1553  uint64_t NumCtorInitializers : 25;
1554  uint64_t IsInheritingConstructor : 1;
1555  };
1556 
1557  /// Number of non-inherited bits in CXXConstructorDeclBitfields.
1558  enum { NumCXXConstructorDeclBits = 26 };
1559 
1560  /// Stores the bits used by ObjCMethodDecl.
1561  /// If modified NumObjCMethodDeclBits and the accessor
1562  /// methods in ObjCMethodDecl should be updated appropriately.
1563  class ObjCMethodDeclBitfields {
1564  friend class ObjCMethodDecl;
1565 
1566  /// This is needed for the bitwidth of Family below but
1567  /// is defined in Basic/IdentifierTable.h which we do not include.
1568  /// To avoid mismatches between the two definitions we have
1569  /// a static_assert in the ctor of ObjCMethodDecl which checks
1570  /// that these two ObjCMethodFamilyBitWidth are equal.
1571  enum { ObjCMethodFamilyBitWidth = 4 };
1572 
1573  /// For the bits in DeclContextBitfields.
1574  uint64_t : NumDeclContextBits;
1575 
1576  /// The conventional meaning of this method; an ObjCMethodFamily.
1577  /// This is not serialized; instead, it is computed on demand and
1578  /// cached.
1579  mutable uint64_t Family : ObjCMethodFamilyBitWidth;
1580 
1581  /// instance (true) or class (false) method.
1582  uint64_t IsInstance : 1;
1583  uint64_t IsVariadic : 1;
1584 
1585  /// True if this method is the getter or setter for an explicit property.
1586  uint64_t IsPropertyAccessor : 1;
1587 
1588  /// Method has a definition.
1589  uint64_t IsDefined : 1;
1590 
1591  /// Method redeclaration in the same interface.
1592  uint64_t IsRedeclaration : 1;
1593 
1594  /// Is redeclared in the same interface.
1595  mutable uint64_t HasRedeclaration : 1;
1596 
1597  /// \@required/\@optional
1598  uint64_t DeclImplementation : 2;
1599 
1600  /// in, inout, etc.
1601  uint64_t objcDeclQualifier : 7;
1602 
1603  /// Indicates whether this method has a related result type.
1604  uint64_t RelatedResultType : 1;
1605 
1606  /// Whether the locations of the selector identifiers are in a
1607  /// "standard" position, a enum SelectorLocationsKind.
1608  uint64_t SelLocsKind : 2;
1609 
1610  /// Whether this method overrides any other in the class hierarchy.
1611  ///
1612  /// A method is said to override any method in the class's
1613  /// base classes, its protocols, or its categories' protocols, that has
1614  /// the same selector and is of the same kind (class or instance).
1615  /// A method in an implementation is not considered as overriding the same
1616  /// method in the interface or its categories.
1617  uint64_t IsOverriding : 1;
1618 
1619  /// Indicates if the method was a definition but its body was skipped.
1620  uint64_t HasSkippedBody : 1;
1621  };
1622 
1623  /// Number of non-inherited bits in ObjCMethodDeclBitfields.
1624  enum { NumObjCMethodDeclBits = 24 };
1625 
1626  /// Stores the bits used by ObjCContainerDecl.
1627  /// If modified NumObjCContainerDeclBits and the accessor
1628  /// methods in ObjCContainerDecl should be updated appropriately.
1629  class ObjCContainerDeclBitfields {
1630  friend class ObjCContainerDecl;
1631  /// For the bits in DeclContextBitfields
1632  uint32_t : NumDeclContextBits;
1633 
1634  // Not a bitfield but this saves space.
1635  // Note that ObjCContainerDeclBitfields is full.
1636  SourceLocation AtStart;
1637  };
1638 
1639  /// Number of non-inherited bits in ObjCContainerDeclBitfields.
1640  /// Note that here we rely on the fact that SourceLocation is 32 bits
1641  /// wide. We check this with the static_assert in the ctor of DeclContext.
1642  enum { NumObjCContainerDeclBits = 64 - NumDeclContextBits };
1643 
1644  /// Stores the bits used by LinkageSpecDecl.
1645  /// If modified NumLinkageSpecDeclBits and the accessor
1646  /// methods in LinkageSpecDecl should be updated appropriately.
1647  class LinkageSpecDeclBitfields {
1648  friend class LinkageSpecDecl;
1649  /// For the bits in DeclContextBitfields.
1650  uint64_t : NumDeclContextBits;
1651 
1652  /// The language for this linkage specification with values
1653  /// in the enum LinkageSpecDecl::LanguageIDs.
1654  uint64_t Language : 3;
1655 
1656  /// True if this linkage spec has braces.
1657  /// This is needed so that hasBraces() returns the correct result while the
1658  /// linkage spec body is being parsed. Once RBraceLoc has been set this is
1659  /// not used, so it doesn't need to be serialized.
1660  uint64_t HasBraces : 1;
1661  };
1662 
1663  /// Number of non-inherited bits in LinkageSpecDeclBitfields.
1664  enum { NumLinkageSpecDeclBits = 4 };
1665 
1666  /// Stores the bits used by BlockDecl.
1667  /// If modified NumBlockDeclBits and the accessor
1668  /// methods in BlockDecl should be updated appropriately.
1669  class BlockDeclBitfields {
1670  friend class BlockDecl;
1671  /// For the bits in DeclContextBitfields.
1672  uint64_t : NumDeclContextBits;
1673 
1674  uint64_t IsVariadic : 1;
1675  uint64_t CapturesCXXThis : 1;
1676  uint64_t BlockMissingReturnType : 1;
1677  uint64_t IsConversionFromLambda : 1;
1678 
1679  /// A bit that indicates this block is passed directly to a function as a
1680  /// non-escaping parameter.
1681  uint64_t DoesNotEscape : 1;
1682  };
1683 
1684  /// Number of non-inherited bits in BlockDeclBitfields.
1685  enum { NumBlockDeclBits = 5 };
1686 
1687  /// Pointer to the data structure used to lookup declarations
1688  /// within this context (or a DependentStoredDeclsMap if this is a
1689  /// dependent context). We maintain the invariant that, if the map
1690  /// contains an entry for a DeclarationName (and we haven't lazily
1691  /// omitted anything), then it contains all relevant entries for that
1692  /// name (modulo the hasExternalDecls() flag).
1693  mutable StoredDeclsMap *LookupPtr = nullptr;
1694 
1695 protected:
1696  /// This anonymous union stores the bits belonging to DeclContext and classes
1697  /// deriving from it. The goal is to use otherwise wasted
1698  /// space in DeclContext to store data belonging to derived classes.
1699  /// The space saved is especially significient when pointers are aligned
1700  /// to 8 bytes. In this case due to alignment requirements we have a
1701  /// little less than 8 bytes free in DeclContext which we can use.
1702  /// We check that none of the classes in this union is larger than
1703  /// 8 bytes with static_asserts in the ctor of DeclContext.
1704  union {
1705  DeclContextBitfields DeclContextBits;
1706  TagDeclBitfields TagDeclBits;
1707  EnumDeclBitfields EnumDeclBits;
1708  RecordDeclBitfields RecordDeclBits;
1709  OMPDeclareReductionDeclBitfields OMPDeclareReductionDeclBits;
1710  FunctionDeclBitfields FunctionDeclBits;
1711  CXXConstructorDeclBitfields CXXConstructorDeclBits;
1712  ObjCMethodDeclBitfields ObjCMethodDeclBits;
1713  ObjCContainerDeclBitfields ObjCContainerDeclBits;
1714  LinkageSpecDeclBitfields LinkageSpecDeclBits;
1715  BlockDeclBitfields BlockDeclBits;
1716 
1717  static_assert(sizeof(DeclContextBitfields) <= 8,
1718  "DeclContextBitfields is larger than 8 bytes!");
1719  static_assert(sizeof(TagDeclBitfields) <= 8,
1720  "TagDeclBitfields is larger than 8 bytes!");
1721  static_assert(sizeof(EnumDeclBitfields) <= 8,
1722  "EnumDeclBitfields is larger than 8 bytes!");
1723  static_assert(sizeof(RecordDeclBitfields) <= 8,
1724  "RecordDeclBitfields is larger than 8 bytes!");
1725  static_assert(sizeof(OMPDeclareReductionDeclBitfields) <= 8,
1726  "OMPDeclareReductionDeclBitfields is larger than 8 bytes!");
1727  static_assert(sizeof(FunctionDeclBitfields) <= 8,
1728  "FunctionDeclBitfields is larger than 8 bytes!");
1729  static_assert(sizeof(CXXConstructorDeclBitfields) <= 8,
1730  "CXXConstructorDeclBitfields is larger than 8 bytes!");
1731  static_assert(sizeof(ObjCMethodDeclBitfields) <= 8,
1732  "ObjCMethodDeclBitfields is larger than 8 bytes!");
1733  static_assert(sizeof(ObjCContainerDeclBitfields) <= 8,
1734  "ObjCContainerDeclBitfields is larger than 8 bytes!");
1735  static_assert(sizeof(LinkageSpecDeclBitfields) <= 8,
1736  "LinkageSpecDeclBitfields is larger than 8 bytes!");
1737  static_assert(sizeof(BlockDeclBitfields) <= 8,
1738  "BlockDeclBitfields is larger than 8 bytes!");
1739  };
1740 
1741  /// FirstDecl - The first declaration stored within this declaration
1742  /// context.
1743  mutable Decl *FirstDecl = nullptr;
1744 
1745  /// LastDecl - The last declaration stored within this declaration
1746  /// context. FIXME: We could probably cache this value somewhere
1747  /// outside of the DeclContext, to reduce the size of DeclContext by
1748  /// another pointer.
1749  mutable Decl *LastDecl = nullptr;
1750 
1751  /// Build up a chain of declarations.
1752  ///
1753  /// \returns the first/last pair of declarations.
1754  static std::pair<Decl *, Decl *>
1755  BuildDeclChain(ArrayRef<Decl*> Decls, bool FieldsAlreadyLoaded);
1756 
1758 
1759 public:
1760  ~DeclContext();
1761 
1763  return static_cast<Decl::Kind>(DeclContextBits.DeclKind);
1764  }
1765 
1766  const char *getDeclKindName() const;
1767 
1768  /// getParent - Returns the containing DeclContext.
1770  return cast<Decl>(this)->getDeclContext();
1771  }
1772  const DeclContext *getParent() const {
1773  return const_cast<DeclContext*>(this)->getParent();
1774  }
1775 
1776  /// getLexicalParent - Returns the containing lexical DeclContext. May be
1777  /// different from getParent, e.g.:
1778  ///
1779  /// namespace A {
1780  /// struct S;
1781  /// }
1782  /// struct A::S {}; // getParent() == namespace 'A'
1783  /// // getLexicalParent() == translation unit
1784  ///
1786  return cast<Decl>(this)->getLexicalDeclContext();
1787  }
1789  return const_cast<DeclContext*>(this)->getLexicalParent();
1790  }
1791 
1792  DeclContext *getLookupParent();
1793 
1794  const DeclContext *getLookupParent() const {
1795  return const_cast<DeclContext*>(this)->getLookupParent();
1796  }
1797 
1799  return cast<Decl>(this)->getASTContext();
1800  }
1801 
1802  bool isClosure() const { return getDeclKind() == Decl::Block; }
1803 
1804  bool isObjCContainer() const {
1805  switch (getDeclKind()) {
1806  case Decl::ObjCCategory:
1807  case Decl::ObjCCategoryImpl:
1808  case Decl::ObjCImplementation:
1809  case Decl::ObjCInterface:
1810  case Decl::ObjCProtocol:
1811  return true;
1812  default:
1813  return false;
1814  }
1815  }
1816 
1817  bool isFunctionOrMethod() const {
1818  switch (getDeclKind()) {
1819  case Decl::Block:
1820  case Decl::Captured:
1821  case Decl::ObjCMethod:
1822  return true;
1823  default:
1824  return getDeclKind() >= Decl::firstFunction &&
1825  getDeclKind() <= Decl::lastFunction;
1826  }
1827  }
1828 
1829  /// Test whether the context supports looking up names.
1830  bool isLookupContext() const {
1831  return !isFunctionOrMethod() && getDeclKind() != Decl::LinkageSpec &&
1832  getDeclKind() != Decl::Export;
1833  }
1834 
1835  bool isFileContext() const {
1836  return getDeclKind() == Decl::TranslationUnit ||
1837  getDeclKind() == Decl::Namespace;
1838  }
1839 
1840  bool isTranslationUnit() const {
1841  return getDeclKind() == Decl::TranslationUnit;
1842  }
1843 
1844  bool isRecord() const {
1845  return getDeclKind() >= Decl::firstRecord &&
1846  getDeclKind() <= Decl::lastRecord;
1847  }
1848 
1849  bool isNamespace() const { return getDeclKind() == Decl::Namespace; }
1850 
1851  bool isStdNamespace() const;
1852 
1853  bool isInlineNamespace() const;
1854 
1855  /// Determines whether this context is dependent on a
1856  /// template parameter.
1857  bool isDependentContext() const;
1858 
1859  /// isTransparentContext - Determines whether this context is a
1860  /// "transparent" context, meaning that the members declared in this
1861  /// context are semantically declared in the nearest enclosing
1862  /// non-transparent (opaque) context but are lexically declared in
1863  /// this context. For example, consider the enumerators of an
1864  /// enumeration type:
1865  /// @code
1866  /// enum E {
1867  /// Val1
1868  /// };
1869  /// @endcode
1870  /// Here, E is a transparent context, so its enumerator (Val1) will
1871  /// appear (semantically) that it is in the same context of E.
1872  /// Examples of transparent contexts include: enumerations (except for
1873  /// C++0x scoped enums), and C++ linkage specifications.
1874  bool isTransparentContext() const;
1875 
1876  /// Determines whether this context or some of its ancestors is a
1877  /// linkage specification context that specifies C linkage.
1878  bool isExternCContext() const;
1879 
1880  /// Retrieve the nearest enclosing C linkage specification context.
1881  const LinkageSpecDecl *getExternCContext() const;
1882 
1883  /// Determines whether this context or some of its ancestors is a
1884  /// linkage specification context that specifies C++ linkage.
1885  bool isExternCXXContext() const;
1886 
1887  /// Determine whether this declaration context is equivalent
1888  /// to the declaration context DC.
1889  bool Equals(const DeclContext *DC) const {
1890  return DC && this->getPrimaryContext() == DC->getPrimaryContext();
1891  }
1892 
1893  /// Determine whether this declaration context encloses the
1894  /// declaration context DC.
1895  bool Encloses(const DeclContext *DC) const;
1896 
1897  /// Find the nearest non-closure ancestor of this context,
1898  /// i.e. the innermost semantic parent of this context which is not
1899  /// a closure. A context may be its own non-closure ancestor.
1900  Decl *getNonClosureAncestor();
1901  const Decl *getNonClosureAncestor() const {
1902  return const_cast<DeclContext*>(this)->getNonClosureAncestor();
1903  }
1904 
1905  /// getPrimaryContext - There may be many different
1906  /// declarations of the same entity (including forward declarations
1907  /// of classes, multiple definitions of namespaces, etc.), each with
1908  /// a different set of declarations. This routine returns the
1909  /// "primary" DeclContext structure, which will contain the
1910  /// information needed to perform name lookup into this context.
1911  DeclContext *getPrimaryContext();
1913  return const_cast<DeclContext*>(this)->getPrimaryContext();
1914  }
1915 
1916  /// getRedeclContext - Retrieve the context in which an entity conflicts with
1917  /// other entities of the same name, or where it is a redeclaration if the
1918  /// two entities are compatible. This skips through transparent contexts.
1919  DeclContext *getRedeclContext();
1921  return const_cast<DeclContext *>(this)->getRedeclContext();
1922  }
1923 
1924  /// Retrieve the nearest enclosing namespace context.
1925  DeclContext *getEnclosingNamespaceContext();
1927  return const_cast<DeclContext *>(this)->getEnclosingNamespaceContext();
1928  }
1929 
1930  /// Retrieve the outermost lexically enclosing record context.
1931  RecordDecl *getOuterLexicalRecordContext();
1933  return const_cast<DeclContext *>(this)->getOuterLexicalRecordContext();
1934  }
1935 
1936  /// Test if this context is part of the enclosing namespace set of
1937  /// the context NS, as defined in C++0x [namespace.def]p9. If either context
1938  /// isn't a namespace, this is equivalent to Equals().
1939  ///
1940  /// The enclosing namespace set of a namespace is the namespace and, if it is
1941  /// inline, its enclosing namespace, recursively.
1942  bool InEnclosingNamespaceSetOf(const DeclContext *NS) const;
1943 
1944  /// Collects all of the declaration contexts that are semantically
1945  /// connected to this declaration context.
1946  ///
1947  /// For declaration contexts that have multiple semantically connected but
1948  /// syntactically distinct contexts, such as C++ namespaces, this routine
1949  /// retrieves the complete set of such declaration contexts in source order.
1950  /// For example, given:
1951  ///
1952  /// \code
1953  /// namespace N {
1954  /// int x;
1955  /// }
1956  /// namespace N {
1957  /// int y;
1958  /// }
1959  /// \endcode
1960  ///
1961  /// The \c Contexts parameter will contain both definitions of N.
1962  ///
1963  /// \param Contexts Will be cleared and set to the set of declaration
1964  /// contexts that are semanticaly connected to this declaration context,
1965  /// in source order, including this context (which may be the only result,
1966  /// for non-namespace contexts).
1967  void collectAllContexts(SmallVectorImpl<DeclContext *> &Contexts);
1968 
1969  /// decl_iterator - Iterates through the declarations stored
1970  /// within this context.
1972  /// Current - The current declaration.
1973  Decl *Current = nullptr;
1974 
1975  public:
1976  using value_type = Decl *;
1977  using reference = const value_type &;
1978  using pointer = const value_type *;
1979  using iterator_category = std::forward_iterator_tag;
1981 
1982  decl_iterator() = default;
1983  explicit decl_iterator(Decl *C) : Current(C) {}
1984 
1985  reference operator*() const { return Current; }
1986 
1987  // This doesn't meet the iterator requirements, but it's convenient
1988  value_type operator->() const { return Current; }
1989 
1991  Current = Current->getNextDeclInContext();
1992  return *this;
1993  }
1994 
1996  decl_iterator tmp(*this);
1997  ++(*this);
1998  return tmp;
1999  }
2000 
2002  return x.Current == y.Current;
2003  }
2004 
2006  return x.Current != y.Current;
2007  }
2008  };
2009 
2010  using decl_range = llvm::iterator_range<decl_iterator>;
2011 
2012  /// decls_begin/decls_end - Iterate over the declarations stored in
2013  /// this context.
2014  decl_range decls() const { return decl_range(decls_begin(), decls_end()); }
2015  decl_iterator decls_begin() const;
2016  decl_iterator decls_end() const { return decl_iterator(); }
2017  bool decls_empty() const;
2018 
2019  /// noload_decls_begin/end - Iterate over the declarations stored in this
2020  /// context that are currently loaded; don't attempt to retrieve anything
2021  /// from an external source.
2023  return decl_range(noload_decls_begin(), noload_decls_end());
2024  }
2025  decl_iterator noload_decls_begin() const { return decl_iterator(FirstDecl); }
2027 
2028  /// specific_decl_iterator - Iterates over a subrange of
2029  /// declarations stored in a DeclContext, providing only those that
2030  /// are of type SpecificDecl (or a class derived from it). This
2031  /// iterator is used, for example, to provide iteration over just
2032  /// the fields within a RecordDecl (with SpecificDecl = FieldDecl).
2033  template<typename SpecificDecl>
2035  /// Current - The current, underlying declaration iterator, which
2036  /// will either be NULL or will point to a declaration of
2037  /// type SpecificDecl.
2039 
2040  /// SkipToNextDecl - Advances the current position up to the next
2041  /// declaration of type SpecificDecl that also meets the criteria
2042  /// required by Acceptable.
2043  void SkipToNextDecl() {
2044  while (*Current && !isa<SpecificDecl>(*Current))
2045  ++Current;
2046  }
2047 
2048  public:
2049  using value_type = SpecificDecl *;
2050  // TODO: Add reference and pointer types (with some appropriate proxy type)
2051  // if we ever have a need for them.
2052  using reference = void;
2053  using pointer = void;
2054  using difference_type =
2055  std::iterator_traits<DeclContext::decl_iterator>::difference_type;
2056  using iterator_category = std::forward_iterator_tag;
2057 
2058  specific_decl_iterator() = default;
2059 
2060  /// specific_decl_iterator - Construct a new iterator over a
2061  /// subset of the declarations the range [C,
2062  /// end-of-declarations). If A is non-NULL, it is a pointer to a
2063  /// member function of SpecificDecl that should return true for
2064  /// all of the SpecificDecl instances that will be in the subset
2065  /// of iterators. For example, if you want Objective-C instance
2066  /// methods, SpecificDecl will be ObjCMethodDecl and A will be
2067  /// &ObjCMethodDecl::isInstanceMethod.
2069  SkipToNextDecl();
2070  }
2071 
2072  value_type operator*() const { return cast<SpecificDecl>(*Current); }
2073 
2074  // This doesn't meet the iterator requirements, but it's convenient
2075  value_type operator->() const { return **this; }
2076 
2078  ++Current;
2079  SkipToNextDecl();
2080  return *this;
2081  }
2082 
2084  specific_decl_iterator tmp(*this);
2085  ++(*this);
2086  return tmp;
2087  }
2088 
2089  friend bool operator==(const specific_decl_iterator& x,
2090  const specific_decl_iterator& y) {
2091  return x.Current == y.Current;
2092  }
2093 
2094  friend bool operator!=(const specific_decl_iterator& x,
2095  const specific_decl_iterator& y) {
2096  return x.Current != y.Current;
2097  }
2098  };
2099 
2100  /// Iterates over a filtered subrange of declarations stored
2101  /// in a DeclContext.
2102  ///
2103  /// This iterator visits only those declarations that are of type
2104  /// SpecificDecl (or a class derived from it) and that meet some
2105  /// additional run-time criteria. This iterator is used, for
2106  /// example, to provide access to the instance methods within an
2107  /// Objective-C interface (with SpecificDecl = ObjCMethodDecl and
2108  /// Acceptable = ObjCMethodDecl::isInstanceMethod).
2109  template<typename SpecificDecl, bool (SpecificDecl::*Acceptable)() const>
2111  /// Current - The current, underlying declaration iterator, which
2112  /// will either be NULL or will point to a declaration of
2113  /// type SpecificDecl.
2115 
2116  /// SkipToNextDecl - Advances the current position up to the next
2117  /// declaration of type SpecificDecl that also meets the criteria
2118  /// required by Acceptable.
2119  void SkipToNextDecl() {
2120  while (*Current &&
2121  (!isa<SpecificDecl>(*Current) ||
2122  (Acceptable && !(cast<SpecificDecl>(*Current)->*Acceptable)())))
2123  ++Current;
2124  }
2125 
2126  public:
2127  using value_type = SpecificDecl *;
2128  // TODO: Add reference and pointer types (with some appropriate proxy type)
2129  // if we ever have a need for them.
2130  using reference = void;
2131  using pointer = void;
2132  using difference_type =
2133  std::iterator_traits<DeclContext::decl_iterator>::difference_type;
2134  using iterator_category = std::forward_iterator_tag;
2135 
2136  filtered_decl_iterator() = default;
2137 
2138  /// filtered_decl_iterator - Construct a new iterator over a
2139  /// subset of the declarations the range [C,
2140  /// end-of-declarations). If A is non-NULL, it is a pointer to a
2141  /// member function of SpecificDecl that should return true for
2142  /// all of the SpecificDecl instances that will be in the subset
2143  /// of iterators. For example, if you want Objective-C instance
2144  /// methods, SpecificDecl will be ObjCMethodDecl and A will be
2145  /// &ObjCMethodDecl::isInstanceMethod.
2147  SkipToNextDecl();
2148  }
2149 
2150  value_type operator*() const { return cast<SpecificDecl>(*Current); }
2151  value_type operator->() const { return cast<SpecificDecl>(*Current); }
2152 
2154  ++Current;
2155  SkipToNextDecl();
2156  return *this;
2157  }
2158 
2160  filtered_decl_iterator tmp(*this);
2161  ++(*this);
2162  return tmp;
2163  }
2164 
2165  friend bool operator==(const filtered_decl_iterator& x,
2166  const filtered_decl_iterator& y) {
2167  return x.Current == y.Current;
2168  }
2169 
2170  friend bool operator!=(const filtered_decl_iterator& x,
2171  const filtered_decl_iterator& y) {
2172  return x.Current != y.Current;
2173  }
2174  };
2175 
2176  /// Add the declaration D into this context.
2177  ///
2178  /// This routine should be invoked when the declaration D has first
2179  /// been declared, to place D into the context where it was
2180  /// (lexically) defined. Every declaration must be added to one
2181  /// (and only one!) context, where it can be visited via
2182  /// [decls_begin(), decls_end()). Once a declaration has been added
2183  /// to its lexical context, the corresponding DeclContext owns the
2184  /// declaration.
2185  ///
2186  /// If D is also a NamedDecl, it will be made visible within its
2187  /// semantic context via makeDeclVisibleInContext.
2188  void addDecl(Decl *D);
2189 
2190  /// Add the declaration D into this context, but suppress
2191  /// searches for external declarations with the same name.
2192  ///
2193  /// Although analogous in function to addDecl, this removes an
2194  /// important check. This is only useful if the Decl is being
2195  /// added in response to an external search; in all other cases,
2196  /// addDecl() is the right function to use.
2197  /// See the ASTImporter for use cases.
2198  void addDeclInternal(Decl *D);
2199 
2200  /// Add the declaration D to this context without modifying
2201  /// any lookup tables.
2202  ///
2203  /// This is useful for some operations in dependent contexts where
2204  /// the semantic context might not be dependent; this basically
2205  /// only happens with friends.
2206  void addHiddenDecl(Decl *D);
2207 
2208  /// Removes a declaration from this context.
2209  void removeDecl(Decl *D);
2210 
2211  /// Checks whether a declaration is in this context.
2212  bool containsDecl(Decl *D) const;
2213 
2214  /// Checks whether a declaration is in this context.
2215  /// This also loads the Decls from the external source before the check.
2216  bool containsDeclAndLoad(Decl *D) const;
2217 
2220 
2221  /// lookup - Find the declarations (if any) with the given Name in
2222  /// this context. Returns a range of iterators that contains all of
2223  /// the declarations with this name, with object, function, member,
2224  /// and enumerator names preceding any tag name. Note that this
2225  /// routine will not look into parent contexts.
2226  lookup_result lookup(DeclarationName Name) const;
2227 
2228  /// Find the declarations with the given name that are visible
2229  /// within this context; don't attempt to retrieve anything from an
2230  /// external source.
2231  lookup_result noload_lookup(DeclarationName Name);
2232 
2233  /// A simplistic name lookup mechanism that performs name lookup
2234  /// into this declaration context without consulting the external source.
2235  ///
2236  /// This function should almost never be used, because it subverts the
2237  /// usual relationship between a DeclContext and the external source.
2238  /// See the ASTImporter for the (few, but important) use cases.
2239  ///
2240  /// FIXME: This is very inefficient; replace uses of it with uses of
2241  /// noload_lookup.
2242  void localUncachedLookup(DeclarationName Name,
2243  SmallVectorImpl<NamedDecl *> &Results);
2244 
2245  /// Makes a declaration visible within this context.
2246  ///
2247  /// This routine makes the declaration D visible to name lookup
2248  /// within this context and, if this is a transparent context,
2249  /// within its parent contexts up to the first enclosing
2250  /// non-transparent context. Making a declaration visible within a
2251  /// context does not transfer ownership of a declaration, and a
2252  /// declaration can be visible in many contexts that aren't its
2253  /// lexical context.
2254  ///
2255  /// If D is a redeclaration of an existing declaration that is
2256  /// visible from this context, as determined by
2257  /// NamedDecl::declarationReplaces, the previous declaration will be
2258  /// replaced with D.
2259  void makeDeclVisibleInContext(NamedDecl *D);
2260 
2261  /// all_lookups_iterator - An iterator that provides a view over the results
2262  /// of looking up every possible name.
2263  class all_lookups_iterator;
2264 
2265  using lookups_range = llvm::iterator_range<all_lookups_iterator>;
2266 
2267  lookups_range lookups() const;
2268  // Like lookups(), but avoids loading external declarations.
2269  // If PreserveInternalState, avoids building lookup data structures too.
2270  lookups_range noload_lookups(bool PreserveInternalState) const;
2271 
2272  /// Iterators over all possible lookups within this context.
2273  all_lookups_iterator lookups_begin() const;
2274  all_lookups_iterator lookups_end() const;
2275 
2276  /// Iterators over all possible lookups within this context that are
2277  /// currently loaded; don't attempt to retrieve anything from an external
2278  /// source.
2279  all_lookups_iterator noload_lookups_begin() const;
2280  all_lookups_iterator noload_lookups_end() const;
2281 
2282  struct udir_iterator;
2283 
2284  using udir_iterator_base =
2285  llvm::iterator_adaptor_base<udir_iterator, lookup_iterator,
2286  std::random_access_iterator_tag,
2288 
2289  struct udir_iterator : udir_iterator_base {
2290  udir_iterator(lookup_iterator I) : udir_iterator_base(I) {}
2291 
2292  UsingDirectiveDecl *operator*() const;
2293  };
2294 
2295  using udir_range = llvm::iterator_range<udir_iterator>;
2296 
2297  udir_range using_directives() const;
2298 
2299  // These are all defined in DependentDiagnostic.h.
2300  class ddiag_iterator;
2301 
2302  using ddiag_range = llvm::iterator_range<DeclContext::ddiag_iterator>;
2303 
2304  inline ddiag_range ddiags() const;
2305 
2306  // Low-level accessors
2307 
2308  /// Mark that there are external lexical declarations that we need
2309  /// to include in our lookup table (and that are not available as external
2310  /// visible lookups). These extra lookup results will be found by walking
2311  /// the lexical declarations of this context. This should be used only if
2312  /// setHasExternalLexicalStorage() has been called on any decl context for
2313  /// which this is the primary context.
2315  assert(this == getPrimaryContext() &&
2316  "should only be called on primary context");
2317  DeclContextBits.HasLazyExternalLexicalLookups = true;
2318  }
2319 
2320  /// Retrieve the internal representation of the lookup structure.
2321  /// This may omit some names if we are lazily building the structure.
2322  StoredDeclsMap *getLookupPtr() const { return LookupPtr; }
2323 
2324  /// Ensure the lookup structure is fully-built and return it.
2325  StoredDeclsMap *buildLookup();
2326 
2327  /// Whether this DeclContext has external storage containing
2328  /// additional declarations that are lexically in this context.
2330  return DeclContextBits.ExternalLexicalStorage;
2331  }
2332 
2333  /// State whether this DeclContext has external storage for
2334  /// declarations lexically in this context.
2335  void setHasExternalLexicalStorage(bool ES = true) const {
2336  DeclContextBits.ExternalLexicalStorage = ES;
2337  }
2338 
2339  /// Whether this DeclContext has external storage containing
2340  /// additional declarations that are visible in this context.
2342  return DeclContextBits.ExternalVisibleStorage;
2343  }
2344 
2345  /// State whether this DeclContext has external storage for
2346  /// declarations visible in this context.
2347  void setHasExternalVisibleStorage(bool ES = true) const {
2348  DeclContextBits.ExternalVisibleStorage = ES;
2349  if (ES && LookupPtr)
2350  DeclContextBits.NeedToReconcileExternalVisibleStorage = true;
2351  }
2352 
2353  /// Determine whether the given declaration is stored in the list of
2354  /// declarations lexically within this context.
2355  bool isDeclInLexicalTraversal(const Decl *D) const {
2356  return D && (D->NextInContextAndBits.getPointer() || D == FirstDecl ||
2357  D == LastDecl);
2358  }
2359 
2360  bool setUseQualifiedLookup(bool use = true) const {
2361  bool old_value = DeclContextBits.UseQualifiedLookup;
2362  DeclContextBits.UseQualifiedLookup = use;
2363  return old_value;
2364  }
2365 
2367  return DeclContextBits.UseQualifiedLookup;
2368  }
2369 
2370  static bool classof(const Decl *D);
2371  static bool classof(const DeclContext *D) { return true; }
2372 
2373  void dumpDeclContext() const;
2374  void dumpLookups() const;
2375  void dumpLookups(llvm::raw_ostream &OS, bool DumpDecls = false,
2376  bool Deserialize = false) const;
2377 
2378 private:
2379  /// Whether this declaration context has had externally visible
2380  /// storage added since the last lookup. In this case, \c LookupPtr's
2381  /// invariant may not hold and needs to be fixed before we perform
2382  /// another lookup.
2383  bool hasNeedToReconcileExternalVisibleStorage() const {
2384  return DeclContextBits.NeedToReconcileExternalVisibleStorage;
2385  }
2386 
2387  /// State that this declaration context has had externally visible
2388  /// storage added since the last lookup. In this case, \c LookupPtr's
2389  /// invariant may not hold and needs to be fixed before we perform
2390  /// another lookup.
2391  void setNeedToReconcileExternalVisibleStorage(bool Need = true) const {
2392  DeclContextBits.NeedToReconcileExternalVisibleStorage = Need;
2393  }
2394 
2395  /// If \c true, this context may have local lexical declarations
2396  /// that are missing from the lookup table.
2397  bool hasLazyLocalLexicalLookups() const {
2398  return DeclContextBits.HasLazyLocalLexicalLookups;
2399  }
2400 
2401  /// If \c true, this context may have local lexical declarations
2402  /// that are missing from the lookup table.
2403  void setHasLazyLocalLexicalLookups(bool HasLLLL = true) const {
2404  DeclContextBits.HasLazyLocalLexicalLookups = HasLLLL;
2405  }
2406 
2407  /// If \c true, the external source may have lexical declarations
2408  /// that are missing from the lookup table.
2409  bool hasLazyExternalLexicalLookups() const {
2410  return DeclContextBits.HasLazyExternalLexicalLookups;
2411  }
2412 
2413  /// If \c true, the external source may have lexical declarations
2414  /// that are missing from the lookup table.
2415  void setHasLazyExternalLexicalLookups(bool HasLELL = true) const {
2416  DeclContextBits.HasLazyExternalLexicalLookups = HasLELL;
2417  }
2418 
2419  void reconcileExternalVisibleStorage() const;
2420  bool LoadLexicalDeclsFromExternalStorage() const;
2421 
2422  /// Makes a declaration visible within this context, but
2423  /// suppresses searches for external declarations with the same
2424  /// name.
2425  ///
2426  /// Analogous to makeDeclVisibleInContext, but for the exclusive
2427  /// use of addDeclInternal().
2428  void makeDeclVisibleInContextInternal(NamedDecl *D);
2429 
2430  StoredDeclsMap *CreateStoredDeclsMap(ASTContext &C) const;
2431 
2432  void loadLazyLocalLexicalLookups();
2433  void buildLookupImpl(DeclContext *DCtx, bool Internal);
2434  void makeDeclVisibleInContextWithFlags(NamedDecl *D, bool Internal,
2435  bool Rediscoverable);
2436  void makeDeclVisibleInContextImpl(NamedDecl *D, bool Internal);
2437 };
2438 
2439 inline bool Decl::isTemplateParameter() const {
2440  return getKind() == TemplateTypeParm || getKind() == NonTypeTemplateParm ||
2441  getKind() == TemplateTemplateParm;
2442 }
2443 
2444 // Specialization selected when ToTy is not a known subclass of DeclContext.
2445 template <class ToTy,
2446  bool IsKnownSubtype = ::std::is_base_of<DeclContext, ToTy>::value>
2448  static const ToTy *doit(const DeclContext *Val) {
2449  return static_cast<const ToTy*>(Decl::castFromDeclContext(Val));
2450  }
2451 
2452  static ToTy *doit(DeclContext *Val) {
2453  return static_cast<ToTy*>(Decl::castFromDeclContext(Val));
2454  }
2455 };
2456 
2457 // Specialization selected when ToTy is a known subclass of DeclContext.
2458 template <class ToTy>
2460  static const ToTy *doit(const DeclContext *Val) {
2461  return static_cast<const ToTy*>(Val);
2462  }
2463 
2464  static ToTy *doit(DeclContext *Val) {
2465  return static_cast<ToTy*>(Val);
2466  }
2467 };
2468 
2469 } // namespace clang
2470 
2471 namespace llvm {
2472 
2473 /// isa<T>(DeclContext*)
2474 template <typename To>
2475 struct isa_impl<To, ::clang::DeclContext> {
2476  static bool doit(const ::clang::DeclContext &Val) {
2477  return To::classofKind(Val.getDeclKind());
2478  }
2479 };
2480 
2481 /// cast<T>(DeclContext*)
2482 template<class ToTy>
2483 struct cast_convert_val<ToTy,
2484  const ::clang::DeclContext,const ::clang::DeclContext> {
2485  static const ToTy &doit(const ::clang::DeclContext &Val) {
2487  }
2488 };
2489 
2490 template<class ToTy>
2491 struct cast_convert_val<ToTy, ::clang::DeclContext, ::clang::DeclContext> {
2492  static ToTy &doit(::clang::DeclContext &Val) {
2494  }
2495 };
2496 
2497 template<class ToTy>
2498 struct cast_convert_val<ToTy,
2499  const ::clang::DeclContext*, const ::clang::DeclContext*> {
2500  static const ToTy *doit(const ::clang::DeclContext *Val) {
2501  return ::clang::cast_convert_decl_context<ToTy>::doit(Val);
2502  }
2503 };
2504 
2505 template<class ToTy>
2506 struct cast_convert_val<ToTy, ::clang::DeclContext*, ::clang::DeclContext*> {
2507  static ToTy *doit(::clang::DeclContext *Val) {
2508  return ::clang::cast_convert_decl_context<ToTy>::doit(Val);
2509  }
2510 };
2511 
2512 /// Implement cast_convert_val for Decl -> DeclContext conversions.
2513 template<class FromTy>
2514 struct cast_convert_val< ::clang::DeclContext, FromTy, FromTy> {
2515  static ::clang::DeclContext &doit(const FromTy &Val) {
2516  return *FromTy::castToDeclContext(&Val);
2517  }
2518 };
2519 
2520 template<class FromTy>
2521 struct cast_convert_val< ::clang::DeclContext, FromTy*, FromTy*> {
2522  static ::clang::DeclContext *doit(const FromTy *Val) {
2523  return FromTy::castToDeclContext(Val);
2524  }
2525 };
2526 
2527 template<class FromTy>
2528 struct cast_convert_val< const ::clang::DeclContext, FromTy, FromTy> {
2529  static const ::clang::DeclContext &doit(const FromTy &Val) {
2530  return *FromTy::castToDeclContext(&Val);
2531  }
2532 };
2533 
2534 template<class FromTy>
2535 struct cast_convert_val< const ::clang::DeclContext, FromTy*, FromTy*> {
2536  static const ::clang::DeclContext *doit(const FromTy *Val) {
2537  return FromTy::castToDeclContext(Val);
2538  }
2539 };
2540 
2541 } // namespace llvm
2542 
2543 #endif // LLVM_CLANG_AST_DECLBASE_H
const Decl * getPreviousDecl() const
Retrieve the most recent declaration that declares the same entity as this declaration, or NULL if there is no previous declaration.
Definition: DeclBase.h:970
bool shouldUseQualifiedLookup() const
Definition: DeclBase.h:2366
specific_decl_iterator & operator++()
Definition: DeclBase.h:2077
void setImplicit(bool I=true)
Definition: DeclBase.h:561
Represents a function declaration or definition.
Definition: Decl.h:1722
redecl_iterator operator++(int)
Definition: DeclBase.h:935
const Decl * getCanonicalDecl() const
Definition: DeclBase.h:884
decl_iterator noload_decls_begin() const
Definition: DeclBase.h:2025
llvm::iterator_range< redecl_iterator > redecl_range
Definition: DeclBase.h:950
static DeclContext * castToDeclContext(const Decl *)
Definition: DeclBase.cpp:863
Module * getOwningModule() const
Get the module that owns this declaration (for visibility purposes).
Definition: DeclBase.h:765
const char * getDeclKindName() const
Definition: DeclBase.cpp:123
llvm::PointerIntPair< Decl *, 2, ModuleOwnershipKind > NextInContextAndBits
The next declaration within the same lexical DeclContext.
Definition: DeclBase.h:239
__SIZE_TYPE__ size_t
The unsigned integer type of the result of the sizeof operator.
Definition: opencl-c.h:60
static Decl * castFromDeclContext(const DeclContext *)
Definition: DeclBase.cpp:844
bool isClosure() const
Definition: DeclBase.h:1802
This declaration has an owning module, but is only visible to lookups that occur within that module...
bool isLookupContext() const
Test whether the context supports looking up names.
Definition: DeclBase.h:1830
virtual Stmt * getBody() const
getBody - If this Decl represents a declaration for a body of code, such as a function or method defi...
Definition: DeclBase.h:992
void setAttrs(const AttrVec &Attrs)
Definition: DeclBase.h:482
DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterat...
Definition: Dominators.h:30
Module * getOwningModuleForLinkage(bool IgnoreLinkage=false) const
Get the module that owns this declaration for linkage purposes.
Definition: Decl.cpp:1461
attr_iterator attr_begin() const
Definition: DeclBase.h:507
specific_attr_iterator< T > specific_attr_begin() const
Definition: DeclBase.h:531
Stmt - This represents one statement.
Definition: Stmt.h:66
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3215
LLVM_ATTRIBUTE_DEPRECATED(SourceLocation getLocStart() const LLVM_READONLY, "Use getBeginLoc instead")
Definition: DeclBase.h:409
unsigned CacheValidAndLinkage
If 0, we have not computed the linkage of this declaration.
Definition: DeclBase.h:330
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
specific_attr_iterator - Iterates over a subrange of an AttrVec, only providing attributes that are o...
Definition: AttrIterator.h:54
friend bool operator==(const specific_decl_iterator &x, const specific_decl_iterator &y)
Definition: DeclBase.h:2089
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: DeclBase.h:413
specific_decl_iterator(DeclContext::decl_iterator C)
specific_decl_iterator - Construct a new iterator over a subset of the declarations the range [C...
Definition: DeclBase.h:2068
static void add(Kind k)
Definition: DeclBase.cpp:193
Not a friend object.
Definition: DeclBase.h:1107
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration, or NULL if there is no previous declaration.
Definition: DeclBase.h:966
static bool doit(const ::clang::DeclContext &Val)
Definition: DeclBase.h:2476
bool isObjCContainer() const
Definition: DeclBase.h:1804
SourceLocation getEndLoc() const LLVM_READONLY
Definition: DeclBase.h:421
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:98
static void printGroup(Decl **Begin, unsigned NumDecls, raw_ostream &Out, const PrintingPolicy &Policy, unsigned Indentation=0)
bool isDeclInLexicalTraversal(const Decl *D) const
Determine whether the given declaration is stored in the list of declarations lexically within this c...
Definition: DeclBase.h:2355
static ToTy * doit(DeclContext *Val)
Definition: DeclBase.h:2452
bool hasExternalVisibleStorage() const
Whether this DeclContext has external storage containing additional declarations that are visible in ...
Definition: DeclBase.h:2341
Iterates over a filtered subrange of declarations stored in a DeclContext.
Definition: DeclBase.h:2110
unsigned getIdentifierNamespace() const
Definition: DeclBase.h:805
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2483
const DeclContext * getParentFunctionOrMethod() const
If this decl is defined inside a function/method/block it returns the corresponding DeclContext...
Definition: DeclBase.cpp:254
unsigned Access
Access - Used by C++ decls for the access specifier.
Definition: DeclBase.h:320
redecl_iterator & operator++()
Definition: DeclBase.h:926
reference back() const
Definition: DeclBase.h:1245
ModuleOwnershipKind
The kind of ownership a declaration has, for visibility purposes.
Definition: DeclBase.h:213
bool hasOwningModule() const
Is this declaration owned by some module?
Definition: DeclBase.h:760
ASTMutationListener * getASTMutationListener() const
Definition: DeclBase.cpp:380
LLVM_ATTRIBUTE_DEPRECATED(SourceLocation getLocEnd() const LLVM_READONLY, "Use getEndLoc instead")
Definition: DeclBase.h:417
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
Definition: DeclBase.h:2014
bool hasLocalOwningModuleStorage() const
Definition: DeclBase.cpp:119
ObjCMethodDecl - Represents an instance or class method declaration.
Definition: DeclObjC.h:139
reference front() const
Definition: DeclBase.h:1244
bool isInvalidDecl() const
Definition: DeclBase.h:555
friend bool operator!=(const specific_decl_iterator &x, const specific_decl_iterator &y)
Definition: DeclBase.h:2094
ExternalSourceSymbolAttr * getExternalSourceSymbolAttr() const
Looks on this and related declarations for an applicable external source symbol attribute.
Definition: DeclBase.cpp:450
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:38
bool isParameterPack() const
Whether this declaration is a parameter pack.
Definition: DeclBase.cpp:211
BlockDeclBitfields BlockDeclBits
Definition: DeclBase.h:1715
Module * getLocalOwningModule() const
Get the local owning module, if known.
Definition: DeclBase.h:744
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have...
Definition: Linkage.h:24
Decl(Kind DK, EmptyShell Empty)
Definition: DeclBase.h:377
value_type operator->() const
Definition: DeclBase.h:1988
Types, declared with &#39;struct foo&#39;, typedefs, etc.
Definition: DeclBase.h:130
bool isLexicallyWithinFunctionOrMethod() const
Returns true if this declaration lexically is inside a function.
Definition: DeclBase.cpp:335
Represents a struct/union/class.
Definition: Decl.h:3572
CXXConstructorDeclBitfields CXXConstructorDeclBits
Definition: DeclBase.h:1711
void dumpColor() const
Definition: ASTDumper.cpp:2749
Provides common interface for the Decls that can be redeclared.
Definition: Redeclarable.h:85
One of these records is kept for each identifier that is lexed.
void setHasExternalLexicalStorage(bool ES=true) const
State whether this DeclContext has external storage for declarations lexically in this context...
Definition: DeclBase.h:2335
void print(raw_ostream &Out, unsigned Indentation=0, bool PrintInstantiation=false) const
bool isInAnonymousNamespace() const
Definition: DeclBase.cpp:347
LinkageSpecDeclBitfields LinkageSpecDeclBits
Definition: DeclBase.h:1714
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:153
The results of name lookup within a DeclContext.
Definition: DeclBase.h:1196
attr_iterator attr_end() const
Definition: DeclBase.h:510
specific_decl_iterator operator++(int)
Definition: DeclBase.h:2083
friend class DeclContext
Definition: DeclBase.h:242
llvm::iterator_range< decl_iterator > decl_range
Definition: DeclBase.h:2010
std::forward_iterator_tag iterator_category
Definition: DeclBase.h:917
This declaration is a friend function.
Definition: DeclBase.h:152
bool isNamespace() const
Definition: DeclBase.h:1849
void setVisibleDespiteOwningModule()
Set that this declaration is globally visible, even if it came from a module that is not visible...
Definition: DeclBase.h:786
virtual SourceRange getSourceRange() const LLVM_READONLY
Source range that this declaration covers.
Definition: DeclBase.h:405
void setOwningModuleID(unsigned ID)
Set the owning module ID.
Definition: DeclBase.h:636
bool isDefinedOutsideFunctionOrMethod() const
isDefinedOutsideFunctionOrMethod - This predicate returns true if this scoped decl is defined outside...
Definition: DeclBase.h:861
bool isInIdentifierNamespace(unsigned NS) const
Definition: DeclBase.h:809
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC...
Definition: DeclBase.h:1889
unsigned FromASTFile
Whether this declaration was loaded from an AST file.
Definition: DeclBase.h:323
clang::CharUnits operator*(clang::CharUnits::QuantityType Scale, const clang::CharUnits &CU)
Definition: CharUnits.h:208
specific_attr_iterator< T > specific_attr_end() const
Definition: DeclBase.h:536
Describes a module or submodule.
Definition: Module.h:65
bool isDeprecated(std::string *Message=nullptr) const
Determine whether this declaration is marked &#39;deprecated&#39;.
Definition: DeclBase.h:677
friend bool operator!=(const filtered_decl_iterator &x, const filtered_decl_iterator &y)
Definition: DeclBase.h:2170
iterator(pointer Pos, value_type Single=nullptr)
Definition: DeclBase.h:1226
ObjCContainerDecl - Represents a container for method declarations.
Definition: DeclObjC.h:966
bool isReferenced() const
Whether any declaration of this entity was referenced.
Definition: DeclBase.cpp:422
Namespaces, declared with &#39;namespace foo {}&#39;.
Definition: DeclBase.h:140
bool hasTagIdentifierNamespace() const
Definition: DeclBase.h:815
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
const DeclContext * getLexicalDeclContext() const
Definition: DeclBase.h:839
ModuleOwnershipKind getModuleOwnershipKind() const
Get the kind of module ownership for this declaration.
Definition: DeclBase.h:792
std::forward_iterator_tag iterator_category
Definition: DeclBase.h:1979
filtered_decl_iterator(DeclContext::decl_iterator C)
filtered_decl_iterator - Construct a new iterator over a subset of the declarations the range [C...
Definition: DeclBase.h:2146
static bool isStdNamespace(const DeclContext *DC)
A friend of a previously-undeclared entity.
Definition: DeclBase.h:1109
std::forward_iterator_tag iterator_category
Definition: DeclBase.h:2056
DeclContextLookupResult slice(size_t N) const
Definition: DeclBase.h:1249
void setMustBuildLookupTable()
Mark that there are external lexical declarations that we need to include in our lookup table (and th...
Definition: DeclBase.h:2314
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Definition: DeclBase.h:1167
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC)...
Definition: DeclBase.h:834
std::iterator_traits< DeclContext::decl_iterator >::difference_type difference_type
Definition: DeclBase.h:2055
Labels, declared with &#39;x:&#39; and referenced with &#39;goto x&#39;.
Definition: DeclBase.h:117
void setLocalOwningModule(Module *M)
Definition: DeclBase.h:752
Represents a linkage specification.
Definition: DeclCXX.h:2825
::clang::DeclContext * doit(const FromTy *Val)
Definition: DeclBase.h:2522
bool isExported() const
Whether this declaration is exported (by virtue of being lexically within an ExportDecl or by being a...
Definition: DeclBase.cpp:434
virtual Decl * getMostRecentDeclImpl()
Implementation of getMostRecentDecl(), to be overridden by any subclass that has a redeclaration chai...
Definition: DeclBase.h:904
Ordinary names.
Definition: DeclBase.h:144
void setCachedLinkage(Linkage L) const
Definition: DeclBase.h:395
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:883
AvailabilityResult
Captures the result of checking the availability of a declaration.
Definition: DeclBase.h:72
NodeId Parent
Definition: ASTDiff.cpp:192
Decl * getNextDeclInContext()
Definition: DeclBase.h:431
bool canBeWeakImported(bool &IsDefinition) const
Determines whether this symbol can be weak-imported, e.g., whether it would be well-formed to add the...
Definition: DeclBase.cpp:655
bool hasAttr() const
Definition: DeclBase.h:544
DeclContextBitfields DeclContextBits
Definition: DeclBase.h:1705
A placeholder type used to construct an empty shell of a decl-derived type that will be filled in lat...
Definition: DeclBase.h:102
AvailabilityResult getAvailability(std::string *Message=nullptr, VersionTuple EnclosingVersion=VersionTuple(), StringRef *RealizedPlatform=nullptr) const
Determine the availability of the given declaration.
Definition: DeclBase.cpp:589
This declaration is a C++ operator declared in a non-class context.
Definition: DeclBase.h:168
Objective C @protocol.
Definition: DeclBase.h:147
llvm::iterator_range< udir_iterator > udir_range
Definition: DeclBase.h:2295
decl_range noload_decls() const
noload_decls_begin/end - Iterate over the declarations stored in this context that are currently load...
Definition: DeclBase.h:2022
std::ptrdiff_t difference_type
Definition: DeclBase.h:918
const DeclContext * getLookupParent() const
Definition: DeclBase.h:1794
const FunctionType * getFunctionType(bool BlocksToo=true) const
Looks through the Decl&#39;s underlying type to extract a FunctionType when possible. ...
Definition: DeclBase.cpp:933
This declaration is a friend class.
Definition: DeclBase.h:157
const Decl * getNonClosureContext() const
Definition: DeclBase.h:449
DeclContext * getLexicalParent()
getLexicalParent - Returns the containing lexical DeclContext.
Definition: DeclBase.h:1785
bool isCanonicalDecl() const
Whether this particular Decl is a canonical one.
Definition: DeclBase.h:889
Pepresents a block literal declaration, which is like an unnamed FunctionDecl.
Definition: Decl.h:3837
const Attr * getDefiningAttr() const
Return this declaration&#39;s defining attribute if it has one.
Definition: DeclBase.cpp:475
llvm::iterator_range< all_lookups_iterator > lookups_range
Definition: DeclBase.h:2265
static bool classofKind(Kind K)
Definition: DeclBase.h:1132
static unsigned getIdentifierNamespaceForKind(Kind DK)
Definition: DeclBase.cpp:704
StoredDeclsMap * getLookupPtr() const
Retrieve the internal representation of the lookup structure.
Definition: DeclBase.h:2322
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:132
This declaration is an OpenMP user defined reduction construction.
Definition: DeclBase.h:178
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:560
Module * getImportedOwningModule() const
Get the imported owning module, if this decl is from an imported (non-local) module.
Definition: DeclBase.h:735
Decl * getMostRecentDecl()
Retrieve the most recent declaration that declares the same entity as this declaration (which may be ...
Definition: DeclBase.h:981
DeclContextLookupResult(ArrayRef< NamedDecl *> Result)
Definition: DeclBase.h:1209
const Decl * getNextDeclInContext() const
Definition: DeclBase.h:432
bool isLocalExternDecl()
Determine whether this is a block-scope declaration with linkage.
Definition: DeclBase.h:1066
bool isFileContext() const
Definition: DeclBase.h:1835
DeclContext * getDeclContext()
Definition: DeclBase.h:434
SourceLocation Begin
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
redecl_iterator redecls_end() const
Definition: DeclBase.h:962
bool isTemplateParameter() const
isTemplateParameter - Determines whether this declaration is a template parameter.
Definition: DeclBase.h:2439
bool isTemplateParameterPack() const
isTemplateParameter - Determines whether this declaration is a template parameter pack...
Definition: DeclBase.cpp:201
void setModulePrivate()
Specify that this declaration was marked as being private to the module in which it was defined...
Definition: DeclBase.h:627
llvm::iterator_range< attr_iterator > attr_range
Definition: DeclBase.h:501
const DeclContext * getParent() const
Definition: DeclBase.h:1772
bool isFunctionOrMethod() const
Definition: DeclBase.h:1817
reference operator[](size_t N) const
Definition: DeclBase.h:1246
unsigned getMaxAlignment() const
getMaxAlignment - return the maximum alignment specified by attributes on this decl, 0 if there are none.
Definition: DeclBase.cpp:384
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1769
SourceLocation getEnd() const
void setLocation(SourceLocation L)
Definition: DeclBase.h:426
const FunctionDecl * getAsFunction() const
Definition: DeclBase.h:1038
Represents a C++ deduction guide declaration.
Definition: DeclCXX.h:1998
The result type of a method or function.
unsigned IdentifierNamespace
IdentifierNamespace - This specifies what IDNS_* namespace this lives in.
Definition: DeclBase.h:326
const SourceManager & SM
Definition: Format.cpp:1475
FunctionDeclBitfields FunctionDeclBits
Definition: DeclBase.h:1710
const DeclContext * getDeclContext() const
Definition: DeclBase.h:439
void setDeclContext(DeclContext *DC)
setDeclContext - Set both the semantic and lexical DeclContext to DC.
Definition: DeclBase.cpp:295
SmallVector< Attr *, 4 > AttrVec
AttrVec - A vector of Attr, which is how they are stored on the AST.
Definition: AttrIterator.h:49
reference operator*() const
Definition: DeclBase.h:923
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so...
Definition: DeclBase.h:1116
static bool isTagIdentifierNamespace(unsigned NS)
Definition: DeclBase.h:819
void setHasExternalVisibleStorage(bool ES=true) const
State whether this DeclContext has external storage for declarations visible in this context...
Definition: DeclBase.h:2347
AttrVec & getAttrs()
Definition: DeclBase.h:486
virtual bool hasBody() const
Returns true if this Decl represents a declaration for a body of code, such as a function or method d...
Definition: DeclBase.h:998
bool hasAttrs() const
Definition: DeclBase.h:480
filtered_decl_iterator & operator++()
Definition: DeclBase.h:2153
void addAttr(Attr *A)
Definition: DeclBase.h:493
static const ::clang::DeclContext * doit(const FromTy *Val)
Definition: DeclBase.h:2536
iterator::reference reference
Definition: DeclBase.h:1236
Abstract interface for external sources of AST nodes.
bool isTemplateDecl() const
returns true if this declaration is a template
Definition: DeclBase.cpp:226
Decl::Kind getDeclKind() const
Definition: DeclBase.h:1762
This declaration has an owning module, but is globally visible (typically because its owning module i...
#define false
Definition: stdbool.h:33
Iterates through all the redeclarations of the same decl.
Definition: DeclBase.h:908
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
Definition: DeclBase.cpp:218
VersionTuple getVersionIntroduced() const
Retrieve the version of the target platform in which this declaration was introduced.
Definition: DeclBase.cpp:641
Encodes a location in the source.
void setTopLevelDeclInObjCContainer(bool V=true)
Definition: DeclBase.h:599
Members, declared with object declarations within tag definitions.
Definition: DeclBase.h:136
all_lookups_iterator - An iterator that provides a view over the results of looking up every possible...
Definition: DeclLookups.h:29
void setModuleOwnershipKind(ModuleOwnershipKind MOK)
Set whether this declaration is hidden from name lookup.
Definition: DeclBase.h:797
This represents &#39;#pragma omp declare reduction ...&#39; directive.
Definition: DeclOpenMP.h:102
The nullability qualifier is set when the nullability of the result or parameter was expressed via a ...
Definition: DeclBase.h:207
Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:3043
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:376
void setReferenced(bool R=true)
Definition: DeclBase.h:590
static bool classof(const DeclContext *D)
Definition: DeclBase.h:2371
std::forward_iterator_tag iterator_category
Definition: DeclBase.h:2134
udir_iterator(lookup_iterator I)
Definition: DeclBase.h:2290
bool hasCachedLinkage() const
Definition: DeclBase.h:399
A friend of a previously-declared entity.
Definition: DeclBase.h:1108
DeclContextLookupResult(NamedDecl *Single)
Definition: DeclBase.h:1211
bool hasExternalLexicalStorage() const
Whether this DeclContext has external storage containing additional declarations that are lexically i...
Definition: DeclBase.h:2329
::clang::DeclContext & doit(const FromTy &Val)
Definition: DeclBase.h:2515
Linkage getCachedLinkage() const
Definition: DeclBase.h:391
bool isFromASTFile() const
Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...
Definition: DeclBase.h:708
friend bool operator==(redecl_iterator x, redecl_iterator y)
Definition: DeclBase.h:941
llvm::iterator_range< DeclContext::ddiag_iterator > ddiag_range
Definition: DeclBase.h:2302
bool isUsed(bool CheckUsedAttr=true) const
Whether any (re-)declaration of the entity was used, meaning that a definition is required...
Definition: DeclBase.cpp:397
virtual Decl * getNextRedeclarationImpl()
Returns the next redeclaration or itself if this is the only decl.
Definition: DeclBase.h:896
static ToTy * doit(DeclContext *Val)
Definition: DeclBase.h:2464
decl_iterator noload_decls_end() const
Definition: DeclBase.h:2026
void dropAttrs()
Definition: DeclBase.cpp:832
__PTRDIFF_TYPE__ ptrdiff_t
A signed integer type that is the result of subtracting two pointers.
Definition: opencl-c.h:68
virtual bool isOutOfLine() const
Determine whether this declaration is declared out of line (outside its semantic context).
Definition: Decl.cpp:99
bool isWeakImported() const
Determine whether this is a weak-imported symbol.
Definition: DeclBase.cpp:685
Defines various enumerations that describe declaration and type specifiers.
decl_iterator - Iterates through the declarations stored within this context.
Definition: DeclBase.h:1971
bool isThisDeclarationReferenced() const
Whether this declaration was referenced.
Definition: DeclBase.h:588
redecl_iterator redecls_begin() const
Definition: DeclBase.h:958
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Definition: DeclBase.h:954
static const ToTy * doit(const DeclContext *Val)
Definition: DeclBase.h:2448
Dataflow Directional Tag Classes.
void updateOutOfDate(IdentifierInfo &II) const
Update a potentially out-of-date declaration.
Definition: DeclBase.cpp:63
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1272
The base class of all kinds of template declarations (e.g., class, function, etc.).
Definition: DeclTemplate.h:399
bool isTopLevelDeclInObjCContainer() const
Whether this declaration is a top-level declaration (function, global variable, etc.) that is lexically inside an objc container definition.
Definition: DeclBase.h:595
const Decl * getMostRecentDecl() const
Retrieve the most recent declaration that declares the same entity as this declaration (which may be ...
Definition: DeclBase.h:985
bool isFunctionOrFunctionTemplate() const
Whether this declaration is a function or function template.
Definition: DeclBase.h:1024
bool isRecord() const
Definition: DeclBase.h:1844
attr_range attrs() const
Definition: DeclBase.h:503
friend bool operator!=(redecl_iterator x, redecl_iterator y)
Definition: DeclBase.h:945
Reads an AST files chain containing the contents of a translation unit.
Definition: ASTReader.h:354
AttrVec::const_iterator attr_iterator
Definition: DeclBase.h:500
AccessSpecifier getAccess() const
Definition: DeclBase.h:469
IdentifierNamespace
IdentifierNamespace - The different namespaces in which declarations may appear.
Definition: DeclBase.h:115
DeclarationName - The name of a declaration.
Kind getKind() const
Definition: DeclBase.h:428
Decl * getNonClosureContext()
Find the innermost non-closure ancestor of this declaration, walking up through blocks, lambdas, etc.
Definition: DeclBase.cpp:971
decl_iterator operator++(int)
Definition: DeclBase.h:1995
const Decl * getNonClosureAncestor() const
Definition: DeclBase.h:1901
Represents an enum.
Definition: Decl.h:3305
Tags, declared with &#39;struct foo;&#39; and referenced with &#39;struct foo&#39;.
Definition: DeclBase.h:125
EnumDeclBitfields EnumDeclBits
Definition: DeclBase.h:1707
bool isHidden() const
Determine whether this declaration might be hidden from name lookup.
Definition: DeclBase.h:780
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext, providing only those that are of type SpecificDecl (or a class derived from it).
Definition: DeclBase.h:2034
This declaration is not owned by a module.
void setObjectOfFriendDecl(bool PerformFriendInjection=false)
Changes the namespace of this declaration to reflect that it&#39;s the object of a friend declaration...
Definition: DeclBase.h:1077
A dependently-generated diagnostic.
void setLocalExternDecl()
Changes the namespace of this declaration to reflect that it&#39;s a function-local extern declaration...
Definition: DeclBase.h:1048
const RecordDecl * getOuterLexicalRecordContext() const
Definition: DeclBase.h:1932
void setIsUsed()
Set whether the declaration is used, in the sense of odr-use.
Definition: DeclBase.h:575
static bool classof(const OMPClause *T)
static bool isFunctionOrMethod(const Decl *D)
isFunctionOrMethod - Return true if the given decl has function type (function or function-typed vari...
void setNonMemberOperator()
Specifies that this declaration is a C++ overloaded non-member.
Definition: DeclBase.h:1125
T * getAttr() const
Definition: DeclBase.h:540
unsigned getOwningModuleID() const
Retrieve the global ID of the module that owns this particular declaration.
Definition: DeclBase.h:720
virtual ~Decl()
filtered_decl_iterator operator++(int)
Definition: DeclBase.h:2159
const DeclContext * getLexicalParent() const
Definition: DeclBase.h:1788
unsigned getGlobalID() const
Retrieve the global declaration ID associated with this declaration, which specifies where this Decl ...
Definition: DeclBase.h:712
An iterator over the dependent diagnostics in a dependent context.
iterator::pointer pointer
Definition: DeclBase.h:1235
ObjCMethodDeclBitfields ObjCMethodDeclBits
Definition: DeclBase.h:1712
void markUsed(ASTContext &C)
Mark the declaration used, in the sense of odr-use.
Definition: DeclBase.cpp:412
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
Definition: DeclBase.h:526
static const ::clang::DeclContext & doit(const FromTy &Val)
Definition: DeclBase.h:2529
Defines the clang::SourceLocation class and associated facilities.
bool isFirstDecl() const
True if this is the first declaration in its redeclaration chain.
Definition: DeclBase.h:975
friend bool operator==(const filtered_decl_iterator &x, const filtered_decl_iterator &y)
Definition: DeclBase.h:2165
ObjCDeclQualifier
ObjCDeclQualifier - &#39;Qualifiers&#39; written next to the return and parameter types in method declaration...
Definition: DeclBase.h:195
decl_iterator & operator++()
Definition: DeclBase.h:1990
PrettyStackTraceDecl(const Decl *theDecl, SourceLocation L, SourceManager &sm, const char *Msg)
Definition: DeclBase.h:1186
bool setUseQualifiedLookup(bool use=true) const
Definition: DeclBase.h:2360
const DeclContext * getEnclosingNamespaceContext() const
Definition: DeclBase.h:1926
value_type operator->() const
Definition: DeclBase.h:924
RecordDeclBitfields RecordDeclBits
Definition: DeclBase.h:1708
const DeclContext * getPrimaryContext() const
Definition: DeclBase.h:1912
Decl(Kind DK, DeclContext *DC, SourceLocation L)
Definition: DeclBase.h:367
virtual Decl * getPreviousDeclImpl()
Implementation of getPreviousDecl(), to be overridden by any subclass that has a redeclaration chain...
Definition: DeclBase.h:900
Writes an AST file containing the contents of a translation unit.
Definition: ASTWriter.h:103
static const ToTy * doit(const DeclContext *Val)
Definition: DeclBase.h:2460
friend class CXXClassMemberWrapper
Definition: DeclBase.h:314
ASTContext & getParentASTContext() const
Definition: DeclBase.h:1798
Kind
Lists the kind of concrete classes of Decl.
Definition: DeclBase.h:89
void dump() const
Definition: ASTDumper.cpp:2738
The top declaration context.
Definition: Decl.h:107
static void PrintStats()
Definition: DeclBase.cpp:169
This declaration is a function-local extern declaration of a variable or function.
Definition: DeclBase.h:175
DeclContext * getPrimaryContext()
getPrimaryContext - There may be many different declarations of the same entity (including forward de...
Definition: DeclBase.cpp:1130
static void EnableStatistics()
Definition: DeclBase.cpp:165
friend bool operator==(decl_iterator x, decl_iterator y)
Definition: DeclBase.h:2001
ObjCContainerDeclBitfields ObjCContainerDeclBits
Definition: DeclBase.h:1713
AccessSpecifier getAccessUnsafe() const
Retrieve the access specifier for this declaration, even though it may not yet have been properly set...
Definition: DeclBase.h:476
#define true
Definition: stdbool.h:32
A trivial tuple used to represent a source range.
bool isModulePrivate() const
Whether this declaration was marked as being private to the module in which it was defined...
Definition: DeclBase.h:609
void setLexicalDeclContext(DeclContext *DC)
Definition: DeclBase.cpp:299
OMPDeclareReductionDeclBitfields OMPDeclareReductionDeclBits
Definition: DeclBase.h:1709
This represents a decl that may have a name.
Definition: Decl.h:248
bool isTranslationUnit() const
Definition: DeclBase.h:1840
void dropAttr()
Definition: DeclBase.h:515
void setAccess(AccessSpecifier AS)
Definition: DeclBase.h:464
const TranslationUnitDecl * getTranslationUnitDecl() const
Definition: DeclBase.h:454
TemplateDecl * getDescribedTemplate() const
If this is a declaration that describes some template, this method returns that template declaration...
Definition: DeclBase.cpp:230
Represents C++ using-directive.
Definition: DeclCXX.h:2919
bool hasDefiningAttr() const
Return true if this declaration has an attribute which acts as definition of the entity, such as &#39;alias&#39; or &#39;ifunc&#39;.
Definition: DeclBase.cpp:471
bool isInStdNamespace() const
Definition: DeclBase.cpp:357
SourceLocation getBegin() const
TranslationUnitDecl * getTranslationUnitDecl()
Definition: DeclBase.cpp:361
bool isTemplated() const
Determine whether this declaration is a templated entity (whether it is.
Definition: DeclBase.cpp:243
This class handles loading and caching of source files into memory.
SourceLocation getBodyRBrace() const
getBodyRBrace - Gets the right brace of the body, if a body exists.
Definition: DeclBase.cpp:882
Attr - This represents one attribute.
Definition: Attr.h:43
SourceLocation getLocation() const
Definition: DeclBase.h:425
TagDeclBitfields TagDeclBits
Definition: DeclBase.h:1706
friend bool operator!=(decl_iterator x, decl_iterator y)
Definition: DeclBase.h:2005
const DeclContext * getRedeclContext() const
Definition: DeclBase.h:1920
bool isUnavailable(std::string *Message=nullptr) const
Determine whether this declaration is marked &#39;unavailable&#39;.
Definition: DeclBase.h:686
decl_iterator decls_end() const
Definition: DeclBase.h:2016
This declaration is a using declaration.
Definition: DeclBase.h:163
std::iterator_traits< DeclContext::decl_iterator >::difference_type difference_type
Definition: DeclBase.h:2133
DeclContext * getParentFunctionOrMethod()
Definition: DeclBase.h:877
PrettyStackTraceDecl - If a crash occurs, indicate that it happened when doing something to a specifi...
Definition: DeclBase.h:1179