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