clang 19.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... Ts> void dropAttrs() {
552 if (!HasAttrs) return;
553
554 AttrVec &Vec = getAttrs();
555 llvm::erase_if(Vec, [](Attr *A) { return isa<Ts...>(A); });
556
557 if (Vec.empty())
558 HasAttrs = false;
559 }
560
561 template <typename T> void dropAttr() { dropAttrs<T>(); }
562
563 template <typename T>
564 llvm::iterator_range<specific_attr_iterator<T>> specific_attrs() const {
565 return llvm::make_range(specific_attr_begin<T>(), specific_attr_end<T>());
566 }
567
568 template <typename T>
571 }
572
573 template <typename T>
576 }
577
578 template<typename T> T *getAttr() const {
579 return hasAttrs() ? getSpecificAttr<T>(getAttrs()) : nullptr;
580 }
581
582 template<typename T> bool hasAttr() const {
583 return hasAttrs() && hasSpecificAttr<T>(getAttrs());
584 }
585
586 /// getMaxAlignment - return the maximum alignment specified by attributes
587 /// on this decl, 0 if there are none.
588 unsigned getMaxAlignment() const;
589
590 /// setInvalidDecl - Indicates the Decl had a semantic error. This
591 /// allows for graceful error recovery.
592 void setInvalidDecl(bool Invalid = true);
593 bool isInvalidDecl() const { return (bool) InvalidDecl; }
594
595 /// isImplicit - Indicates whether the declaration was implicitly
596 /// generated by the implementation. If false, this declaration
597 /// was written explicitly in the source code.
598 bool isImplicit() const { return Implicit; }
599 void setImplicit(bool I = true) { Implicit = I; }
600
601 /// Whether *any* (re-)declaration of the entity was used, meaning that
602 /// a definition is required.
603 ///
604 /// \param CheckUsedAttr When true, also consider the "used" attribute
605 /// (in addition to the "used" bit set by \c setUsed()) when determining
606 /// whether the function is used.
607 bool isUsed(bool CheckUsedAttr = true) const;
608
609 /// Set whether the declaration is used, in the sense of odr-use.
610 ///
611 /// This should only be used immediately after creating a declaration.
612 /// It intentionally doesn't notify any listeners.
613 void setIsUsed() { getCanonicalDecl()->Used = true; }
614
615 /// Mark the declaration used, in the sense of odr-use.
616 ///
617 /// This notifies any mutation listeners in addition to setting a bit
618 /// indicating the declaration is used.
619 void markUsed(ASTContext &C);
620
621 /// Whether any declaration of this entity was referenced.
622 bool isReferenced() const;
623
624 /// Whether this declaration was referenced. This should not be relied
625 /// upon for anything other than debugging.
626 bool isThisDeclarationReferenced() const { return Referenced; }
627
628 void setReferenced(bool R = true) { Referenced = R; }
629
630 /// Whether this declaration is a top-level declaration (function,
631 /// global variable, etc.) that is lexically inside an objc container
632 /// definition.
634 return TopLevelDeclInObjCContainer;
635 }
636
638 TopLevelDeclInObjCContainer = V;
639 }
640
641 /// Looks on this and related declarations for an applicable
642 /// external source symbol attribute.
643 ExternalSourceSymbolAttr *getExternalSourceSymbolAttr() const;
644
645 /// Whether this declaration was marked as being private to the
646 /// module in which it was defined.
647 bool isModulePrivate() const {
649 }
650
651 /// Whether this declaration was exported in a lexical context.
652 /// e.g.:
653 ///
654 /// export namespace A {
655 /// void f1(); // isInExportDeclContext() == true
656 /// }
657 /// void A::f1(); // isInExportDeclContext() == false
658 ///
659 /// namespace B {
660 /// void f2(); // isInExportDeclContext() == false
661 /// }
662 /// export void B::f2(); // isInExportDeclContext() == true
663 bool isInExportDeclContext() const;
664
667 }
668
669 /// Whether this declaration comes from another module unit.
670 bool isInAnotherModuleUnit() const;
671
672 /// FIXME: Implement discarding declarations actually in global module
673 /// fragment. See [module.global.frag]p3,4 for details.
674 bool isDiscardedInGlobalModuleFragment() const { return false; }
675
676 /// Check if we should skip checking ODRHash for declaration \param D.
677 ///
678 /// The existing ODRHash mechanism seems to be not stable enough and
679 /// the false positive ODR violation reports are annoying and we rarely see
680 /// true ODR violation reports. Also we learned that MSVC disabled ODR checks
681 /// for declarations in GMF. So we try to disable ODR checks in the GMF to
682 /// get better user experiences before we make the ODR violation checks stable
683 /// enough.
684 bool shouldSkipCheckingODR() const;
685
686 /// Return true if this declaration has an attribute which acts as
687 /// definition of the entity, such as 'alias' or 'ifunc'.
688 bool hasDefiningAttr() const;
689
690 /// Return this declaration's defining attribute if it has one.
691 const Attr *getDefiningAttr() const;
692
693protected:
694 /// Specify that this declaration was marked as being private
695 /// to the module in which it was defined.
697 // The module-private specifier has no effect on unowned declarations.
698 // FIXME: We should track this in some way for source fidelity.
700 return;
702 }
703
704public:
705 /// Set the FromASTFile flag. This indicates that this declaration
706 /// was deserialized and not parsed from source code and enables
707 /// features such as module ownership information.
709 FromASTFile = true;
710 }
711
712 /// Set the owning module ID. This may only be called for
713 /// deserialized Decls.
714 void setOwningModuleID(unsigned ID) {
715 assert(isFromASTFile() && "Only works on a deserialized declaration");
716 *((unsigned*)this - 2) = ID;
717 }
718
719public:
720 /// Determine the availability of the given declaration.
721 ///
722 /// This routine will determine the most restrictive availability of
723 /// the given declaration (e.g., preferring 'unavailable' to
724 /// 'deprecated').
725 ///
726 /// \param Message If non-NULL and the result is not \c
727 /// AR_Available, will be set to a (possibly empty) message
728 /// describing why the declaration has not been introduced, is
729 /// deprecated, or is unavailable.
730 ///
731 /// \param EnclosingVersion The version to compare with. If empty, assume the
732 /// deployment target version.
733 ///
734 /// \param RealizedPlatform If non-NULL and the availability result is found
735 /// in an available attribute it will set to the platform which is written in
736 /// the available attribute.
738 getAvailability(std::string *Message = nullptr,
739 VersionTuple EnclosingVersion = VersionTuple(),
740 StringRef *RealizedPlatform = nullptr) const;
741
742 /// Retrieve the version of the target platform in which this
743 /// declaration was introduced.
744 ///
745 /// \returns An empty version tuple if this declaration has no 'introduced'
746 /// availability attributes, or the version tuple that's specified in the
747 /// attribute otherwise.
748 VersionTuple getVersionIntroduced() const;
749
750 /// Determine whether this declaration is marked 'deprecated'.
751 ///
752 /// \param Message If non-NULL and the declaration is deprecated,
753 /// this will be set to the message describing why the declaration
754 /// was deprecated (which may be empty).
755 bool isDeprecated(std::string *Message = nullptr) const {
756 return getAvailability(Message) == AR_Deprecated;
757 }
758
759 /// Determine whether this declaration is marked 'unavailable'.
760 ///
761 /// \param Message If non-NULL and the declaration is unavailable,
762 /// this will be set to the message describing why the declaration
763 /// was made unavailable (which may be empty).
764 bool isUnavailable(std::string *Message = nullptr) const {
765 return getAvailability(Message) == AR_Unavailable;
766 }
767
768 /// Determine whether this is a weak-imported symbol.
769 ///
770 /// Weak-imported symbols are typically marked with the
771 /// 'weak_import' attribute, but may also be marked with an
772 /// 'availability' attribute where we're targing a platform prior to
773 /// the introduction of this feature.
774 bool isWeakImported() const;
775
776 /// Determines whether this symbol can be weak-imported,
777 /// e.g., whether it would be well-formed to add the weak_import
778 /// attribute.
779 ///
780 /// \param IsDefinition Set to \c true to indicate that this
781 /// declaration cannot be weak-imported because it has a definition.
782 bool canBeWeakImported(bool &IsDefinition) const;
783
784 /// Determine whether this declaration came from an AST file (such as
785 /// a precompiled header or module) rather than having been parsed.
786 bool isFromASTFile() const { return FromASTFile; }
787
788 /// Retrieve the global declaration ID associated with this
789 /// declaration, which specifies where this Decl was loaded from.
790 unsigned getGlobalID() const {
791 if (isFromASTFile())
792 return *((const unsigned*)this - 1);
793 return 0;
794 }
795
796 /// Retrieve the global ID of the module that owns this particular
797 /// declaration.
798 unsigned getOwningModuleID() const {
799 if (isFromASTFile())
800 return *((const unsigned*)this - 2);
801 return 0;
802 }
803
804private:
805 Module *getOwningModuleSlow() const;
806
807protected:
808 bool hasLocalOwningModuleStorage() const;
809
810public:
811 /// Get the imported owning module, if this decl is from an imported
812 /// (non-local) module.
814 if (!isFromASTFile() || !hasOwningModule())
815 return nullptr;
816
817 return getOwningModuleSlow();
818 }
819
820 /// Get the local owning module, if known. Returns nullptr if owner is
821 /// not yet known or declaration is not from a module.
823 if (isFromASTFile() || !hasOwningModule())
824 return nullptr;
825
827 "owned local decl but no local module storage");
828 return reinterpret_cast<Module *const *>(this)[-1];
829 }
831 assert(!isFromASTFile() && hasOwningModule() &&
833 "should not have a cached owning module");
834 reinterpret_cast<Module **>(this)[-1] = M;
835 }
836
837 /// Is this declaration owned by some module?
838 bool hasOwningModule() const {
840 }
841
842 /// Get the module that owns this declaration (for visibility purposes).
845 }
846
847 /// Get the module that owns this declaration for linkage purposes.
848 /// There only ever is such a standard C++ module.
849 ///
850 /// \param IgnoreLinkage Ignore the linkage of the entity; assume that
851 /// all declarations in a global module fragment are unowned.
852 Module *getOwningModuleForLinkage(bool IgnoreLinkage = false) const;
853
854 /// Determine whether this declaration is definitely visible to name lookup,
855 /// independent of whether the owning module is visible.
856 /// Note: The declaration may be visible even if this returns \c false if the
857 /// owning module is visible within the query context. This is a low-level
858 /// helper function; most code should be calling Sema::isVisible() instead.
861 }
862
863 bool isReachable() const {
864 return (int)getModuleOwnershipKind() <=
866 }
867
868 /// Set that this declaration is globally visible, even if it came from a
869 /// module that is not visible.
873 }
874
875 /// Get the kind of module ownership for this declaration.
877 return NextInContextAndBits.getInt();
878 }
879
880 /// Set whether this declaration is hidden from name lookup.
885 "no storage available for owning module for this declaration");
886 NextInContextAndBits.setInt(MOK);
887 }
888
889 unsigned getIdentifierNamespace() const {
890 return IdentifierNamespace;
891 }
892
893 bool isInIdentifierNamespace(unsigned NS) const {
894 return getIdentifierNamespace() & NS;
895 }
896
897 static unsigned getIdentifierNamespaceForKind(Kind DK);
898
901 }
902
903 static bool isTagIdentifierNamespace(unsigned NS) {
904 // TagDecls have Tag and Type set and may also have TagFriend.
905 return (NS & ~IDNS_TagFriend) == (IDNS_Tag | IDNS_Type);
906 }
907
908 /// getLexicalDeclContext - The declaration context where this Decl was
909 /// lexically declared (LexicalDC). May be different from
910 /// getDeclContext() (SemanticDC).
911 /// e.g.:
912 ///
913 /// namespace A {
914 /// void f(); // SemanticDC == LexicalDC == 'namespace A'
915 /// }
916 /// void A::f(); // SemanticDC == namespace 'A'
917 /// // LexicalDC == global namespace
919 if (isInSemaDC())
920 return getSemanticDC();
921 return getMultipleDC()->LexicalDC;
922 }
924 return const_cast<Decl*>(this)->getLexicalDeclContext();
925 }
926
927 /// Determine whether this declaration is declared out of line (outside its
928 /// semantic context).
929 virtual bool isOutOfLine() const;
930
931 /// setDeclContext - Set both the semantic and lexical DeclContext
932 /// to DC.
933 void setDeclContext(DeclContext *DC);
934
936
937 /// Determine whether this declaration is a templated entity (whether it is
938 // within the scope of a template parameter).
939 bool isTemplated() const;
940
941 /// Determine the number of levels of template parameter surrounding this
942 /// declaration.
943 unsigned getTemplateDepth() const;
944
945 /// isDefinedOutsideFunctionOrMethod - This predicate returns true if this
946 /// scoped decl is defined outside the current function or method. This is
947 /// roughly global variables and functions, but also handles enums (which
948 /// could be defined inside or outside a function etc).
950 return getParentFunctionOrMethod() == nullptr;
951 }
952
953 /// Determine whether a substitution into this declaration would occur as
954 /// part of a substitution into a dependent local scope. Such a substitution
955 /// transitively substitutes into all constructs nested within this
956 /// declaration.
957 ///
958 /// This recognizes non-defining declarations as well as members of local
959 /// classes and lambdas:
960 /// \code
961 /// template<typename T> void foo() { void bar(); }
962 /// template<typename T> void foo2() { class ABC { void bar(); }; }
963 /// template<typename T> inline int x = [](){ return 0; }();
964 /// \endcode
966
967 /// If this decl is defined inside a function/method/block it returns
968 /// the corresponding DeclContext, otherwise it returns null.
969 const DeclContext *
970 getParentFunctionOrMethod(bool LexicalParent = false) const;
971 DeclContext *getParentFunctionOrMethod(bool LexicalParent = false) {
972 return const_cast<DeclContext *>(
973 const_cast<const Decl *>(this)->getParentFunctionOrMethod(
974 LexicalParent));
975 }
976
977 /// Retrieves the "canonical" declaration of the given declaration.
978 virtual Decl *getCanonicalDecl() { return this; }
979 const Decl *getCanonicalDecl() const {
980 return const_cast<Decl*>(this)->getCanonicalDecl();
981 }
982
983 /// Whether this particular Decl is a canonical one.
984 bool isCanonicalDecl() const { return getCanonicalDecl() == this; }
985
986protected:
987 /// Returns the next redeclaration or itself if this is the only decl.
988 ///
989 /// Decl subclasses that can be redeclared should override this method so that
990 /// Decl::redecl_iterator can iterate over them.
991 virtual Decl *getNextRedeclarationImpl() { return this; }
992
993 /// Implementation of getPreviousDecl(), to be overridden by any
994 /// subclass that has a redeclaration chain.
995 virtual Decl *getPreviousDeclImpl() { return nullptr; }
996
997 /// Implementation of getMostRecentDecl(), to be overridden by any
998 /// subclass that has a redeclaration chain.
999 virtual Decl *getMostRecentDeclImpl() { return this; }
1000
1001public:
1002 /// Iterates through all the redeclarations of the same decl.
1004 /// Current - The current declaration.
1005 Decl *Current = nullptr;
1006 Decl *Starter;
1007
1008 public:
1009 using value_type = Decl *;
1010 using reference = const value_type &;
1011 using pointer = const value_type *;
1012 using iterator_category = std::forward_iterator_tag;
1013 using difference_type = std::ptrdiff_t;
1014
1015 redecl_iterator() = default;
1016 explicit redecl_iterator(Decl *C) : Current(C), Starter(C) {}
1017
1018 reference operator*() const { return Current; }
1019 value_type operator->() const { return Current; }
1020
1022 assert(Current && "Advancing while iterator has reached end");
1023 // Get either previous decl or latest decl.
1024 Decl *Next = Current->getNextRedeclarationImpl();
1025 assert(Next && "Should return next redeclaration or itself, never null!");
1026 Current = (Next != Starter) ? Next : nullptr;
1027 return *this;
1028 }
1029
1031 redecl_iterator tmp(*this);
1032 ++(*this);
1033 return tmp;
1034 }
1035
1037 return x.Current == y.Current;
1038 }
1039
1041 return x.Current != y.Current;
1042 }
1043 };
1044
1045 using redecl_range = llvm::iterator_range<redecl_iterator>;
1046
1047 /// Returns an iterator range for all the redeclarations of the same
1048 /// decl. It will iterate at least once (when this decl is the only one).
1051 }
1052
1054 return redecl_iterator(const_cast<Decl *>(this));
1055 }
1056
1058
1059 /// Retrieve the previous declaration that declares the same entity
1060 /// as this declaration, or NULL if there is no previous declaration.
1062
1063 /// Retrieve the previous declaration that declares the same entity
1064 /// as this declaration, or NULL if there is no previous declaration.
1065 const Decl *getPreviousDecl() const {
1066 return const_cast<Decl *>(this)->getPreviousDeclImpl();
1067 }
1068
1069 /// True if this is the first declaration in its redeclaration chain.
1070 bool isFirstDecl() const {
1071 return getPreviousDecl() == nullptr;
1072 }
1073
1074 /// Retrieve the most recent declaration that declares the same entity
1075 /// as this declaration (which may be this declaration).
1077
1078 /// Retrieve the most recent declaration that declares the same entity
1079 /// as this declaration (which may be this declaration).
1080 const Decl *getMostRecentDecl() const {
1081 return const_cast<Decl *>(this)->getMostRecentDeclImpl();
1082 }
1083
1084 /// getBody - If this Decl represents a declaration for a body of code,
1085 /// such as a function or method definition, this method returns the
1086 /// top-level Stmt* of that body. Otherwise this method returns null.
1087 virtual Stmt* getBody() const { return nullptr; }
1088
1089 /// Returns true if this \c Decl represents a declaration for a body of
1090 /// code, such as a function or method definition.
1091 /// Note that \c hasBody can also return true if any redeclaration of this
1092 /// \c Decl represents a declaration for a body of code.
1093 virtual bool hasBody() const { return getBody() != nullptr; }
1094
1095 /// getBodyRBrace - Gets the right brace of the body, if a body exists.
1096 /// This works whether the body is a CompoundStmt or a CXXTryStmt.
1098
1099 // global temp stats (until we have a per-module visitor)
1100 static void add(Kind k);
1101 static void EnableStatistics();
1102 static void PrintStats();
1103
1104 /// isTemplateParameter - Determines whether this declaration is a
1105 /// template parameter.
1106 bool isTemplateParameter() const;
1107
1108 /// isTemplateParameter - Determines whether this declaration is a
1109 /// template parameter pack.
1110 bool isTemplateParameterPack() const;
1111
1112 /// Whether this declaration is a parameter pack.
1113 bool isParameterPack() const;
1114
1115 /// returns true if this declaration is a template
1116 bool isTemplateDecl() const;
1117
1118 /// Whether this declaration is a function or function template.
1120 return (DeclKind >= Decl::firstFunction &&
1121 DeclKind <= Decl::lastFunction) ||
1122 DeclKind == FunctionTemplate;
1123 }
1124
1125 /// If this is a declaration that describes some template, this
1126 /// method returns that template declaration.
1127 ///
1128 /// Note that this returns nullptr for partial specializations, because they
1129 /// are not modeled as TemplateDecls. Use getDescribedTemplateParams to handle
1130 /// those cases.
1132
1133 /// If this is a declaration that describes some template or partial
1134 /// specialization, this returns the corresponding template parameter list.
1136
1137 /// Returns the function itself, or the templated function if this is a
1138 /// function template.
1139 FunctionDecl *getAsFunction() LLVM_READONLY;
1140
1142 return const_cast<Decl *>(this)->getAsFunction();
1143 }
1144
1145 /// Changes the namespace of this declaration to reflect that it's
1146 /// a function-local extern declaration.
1147 ///
1148 /// These declarations appear in the lexical context of the extern
1149 /// declaration, but in the semantic context of the enclosing namespace
1150 /// scope.
1152 Decl *Prev = getPreviousDecl();
1153 IdentifierNamespace &= ~IDNS_Ordinary;
1154
1155 // It's OK for the declaration to still have the "invisible friend" flag or
1156 // the "conflicts with tag declarations in this scope" flag for the outer
1157 // scope.
1158 assert((IdentifierNamespace & ~(IDNS_OrdinaryFriend | IDNS_Tag)) == 0 &&
1159 "namespace is not ordinary");
1160
1162 if (Prev && Prev->getIdentifierNamespace() & IDNS_Ordinary)
1164 }
1165
1166 /// Determine whether this is a block-scope declaration with linkage.
1167 /// This will either be a local variable declaration declared 'extern', or a
1168 /// local function declaration.
1169 bool isLocalExternDecl() const {
1171 }
1172
1173 /// Changes the namespace of this declaration to reflect that it's
1174 /// the object of a friend declaration.
1175 ///
1176 /// These declarations appear in the lexical context of the friending
1177 /// class, but in the semantic context of the actual entity. This property
1178 /// applies only to a specific decl object; other redeclarations of the
1179 /// same entity may not (and probably don't) share this property.
1180 void setObjectOfFriendDecl(bool PerformFriendInjection = false) {
1181 unsigned OldNS = IdentifierNamespace;
1182 assert((OldNS & (IDNS_Tag | IDNS_Ordinary |
1185 "namespace includes neither ordinary nor tag");
1186 assert(!(OldNS & ~(IDNS_Tag | IDNS_Ordinary | IDNS_Type |
1189 "namespace includes other than ordinary or tag");
1190
1191 Decl *Prev = getPreviousDecl();
1193
1194 if (OldNS & (IDNS_Tag | IDNS_TagFriend)) {
1196 if (PerformFriendInjection ||
1197 (Prev && Prev->getIdentifierNamespace() & IDNS_Tag))
1199 }
1200
1201 if (OldNS & (IDNS_Ordinary | IDNS_OrdinaryFriend |
1204 if (PerformFriendInjection ||
1205 (Prev && Prev->getIdentifierNamespace() & IDNS_Ordinary))
1207 }
1208 }
1209
1210 /// Clears the namespace of this declaration.
1211 ///
1212 /// This is useful if we want this declaration to be available for
1213 /// redeclaration lookup but otherwise hidden for ordinary name lookups.
1215
1217 FOK_None, ///< Not a friend object.
1218 FOK_Declared, ///< A friend of a previously-declared entity.
1219 FOK_Undeclared ///< A friend of a previously-undeclared entity.
1221
1222 /// Determines whether this declaration is the object of a
1223 /// friend declaration and, if so, what kind.
1224 ///
1225 /// There is currently no direct way to find the associated FriendDecl.
1227 unsigned mask =
1229 if (!mask) return FOK_None;
1231 : FOK_Undeclared);
1232 }
1233
1234 /// Specifies that this declaration is a C++ overloaded non-member.
1236 assert(getKind() == Function || getKind() == FunctionTemplate);
1238 "visible non-member operators should be in ordinary namespace");
1240 }
1241
1242 static bool classofKind(Kind K) { return true; }
1243 static DeclContext *castToDeclContext(const Decl *);
1244 static Decl *castFromDeclContext(const DeclContext *);
1245
1246 void print(raw_ostream &Out, unsigned Indentation = 0,
1247 bool PrintInstantiation = false) const;
1248 void print(raw_ostream &Out, const PrintingPolicy &Policy,
1249 unsigned Indentation = 0, bool PrintInstantiation = false) const;
1250 static void printGroup(Decl** Begin, unsigned NumDecls,
1251 raw_ostream &Out, const PrintingPolicy &Policy,
1252 unsigned Indentation = 0);
1253
1254 // Debuggers don't usually respect default arguments.
1255 void dump() const;
1256
1257 // Same as dump(), but forces color printing.
1258 void dumpColor() const;
1259
1260 void dump(raw_ostream &Out, bool Deserialize = false,
1261 ASTDumpOutputFormat OutputFormat = ADOF_Default) const;
1262
1263 /// \return Unique reproducible object identifier
1264 int64_t getID() const;
1265
1266 /// Looks through the Decl's underlying type to extract a FunctionType
1267 /// when possible. Will return null if the type underlying the Decl does not
1268 /// have a FunctionType.
1269 const FunctionType *getFunctionType(bool BlocksToo = true) const;
1270
1271 // Looks through the Decl's underlying type to determine if it's a
1272 // function pointer type.
1273 bool isFunctionPointerType() const;
1274
1275private:
1276 void setAttrsImpl(const AttrVec& Attrs, ASTContext &Ctx);
1277 void setDeclContextsImpl(DeclContext *SemaDC, DeclContext *LexicalDC,
1278 ASTContext &Ctx);
1279
1280protected:
1282};
1283
1284/// Determine whether two declarations declare the same entity.
1285inline bool declaresSameEntity(const Decl *D1, const Decl *D2) {
1286 if (!D1 || !D2)
1287 return false;
1288
1289 if (D1 == D2)
1290 return true;
1291
1292 return D1->getCanonicalDecl() == D2->getCanonicalDecl();
1293}
1294
1295/// PrettyStackTraceDecl - If a crash occurs, indicate that it happened when
1296/// doing something to a specific decl.
1297class PrettyStackTraceDecl : public llvm::PrettyStackTraceEntry {
1298 const Decl *TheDecl;
1299 SourceLocation Loc;
1300 SourceManager &SM;
1301 const char *Message;
1302
1303public:
1305 SourceManager &sm, const char *Msg)
1306 : TheDecl(theDecl), Loc(L), SM(sm), Message(Msg) {}
1307
1308 void print(raw_ostream &OS) const override;
1309};
1310} // namespace clang
1311
1312// Required to determine the layout of the PointerUnion<NamedDecl*> before
1313// seeing the NamedDecl definition being first used in DeclListNode::operator*.
1314namespace llvm {
1315 template <> struct PointerLikeTypeTraits<::clang::NamedDecl *> {
1316 static inline void *getAsVoidPointer(::clang::NamedDecl *P) { return P; }
1317 static inline ::clang::NamedDecl *getFromVoidPointer(void *P) {
1318 return static_cast<::clang::NamedDecl *>(P);
1319 }
1320 static constexpr int NumLowBitsAvailable = 3;
1321 };
1322}
1323
1324namespace clang {
1325/// A list storing NamedDecls in the lookup tables.
1327 friend class ASTContext; // allocate, deallocate nodes.
1328 friend class StoredDeclsList;
1329public:
1330 using Decls = llvm::PointerUnion<NamedDecl*, DeclListNode*>;
1331 class iterator {
1333 friend class StoredDeclsList;
1334
1335 Decls Ptr;
1336 iterator(Decls Node) : Ptr(Node) { }
1337 public:
1340 using pointer = void;
1342 using iterator_category = std::forward_iterator_tag;
1343
1344 iterator() = default;
1345
1347 assert(Ptr && "dereferencing end() iterator");
1348 if (DeclListNode *CurNode = Ptr.dyn_cast<DeclListNode*>())
1349 return CurNode->D;
1350 return Ptr.get<NamedDecl*>();
1351 }
1352 void operator->() const { } // Unsupported.
1353 bool operator==(const iterator &X) const { return Ptr == X.Ptr; }
1354 bool operator!=(const iterator &X) const { return Ptr != X.Ptr; }
1355 inline iterator &operator++() { // ++It
1356 assert(!Ptr.isNull() && "Advancing empty iterator");
1357
1358 if (DeclListNode *CurNode = Ptr.dyn_cast<DeclListNode*>())
1359 Ptr = CurNode->Rest;
1360 else
1361 Ptr = nullptr;
1362 return *this;
1363 }
1364 iterator operator++(int) { // It++
1365 iterator temp = *this;
1366 ++(*this);
1367 return temp;
1368 }
1369 // Enables the pattern for (iterator I =..., E = I.end(); I != E; ++I)
1370 iterator end() { return iterator(); }
1371 };
1372private:
1373 NamedDecl *D = nullptr;
1374 Decls Rest = nullptr;
1375 DeclListNode(NamedDecl *ND) : D(ND) {}
1376};
1377
1378/// The results of name lookup within a DeclContext.
1380 using Decls = DeclListNode::Decls;
1381
1382 /// When in collection form, this is what the Data pointer points to.
1383 Decls Result;
1384
1385public:
1387 DeclContextLookupResult(Decls Result) : Result(Result) {}
1388
1392
1393 iterator begin() { return iterator(Result); }
1394 iterator end() { return iterator(); }
1396 return const_cast<DeclContextLookupResult*>(this)->begin();
1397 }
1398 const_iterator end() const { return iterator(); }
1399
1400 bool empty() const { return Result.isNull(); }
1401 bool isSingleResult() const { return Result.dyn_cast<NamedDecl*>(); }
1402 reference front() const { return *begin(); }
1403
1404 // Find the first declaration of the given type in the list. Note that this
1405 // is not in general the earliest-declared declaration, and should only be
1406 // used when it's not possible for there to be more than one match or where
1407 // it doesn't matter which one is found.
1408 template<class T> T *find_first() const {
1409 for (auto *D : *this)
1410 if (T *Decl = dyn_cast<T>(D))
1411 return Decl;
1412
1413 return nullptr;
1414 }
1415};
1416
1417/// Only used by CXXDeductionGuideDecl.
1418enum class DeductionCandidate : unsigned char {
1419 Normal,
1420 Copy,
1421 Aggregate,
1422};
1423
1424enum class RecordArgPassingKind;
1426enum class ObjCImplementationControl;
1427enum class LinkageSpecLanguageIDs;
1428
1429/// DeclContext - This is used only as base class of specific decl types that
1430/// can act as declaration contexts. These decls are (only the top classes
1431/// that directly derive from DeclContext are mentioned, not their subclasses):
1432///
1433/// TranslationUnitDecl
1434/// ExternCContext
1435/// NamespaceDecl
1436/// TagDecl
1437/// OMPDeclareReductionDecl
1438/// OMPDeclareMapperDecl
1439/// FunctionDecl
1440/// ObjCMethodDecl
1441/// ObjCContainerDecl
1442/// LinkageSpecDecl
1443/// ExportDecl
1444/// BlockDecl
1445/// CapturedDecl
1447 /// For makeDeclVisibleInContextImpl
1448 friend class ASTDeclReader;
1449 /// For checking the new bits in the Serialization part.
1450 friend class ASTDeclWriter;
1451 /// For reconcileExternalVisibleStorage, CreateStoredDeclsMap,
1452 /// hasNeedToReconcileExternalVisibleStorage
1453 friend class ExternalASTSource;
1454 /// For CreateStoredDeclsMap
1456 /// For hasNeedToReconcileExternalVisibleStorage,
1457 /// hasLazyLocalLexicalLookups, hasLazyExternalLexicalLookups
1458 friend class ASTWriter;
1459
1460 // We use uint64_t in the bit-fields below since some bit-fields
1461 // cross the unsigned boundary and this breaks the packing.
1462
1463 /// Stores the bits used by DeclContext.
1464 /// If modified NumDeclContextBit, the ctor of DeclContext and the accessor
1465 /// methods in DeclContext should be updated appropriately.
1466 class DeclContextBitfields {
1467 friend class DeclContext;
1468 /// DeclKind - This indicates which class this is.
1469 LLVM_PREFERRED_TYPE(Decl::Kind)
1470 uint64_t DeclKind : 7;
1471
1472 /// Whether this declaration context also has some external
1473 /// storage that contains additional declarations that are lexically
1474 /// part of this context.
1475 LLVM_PREFERRED_TYPE(bool)
1476 mutable uint64_t ExternalLexicalStorage : 1;
1477
1478 /// Whether this declaration context also has some external
1479 /// storage that contains additional declarations that are visible
1480 /// in this context.
1481 LLVM_PREFERRED_TYPE(bool)
1482 mutable uint64_t ExternalVisibleStorage : 1;
1483
1484 /// Whether this declaration context has had externally visible
1485 /// storage added since the last lookup. In this case, \c LookupPtr's
1486 /// invariant may not hold and needs to be fixed before we perform
1487 /// another lookup.
1488 LLVM_PREFERRED_TYPE(bool)
1489 mutable uint64_t NeedToReconcileExternalVisibleStorage : 1;
1490
1491 /// If \c true, this context may have local lexical declarations
1492 /// that are missing from the lookup table.
1493 LLVM_PREFERRED_TYPE(bool)
1494 mutable uint64_t HasLazyLocalLexicalLookups : 1;
1495
1496 /// If \c true, the external source may have lexical declarations
1497 /// that are missing from the lookup table.
1498 LLVM_PREFERRED_TYPE(bool)
1499 mutable uint64_t HasLazyExternalLexicalLookups : 1;
1500
1501 /// If \c true, lookups should only return identifier from
1502 /// DeclContext scope (for example TranslationUnit). Used in
1503 /// LookupQualifiedName()
1504 LLVM_PREFERRED_TYPE(bool)
1505 mutable uint64_t UseQualifiedLookup : 1;
1506 };
1507
1508 /// Number of bits in DeclContextBitfields.
1509 enum { NumDeclContextBits = 13 };
1510
1511 /// Stores the bits used by TagDecl.
1512 /// If modified NumTagDeclBits and the accessor
1513 /// methods in TagDecl should be updated appropriately.
1514 class TagDeclBitfields {
1515 friend class TagDecl;
1516 /// For the bits in DeclContextBitfields
1517 LLVM_PREFERRED_TYPE(DeclContextBitfields)
1518 uint64_t : NumDeclContextBits;
1519
1520 /// The TagKind enum.
1521 LLVM_PREFERRED_TYPE(TagTypeKind)
1522 uint64_t TagDeclKind : 3;
1523
1524 /// True if this is a definition ("struct foo {};"), false if it is a
1525 /// declaration ("struct foo;"). It is not considered a definition
1526 /// until the definition has been fully processed.
1527 LLVM_PREFERRED_TYPE(bool)
1528 uint64_t IsCompleteDefinition : 1;
1529
1530 /// True if this is currently being defined.
1531 LLVM_PREFERRED_TYPE(bool)
1532 uint64_t IsBeingDefined : 1;
1533
1534 /// True if this tag declaration is "embedded" (i.e., defined or declared
1535 /// for the very first time) in the syntax of a declarator.
1536 LLVM_PREFERRED_TYPE(bool)
1537 uint64_t IsEmbeddedInDeclarator : 1;
1538
1539 /// True if this tag is free standing, e.g. "struct foo;".
1540 LLVM_PREFERRED_TYPE(bool)
1541 uint64_t IsFreeStanding : 1;
1542
1543 /// Indicates whether it is possible for declarations of this kind
1544 /// to have an out-of-date definition.
1545 ///
1546 /// This option is only enabled when modules are enabled.
1547 LLVM_PREFERRED_TYPE(bool)
1548 uint64_t MayHaveOutOfDateDef : 1;
1549
1550 /// Has the full definition of this type been required by a use somewhere in
1551 /// the TU.
1552 LLVM_PREFERRED_TYPE(bool)
1553 uint64_t IsCompleteDefinitionRequired : 1;
1554
1555 /// Whether this tag is a definition which was demoted due to
1556 /// a module merge.
1557 LLVM_PREFERRED_TYPE(bool)
1558 uint64_t IsThisDeclarationADemotedDefinition : 1;
1559 };
1560
1561 /// Number of inherited and non-inherited bits in TagDeclBitfields.
1562 enum { NumTagDeclBits = NumDeclContextBits + 10 };
1563
1564 /// Stores the bits used by EnumDecl.
1565 /// If modified NumEnumDeclBit and the accessor
1566 /// methods in EnumDecl should be updated appropriately.
1567 class EnumDeclBitfields {
1568 friend class EnumDecl;
1569 /// For the bits in TagDeclBitfields.
1570 LLVM_PREFERRED_TYPE(TagDeclBitfields)
1571 uint64_t : NumTagDeclBits;
1572
1573 /// Width in bits required to store all the non-negative
1574 /// enumerators of this enum.
1575 uint64_t NumPositiveBits : 8;
1576
1577 /// Width in bits required to store all the negative
1578 /// enumerators of this enum.
1579 uint64_t NumNegativeBits : 8;
1580
1581 /// True if this tag declaration is a scoped enumeration. Only
1582 /// possible in C++11 mode.
1583 LLVM_PREFERRED_TYPE(bool)
1584 uint64_t IsScoped : 1;
1585
1586 /// If this tag declaration is a scoped enum,
1587 /// then this is true if the scoped enum was declared using the class
1588 /// tag, false if it was declared with the struct tag. No meaning is
1589 /// associated if this tag declaration is not a scoped enum.
1590 LLVM_PREFERRED_TYPE(bool)
1591 uint64_t IsScopedUsingClassTag : 1;
1592
1593 /// True if this is an enumeration with fixed underlying type. Only
1594 /// possible in C++11, Microsoft extensions, or Objective C mode.
1595 LLVM_PREFERRED_TYPE(bool)
1596 uint64_t IsFixed : 1;
1597
1598 /// True if a valid hash is stored in ODRHash.
1599 LLVM_PREFERRED_TYPE(bool)
1600 uint64_t HasODRHash : 1;
1601 };
1602
1603 /// Number of inherited and non-inherited bits in EnumDeclBitfields.
1604 enum { NumEnumDeclBits = NumTagDeclBits + 20 };
1605
1606 /// Stores the bits used by RecordDecl.
1607 /// If modified NumRecordDeclBits and the accessor
1608 /// methods in RecordDecl should be updated appropriately.
1609 class RecordDeclBitfields {
1610 friend class RecordDecl;
1611 /// For the bits in TagDeclBitfields.
1612 LLVM_PREFERRED_TYPE(TagDeclBitfields)
1613 uint64_t : NumTagDeclBits;
1614
1615 /// This is true if this struct ends with a flexible
1616 /// array member (e.g. int X[]) or if this union contains a struct that does.
1617 /// If so, this cannot be contained in arrays or other structs as a member.
1618 LLVM_PREFERRED_TYPE(bool)
1619 uint64_t HasFlexibleArrayMember : 1;
1620
1621 /// Whether this is the type of an anonymous struct or union.
1622 LLVM_PREFERRED_TYPE(bool)
1623 uint64_t AnonymousStructOrUnion : 1;
1624
1625 /// This is true if this struct has at least one member
1626 /// containing an Objective-C object pointer type.
1627 LLVM_PREFERRED_TYPE(bool)
1628 uint64_t HasObjectMember : 1;
1629
1630 /// This is true if struct has at least one member of
1631 /// 'volatile' type.
1632 LLVM_PREFERRED_TYPE(bool)
1633 uint64_t HasVolatileMember : 1;
1634
1635 /// Whether the field declarations of this record have been loaded
1636 /// from external storage. To avoid unnecessary deserialization of
1637 /// methods/nested types we allow deserialization of just the fields
1638 /// when needed.
1639 LLVM_PREFERRED_TYPE(bool)
1640 mutable uint64_t LoadedFieldsFromExternalStorage : 1;
1641
1642 /// Basic properties of non-trivial C structs.
1643 LLVM_PREFERRED_TYPE(bool)
1644 uint64_t NonTrivialToPrimitiveDefaultInitialize : 1;
1645 LLVM_PREFERRED_TYPE(bool)
1646 uint64_t NonTrivialToPrimitiveCopy : 1;
1647 LLVM_PREFERRED_TYPE(bool)
1648 uint64_t NonTrivialToPrimitiveDestroy : 1;
1649
1650 /// The following bits indicate whether this is or contains a C union that
1651 /// is non-trivial to default-initialize, destruct, or copy. These bits
1652 /// imply the associated basic non-triviality predicates declared above.
1653 LLVM_PREFERRED_TYPE(bool)
1654 uint64_t HasNonTrivialToPrimitiveDefaultInitializeCUnion : 1;
1655 LLVM_PREFERRED_TYPE(bool)
1656 uint64_t HasNonTrivialToPrimitiveDestructCUnion : 1;
1657 LLVM_PREFERRED_TYPE(bool)
1658 uint64_t HasNonTrivialToPrimitiveCopyCUnion : 1;
1659
1660 /// Indicates whether this struct is destroyed in the callee.
1661 LLVM_PREFERRED_TYPE(bool)
1662 uint64_t ParamDestroyedInCallee : 1;
1663
1664 /// Represents the way this type is passed to a function.
1665 LLVM_PREFERRED_TYPE(RecordArgPassingKind)
1666 uint64_t ArgPassingRestrictions : 2;
1667
1668 /// Indicates whether this struct has had its field layout randomized.
1669 LLVM_PREFERRED_TYPE(bool)
1670 uint64_t IsRandomized : 1;
1671
1672 /// True if a valid hash is stored in ODRHash. This should shave off some
1673 /// extra storage and prevent CXXRecordDecl to store unused bits.
1674 uint64_t ODRHash : 26;
1675 };
1676
1677 /// Number of inherited and non-inherited bits in RecordDeclBitfields.
1678 enum { NumRecordDeclBits = NumTagDeclBits + 41 };
1679
1680 /// Stores the bits used by OMPDeclareReductionDecl.
1681 /// If modified NumOMPDeclareReductionDeclBits and the accessor
1682 /// methods in OMPDeclareReductionDecl should be updated appropriately.
1683 class OMPDeclareReductionDeclBitfields {
1684 friend class OMPDeclareReductionDecl;
1685 /// For the bits in DeclContextBitfields
1686 LLVM_PREFERRED_TYPE(DeclContextBitfields)
1687 uint64_t : NumDeclContextBits;
1688
1689 /// Kind of initializer,
1690 /// function call or omp_priv<init_expr> initialization.
1691 LLVM_PREFERRED_TYPE(OMPDeclareReductionInitKind)
1692 uint64_t InitializerKind : 2;
1693 };
1694
1695 /// Number of inherited and non-inherited bits in
1696 /// OMPDeclareReductionDeclBitfields.
1697 enum { NumOMPDeclareReductionDeclBits = NumDeclContextBits + 2 };
1698
1699 /// Stores the bits used by FunctionDecl.
1700 /// If modified NumFunctionDeclBits and the accessor
1701 /// methods in FunctionDecl and CXXDeductionGuideDecl
1702 /// (for DeductionCandidateKind) should be updated appropriately.
1703 class FunctionDeclBitfields {
1704 friend class FunctionDecl;
1705 /// For DeductionCandidateKind
1706 friend class CXXDeductionGuideDecl;
1707 /// For the bits in DeclContextBitfields.
1708 LLVM_PREFERRED_TYPE(DeclContextBitfields)
1709 uint64_t : NumDeclContextBits;
1710
1711 LLVM_PREFERRED_TYPE(StorageClass)
1712 uint64_t SClass : 3;
1713 LLVM_PREFERRED_TYPE(bool)
1714 uint64_t IsInline : 1;
1715 LLVM_PREFERRED_TYPE(bool)
1716 uint64_t IsInlineSpecified : 1;
1717
1718 LLVM_PREFERRED_TYPE(bool)
1719 uint64_t IsVirtualAsWritten : 1;
1720 LLVM_PREFERRED_TYPE(bool)
1721 uint64_t IsPureVirtual : 1;
1722 LLVM_PREFERRED_TYPE(bool)
1723 uint64_t HasInheritedPrototype : 1;
1724 LLVM_PREFERRED_TYPE(bool)
1725 uint64_t HasWrittenPrototype : 1;
1726 LLVM_PREFERRED_TYPE(bool)
1727 uint64_t IsDeleted : 1;
1728 /// Used by CXXMethodDecl
1729 LLVM_PREFERRED_TYPE(bool)
1730 uint64_t IsTrivial : 1;
1731
1732 /// This flag indicates whether this function is trivial for the purpose of
1733 /// calls. This is meaningful only when this function is a copy/move
1734 /// constructor or a destructor.
1735 LLVM_PREFERRED_TYPE(bool)
1736 uint64_t IsTrivialForCall : 1;
1737
1738 LLVM_PREFERRED_TYPE(bool)
1739 uint64_t IsDefaulted : 1;
1740 LLVM_PREFERRED_TYPE(bool)
1741 uint64_t IsExplicitlyDefaulted : 1;
1742 LLVM_PREFERRED_TYPE(bool)
1743 uint64_t HasDefaultedFunctionInfo : 1;
1744
1745 /// For member functions of complete types, whether this is an ineligible
1746 /// special member function or an unselected destructor. See
1747 /// [class.mem.special].
1748 LLVM_PREFERRED_TYPE(bool)
1749 uint64_t IsIneligibleOrNotSelected : 1;
1750
1751 LLVM_PREFERRED_TYPE(bool)
1752 uint64_t HasImplicitReturnZero : 1;
1753 LLVM_PREFERRED_TYPE(bool)
1754 uint64_t IsLateTemplateParsed : 1;
1755
1756 /// Kind of contexpr specifier as defined by ConstexprSpecKind.
1757 LLVM_PREFERRED_TYPE(ConstexprSpecKind)
1758 uint64_t ConstexprKind : 2;
1759 LLVM_PREFERRED_TYPE(bool)
1760 uint64_t BodyContainsImmediateEscalatingExpression : 1;
1761
1762 LLVM_PREFERRED_TYPE(bool)
1763 uint64_t InstantiationIsPending : 1;
1764
1765 /// Indicates if the function uses __try.
1766 LLVM_PREFERRED_TYPE(bool)
1767 uint64_t UsesSEHTry : 1;
1768
1769 /// Indicates if the function was a definition
1770 /// but its body was skipped.
1771 LLVM_PREFERRED_TYPE(bool)
1772 uint64_t HasSkippedBody : 1;
1773
1774 /// Indicates if the function declaration will
1775 /// have a body, once we're done parsing it.
1776 LLVM_PREFERRED_TYPE(bool)
1777 uint64_t WillHaveBody : 1;
1778
1779 /// Indicates that this function is a multiversioned
1780 /// function using attribute 'target'.
1781 LLVM_PREFERRED_TYPE(bool)
1782 uint64_t IsMultiVersion : 1;
1783
1784 /// Only used by CXXDeductionGuideDecl. Indicates the kind
1785 /// of the Deduction Guide that is implicitly generated
1786 /// (used during overload resolution).
1787 LLVM_PREFERRED_TYPE(DeductionCandidate)
1788 uint64_t DeductionCandidateKind : 2;
1789
1790 /// Store the ODRHash after first calculation.
1791 LLVM_PREFERRED_TYPE(bool)
1792 uint64_t HasODRHash : 1;
1793
1794 /// Indicates if the function uses Floating Point Constrained Intrinsics
1795 LLVM_PREFERRED_TYPE(bool)
1796 uint64_t UsesFPIntrin : 1;
1797
1798 // Indicates this function is a constrained friend, where the constraint
1799 // refers to an enclosing template for hte purposes of [temp.friend]p9.
1800 LLVM_PREFERRED_TYPE(bool)
1801 uint64_t FriendConstraintRefersToEnclosingTemplate : 1;
1802 };
1803
1804 /// Number of inherited and non-inherited bits in FunctionDeclBitfields.
1805 enum { NumFunctionDeclBits = NumDeclContextBits + 31 };
1806
1807 /// Stores the bits used by CXXConstructorDecl. If modified
1808 /// NumCXXConstructorDeclBits and the accessor
1809 /// methods in CXXConstructorDecl should be updated appropriately.
1810 class CXXConstructorDeclBitfields {
1811 friend class CXXConstructorDecl;
1812 /// For the bits in FunctionDeclBitfields.
1813 LLVM_PREFERRED_TYPE(FunctionDeclBitfields)
1814 uint64_t : NumFunctionDeclBits;
1815
1816 /// 20 bits to fit in the remaining available space.
1817 /// Note that this makes CXXConstructorDeclBitfields take
1818 /// exactly 64 bits and thus the width of NumCtorInitializers
1819 /// will need to be shrunk if some bit is added to NumDeclContextBitfields,
1820 /// NumFunctionDeclBitfields or CXXConstructorDeclBitfields.
1821 uint64_t NumCtorInitializers : 17;
1822 LLVM_PREFERRED_TYPE(bool)
1823 uint64_t IsInheritingConstructor : 1;
1824
1825 /// Whether this constructor has a trail-allocated explicit specifier.
1826 LLVM_PREFERRED_TYPE(bool)
1827 uint64_t HasTrailingExplicitSpecifier : 1;
1828 /// If this constructor does't have a trail-allocated explicit specifier.
1829 /// Whether this constructor is explicit specified.
1830 LLVM_PREFERRED_TYPE(bool)
1831 uint64_t IsSimpleExplicit : 1;
1832 };
1833
1834 /// Number of inherited and non-inherited bits in CXXConstructorDeclBitfields.
1835 enum { NumCXXConstructorDeclBits = NumFunctionDeclBits + 20 };
1836
1837 /// Stores the bits used by ObjCMethodDecl.
1838 /// If modified NumObjCMethodDeclBits and the accessor
1839 /// methods in ObjCMethodDecl should be updated appropriately.
1840 class ObjCMethodDeclBitfields {
1841 friend class ObjCMethodDecl;
1842
1843 /// For the bits in DeclContextBitfields.
1844 LLVM_PREFERRED_TYPE(DeclContextBitfields)
1845 uint64_t : NumDeclContextBits;
1846
1847 /// The conventional meaning of this method; an ObjCMethodFamily.
1848 /// This is not serialized; instead, it is computed on demand and
1849 /// cached.
1850 LLVM_PREFERRED_TYPE(ObjCMethodFamily)
1851 mutable uint64_t Family : ObjCMethodFamilyBitWidth;
1852
1853 /// instance (true) or class (false) method.
1854 LLVM_PREFERRED_TYPE(bool)
1855 uint64_t IsInstance : 1;
1856 LLVM_PREFERRED_TYPE(bool)
1857 uint64_t IsVariadic : 1;
1858
1859 /// True if this method is the getter or setter for an explicit property.
1860 LLVM_PREFERRED_TYPE(bool)
1861 uint64_t IsPropertyAccessor : 1;
1862
1863 /// True if this method is a synthesized property accessor stub.
1864 LLVM_PREFERRED_TYPE(bool)
1865 uint64_t IsSynthesizedAccessorStub : 1;
1866
1867 /// Method has a definition.
1868 LLVM_PREFERRED_TYPE(bool)
1869 uint64_t IsDefined : 1;
1870
1871 /// Method redeclaration in the same interface.
1872 LLVM_PREFERRED_TYPE(bool)
1873 uint64_t IsRedeclaration : 1;
1874
1875 /// Is redeclared in the same interface.
1876 LLVM_PREFERRED_TYPE(bool)
1877 mutable uint64_t HasRedeclaration : 1;
1878
1879 /// \@required/\@optional
1880 LLVM_PREFERRED_TYPE(ObjCImplementationControl)
1881 uint64_t DeclImplementation : 2;
1882
1883 /// in, inout, etc.
1884 LLVM_PREFERRED_TYPE(Decl::ObjCDeclQualifier)
1885 uint64_t objcDeclQualifier : 7;
1886
1887 /// Indicates whether this method has a related result type.
1888 LLVM_PREFERRED_TYPE(bool)
1889 uint64_t RelatedResultType : 1;
1890
1891 /// Whether the locations of the selector identifiers are in a
1892 /// "standard" position, a enum SelectorLocationsKind.
1893 LLVM_PREFERRED_TYPE(SelectorLocationsKind)
1894 uint64_t SelLocsKind : 2;
1895
1896 /// Whether this method overrides any other in the class hierarchy.
1897 ///
1898 /// A method is said to override any method in the class's
1899 /// base classes, its protocols, or its categories' protocols, that has
1900 /// the same selector and is of the same kind (class or instance).
1901 /// A method in an implementation is not considered as overriding the same
1902 /// method in the interface or its categories.
1903 LLVM_PREFERRED_TYPE(bool)
1904 uint64_t IsOverriding : 1;
1905
1906 /// Indicates if the method was a definition but its body was skipped.
1907 LLVM_PREFERRED_TYPE(bool)
1908 uint64_t HasSkippedBody : 1;
1909 };
1910
1911 /// Number of inherited and non-inherited bits in ObjCMethodDeclBitfields.
1912 enum { NumObjCMethodDeclBits = NumDeclContextBits + 24 };
1913
1914 /// Stores the bits used by ObjCContainerDecl.
1915 /// If modified NumObjCContainerDeclBits and the accessor
1916 /// methods in ObjCContainerDecl should be updated appropriately.
1917 class ObjCContainerDeclBitfields {
1918 friend class ObjCContainerDecl;
1919 /// For the bits in DeclContextBitfields
1920 LLVM_PREFERRED_TYPE(DeclContextBitfields)
1921 uint32_t : NumDeclContextBits;
1922
1923 // Not a bitfield but this saves space.
1924 // Note that ObjCContainerDeclBitfields is full.
1925 SourceLocation AtStart;
1926 };
1927
1928 /// Number of inherited and non-inherited bits in ObjCContainerDeclBitfields.
1929 /// Note that here we rely on the fact that SourceLocation is 32 bits
1930 /// wide. We check this with the static_assert in the ctor of DeclContext.
1931 enum { NumObjCContainerDeclBits = 64 };
1932
1933 /// Stores the bits used by LinkageSpecDecl.
1934 /// If modified NumLinkageSpecDeclBits and the accessor
1935 /// methods in LinkageSpecDecl should be updated appropriately.
1936 class LinkageSpecDeclBitfields {
1937 friend class LinkageSpecDecl;
1938 /// For the bits in DeclContextBitfields.
1939 LLVM_PREFERRED_TYPE(DeclContextBitfields)
1940 uint64_t : NumDeclContextBits;
1941
1942 /// The language for this linkage specification.
1943 LLVM_PREFERRED_TYPE(LinkageSpecLanguageIDs)
1944 uint64_t Language : 3;
1945
1946 /// True if this linkage spec has braces.
1947 /// This is needed so that hasBraces() returns the correct result while the
1948 /// linkage spec body is being parsed. Once RBraceLoc has been set this is
1949 /// not used, so it doesn't need to be serialized.
1950 LLVM_PREFERRED_TYPE(bool)
1951 uint64_t HasBraces : 1;
1952 };
1953
1954 /// Number of inherited and non-inherited bits in LinkageSpecDeclBitfields.
1955 enum { NumLinkageSpecDeclBits = NumDeclContextBits + 4 };
1956
1957 /// Stores the bits used by BlockDecl.
1958 /// If modified NumBlockDeclBits and the accessor
1959 /// methods in BlockDecl should be updated appropriately.
1960 class BlockDeclBitfields {
1961 friend class BlockDecl;
1962 /// For the bits in DeclContextBitfields.
1963 LLVM_PREFERRED_TYPE(DeclContextBitfields)
1964 uint64_t : NumDeclContextBits;
1965
1966 LLVM_PREFERRED_TYPE(bool)
1967 uint64_t IsVariadic : 1;
1968 LLVM_PREFERRED_TYPE(bool)
1969 uint64_t CapturesCXXThis : 1;
1970 LLVM_PREFERRED_TYPE(bool)
1971 uint64_t BlockMissingReturnType : 1;
1972 LLVM_PREFERRED_TYPE(bool)
1973 uint64_t IsConversionFromLambda : 1;
1974
1975 /// A bit that indicates this block is passed directly to a function as a
1976 /// non-escaping parameter.
1977 LLVM_PREFERRED_TYPE(bool)
1978 uint64_t DoesNotEscape : 1;
1979
1980 /// A bit that indicates whether it's possible to avoid coying this block to
1981 /// the heap when it initializes or is assigned to a local variable with
1982 /// automatic storage.
1983 LLVM_PREFERRED_TYPE(bool)
1984 uint64_t CanAvoidCopyToHeap : 1;
1985 };
1986
1987 /// Number of inherited and non-inherited bits in BlockDeclBitfields.
1988 enum { NumBlockDeclBits = NumDeclContextBits + 5 };
1989
1990 /// Pointer to the data structure used to lookup declarations
1991 /// within this context (or a DependentStoredDeclsMap if this is a
1992 /// dependent context). We maintain the invariant that, if the map
1993 /// contains an entry for a DeclarationName (and we haven't lazily
1994 /// omitted anything), then it contains all relevant entries for that
1995 /// name (modulo the hasExternalDecls() flag).
1996 mutable StoredDeclsMap *LookupPtr = nullptr;
1997
1998protected:
1999 /// This anonymous union stores the bits belonging to DeclContext and classes
2000 /// deriving from it. The goal is to use otherwise wasted
2001 /// space in DeclContext to store data belonging to derived classes.
2002 /// The space saved is especially significient when pointers are aligned
2003 /// to 8 bytes. In this case due to alignment requirements we have a
2004 /// little less than 8 bytes free in DeclContext which we can use.
2005 /// We check that none of the classes in this union is larger than
2006 /// 8 bytes with static_asserts in the ctor of DeclContext.
2007 union {
2008 DeclContextBitfields DeclContextBits;
2009 TagDeclBitfields TagDeclBits;
2010 EnumDeclBitfields EnumDeclBits;
2011 RecordDeclBitfields RecordDeclBits;
2012 OMPDeclareReductionDeclBitfields OMPDeclareReductionDeclBits;
2013 FunctionDeclBitfields FunctionDeclBits;
2014 CXXConstructorDeclBitfields CXXConstructorDeclBits;
2015 ObjCMethodDeclBitfields ObjCMethodDeclBits;
2016 ObjCContainerDeclBitfields ObjCContainerDeclBits;
2017 LinkageSpecDeclBitfields LinkageSpecDeclBits;
2018 BlockDeclBitfields BlockDeclBits;
2019
2020 static_assert(sizeof(DeclContextBitfields) <= 8,
2021 "DeclContextBitfields is larger than 8 bytes!");
2022 static_assert(sizeof(TagDeclBitfields) <= 8,
2023 "TagDeclBitfields is larger than 8 bytes!");
2024 static_assert(sizeof(EnumDeclBitfields) <= 8,
2025 "EnumDeclBitfields is larger than 8 bytes!");
2026 static_assert(sizeof(RecordDeclBitfields) <= 8,
2027 "RecordDeclBitfields is larger than 8 bytes!");
2028 static_assert(sizeof(OMPDeclareReductionDeclBitfields) <= 8,
2029 "OMPDeclareReductionDeclBitfields is larger than 8 bytes!");
2030 static_assert(sizeof(FunctionDeclBitfields) <= 8,
2031 "FunctionDeclBitfields is larger than 8 bytes!");
2032 static_assert(sizeof(CXXConstructorDeclBitfields) <= 8,
2033 "CXXConstructorDeclBitfields is larger than 8 bytes!");
2034 static_assert(sizeof(ObjCMethodDeclBitfields) <= 8,
2035 "ObjCMethodDeclBitfields is larger than 8 bytes!");
2036 static_assert(sizeof(ObjCContainerDeclBitfields) <= 8,
2037 "ObjCContainerDeclBitfields is larger than 8 bytes!");
2038 static_assert(sizeof(LinkageSpecDeclBitfields) <= 8,
2039 "LinkageSpecDeclBitfields is larger than 8 bytes!");
2040 static_assert(sizeof(BlockDeclBitfields) <= 8,
2041 "BlockDeclBitfields is larger than 8 bytes!");
2042 };
2043
2044 /// FirstDecl - The first declaration stored within this declaration
2045 /// context.
2046 mutable Decl *FirstDecl = nullptr;
2047
2048 /// LastDecl - The last declaration stored within this declaration
2049 /// context. FIXME: We could probably cache this value somewhere
2050 /// outside of the DeclContext, to reduce the size of DeclContext by
2051 /// another pointer.
2052 mutable Decl *LastDecl = nullptr;
2053
2054 /// Build up a chain of declarations.
2055 ///
2056 /// \returns the first/last pair of declarations.
2057 static std::pair<Decl *, Decl *>
2058 BuildDeclChain(ArrayRef<Decl*> Decls, bool FieldsAlreadyLoaded);
2059
2061
2062public:
2064
2065 // For use when debugging; hasValidDeclKind() will always return true for
2066 // a correctly constructed object within its lifetime.
2067 bool hasValidDeclKind() const;
2068
2070 return static_cast<Decl::Kind>(DeclContextBits.DeclKind);
2071 }
2072
2073 const char *getDeclKindName() const;
2074
2075 /// getParent - Returns the containing DeclContext.
2077 return cast<Decl>(this)->getDeclContext();
2078 }
2079 const DeclContext *getParent() const {
2080 return const_cast<DeclContext*>(this)->getParent();
2081 }
2082
2083 /// getLexicalParent - Returns the containing lexical DeclContext. May be
2084 /// different from getParent, e.g.:
2085 ///
2086 /// namespace A {
2087 /// struct S;
2088 /// }
2089 /// struct A::S {}; // getParent() == namespace 'A'
2090 /// // getLexicalParent() == translation unit
2091 ///
2093 return cast<Decl>(this)->getLexicalDeclContext();
2094 }
2096 return const_cast<DeclContext*>(this)->getLexicalParent();
2097 }
2098
2100
2102 return const_cast<DeclContext*>(this)->getLookupParent();
2103 }
2104
2106 return cast<Decl>(this)->getASTContext();
2107 }
2108
2109 bool isClosure() const { return getDeclKind() == Decl::Block; }
2110
2111 /// Return this DeclContext if it is a BlockDecl. Otherwise, return the
2112 /// innermost enclosing BlockDecl or null if there are no enclosing blocks.
2113 const BlockDecl *getInnermostBlockDecl() const;
2114
2115 bool isObjCContainer() const {
2116 switch (getDeclKind()) {
2117 case Decl::ObjCCategory:
2118 case Decl::ObjCCategoryImpl:
2119 case Decl::ObjCImplementation:
2120 case Decl::ObjCInterface:
2121 case Decl::ObjCProtocol:
2122 return true;
2123 default:
2124 return false;
2125 }
2126 }
2127
2128 bool isFunctionOrMethod() const {
2129 switch (getDeclKind()) {
2130 case Decl::Block:
2131 case Decl::Captured:
2132 case Decl::ObjCMethod:
2133 case Decl::TopLevelStmt:
2134 return true;
2135 default:
2136 return getDeclKind() >= Decl::firstFunction &&
2137 getDeclKind() <= Decl::lastFunction;
2138 }
2139 }
2140
2141 /// Test whether the context supports looking up names.
2142 bool isLookupContext() const {
2143 return !isFunctionOrMethod() && getDeclKind() != Decl::LinkageSpec &&
2144 getDeclKind() != Decl::Export;
2145 }
2146
2147 bool isFileContext() const {
2148 return getDeclKind() == Decl::TranslationUnit ||
2149 getDeclKind() == Decl::Namespace;
2150 }
2151
2152 bool isTranslationUnit() const {
2153 return getDeclKind() == Decl::TranslationUnit;
2154 }
2155
2156 bool isRecord() const {
2157 return getDeclKind() >= Decl::firstRecord &&
2158 getDeclKind() <= Decl::lastRecord;
2159 }
2160
2161 bool isNamespace() const { return getDeclKind() == Decl::Namespace; }
2162
2163 bool isStdNamespace() const;
2164
2165 bool isInlineNamespace() const;
2166
2167 /// Determines whether this context is dependent on a
2168 /// template parameter.
2169 bool isDependentContext() const;
2170
2171 /// isTransparentContext - Determines whether this context is a
2172 /// "transparent" context, meaning that the members declared in this
2173 /// context are semantically declared in the nearest enclosing
2174 /// non-transparent (opaque) context but are lexically declared in
2175 /// this context. For example, consider the enumerators of an
2176 /// enumeration type:
2177 /// @code
2178 /// enum E {
2179 /// Val1
2180 /// };
2181 /// @endcode
2182 /// Here, E is a transparent context, so its enumerator (Val1) will
2183 /// appear (semantically) that it is in the same context of E.
2184 /// Examples of transparent contexts include: enumerations (except for
2185 /// C++0x scoped enums), C++ linkage specifications and export declaration.
2186 bool isTransparentContext() const;
2187
2188 /// Determines whether this context or some of its ancestors is a
2189 /// linkage specification context that specifies C linkage.
2190 bool isExternCContext() const;
2191
2192 /// Retrieve the nearest enclosing C linkage specification context.
2193 const LinkageSpecDecl *getExternCContext() const;
2194
2195 /// Determines whether this context or some of its ancestors is a
2196 /// linkage specification context that specifies C++ linkage.
2197 bool isExternCXXContext() const;
2198
2199 /// Determine whether this declaration context is equivalent
2200 /// to the declaration context DC.
2201 bool Equals(const DeclContext *DC) const {
2202 return DC && this->getPrimaryContext() == DC->getPrimaryContext();
2203 }
2204
2205 /// Determine whether this declaration context encloses the
2206 /// declaration context DC.
2207 bool Encloses(const DeclContext *DC) const;
2208
2209 /// Find the nearest non-closure ancestor of this context,
2210 /// i.e. the innermost semantic parent of this context which is not
2211 /// a closure. A context may be its own non-closure ancestor.
2214 return const_cast<DeclContext*>(this)->getNonClosureAncestor();
2215 }
2216
2217 // Retrieve the nearest context that is not a transparent context.
2220 return const_cast<DeclContext *>(this)->getNonTransparentContext();
2221 }
2222
2223 /// getPrimaryContext - There may be many different
2224 /// declarations of the same entity (including forward declarations
2225 /// of classes, multiple definitions of namespaces, etc.), each with
2226 /// a different set of declarations. This routine returns the
2227 /// "primary" DeclContext structure, which will contain the
2228 /// information needed to perform name lookup into this context.
2231 return const_cast<DeclContext*>(this)->getPrimaryContext();
2232 }
2233
2234 /// getRedeclContext - Retrieve the context in which an entity conflicts with
2235 /// other entities of the same name, or where it is a redeclaration if the
2236 /// two entities are compatible. This skips through transparent contexts.
2239 return const_cast<DeclContext *>(this)->getRedeclContext();
2240 }
2241
2242 /// Retrieve the nearest enclosing namespace context.
2245 return const_cast<DeclContext *>(this)->getEnclosingNamespaceContext();
2246 }
2247
2248 /// Retrieve the outermost lexically enclosing record context.
2251 return const_cast<DeclContext *>(this)->getOuterLexicalRecordContext();
2252 }
2253
2254 /// Test if this context is part of the enclosing namespace set of
2255 /// the context NS, as defined in C++0x [namespace.def]p9. If either context
2256 /// isn't a namespace, this is equivalent to Equals().
2257 ///
2258 /// The enclosing namespace set of a namespace is the namespace and, if it is
2259 /// inline, its enclosing namespace, recursively.
2260 bool InEnclosingNamespaceSetOf(const DeclContext *NS) const;
2261
2262 /// Collects all of the declaration contexts that are semantically
2263 /// connected to this declaration context.
2264 ///
2265 /// For declaration contexts that have multiple semantically connected but
2266 /// syntactically distinct contexts, such as C++ namespaces, this routine
2267 /// retrieves the complete set of such declaration contexts in source order.
2268 /// For example, given:
2269 ///
2270 /// \code
2271 /// namespace N {
2272 /// int x;
2273 /// }
2274 /// namespace N {
2275 /// int y;
2276 /// }
2277 /// \endcode
2278 ///
2279 /// The \c Contexts parameter will contain both definitions of N.
2280 ///
2281 /// \param Contexts Will be cleared and set to the set of declaration
2282 /// contexts that are semanticaly connected to this declaration context,
2283 /// in source order, including this context (which may be the only result,
2284 /// for non-namespace contexts).
2286
2287 /// decl_iterator - Iterates through the declarations stored
2288 /// within this context.
2290 /// Current - The current declaration.
2291 Decl *Current = nullptr;
2292
2293 public:
2294 using value_type = Decl *;
2295 using reference = const value_type &;
2296 using pointer = const value_type *;
2297 using iterator_category = std::forward_iterator_tag;
2298 using difference_type = std::ptrdiff_t;
2299
2300 decl_iterator() = default;
2301 explicit decl_iterator(Decl *C) : Current(C) {}
2302
2303 reference operator*() const { return Current; }
2304
2305 // This doesn't meet the iterator requirements, but it's convenient
2306 value_type operator->() const { return Current; }
2307
2309 Current = Current->getNextDeclInContext();
2310 return *this;
2311 }
2312
2314 decl_iterator tmp(*this);
2315 ++(*this);
2316 return tmp;
2317 }
2318
2320 return x.Current == y.Current;
2321 }
2322
2324 return x.Current != y.Current;
2325 }
2326 };
2327
2328 using decl_range = llvm::iterator_range<decl_iterator>;
2329
2330 /// decls_begin/decls_end - Iterate over the declarations stored in
2331 /// this context.
2333 decl_iterator decls_begin() const;
2335 bool decls_empty() const;
2336
2337 /// noload_decls_begin/end - Iterate over the declarations stored in this
2338 /// context that are currently loaded; don't attempt to retrieve anything
2339 /// from an external source.
2342 }
2345
2346 /// specific_decl_iterator - Iterates over a subrange of
2347 /// declarations stored in a DeclContext, providing only those that
2348 /// are of type SpecificDecl (or a class derived from it). This
2349 /// iterator is used, for example, to provide iteration over just
2350 /// the fields within a RecordDecl (with SpecificDecl = FieldDecl).
2351 template<typename SpecificDecl>
2353 /// Current - The current, underlying declaration iterator, which
2354 /// will either be NULL or will point to a declaration of
2355 /// type SpecificDecl.
2357
2358 /// SkipToNextDecl - Advances the current position up to the next
2359 /// declaration of type SpecificDecl that also meets the criteria
2360 /// required by Acceptable.
2361 void SkipToNextDecl() {
2362 while (*Current && !isa<SpecificDecl>(*Current))
2363 ++Current;
2364 }
2365
2366 public:
2367 using value_type = SpecificDecl *;
2368 // TODO: Add reference and pointer types (with some appropriate proxy type)
2369 // if we ever have a need for them.
2370 using reference = void;
2371 using pointer = void;
2373 std::iterator_traits<DeclContext::decl_iterator>::difference_type;
2374 using iterator_category = std::forward_iterator_tag;
2375
2377
2378 /// specific_decl_iterator - Construct a new iterator over a
2379 /// subset of the declarations the range [C,
2380 /// end-of-declarations). If A is non-NULL, it is a pointer to a
2381 /// member function of SpecificDecl that should return true for
2382 /// all of the SpecificDecl instances that will be in the subset
2383 /// of iterators. For example, if you want Objective-C instance
2384 /// methods, SpecificDecl will be ObjCMethodDecl and A will be
2385 /// &ObjCMethodDecl::isInstanceMethod.
2387 SkipToNextDecl();
2388 }
2389
2390 value_type operator*() const { return cast<SpecificDecl>(*Current); }
2391
2392 // This doesn't meet the iterator requirements, but it's convenient
2393 value_type operator->() const { return **this; }
2394
2396 ++Current;
2397 SkipToNextDecl();
2398 return *this;
2399 }
2400
2402 specific_decl_iterator tmp(*this);
2403 ++(*this);
2404 return tmp;
2405 }
2406
2408 const specific_decl_iterator& y) {
2409 return x.Current == y.Current;
2410 }
2411
2413 const specific_decl_iterator& y) {
2414 return x.Current != y.Current;
2415 }
2416 };
2417
2418 /// Iterates over a filtered subrange of declarations stored
2419 /// in a DeclContext.
2420 ///
2421 /// This iterator visits only those declarations that are of type
2422 /// SpecificDecl (or a class derived from it) and that meet some
2423 /// additional run-time criteria. This iterator is used, for
2424 /// example, to provide access to the instance methods within an
2425 /// Objective-C interface (with SpecificDecl = ObjCMethodDecl and
2426 /// Acceptable = ObjCMethodDecl::isInstanceMethod).
2427 template<typename SpecificDecl, bool (SpecificDecl::*Acceptable)() const>
2429 /// Current - The current, underlying declaration iterator, which
2430 /// will either be NULL or will point to a declaration of
2431 /// type SpecificDecl.
2433
2434 /// SkipToNextDecl - Advances the current position up to the next
2435 /// declaration of type SpecificDecl that also meets the criteria
2436 /// required by Acceptable.
2437 void SkipToNextDecl() {
2438 while (*Current &&
2439 (!isa<SpecificDecl>(*Current) ||
2440 (Acceptable && !(cast<SpecificDecl>(*Current)->*Acceptable)())))
2441 ++Current;
2442 }
2443
2444 public:
2445 using value_type = SpecificDecl *;
2446 // TODO: Add reference and pointer types (with some appropriate proxy type)
2447 // if we ever have a need for them.
2448 using reference = void;
2449 using pointer = void;
2451 std::iterator_traits<DeclContext::decl_iterator>::difference_type;
2452 using iterator_category = std::forward_iterator_tag;
2453
2455
2456 /// filtered_decl_iterator - Construct a new iterator over a
2457 /// subset of the declarations the range [C,
2458 /// end-of-declarations). If A is non-NULL, it is a pointer to a
2459 /// member function of SpecificDecl that should return true for
2460 /// all of the SpecificDecl instances that will be in the subset
2461 /// of iterators. For example, if you want Objective-C instance
2462 /// methods, SpecificDecl will be ObjCMethodDecl and A will be
2463 /// &ObjCMethodDecl::isInstanceMethod.
2465 SkipToNextDecl();
2466 }
2467
2468 value_type operator*() const { return cast<SpecificDecl>(*Current); }
2469 value_type operator->() const { return cast<SpecificDecl>(*Current); }
2470
2472 ++Current;
2473 SkipToNextDecl();
2474 return *this;
2475 }
2476
2478 filtered_decl_iterator tmp(*this);
2479 ++(*this);
2480 return tmp;
2481 }
2482
2484 const filtered_decl_iterator& y) {
2485 return x.Current == y.Current;
2486 }
2487
2489 const filtered_decl_iterator& y) {
2490 return x.Current != y.Current;
2491 }
2492 };
2493
2494 /// Add the declaration D into this context.
2495 ///
2496 /// This routine should be invoked when the declaration D has first
2497 /// been declared, to place D into the context where it was
2498 /// (lexically) defined. Every declaration must be added to one
2499 /// (and only one!) context, where it can be visited via
2500 /// [decls_begin(), decls_end()). Once a declaration has been added
2501 /// to its lexical context, the corresponding DeclContext owns the
2502 /// declaration.
2503 ///
2504 /// If D is also a NamedDecl, it will be made visible within its
2505 /// semantic context via makeDeclVisibleInContext.
2506 void addDecl(Decl *D);
2507
2508 /// Add the declaration D into this context, but suppress
2509 /// searches for external declarations with the same name.
2510 ///
2511 /// Although analogous in function to addDecl, this removes an
2512 /// important check. This is only useful if the Decl is being
2513 /// added in response to an external search; in all other cases,
2514 /// addDecl() is the right function to use.
2515 /// See the ASTImporter for use cases.
2516 void addDeclInternal(Decl *D);
2517
2518 /// Add the declaration D to this context without modifying
2519 /// any lookup tables.
2520 ///
2521 /// This is useful for some operations in dependent contexts where
2522 /// the semantic context might not be dependent; this basically
2523 /// only happens with friends.
2524 void addHiddenDecl(Decl *D);
2525
2526 /// Removes a declaration from this context.
2527 void removeDecl(Decl *D);
2528
2529 /// Checks whether a declaration is in this context.
2530 bool containsDecl(Decl *D) const;
2531
2532 /// Checks whether a declaration is in this context.
2533 /// This also loads the Decls from the external source before the check.
2534 bool containsDeclAndLoad(Decl *D) const;
2535
2538
2539 /// lookup - Find the declarations (if any) with the given Name in
2540 /// this context. Returns a range of iterators that contains all of
2541 /// the declarations with this name, with object, function, member,
2542 /// and enumerator names preceding any tag name. Note that this
2543 /// routine will not look into parent contexts.
2545
2546 /// Find the declarations with the given name that are visible
2547 /// within this context; don't attempt to retrieve anything from an
2548 /// external source.
2550
2551 /// A simplistic name lookup mechanism that performs name lookup
2552 /// into this declaration context without consulting the external source.
2553 ///
2554 /// This function should almost never be used, because it subverts the
2555 /// usual relationship between a DeclContext and the external source.
2556 /// See the ASTImporter for the (few, but important) use cases.
2557 ///
2558 /// FIXME: This is very inefficient; replace uses of it with uses of
2559 /// noload_lookup.
2562
2563 /// Makes a declaration visible within this context.
2564 ///
2565 /// This routine makes the declaration D visible to name lookup
2566 /// within this context and, if this is a transparent context,
2567 /// within its parent contexts up to the first enclosing
2568 /// non-transparent context. Making a declaration visible within a
2569 /// context does not transfer ownership of a declaration, and a
2570 /// declaration can be visible in many contexts that aren't its
2571 /// lexical context.
2572 ///
2573 /// If D is a redeclaration of an existing declaration that is
2574 /// visible from this context, as determined by
2575 /// NamedDecl::declarationReplaces, the previous declaration will be
2576 /// replaced with D.
2578
2579 /// all_lookups_iterator - An iterator that provides a view over the results
2580 /// of looking up every possible name.
2582
2583 using lookups_range = llvm::iterator_range<all_lookups_iterator>;
2584
2585 lookups_range lookups() const;
2586 // Like lookups(), but avoids loading external declarations.
2587 // If PreserveInternalState, avoids building lookup data structures too.
2588 lookups_range noload_lookups(bool PreserveInternalState) const;
2589
2590 /// Iterators over all possible lookups within this context.
2593
2594 /// Iterators over all possible lookups within this context that are
2595 /// currently loaded; don't attempt to retrieve anything from an external
2596 /// source.
2599
2600 struct udir_iterator;
2601
2603 llvm::iterator_adaptor_base<udir_iterator, lookup_iterator,
2606
2609
2611 };
2612
2613 using udir_range = llvm::iterator_range<udir_iterator>;
2614
2616
2617 // These are all defined in DependentDiagnostic.h.
2618 class ddiag_iterator;
2619
2620 using ddiag_range = llvm::iterator_range<DeclContext::ddiag_iterator>;
2621
2622 inline ddiag_range ddiags() const;
2623
2624 // Low-level accessors
2625
2626 /// Mark that there are external lexical declarations that we need
2627 /// to include in our lookup table (and that are not available as external
2628 /// visible lookups). These extra lookup results will be found by walking
2629 /// the lexical declarations of this context. This should be used only if
2630 /// setHasExternalLexicalStorage() has been called on any decl context for
2631 /// which this is the primary context.
2633 assert(this == getPrimaryContext() &&
2634 "should only be called on primary context");
2635 DeclContextBits.HasLazyExternalLexicalLookups = true;
2636 }
2637
2638 /// Retrieve the internal representation of the lookup structure.
2639 /// This may omit some names if we are lazily building the structure.
2640 StoredDeclsMap *getLookupPtr() const { return LookupPtr; }
2641
2642 /// Ensure the lookup structure is fully-built and return it.
2644
2645 /// Whether this DeclContext has external storage containing
2646 /// additional declarations that are lexically in this context.
2648 return DeclContextBits.ExternalLexicalStorage;
2649 }
2650
2651 /// State whether this DeclContext has external storage for
2652 /// declarations lexically in this context.
2653 void setHasExternalLexicalStorage(bool ES = true) const {
2654 DeclContextBits.ExternalLexicalStorage = ES;
2655 }
2656
2657 /// Whether this DeclContext has external storage containing
2658 /// additional declarations that are visible in this context.
2660 return DeclContextBits.ExternalVisibleStorage;
2661 }
2662
2663 /// State whether this DeclContext has external storage for
2664 /// declarations visible in this context.
2665 void setHasExternalVisibleStorage(bool ES = true) const {
2666 DeclContextBits.ExternalVisibleStorage = ES;
2667 if (ES && LookupPtr)
2668 DeclContextBits.NeedToReconcileExternalVisibleStorage = true;
2669 }
2670
2671 /// Determine whether the given declaration is stored in the list of
2672 /// declarations lexically within this context.
2673 bool isDeclInLexicalTraversal(const Decl *D) const {
2674 return D && (D->NextInContextAndBits.getPointer() || D == FirstDecl ||
2675 D == LastDecl);
2676 }
2677
2678 void setUseQualifiedLookup(bool use = true) const {
2679 DeclContextBits.UseQualifiedLookup = use;
2680 }
2681
2683 return DeclContextBits.UseQualifiedLookup;
2684 }
2685
2686 static bool classof(const Decl *D);
2687 static bool classof(const DeclContext *D) { return true; }
2688
2689 void dumpAsDecl() const;
2690 void dumpAsDecl(const ASTContext *Ctx) const;
2691 void dumpDeclContext() const;
2692 void dumpLookups() const;
2693 void dumpLookups(llvm::raw_ostream &OS, bool DumpDecls = false,
2694 bool Deserialize = false) const;
2695
2696private:
2697 /// Whether this declaration context has had externally visible
2698 /// storage added since the last lookup. In this case, \c LookupPtr's
2699 /// invariant may not hold and needs to be fixed before we perform
2700 /// another lookup.
2701 bool hasNeedToReconcileExternalVisibleStorage() const {
2702 return DeclContextBits.NeedToReconcileExternalVisibleStorage;
2703 }
2704
2705 /// State that this declaration context has had externally visible
2706 /// storage added since the last lookup. In this case, \c LookupPtr's
2707 /// invariant may not hold and needs to be fixed before we perform
2708 /// another lookup.
2709 void setNeedToReconcileExternalVisibleStorage(bool Need = true) const {
2710 DeclContextBits.NeedToReconcileExternalVisibleStorage = Need;
2711 }
2712
2713 /// If \c true, this context may have local lexical declarations
2714 /// that are missing from the lookup table.
2715 bool hasLazyLocalLexicalLookups() const {
2716 return DeclContextBits.HasLazyLocalLexicalLookups;
2717 }
2718
2719 /// If \c true, this context may have local lexical declarations
2720 /// that are missing from the lookup table.
2721 void setHasLazyLocalLexicalLookups(bool HasLLLL = true) const {
2722 DeclContextBits.HasLazyLocalLexicalLookups = HasLLLL;
2723 }
2724
2725 /// If \c true, the external source may have lexical declarations
2726 /// that are missing from the lookup table.
2727 bool hasLazyExternalLexicalLookups() const {
2728 return DeclContextBits.HasLazyExternalLexicalLookups;
2729 }
2730
2731 /// If \c true, the external source may have lexical declarations
2732 /// that are missing from the lookup table.
2733 void setHasLazyExternalLexicalLookups(bool HasLELL = true) const {
2734 DeclContextBits.HasLazyExternalLexicalLookups = HasLELL;
2735 }
2736
2737 void reconcileExternalVisibleStorage() const;
2738 bool LoadLexicalDeclsFromExternalStorage() const;
2739
2740 StoredDeclsMap *CreateStoredDeclsMap(ASTContext &C) const;
2741
2742 void loadLazyLocalLexicalLookups();
2743 void buildLookupImpl(DeclContext *DCtx, bool Internal);
2744 void makeDeclVisibleInContextWithFlags(NamedDecl *D, bool Internal,
2745 bool Rediscoverable);
2746 void makeDeclVisibleInContextImpl(NamedDecl *D, bool Internal);
2747};
2748
2749inline bool Decl::isTemplateParameter() const {
2750 return getKind() == TemplateTypeParm || getKind() == NonTypeTemplateParm ||
2751 getKind() == TemplateTemplateParm;
2752}
2753
2754// Specialization selected when ToTy is not a known subclass of DeclContext.
2755template <class ToTy,
2756 bool IsKnownSubtype = ::std::is_base_of<DeclContext, ToTy>::value>
2758 static const ToTy *doit(const DeclContext *Val) {
2759 return static_cast<const ToTy*>(Decl::castFromDeclContext(Val));
2760 }
2761
2762 static ToTy *doit(DeclContext *Val) {
2763 return static_cast<ToTy*>(Decl::castFromDeclContext(Val));
2764 }
2765};
2766
2767// Specialization selected when ToTy is a known subclass of DeclContext.
2768template <class ToTy>
2770 static const ToTy *doit(const DeclContext *Val) {
2771 return static_cast<const ToTy*>(Val);
2772 }
2773
2774 static ToTy *doit(DeclContext *Val) {
2775 return static_cast<ToTy*>(Val);
2776 }
2777};
2778
2779} // namespace clang
2780
2781namespace llvm {
2782
2783/// isa<T>(DeclContext*)
2784template <typename To>
2785struct isa_impl<To, ::clang::DeclContext> {
2786 static bool doit(const ::clang::DeclContext &Val) {
2787 return To::classofKind(Val.getDeclKind());
2788 }
2789};
2790
2791/// cast<T>(DeclContext*)
2792template<class ToTy>
2793struct cast_convert_val<ToTy,
2795 static const ToTy &doit(const ::clang::DeclContext &Val) {
2797 }
2798};
2799
2800template<class ToTy>
2801struct cast_convert_val<ToTy, ::clang::DeclContext, ::clang::DeclContext> {
2802 static ToTy &doit(::clang::DeclContext &Val) {
2804 }
2805};
2806
2807template<class ToTy>
2808struct cast_convert_val<ToTy,
2809 const ::clang::DeclContext*, const ::clang::DeclContext*> {
2810 static const ToTy *doit(const ::clang::DeclContext *Val) {
2811 return ::clang::cast_convert_decl_context<ToTy>::doit(Val);
2812 }
2813};
2814
2815template<class ToTy>
2816struct cast_convert_val<ToTy, ::clang::DeclContext*, ::clang::DeclContext*> {
2817 static ToTy *doit(::clang::DeclContext *Val) {
2818 return ::clang::cast_convert_decl_context<ToTy>::doit(Val);
2819 }
2820};
2821
2822/// Implement cast_convert_val for Decl -> DeclContext conversions.
2823template<class FromTy>
2824struct cast_convert_val< ::clang::DeclContext, FromTy, FromTy> {
2825 static ::clang::DeclContext &doit(const FromTy &Val) {
2826 return *FromTy::castToDeclContext(&Val);
2827 }
2828};
2829
2830template<class FromTy>
2831struct cast_convert_val< ::clang::DeclContext, FromTy*, FromTy*> {
2832 static ::clang::DeclContext *doit(const FromTy *Val) {
2833 return FromTy::castToDeclContext(Val);
2834 }
2835};
2836
2837template<class FromTy>
2838struct cast_convert_val< const ::clang::DeclContext, FromTy, FromTy> {
2839 static const ::clang::DeclContext &doit(const FromTy &Val) {
2840 return *FromTy::castToDeclContext(&Val);
2841 }
2842};
2843
2844template<class FromTy>
2845struct cast_convert_val< const ::clang::DeclContext, FromTy*, FromTy*> {
2846 static const ::clang::DeclContext *doit(const FromTy *Val) {
2847 return FromTy::castToDeclContext(Val);
2848 }
2849};
2850
2851} // namespace llvm
2852
2853#endif // LLVM_CLANG_AST_DECLBASE_H
#define V(N, I)
Definition: ASTContext.h:3259
NodeId Parent
Definition: ASTDiff.cpp:191
DynTypedNode Node
StringRef P
static char ID
Definition: Arena.cpp:183
#define SM(sm)
Definition: Cuda.cpp:82
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:42
Represents a block literal declaration, which is like an unnamed FunctionDecl.
Definition: Decl.h:4459
The results of name lookup within a DeclContext.
Definition: DeclBase.h:1379
reference front() const
Definition: DeclBase.h:1402
DeclContextLookupResult(Decls Result)
Definition: DeclBase.h:1387
const_iterator begin() const
Definition: DeclBase.h:1395
DeclListNode::iterator iterator
Definition: DeclBase.h:1389
const_iterator end() const
Definition: DeclBase.h:1398
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:2289
std::forward_iterator_tag iterator_category
Definition: DeclBase.h:2297
decl_iterator operator++(int)
Definition: DeclBase.h:2313
value_type operator->() const
Definition: DeclBase.h:2306
friend bool operator!=(decl_iterator x, decl_iterator y)
Definition: DeclBase.h:2323
friend bool operator==(decl_iterator x, decl_iterator y)
Definition: DeclBase.h:2319
decl_iterator & operator++()
Definition: DeclBase.h:2308
Iterates over a filtered subrange of declarations stored in a DeclContext.
Definition: DeclBase.h:2428
std::forward_iterator_tag iterator_category
Definition: DeclBase.h:2452
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:2464
friend bool operator==(const filtered_decl_iterator &x, const filtered_decl_iterator &y)
Definition: DeclBase.h:2483
filtered_decl_iterator operator++(int)
Definition: DeclBase.h:2477
friend bool operator!=(const filtered_decl_iterator &x, const filtered_decl_iterator &y)
Definition: DeclBase.h:2488
std::iterator_traits< DeclContext::decl_iterator >::difference_type difference_type
Definition: DeclBase.h:2451
filtered_decl_iterator & operator++()
Definition: DeclBase.h:2471
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext,...
Definition: DeclBase.h:2352
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:2386
friend bool operator==(const specific_decl_iterator &x, const specific_decl_iterator &y)
Definition: DeclBase.h:2407
std::forward_iterator_tag iterator_category
Definition: DeclBase.h:2374
specific_decl_iterator operator++(int)
Definition: DeclBase.h:2401
friend bool operator!=(const specific_decl_iterator &x, const specific_decl_iterator &y)
Definition: DeclBase.h:2412
specific_decl_iterator & operator++()
Definition: DeclBase.h:2395
std::iterator_traits< DeclContext::decl_iterator >::difference_type difference_type
Definition: DeclBase.h:2373
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1446
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:2076
udir_range using_directives() const
Returns iterator range [First, Last) of UsingDirectiveDecls stored within this context.
Definition: DeclBase.cpp:2073
bool Equals(const DeclContext *DC) const
Determine whether this declaration context is equivalent to the declaration context DC.
Definition: DeclBase.h:2201
lookup_result::iterator lookup_iterator
Definition: DeclBase.h:2537
void dumpAsDecl() const
Definition: ASTDumper.cpp:245
FunctionDeclBitfields FunctionDeclBits
Definition: DeclBase.h:2013
bool isFileContext() const
Definition: DeclBase.h:2147
void setHasExternalVisibleStorage(bool ES=true) const
State whether this DeclContext has external storage for declarations visible in this context.
Definition: DeclBase.h:2665
void makeDeclVisibleInContext(NamedDecl *D)
Makes a declaration visible within this context.
Definition: DeclBase.cpp:1976
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:1456
bool isTransparentContext() const
isTransparentContext - Determines whether this context is a "transparent" context,...
Definition: DeclBase.cpp:1299
Decl * getNonClosureAncestor()
Find the nearest non-closure ancestor of this context, i.e.
Definition: DeclBase.cpp:1178
bool isObjCContainer() const
Definition: DeclBase.h:2115
ObjCMethodDeclBitfields ObjCMethodDeclBits
Definition: DeclBase.h:2015
TagDeclBitfields TagDeclBits
Definition: DeclBase.h:2009
ASTContext & getParentASTContext() const
Definition: DeclBase.h:2105
lookups_range noload_lookups(bool PreserveInternalState) const
Definition: DeclLookups.h:89
const DeclContext * getParent() const
Definition: DeclBase.h:2079
bool isExternCXXContext() const
Determines whether this context or some of its ancestors is a linkage specification context that spec...
Definition: DeclBase.cpp:1331
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:1265
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:1958
const DeclContext * getRedeclContext() const
Definition: DeclBase.h:2238
EnumDeclBitfields EnumDeclBits
Definition: DeclBase.h:2010
CXXConstructorDeclBitfields CXXConstructorDeclBits
Definition: DeclBase.h:2014
bool isClosure() const
Definition: DeclBase.h:2109
static bool classof(const DeclContext *D)
Definition: DeclBase.h:2687
const Decl * getNonClosureAncestor() const
Definition: DeclBase.h:2213
DeclContext * getLexicalParent()
getLexicalParent - Returns the containing lexical DeclContext.
Definition: DeclBase.h:2092
bool isNamespace() const
Definition: DeclBase.h:2161
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
Definition: DeclBase.cpp:1785
void dumpLookups() const
Definition: ASTDumper.cpp:270
bool isLookupContext() const
Test whether the context supports looking up names.
Definition: DeclBase.h:2142
const BlockDecl * getInnermostBlockDecl() const
Return this DeclContext if it is a BlockDecl.
Definition: DeclBase.cpp:1232
bool hasExternalVisibleStorage() const
Whether this DeclContext has external storage containing additional declarations that are visible in ...
Definition: DeclBase.h:2659
const DeclContext * getPrimaryContext() const
Definition: DeclBase.h:2230
ObjCContainerDeclBitfields ObjCContainerDeclBits
Definition: DeclBase.h:2016
const char * getDeclKindName() const
Definition: DeclBase.cpp:164
BlockDeclBitfields BlockDeclBits
Definition: DeclBase.h:2018
bool isTranslationUnit() const
Definition: DeclBase.h:2152
bool isRecord() const
Definition: DeclBase.h:2156
void collectAllContexts(SmallVectorImpl< DeclContext * > &Contexts)
Collects all of the declaration contexts that are semantically connected to this declaration context.
Definition: DeclBase.cpp:1442
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:1921
llvm::iterator_range< udir_iterator > udir_range
Definition: DeclBase.h:2613
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:2632
RecordDeclBitfields RecordDeclBits
Definition: DeclBase.h:2011
Decl * FirstDecl
FirstDecl - The first declaration stored within this declaration context.
Definition: DeclBase.h:2046
decl_iterator noload_decls_begin() const
Definition: DeclBase.h:2343
void addDeclInternal(Decl *D)
Add the declaration D into this context, but suppress searches for external declarations with the sam...
Definition: DeclBase.cpp:1707
lookups_range lookups() const
Definition: DeclLookups.h:75
const DeclContext * getLookupParent() const
Definition: DeclBase.h:2101
bool shouldUseQualifiedLookup() const
Definition: DeclBase.h:2682
bool containsDeclAndLoad(Decl *D) const
Checks whether a declaration is in this context.
Definition: DeclBase.cpp:1573
void removeDecl(Decl *D)
Removes a declaration from this context.
Definition: DeclBase.cpp:1618
void addDecl(Decl *D)
Add the declaration D into this context.
Definition: DeclBase.cpp:1699
llvm::iterator_range< decl_iterator > decl_range
Definition: DeclBase.h:2328
void dumpDeclContext() const
StoredDeclsMap * buildLookup()
Ensure the lookup structure is fully-built and return it.
Definition: DeclBase.cpp:1722
decl_iterator decls_end() const
Definition: DeclBase.h:2334
bool hasValidDeclKind() const
Definition: DeclBase.cpp:155
bool isStdNamespace() const
Definition: DeclBase.cpp:1249
ddiag_range ddiags() const
llvm::iterator_adaptor_base< udir_iterator, lookup_iterator, typename lookup_iterator::iterator_category, UsingDirectiveDecl * > udir_iterator_base
Definition: DeclBase.h:2605
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:1850
static bool classof(const Decl *D)
Definition: DeclBase.cpp:1196
const DeclContext * getNonTransparentContext() const
Definition: DeclBase.h:2219
const RecordDecl * getOuterLexicalRecordContext() const
Definition: DeclBase.h:2250
bool containsDecl(Decl *D) const
Checks whether a declaration is in this context.
Definition: DeclBase.cpp:1568
llvm::iterator_range< DeclContext::ddiag_iterator > ddiag_range
Definition: DeclBase.h:2620
bool hasExternalLexicalStorage() const
Whether this DeclContext has external storage containing additional declarations that are lexically i...
Definition: DeclBase.h:2647
void setUseQualifiedLookup(bool use=true) const
Definition: DeclBase.h:2678
DeclContext * getEnclosingNamespaceContext()
Retrieve the nearest enclosing namespace context.
Definition: DeclBase.cpp:1939
Decl * LastDecl
LastDecl - The last declaration stored within this declaration context.
Definition: DeclBase.h:2052
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:2583
decl_range noload_decls() const
noload_decls_begin/end - Iterate over the declarations stored in this context that are currently load...
Definition: DeclBase.h:2340
DeclContext * getPrimaryContext()
getPrimaryContext - There may be many different declarations of the same entity (including forward de...
Definition: DeclBase.cpp:1355
RecordDecl * getOuterLexicalRecordContext()
Retrieve the outermost lexically enclosing record context.
Definition: DeclBase.cpp:1947
const DeclContext * getEnclosingNamespaceContext() const
Definition: DeclBase.h:2244
bool decls_empty() const
Definition: DeclBase.cpp:1561
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
Definition: DeclBase.h:2332
bool isInlineNamespace() const
Definition: DeclBase.cpp:1244
DeclContextBitfields DeclContextBits
Definition: DeclBase.h:2008
bool isFunctionOrMethod() const
Definition: DeclBase.h:2128
void setHasExternalLexicalStorage(bool ES=true) const
State whether this DeclContext has external storage for declarations lexically in this context.
Definition: DeclBase.h:2653
DeclContext * getLookupParent()
Find the parent context of this context that will be used for unqualified name lookup.
Definition: DeclBase.cpp:1216
bool isExternCContext() const
Determines whether this context or some of its ancestors is a linkage specification context that spec...
Definition: DeclBase.cpp:1316
all_lookups_iterator noload_lookups_end() const
const LinkageSpecDecl * getExternCContext() const
Retrieve the nearest enclosing C linkage specification context.
Definition: DeclBase.cpp:1320
LinkageSpecDeclBitfields LinkageSpecDeclBits
Definition: DeclBase.h:2017
decl_iterator noload_decls_end() const
Definition: DeclBase.h:2344
StoredDeclsMap * getLookupPtr() const
Retrieve the internal representation of the lookup structure.
Definition: DeclBase.h:2640
bool Encloses(const DeclContext *DC) const
Determine whether this declaration context encloses the declaration context DC.
Definition: DeclBase.cpp:1335
void addHiddenDecl(Decl *D)
Add the declaration D to this context without modifying any lookup tables.
Definition: DeclBase.cpp:1673
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:1882
OMPDeclareReductionDeclBitfields OMPDeclareReductionDeclBits
Definition: DeclBase.h:2012
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:2673
Decl::Kind getDeclKind() const
Definition: DeclBase.h:2069
DeclContext * getNonTransparentContext()
Definition: DeclBase.cpp:1346
decl_iterator decls_begin() const
Definition: DeclBase.cpp:1555
const DeclContext * getLexicalParent() const
Definition: DeclBase.h:2095
std::forward_iterator_tag iterator_category
Definition: DeclBase.h:1342
reference operator*() const
Definition: DeclBase.h:1346
bool operator==(const iterator &X) const
Definition: DeclBase.h:1353
bool operator!=(const iterator &X) const
Definition: DeclBase.h:1354
A list storing NamedDecls in the lookup tables.
Definition: DeclBase.h:1326
llvm::PointerUnion< NamedDecl *, DeclListNode * > Decls
Definition: DeclBase.h:1330
Iterates through all the redeclarations of the same decl.
Definition: DeclBase.h:1003
friend bool operator!=(redecl_iterator x, redecl_iterator y)
Definition: DeclBase.h:1040
value_type operator->() const
Definition: DeclBase.h:1019
redecl_iterator & operator++()
Definition: DeclBase.h:1021
redecl_iterator operator++(int)
Definition: DeclBase.h:1030
friend bool operator==(redecl_iterator x, redecl_iterator y)
Definition: DeclBase.h:1036
std::ptrdiff_t difference_type
Definition: DeclBase.h:1013
reference operator*() const
Definition: DeclBase.h:1018
std::forward_iterator_tag iterator_category
Definition: DeclBase.h:1012
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:1061
Decl * getMostRecentDecl()
Retrieve the most recent declaration that declares the same entity as this declaration (which may be ...
Definition: DeclBase.h:1076
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:647
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:798
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:1226
bool isFunctionOrFunctionTemplate() const
Whether this declaration is a function or function template.
Definition: DeclBase.h:1119
T * getAttr() const
Definition: DeclBase.h:578
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:598
void setAttrs(const AttrVec &Attrs)
Definition: DeclBase.h:525
void dropAttrs()
Definition: DeclBase.h:551
bool isUnavailable(std::string *Message=nullptr) const
Determine whether this declaration is marked 'unavailable'.
Definition: DeclBase.h:764
bool hasLocalOwningModuleStorage() const
Definition: DeclBase.cpp:119
void dumpColor() const
Definition: ASTDumper.cpp:239
const Decl * getPreviousDecl() const
Retrieve the previous declaration that declares the same entity as this declaration,...
Definition: DeclBase.h:1065
bool isFunctionPointerType() const
Definition: DeclBase.cpp:1136
const TranslationUnitDecl * getTranslationUnitDecl() const
Definition: DeclBase.h:481
virtual ~Decl()
bool isReachable() const
Definition: DeclBase.h:863
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:708
void setLocalExternDecl()
Changes the namespace of this declaration to reflect that it's a function-local extern declaration.
Definition: DeclBase.h:1151
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:995
Module * getOwningModuleForLinkage(bool IgnoreLinkage=false) const
Get the module that owns this declaration for linkage purposes.
Definition: Decl.cpp:1624
Decl(Kind DK, EmptyShell Empty)
Definition: DeclBase.h:404
llvm::iterator_range< redecl_iterator > redecl_range
Definition: DeclBase.h:1045
const Decl * getCanonicalDecl() const
Definition: DeclBase.h:979
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:876
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:859
DeclContext * getParentFunctionOrMethod(bool LexicalParent=false)
Definition: DeclBase.h:971
Kind
Lists the kind of concrete classes of Decl.
Definition: DeclBase.h:88
void clearIdentifierNamespace()
Clears the namespace of this declaration.
Definition: DeclBase.h:1214
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:637
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:1087
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:893
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:1219
@ FOK_None
Not a friend object.
Definition: DeclBase.h:1217
@ FOK_Declared
A friend of a previously-declared entity.
Definition: DeclBase.h:1218
Decl * getNextDeclInContext()
Definition: DeclBase.h:450
bool isInvisibleOutsideTheOwningModule() const
Definition: DeclBase.h:665
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:1074
SourceLocation getBodyRBrace() const
getBodyRBrace - Gets the right brace of the body, if a body exists.
Definition: DeclBase.cpp:1029
static bool isTagIdentifierNamespace(unsigned NS)
Definition: DeclBase.h:903
int64_t getID() const
Definition: DeclBase.cpp:1113
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:1117
bool isCanonicalDecl() const
Whether this particular Decl is a canonical one.
Definition: DeclBase.h:984
bool isInAnotherModuleUnit() const
Whether this declaration comes from another module unit.
Definition: DeclBase.cpp:1083
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:843
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:1070
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:813
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:1016
void setOwningModuleID(unsigned ID)
Set the owning module ID.
Definition: DeclBase.h:714
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:220
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:1180
bool isFromASTFile() const
Determine whether this declaration came from an AST file (such as a precompiled header or module) rat...
Definition: DeclBase.h:786
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:2749
DeclContext * getNonTransparentDeclContext()
Return the non transparent context.
Definition: DeclBase.cpp:1148
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:1093
Decl * getNonClosureContext()
Find the innermost non-closure ancestor of this declaration, walking up through blocks,...
Definition: DeclBase.cpp:1174
bool isInvalidDecl() const
Definition: DeclBase.h:593
unsigned getIdentifierNamespace() const
Definition: DeclBase.h:889
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:1080
virtual Decl * getNextRedeclarationImpl()
Returns the next redeclaration or itself if this is the only decl.
Definition: DeclBase.h:991
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:1169
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
Definition: DeclBase.h:564
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:1057
bool shouldSkipCheckingODR() const
Check if we should skip checking ODRHash for declaration.
Definition: DeclBase.cpp:1105
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:755
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:830
const DeclContext * getNonTransparentDeclContext() const
Definition: DeclBase.h:466
void setImplicit(bool I=true)
Definition: DeclBase.h:599
void setReferenced(bool R=true)
Definition: DeclBase.h:628
const DeclContext * getLexicalDeclContext() const
Definition: DeclBase.h:923
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:626
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Definition: DeclBase.h:1049
void setIsUsed()
Set whether the declaration is used, in the sense of odr-use.
Definition: DeclBase.h:613
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:633
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:949
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:1053
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:574
virtual Decl * getMostRecentDeclImpl()
Implementation of getMostRecentDecl(), to be overridden by any subclass that has a redeclaration chai...
Definition: DeclBase.h:999
bool hasOwningModule() const
Is this declaration owned by some module?
Definition: DeclBase.h:838
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:696
void dropAttr()
Definition: DeclBase.h:561
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:569
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:899
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
Definition: DeclBase.h:918
bool hasAttr() const
Definition: DeclBase.h:582
friend class DeclContext
Definition: DeclBase.h:251
void setNonMemberOperator()
Specifies that this declaration is a C++ overloaded non-member.
Definition: DeclBase.h:1235
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:790
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclBase.h:978
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:881
Module * getLocalOwningModule() const
Get the local owning module, if known.
Definition: DeclBase.h:822
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:1242
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:870
bool isDiscardedInGlobalModuleFragment() const
FIXME: Implement discarding declarations actually in global module fragment.
Definition: DeclBase.h:674
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:1959
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3799
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:418
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:249
PrettyStackTraceDecl - If a crash occurs, indicate that it happened when doing something to a specifi...
Definition: DeclBase.h:1297
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:1304
A (possibly-)qualified type.
Definition: Type.h:737
Represents a struct/union/class.
Definition: Decl.h:4133
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:394
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:73
The top declaration context.
Definition: Decl.h:84
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
The JSON file list parser is used to communicate input to InstallAPI.
ASTDumpOutputFormat
Used to specify the format for printing AST dump information.
@ ADOF_Default
bool isa(CodeGen::Address addr)
Definition: Address.h:155
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:245
ObjCMethodFamily
A family of Objective-C methods.
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:5842
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:4110
@ ObjCMethodFamilyBitWidth
DeductionCandidate
Only used by CXXDeductionGuideDecl.
Definition: DeclBase.h:1418
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Definition: DeclBase.h:1285
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:120
@ AS_none
Definition: Specifiers.h:124
unsigned long uint64_t
YAML serialization mapping.
Definition: Dominators.h:30
Definition: Format.h:5304
#define true
Definition: stdbool.h:21
#define false
Definition: stdbool.h:22
UsingDirectiveDecl * operator*() const
Definition: DeclBase.cpp:2067
udir_iterator(lookup_iterator I)
Definition: DeclBase.h:2608
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:2774
static const ToTy * doit(const DeclContext *Val)
Definition: DeclBase.h:2770
static const ToTy * doit(const DeclContext *Val)
Definition: DeclBase.h:2758
static ToTy * doit(DeclContext *Val)
Definition: DeclBase.h:2762
static void * getAsVoidPointer(::clang::NamedDecl *P)
Definition: DeclBase.h:1316
static inline ::clang::NamedDecl * getFromVoidPointer(void *P)
Definition: DeclBase.h:1317
::clang::DeclContext & doit(const FromTy &Val)
Definition: DeclBase.h:2825
::clang::DeclContext * doit(const FromTy *Val)
Definition: DeclBase.h:2832
static const ::clang::DeclContext & doit(const FromTy &Val)
Definition: DeclBase.h:2839
static const ::clang::DeclContext * doit(const FromTy *Val)
Definition: DeclBase.h:2846
static bool doit(const ::clang::DeclContext &Val)
Definition: DeclBase.h:2786