1 //===--- Decl.h - Classes for representing declarations ---------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the Decl subclasses.
12 //===----------------------------------------------------------------------===//
14 #ifndef LLVM_CLANG_AST_DECL_H
15 #define LLVM_CLANG_AST_DECL_H
17 #include "clang/AST/APValue.h"
18 #include "clang/AST/DeclBase.h"
19 #include "clang/AST/DeclarationName.h"
20 #include "clang/AST/ExternalASTSource.h"
21 #include "clang/AST/Redeclarable.h"
22 #include "clang/AST/Type.h"
23 #include "clang/Basic/Linkage.h"
24 #include "clang/Basic/OperatorKinds.h"
25 #include "llvm/ADT/ArrayRef.h"
26 #include "llvm/ADT/Optional.h"
27 #include "llvm/Support/Compiler.h"
28 #include "llvm/Support/raw_ostream.h"
31 struct ASTTemplateArgumentListInfo;
34 class DependentFunctionTemplateSpecializationInfo;
36 class FunctionTemplateDecl;
37 class FunctionTemplateSpecializationInfo;
39 class MemberSpecializationInfo;
41 class NestedNameSpecifier;
44 class TemplateArgumentList;
45 class TemplateParameterList;
47 class UnresolvedSetImpl;
48 class VarTemplateDecl;
50 /// \brief A container of type source information.
52 /// A client can read the relevant info using TypeLoc wrappers, e.g:
54 /// TypeLoc TL = TypeSourceInfo->getTypeLoc();
55 /// TL.getStartLoc().print(OS, SrcMgr);
58 class TypeSourceInfo {
60 // Contains a memory block after the class, used for type source information,
61 // allocated by ASTContext.
62 friend class ASTContext;
63 TypeSourceInfo(QualType ty) : Ty(ty) { }
65 /// \brief Return the type wrapped by this type source info.
66 QualType getType() const { return Ty; }
68 /// \brief Return the TypeLoc wrapper for the type source info.
69 TypeLoc getTypeLoc() const; // implemented in TypeLoc.h
72 /// TranslationUnitDecl - The top declaration context.
73 class TranslationUnitDecl : public Decl, public DeclContext {
74 virtual void anchor();
77 /// The (most recently entered) anonymous namespace for this
78 /// translation unit, if one has been created.
79 NamespaceDecl *AnonymousNamespace;
81 explicit TranslationUnitDecl(ASTContext &ctx)
82 : Decl(TranslationUnit, nullptr, SourceLocation()),
83 DeclContext(TranslationUnit),
84 Ctx(ctx), AnonymousNamespace(nullptr) {}
86 ASTContext &getASTContext() const { return Ctx; }
88 NamespaceDecl *getAnonymousNamespace() const { return AnonymousNamespace; }
89 void setAnonymousNamespace(NamespaceDecl *D) { AnonymousNamespace = D; }
91 static TranslationUnitDecl *Create(ASTContext &C);
92 // Implement isa/cast/dyncast/etc.
93 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
94 static bool classofKind(Kind K) { return K == TranslationUnit; }
95 static DeclContext *castToDeclContext(const TranslationUnitDecl *D) {
96 return static_cast<DeclContext *>(const_cast<TranslationUnitDecl*>(D));
98 static TranslationUnitDecl *castFromDeclContext(const DeclContext *DC) {
99 return static_cast<TranslationUnitDecl *>(const_cast<DeclContext*>(DC));
103 /// NamedDecl - This represents a decl with a name. Many decls have names such
104 /// as ObjCMethodDecl, but not \@class, etc.
105 class NamedDecl : public Decl {
106 virtual void anchor();
107 /// Name - The name of this declaration, which is typically a normal
108 /// identifier but may also be a special kind of name (C++
109 /// constructor, Objective-C selector, etc.)
110 DeclarationName Name;
113 NamedDecl *getUnderlyingDeclImpl() LLVM_READONLY;
116 NamedDecl(Kind DK, DeclContext *DC, SourceLocation L, DeclarationName N)
117 : Decl(DK, DC, L), Name(N) { }
120 /// getIdentifier - Get the identifier that names this declaration,
121 /// if there is one. This will return NULL if this declaration has
122 /// no name (e.g., for an unnamed class) or if the name is a special
123 /// name (C++ constructor, Objective-C selector, etc.).
124 IdentifierInfo *getIdentifier() const { return Name.getAsIdentifierInfo(); }
126 /// getName - Get the name of identifier for this declaration as a StringRef.
127 /// This requires that the declaration have a name and that it be a simple
129 StringRef getName() const {
130 assert(Name.isIdentifier() && "Name is not a simple identifier");
131 return getIdentifier() ? getIdentifier()->getName() : "";
134 /// getNameAsString - Get a human-readable name for the declaration, even if
135 /// it is one of the special kinds of names (C++ constructor, Objective-C
136 /// selector, etc). Creating this name requires expensive string
137 /// manipulation, so it should be called only when performance doesn't matter.
138 /// For simple declarations, getNameAsCString() should suffice.
140 // FIXME: This function should be renamed to indicate that it is not just an
141 // alternate form of getName(), and clients should move as appropriate.
143 // FIXME: Deprecated, move clients to getName().
144 std::string getNameAsString() const { return Name.getAsString(); }
146 void printName(raw_ostream &os) const { os << Name; }
148 /// getDeclName - Get the actual, stored name of the declaration,
149 /// which may be a special name.
150 DeclarationName getDeclName() const { return Name; }
152 /// \brief Set the name of this declaration.
153 void setDeclName(DeclarationName N) { Name = N; }
155 /// printQualifiedName - Returns human-readable qualified name for
156 /// declaration, like A::B::i, for i being member of namespace A::B.
157 /// If declaration is not member of context which can be named (record,
158 /// namespace), it will return same result as printName().
159 /// Creating this name is expensive, so it should be called only when
160 /// performance doesn't matter.
161 void printQualifiedName(raw_ostream &OS) const;
162 void printQualifiedName(raw_ostream &OS, const PrintingPolicy &Policy) const;
164 // FIXME: Remove string version.
165 std::string getQualifiedNameAsString() const;
167 /// getNameForDiagnostic - Appends a human-readable name for this
168 /// declaration into the given stream.
170 /// This is the method invoked by Sema when displaying a NamedDecl
171 /// in a diagnostic. It does not necessarily produce the same
172 /// result as printName(); for example, class template
173 /// specializations are printed with their template arguments.
174 virtual void getNameForDiagnostic(raw_ostream &OS,
175 const PrintingPolicy &Policy,
176 bool Qualified) const;
178 /// declarationReplaces - Determine whether this declaration, if
179 /// known to be well-formed within its context, will replace the
180 /// declaration OldD if introduced into scope. A declaration will
181 /// replace another declaration if, for example, it is a
182 /// redeclaration of the same variable or function, but not if it is
183 /// a declaration of a different kind (function vs. class) or an
184 /// overloaded function.
185 bool declarationReplaces(NamedDecl *OldD) const;
187 /// \brief Determine whether this declaration has linkage.
188 bool hasLinkage() const;
190 using Decl::isModulePrivate;
191 using Decl::setModulePrivate;
193 /// \brief Determine whether this declaration is hidden from name lookup.
194 bool isHidden() const { return Hidden; }
196 /// \brief Set whether this declaration is hidden from name lookup.
197 void setHidden(bool Hide) { Hidden = Hide; }
199 /// \brief Determine whether this declaration is a C++ class member.
200 bool isCXXClassMember() const {
201 const DeclContext *DC = getDeclContext();
203 // C++0x [class.mem]p1:
204 // The enumerators of an unscoped enumeration defined in
205 // the class are members of the class.
206 if (isa<EnumDecl>(DC))
207 DC = DC->getRedeclContext();
209 return DC->isRecord();
212 /// \brief Determine whether the given declaration is an instance member of
214 bool isCXXInstanceMember() const;
216 /// \brief Determine what kind of linkage this entity has.
217 /// This is not the linkage as defined by the standard or the codegen notion
218 /// of linkage. It is just an implementation detail that is used to compute
220 Linkage getLinkageInternal() const;
222 /// \brief Get the linkage from a semantic point of view. Entities in
223 /// anonymous namespaces are external (in c++98).
224 Linkage getFormalLinkage() const {
225 return clang::getFormalLinkage(getLinkageInternal());
228 /// \brief True if this decl has external linkage.
229 bool hasExternalFormalLinkage() const {
230 return isExternalFormalLinkage(getLinkageInternal());
233 bool isExternallyVisible() const {
234 return clang::isExternallyVisible(getLinkageInternal());
237 /// \brief Determines the visibility of this entity.
238 Visibility getVisibility() const {
239 return getLinkageAndVisibility().getVisibility();
242 /// \brief Determines the linkage and visibility of this entity.
243 LinkageInfo getLinkageAndVisibility() const;
245 /// Kinds of explicit visibility.
246 enum ExplicitVisibilityKind {
251 /// \brief If visibility was explicitly specified for this
252 /// declaration, return that visibility.
254 getExplicitVisibility(ExplicitVisibilityKind kind) const;
256 /// \brief True if the computed linkage is valid. Used for consistency
257 /// checking. Should always return true.
258 bool isLinkageValid() const;
260 /// \brief True if something has required us to compute the linkage
261 /// of this declaration.
263 /// Language features which can retroactively change linkage (like a
264 /// typedef name for linkage purposes) may need to consider this,
265 /// but hopefully only in transitory ways during parsing.
266 bool hasLinkageBeenComputed() const {
267 return hasCachedLinkage();
270 /// \brief Looks through UsingDecls and ObjCCompatibleAliasDecls for
271 /// the underlying named decl.
272 NamedDecl *getUnderlyingDecl() {
273 // Fast-path the common case.
274 if (this->getKind() != UsingShadow &&
275 this->getKind() != ObjCCompatibleAlias)
278 return getUnderlyingDeclImpl();
280 const NamedDecl *getUnderlyingDecl() const {
281 return const_cast<NamedDecl*>(this)->getUnderlyingDecl();
284 NamedDecl *getMostRecentDecl() {
285 return cast<NamedDecl>(static_cast<Decl *>(this)->getMostRecentDecl());
287 const NamedDecl *getMostRecentDecl() const {
288 return const_cast<NamedDecl*>(this)->getMostRecentDecl();
291 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
292 static bool classofKind(Kind K) { return K >= firstNamed && K <= lastNamed; }
295 inline raw_ostream &operator<<(raw_ostream &OS, const NamedDecl &ND) {
300 /// LabelDecl - Represents the declaration of a label. Labels also have a
301 /// corresponding LabelStmt, which indicates the position that the label was
302 /// defined at. For normal labels, the location of the decl is the same as the
303 /// location of the statement. For GNU local labels (__label__), the decl
304 /// location is where the __label__ is.
305 class LabelDecl : public NamedDecl {
306 void anchor() override;
308 /// LocStart - For normal labels, this is the same as the main declaration
309 /// label, i.e., the location of the identifier; for GNU local labels,
310 /// this is the location of the __label__ keyword.
311 SourceLocation LocStart;
313 LabelDecl(DeclContext *DC, SourceLocation IdentL, IdentifierInfo *II,
314 LabelStmt *S, SourceLocation StartL)
315 : NamedDecl(Label, DC, IdentL, II), TheStmt(S), LocStart(StartL) {}
318 static LabelDecl *Create(ASTContext &C, DeclContext *DC,
319 SourceLocation IdentL, IdentifierInfo *II);
320 static LabelDecl *Create(ASTContext &C, DeclContext *DC,
321 SourceLocation IdentL, IdentifierInfo *II,
322 SourceLocation GnuLabelL);
323 static LabelDecl *CreateDeserialized(ASTContext &C, unsigned ID);
325 LabelStmt *getStmt() const { return TheStmt; }
326 void setStmt(LabelStmt *T) { TheStmt = T; }
328 bool isGnuLocal() const { return LocStart != getLocation(); }
329 void setLocStart(SourceLocation L) { LocStart = L; }
331 SourceRange getSourceRange() const override LLVM_READONLY {
332 return SourceRange(LocStart, getLocation());
335 // Implement isa/cast/dyncast/etc.
336 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
337 static bool classofKind(Kind K) { return K == Label; }
340 /// NamespaceDecl - Represent a C++ namespace.
341 class NamespaceDecl : public NamedDecl, public DeclContext,
342 public Redeclarable<NamespaceDecl>
344 /// LocStart - The starting location of the source range, pointing
345 /// to either the namespace or the inline keyword.
346 SourceLocation LocStart;
347 /// RBraceLoc - The ending location of the source range.
348 SourceLocation RBraceLoc;
350 /// \brief A pointer to either the anonymous namespace that lives just inside
351 /// this namespace or to the first namespace in the chain (the latter case
352 /// only when this is not the first in the chain), along with a
353 /// boolean value indicating whether this is an inline namespace.
354 llvm::PointerIntPair<NamespaceDecl *, 1, bool> AnonOrFirstNamespaceAndInline;
356 NamespaceDecl(ASTContext &C, DeclContext *DC, bool Inline,
357 SourceLocation StartLoc, SourceLocation IdLoc,
358 IdentifierInfo *Id, NamespaceDecl *PrevDecl);
360 typedef Redeclarable<NamespaceDecl> redeclarable_base;
361 NamespaceDecl *getNextRedeclarationImpl() override;
362 NamespaceDecl *getPreviousDeclImpl() override;
363 NamespaceDecl *getMostRecentDeclImpl() override;
366 static NamespaceDecl *Create(ASTContext &C, DeclContext *DC,
367 bool Inline, SourceLocation StartLoc,
368 SourceLocation IdLoc, IdentifierInfo *Id,
369 NamespaceDecl *PrevDecl);
371 static NamespaceDecl *CreateDeserialized(ASTContext &C, unsigned ID);
373 typedef redeclarable_base::redecl_range redecl_range;
374 typedef redeclarable_base::redecl_iterator redecl_iterator;
375 using redeclarable_base::redecls_begin;
376 using redeclarable_base::redecls_end;
377 using redeclarable_base::redecls;
378 using redeclarable_base::getPreviousDecl;
379 using redeclarable_base::getMostRecentDecl;
380 using redeclarable_base::isFirstDecl;
382 /// \brief Returns true if this is an anonymous namespace declaration.
390 /// q.v. C++ [namespace.unnamed]
391 bool isAnonymousNamespace() const {
392 return !getIdentifier();
395 /// \brief Returns true if this is an inline namespace declaration.
396 bool isInline() const {
397 return AnonOrFirstNamespaceAndInline.getInt();
400 /// \brief Set whether this is an inline namespace declaration.
401 void setInline(bool Inline) {
402 AnonOrFirstNamespaceAndInline.setInt(Inline);
405 /// \brief Get the original (first) namespace declaration.
406 NamespaceDecl *getOriginalNamespace() {
410 return AnonOrFirstNamespaceAndInline.getPointer();
413 /// \brief Get the original (first) namespace declaration.
414 const NamespaceDecl *getOriginalNamespace() const {
418 return AnonOrFirstNamespaceAndInline.getPointer();
421 /// \brief Return true if this declaration is an original (first) declaration
422 /// of the namespace. This is false for non-original (subsequent) namespace
423 /// declarations and anonymous namespaces.
424 bool isOriginalNamespace() const { return isFirstDecl(); }
426 /// \brief Retrieve the anonymous namespace nested inside this namespace,
428 NamespaceDecl *getAnonymousNamespace() const {
429 return getOriginalNamespace()->AnonOrFirstNamespaceAndInline.getPointer();
432 void setAnonymousNamespace(NamespaceDecl *D) {
433 getOriginalNamespace()->AnonOrFirstNamespaceAndInline.setPointer(D);
436 /// Retrieves the canonical declaration of this namespace.
437 NamespaceDecl *getCanonicalDecl() override {
438 return getOriginalNamespace();
440 const NamespaceDecl *getCanonicalDecl() const {
441 return getOriginalNamespace();
444 SourceRange getSourceRange() const override LLVM_READONLY {
445 return SourceRange(LocStart, RBraceLoc);
448 SourceLocation getLocStart() const LLVM_READONLY { return LocStart; }
449 SourceLocation getRBraceLoc() const { return RBraceLoc; }
450 void setLocStart(SourceLocation L) { LocStart = L; }
451 void setRBraceLoc(SourceLocation L) { RBraceLoc = L; }
453 // Implement isa/cast/dyncast/etc.
454 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
455 static bool classofKind(Kind K) { return K == Namespace; }
456 static DeclContext *castToDeclContext(const NamespaceDecl *D) {
457 return static_cast<DeclContext *>(const_cast<NamespaceDecl*>(D));
459 static NamespaceDecl *castFromDeclContext(const DeclContext *DC) {
460 return static_cast<NamespaceDecl *>(const_cast<DeclContext*>(DC));
463 friend class ASTDeclReader;
464 friend class ASTDeclWriter;
467 /// ValueDecl - Represent the declaration of a variable (in which case it is
468 /// an lvalue) a function (in which case it is a function designator) or
469 /// an enum constant.
470 class ValueDecl : public NamedDecl {
471 void anchor() override;
475 ValueDecl(Kind DK, DeclContext *DC, SourceLocation L,
476 DeclarationName N, QualType T)
477 : NamedDecl(DK, DC, L, N), DeclType(T) {}
479 QualType getType() const { return DeclType; }
480 void setType(QualType newType) { DeclType = newType; }
482 /// \brief Determine whether this symbol is weakly-imported,
483 /// or declared with the weak or weak-ref attr.
486 // Implement isa/cast/dyncast/etc.
487 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
488 static bool classofKind(Kind K) { return K >= firstValue && K <= lastValue; }
491 /// QualifierInfo - A struct with extended info about a syntactic
492 /// name qualifier, to be used for the case of out-of-line declarations.
493 struct QualifierInfo {
494 NestedNameSpecifierLoc QualifierLoc;
496 /// NumTemplParamLists - The number of "outer" template parameter lists.
497 /// The count includes all of the template parameter lists that were matched
498 /// against the template-ids occurring into the NNS and possibly (in the
499 /// case of an explicit specialization) a final "template <>".
500 unsigned NumTemplParamLists;
502 /// TemplParamLists - A new-allocated array of size NumTemplParamLists,
503 /// containing pointers to the "outer" template parameter lists.
504 /// It includes all of the template parameter lists that were matched
505 /// against the template-ids occurring into the NNS and possibly (in the
506 /// case of an explicit specialization) a final "template <>".
507 TemplateParameterList** TemplParamLists;
509 /// Default constructor.
511 : QualifierLoc(), NumTemplParamLists(0), TemplParamLists(nullptr) {}
513 /// setTemplateParameterListsInfo - Sets info about "outer" template
515 void setTemplateParameterListsInfo(ASTContext &Context,
517 TemplateParameterList **TPLists);
520 // Copy constructor and copy assignment are disabled.
521 QualifierInfo(const QualifierInfo&) LLVM_DELETED_FUNCTION;
522 QualifierInfo& operator=(const QualifierInfo&) LLVM_DELETED_FUNCTION;
525 /// \brief Represents a ValueDecl that came out of a declarator.
526 /// Contains type source information through TypeSourceInfo.
527 class DeclaratorDecl : public ValueDecl {
528 // A struct representing both a TInfo and a syntactic qualifier,
529 // to be used for the (uncommon) case of out-of-line declarations.
530 struct ExtInfo : public QualifierInfo {
531 TypeSourceInfo *TInfo;
534 llvm::PointerUnion<TypeSourceInfo*, ExtInfo*> DeclInfo;
536 /// InnerLocStart - The start of the source range for this declaration,
537 /// ignoring outer template declarations.
538 SourceLocation InnerLocStart;
540 bool hasExtInfo() const { return DeclInfo.is<ExtInfo*>(); }
541 ExtInfo *getExtInfo() { return DeclInfo.get<ExtInfo*>(); }
542 const ExtInfo *getExtInfo() const { return DeclInfo.get<ExtInfo*>(); }
545 DeclaratorDecl(Kind DK, DeclContext *DC, SourceLocation L,
546 DeclarationName N, QualType T, TypeSourceInfo *TInfo,
547 SourceLocation StartL)
548 : ValueDecl(DK, DC, L, N, T), DeclInfo(TInfo), InnerLocStart(StartL) {
552 TypeSourceInfo *getTypeSourceInfo() const {
554 ? getExtInfo()->TInfo
555 : DeclInfo.get<TypeSourceInfo*>();
557 void setTypeSourceInfo(TypeSourceInfo *TI) {
559 getExtInfo()->TInfo = TI;
564 /// getInnerLocStart - Return SourceLocation representing start of source
565 /// range ignoring outer template declarations.
566 SourceLocation getInnerLocStart() const { return InnerLocStart; }
567 void setInnerLocStart(SourceLocation L) { InnerLocStart = L; }
569 /// getOuterLocStart - Return SourceLocation representing start of source
570 /// range taking into account any outer template declarations.
571 SourceLocation getOuterLocStart() const;
573 SourceRange getSourceRange() const override LLVM_READONLY;
574 SourceLocation getLocStart() const LLVM_READONLY {
575 return getOuterLocStart();
578 /// \brief Retrieve the nested-name-specifier that qualifies the name of this
579 /// declaration, if it was present in the source.
580 NestedNameSpecifier *getQualifier() const {
581 return hasExtInfo() ? getExtInfo()->QualifierLoc.getNestedNameSpecifier()
585 /// \brief Retrieve the nested-name-specifier (with source-location
586 /// information) that qualifies the name of this declaration, if it was
587 /// present in the source.
588 NestedNameSpecifierLoc getQualifierLoc() const {
589 return hasExtInfo() ? getExtInfo()->QualifierLoc
590 : NestedNameSpecifierLoc();
593 void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc);
595 unsigned getNumTemplateParameterLists() const {
596 return hasExtInfo() ? getExtInfo()->NumTemplParamLists : 0;
598 TemplateParameterList *getTemplateParameterList(unsigned index) const {
599 assert(index < getNumTemplateParameterLists());
600 return getExtInfo()->TemplParamLists[index];
602 void setTemplateParameterListsInfo(ASTContext &Context, unsigned NumTPLists,
603 TemplateParameterList **TPLists);
605 SourceLocation getTypeSpecStartLoc() const;
607 // Implement isa/cast/dyncast/etc.
608 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
609 static bool classofKind(Kind K) {
610 return K >= firstDeclarator && K <= lastDeclarator;
613 friend class ASTDeclReader;
614 friend class ASTDeclWriter;
617 /// \brief Structure used to store a statement, the constant value to
618 /// which it was evaluated (if any), and whether or not the statement
619 /// is an integral constant expression (if known).
620 struct EvaluatedStmt {
621 EvaluatedStmt() : WasEvaluated(false), IsEvaluating(false), CheckedICE(false),
622 CheckingICE(false), IsICE(false) { }
624 /// \brief Whether this statement was already evaluated.
625 bool WasEvaluated : 1;
627 /// \brief Whether this statement is being evaluated.
628 bool IsEvaluating : 1;
630 /// \brief Whether we already checked whether this statement was an
631 /// integral constant expression.
634 /// \brief Whether we are checking whether this statement is an
635 /// integral constant expression.
636 bool CheckingICE : 1;
638 /// \brief Whether this statement is an integral constant expression,
639 /// or in C++11, whether the statement is a constant expression. Only
640 /// valid if CheckedICE is true.
647 /// VarDecl - An instance of this class is created to represent a variable
648 /// declaration or definition.
649 class VarDecl : public DeclaratorDecl, public Redeclarable<VarDecl> {
651 typedef clang::StorageClass StorageClass;
653 /// getStorageClassSpecifierString - Return the string used to
654 /// specify the storage class \p SC.
656 /// It is illegal to call this function with SC == None.
657 static const char *getStorageClassSpecifierString(StorageClass SC);
659 /// \brief Initialization styles.
660 enum InitializationStyle {
661 CInit, ///< C-style initialization with assignment
662 CallInit, ///< Call-style initialization (C++98)
663 ListInit ///< Direct list-initialization (C++11)
666 /// \brief Kinds of thread-local storage.
668 TLS_None, ///< Not a TLS variable.
669 TLS_Static, ///< TLS with a known-constant initializer.
670 TLS_Dynamic ///< TLS with a dynamic initializer.
674 /// \brief Placeholder type used in Init to denote an unparsed C++ default
676 struct UnparsedDefaultArgument;
678 /// \brief Placeholder type used in Init to denote an uninstantiated C++
679 /// default argument.
680 struct UninstantiatedDefaultArgument;
682 typedef llvm::PointerUnion4<Stmt *, EvaluatedStmt *,
683 UnparsedDefaultArgument *,
684 UninstantiatedDefaultArgument *> InitType;
686 /// \brief The initializer for this variable or, for a ParmVarDecl, the
687 /// C++ default argument.
688 mutable InitType Init;
691 class VarDeclBitfields {
692 friend class VarDecl;
693 friend class ASTDeclReader;
696 unsigned TSCSpec : 2;
697 unsigned InitStyle : 2;
699 /// \brief Whether this variable is the exception variable in a C++ catch
700 /// or an Objective-C @catch statement.
701 unsigned ExceptionVar : 1;
703 /// \brief Whether this local variable could be allocated in the return
704 /// slot of its function, enabling the named return value optimization
706 unsigned NRVOVariable : 1;
708 /// \brief Whether this variable is the for-range-declaration in a C++0x
709 /// for-range statement.
710 unsigned CXXForRangeDecl : 1;
712 /// \brief Whether this variable is an ARC pseudo-__strong
713 /// variable; see isARCPseudoStrong() for details.
714 unsigned ARCPseudoStrong : 1;
716 /// \brief Whether this variable is (C++0x) constexpr.
717 unsigned IsConstexpr : 1;
719 /// \brief Whether this variable is the implicit variable for a lambda
721 unsigned IsInitCapture : 1;
723 /// \brief Whether this local extern variable's previous declaration was
724 /// declared in the same block scope. This controls whether we should merge
725 /// the type of this declaration with its previous declaration.
726 unsigned PreviousDeclInSameBlockScope : 1;
728 enum { NumVarDeclBits = 14 };
730 friend class ASTDeclReader;
731 friend class StmtIteratorBase;
732 friend class ASTNodeImporter;
735 enum { NumParameterIndexBits = 8 };
737 class ParmVarDeclBitfields {
738 friend class ParmVarDecl;
739 friend class ASTDeclReader;
741 unsigned : NumVarDeclBits;
743 /// Whether this parameter inherits a default argument from a
744 /// prior declaration.
745 unsigned HasInheritedDefaultArg : 1;
747 /// Whether this parameter undergoes K&R argument promotion.
748 unsigned IsKNRPromoted : 1;
750 /// Whether this parameter is an ObjC method parameter or not.
751 unsigned IsObjCMethodParam : 1;
753 /// If IsObjCMethodParam, a Decl::ObjCDeclQualifier.
754 /// Otherwise, the number of function parameter scopes enclosing
755 /// the function parameter scope in which this parameter was
757 unsigned ScopeDepthOrObjCQuals : 7;
759 /// The number of parameters preceding this parameter in the
760 /// function parameter scope in which it was declared.
761 unsigned ParameterIndex : NumParameterIndexBits;
766 VarDeclBitfields VarDeclBits;
767 ParmVarDeclBitfields ParmVarDeclBits;
770 VarDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
771 SourceLocation IdLoc, IdentifierInfo *Id, QualType T,
772 TypeSourceInfo *TInfo, StorageClass SC);
774 typedef Redeclarable<VarDecl> redeclarable_base;
775 VarDecl *getNextRedeclarationImpl() override {
776 return getNextRedeclaration();
778 VarDecl *getPreviousDeclImpl() override {
779 return getPreviousDecl();
781 VarDecl *getMostRecentDeclImpl() override {
782 return getMostRecentDecl();
786 typedef redeclarable_base::redecl_range redecl_range;
787 typedef redeclarable_base::redecl_iterator redecl_iterator;
788 using redeclarable_base::redecls_begin;
789 using redeclarable_base::redecls_end;
790 using redeclarable_base::redecls;
791 using redeclarable_base::getPreviousDecl;
792 using redeclarable_base::getMostRecentDecl;
793 using redeclarable_base::isFirstDecl;
795 static VarDecl *Create(ASTContext &C, DeclContext *DC,
796 SourceLocation StartLoc, SourceLocation IdLoc,
797 IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo,
800 static VarDecl *CreateDeserialized(ASTContext &C, unsigned ID);
802 SourceRange getSourceRange() const override LLVM_READONLY;
804 /// \brief Returns the storage class as written in the source. For the
805 /// computed linkage of symbol, see getLinkage.
806 StorageClass getStorageClass() const {
807 return (StorageClass) VarDeclBits.SClass;
809 void setStorageClass(StorageClass SC);
811 void setTSCSpec(ThreadStorageClassSpecifier TSC) {
812 VarDeclBits.TSCSpec = TSC;
813 assert(VarDeclBits.TSCSpec == TSC && "truncation");
815 ThreadStorageClassSpecifier getTSCSpec() const {
816 return static_cast<ThreadStorageClassSpecifier>(VarDeclBits.TSCSpec);
818 TLSKind getTLSKind() const;
820 /// hasLocalStorage - Returns true if a variable with function scope
821 /// is a non-static local variable.
822 bool hasLocalStorage() const {
823 if (getStorageClass() == SC_None)
824 // Second check is for C++11 [dcl.stc]p4.
825 return !isFileVarDecl() && getTSCSpec() == TSCS_unspecified;
827 // Global Named Register (GNU extension)
828 if (getStorageClass() == SC_Register && !isLocalVarDecl())
831 // Return true for: Auto, Register.
832 // Return false for: Extern, Static, PrivateExtern, OpenCLWorkGroupLocal.
834 return getStorageClass() >= SC_Auto;
837 /// isStaticLocal - Returns true if a variable with function scope is a
838 /// static local variable.
839 bool isStaticLocal() const {
840 return (getStorageClass() == SC_Static ||
842 (getStorageClass() == SC_None && getTSCSpec() == TSCS_thread_local))
846 /// \brief Returns true if a variable has extern or __private_extern__
848 bool hasExternalStorage() const {
849 return getStorageClass() == SC_Extern ||
850 getStorageClass() == SC_PrivateExtern;
853 /// \brief Returns true for all variables that do not have local storage.
855 /// This includes all global variables as well as static variables declared
856 /// within a function.
857 bool hasGlobalStorage() const { return !hasLocalStorage(); }
859 /// \brief Get the storage duration of this variable, per C++ [basic.stc].
860 StorageDuration getStorageDuration() const {
861 return hasLocalStorage() ? SD_Automatic :
862 getTSCSpec() ? SD_Thread : SD_Static;
865 /// \brief Compute the language linkage.
866 LanguageLinkage getLanguageLinkage() const;
868 /// \brief Determines whether this variable is a variable with
869 /// external, C linkage.
870 bool isExternC() const;
872 /// \brief Determines whether this variable's context is, or is nested within,
873 /// a C++ extern "C" linkage spec.
874 bool isInExternCContext() const;
876 /// \brief Determines whether this variable's context is, or is nested within,
877 /// a C++ extern "C++" linkage spec.
878 bool isInExternCXXContext() const;
880 /// isLocalVarDecl - Returns true for local variable declarations
881 /// other than parameters. Note that this includes static variables
882 /// inside of functions. It also includes variables inside blocks.
884 /// void foo() { int x; static int y; extern int z; }
886 bool isLocalVarDecl() const {
887 if (getKind() != Decl::Var)
889 if (const DeclContext *DC = getLexicalDeclContext())
890 return DC->getRedeclContext()->isFunctionOrMethod();
894 /// isFunctionOrMethodVarDecl - Similar to isLocalVarDecl, but
895 /// excludes variables declared in blocks.
896 bool isFunctionOrMethodVarDecl() const {
897 if (getKind() != Decl::Var)
899 const DeclContext *DC = getLexicalDeclContext()->getRedeclContext();
900 return DC->isFunctionOrMethod() && DC->getDeclKind() != Decl::Block;
903 /// \brief Determines whether this is a static data member.
905 /// This will only be true in C++, and applies to, e.g., the
912 bool isStaticDataMember() const {
913 // If it wasn't static, it would be a FieldDecl.
914 return getKind() != Decl::ParmVar && getDeclContext()->isRecord();
917 VarDecl *getCanonicalDecl() override;
918 const VarDecl *getCanonicalDecl() const {
919 return const_cast<VarDecl*>(this)->getCanonicalDecl();
922 enum DefinitionKind {
923 DeclarationOnly, ///< This declaration is only a declaration.
924 TentativeDefinition, ///< This declaration is a tentative definition.
925 Definition ///< This declaration is definitely a definition.
928 /// \brief Check whether this declaration is a definition. If this could be
929 /// a tentative definition (in C), don't check whether there's an overriding
931 DefinitionKind isThisDeclarationADefinition(ASTContext &) const;
932 DefinitionKind isThisDeclarationADefinition() const {
933 return isThisDeclarationADefinition(getASTContext());
936 /// \brief Check whether this variable is defined in this
937 /// translation unit.
938 DefinitionKind hasDefinition(ASTContext &) const;
939 DefinitionKind hasDefinition() const {
940 return hasDefinition(getASTContext());
943 /// \brief Get the tentative definition that acts as the real definition in
944 /// a TU. Returns null if there is a proper definition available.
945 VarDecl *getActingDefinition();
946 const VarDecl *getActingDefinition() const {
947 return const_cast<VarDecl*>(this)->getActingDefinition();
950 /// \brief Get the real (not just tentative) definition for this declaration.
951 VarDecl *getDefinition(ASTContext &);
952 const VarDecl *getDefinition(ASTContext &C) const {
953 return const_cast<VarDecl*>(this)->getDefinition(C);
955 VarDecl *getDefinition() {
956 return getDefinition(getASTContext());
958 const VarDecl *getDefinition() const {
959 return const_cast<VarDecl*>(this)->getDefinition();
962 /// \brief Determine whether this is or was instantiated from an out-of-line
963 /// definition of a static data member.
964 bool isOutOfLine() const override;
966 /// \brief If this is a static data member, find its out-of-line definition.
967 VarDecl *getOutOfLineDefinition();
969 /// isFileVarDecl - Returns true for file scoped variable declaration.
970 bool isFileVarDecl() const {
972 if (K == ParmVar || K == ImplicitParam)
975 if (getLexicalDeclContext()->getRedeclContext()->isFileContext())
978 if (isStaticDataMember())
984 /// getAnyInitializer - Get the initializer for this variable, no matter which
985 /// declaration it is attached to.
986 const Expr *getAnyInitializer() const {
988 return getAnyInitializer(D);
991 /// getAnyInitializer - Get the initializer for this variable, no matter which
992 /// declaration it is attached to. Also get that declaration.
993 const Expr *getAnyInitializer(const VarDecl *&D) const;
995 bool hasInit() const {
996 return !Init.isNull() && (Init.is<Stmt *>() || Init.is<EvaluatedStmt *>());
998 const Expr *getInit() const {
1002 const Stmt *S = Init.dyn_cast<Stmt *>();
1004 if (EvaluatedStmt *ES = Init.dyn_cast<EvaluatedStmt*>())
1007 return (const Expr*) S;
1013 Stmt *S = Init.dyn_cast<Stmt *>();
1015 if (EvaluatedStmt *ES = Init.dyn_cast<EvaluatedStmt*>())
1022 /// \brief Retrieve the address of the initializer expression.
1023 Stmt **getInitAddress() {
1024 if (EvaluatedStmt *ES = Init.dyn_cast<EvaluatedStmt*>())
1027 // This union hack tip-toes around strict-aliasing rules.
1037 void setInit(Expr *I);
1039 /// \brief Determine whether this variable's value can be used in a
1040 /// constant expression, according to the relevant language standard.
1041 /// This only checks properties of the declaration, and does not check
1042 /// whether the initializer is in fact a constant expression.
1043 bool isUsableInConstantExpressions(ASTContext &C) const;
1045 EvaluatedStmt *ensureEvaluatedStmt() const;
1047 /// \brief Attempt to evaluate the value of the initializer attached to this
1048 /// declaration, and produce notes explaining why it cannot be evaluated or is
1049 /// not a constant expression. Returns a pointer to the value if evaluation
1050 /// succeeded, 0 otherwise.
1051 APValue *evaluateValue() const;
1052 APValue *evaluateValue(SmallVectorImpl<PartialDiagnosticAt> &Notes) const;
1054 /// \brief Return the already-evaluated value of this variable's
1055 /// initializer, or NULL if the value is not yet known. Returns pointer
1056 /// to untyped APValue if the value could not be evaluated.
1057 APValue *getEvaluatedValue() const {
1058 if (EvaluatedStmt *Eval = Init.dyn_cast<EvaluatedStmt *>())
1059 if (Eval->WasEvaluated)
1060 return &Eval->Evaluated;
1065 /// \brief Determines whether it is already known whether the
1066 /// initializer is an integral constant expression or not.
1067 bool isInitKnownICE() const {
1068 if (EvaluatedStmt *Eval = Init.dyn_cast<EvaluatedStmt *>())
1069 return Eval->CheckedICE;
1074 /// \brief Determines whether the initializer is an integral constant
1075 /// expression, or in C++11, whether the initializer is a constant
1078 /// \pre isInitKnownICE()
1079 bool isInitICE() const {
1080 assert(isInitKnownICE() &&
1081 "Check whether we already know that the initializer is an ICE");
1082 return Init.get<EvaluatedStmt *>()->IsICE;
1085 /// \brief Determine whether the value of the initializer attached to this
1086 /// declaration is an integral constant expression.
1087 bool checkInitIsICE() const;
1089 void setInitStyle(InitializationStyle Style) {
1090 VarDeclBits.InitStyle = Style;
1093 /// \brief The style of initialization for this declaration.
1095 /// C-style initialization is "int x = 1;". Call-style initialization is
1096 /// a C++98 direct-initializer, e.g. "int x(1);". The Init expression will be
1097 /// the expression inside the parens or a "ClassType(a,b,c)" class constructor
1098 /// expression for class types. List-style initialization is C++11 syntax,
1099 /// e.g. "int x{1};". Clients can distinguish between different forms of
1100 /// initialization by checking this value. In particular, "int x = {1};" is
1101 /// C-style, "int x({1})" is call-style, and "int x{1};" is list-style; the
1102 /// Init expression in all three cases is an InitListExpr.
1103 InitializationStyle getInitStyle() const {
1104 return static_cast<InitializationStyle>(VarDeclBits.InitStyle);
1107 /// \brief Whether the initializer is a direct-initializer (list or call).
1108 bool isDirectInit() const {
1109 return getInitStyle() != CInit;
1112 /// \brief Determine whether this variable is the exception variable in a
1113 /// C++ catch statememt or an Objective-C \@catch statement.
1114 bool isExceptionVariable() const {
1115 return VarDeclBits.ExceptionVar;
1117 void setExceptionVariable(bool EV) { VarDeclBits.ExceptionVar = EV; }
1119 /// \brief Determine whether this local variable can be used with the named
1120 /// return value optimization (NRVO).
1122 /// The named return value optimization (NRVO) works by marking certain
1123 /// non-volatile local variables of class type as NRVO objects. These
1124 /// locals can be allocated within the return slot of their containing
1125 /// function, in which case there is no need to copy the object to the
1126 /// return slot when returning from the function. Within the function body,
1127 /// each return that returns the NRVO object will have this variable as its
1129 bool isNRVOVariable() const { return VarDeclBits.NRVOVariable; }
1130 void setNRVOVariable(bool NRVO) { VarDeclBits.NRVOVariable = NRVO; }
1132 /// \brief Determine whether this variable is the for-range-declaration in
1133 /// a C++0x for-range statement.
1134 bool isCXXForRangeDecl() const { return VarDeclBits.CXXForRangeDecl; }
1135 void setCXXForRangeDecl(bool FRD) { VarDeclBits.CXXForRangeDecl = FRD; }
1137 /// \brief Determine whether this variable is an ARC pseudo-__strong
1138 /// variable. A pseudo-__strong variable has a __strong-qualified
1139 /// type but does not actually retain the object written into it.
1140 /// Generally such variables are also 'const' for safety.
1141 bool isARCPseudoStrong() const { return VarDeclBits.ARCPseudoStrong; }
1142 void setARCPseudoStrong(bool ps) { VarDeclBits.ARCPseudoStrong = ps; }
1144 /// Whether this variable is (C++11) constexpr.
1145 bool isConstexpr() const { return VarDeclBits.IsConstexpr; }
1146 void setConstexpr(bool IC) { VarDeclBits.IsConstexpr = IC; }
1148 /// Whether this variable is the implicit variable for a lambda init-capture.
1149 bool isInitCapture() const { return VarDeclBits.IsInitCapture; }
1150 void setInitCapture(bool IC) { VarDeclBits.IsInitCapture = IC; }
1152 /// Whether this local extern variable declaration's previous declaration
1153 /// was declared in the same block scope. Only correct in C++.
1154 bool isPreviousDeclInSameBlockScope() const {
1155 return VarDeclBits.PreviousDeclInSameBlockScope;
1157 void setPreviousDeclInSameBlockScope(bool Same) {
1158 VarDeclBits.PreviousDeclInSameBlockScope = Same;
1161 /// \brief If this variable is an instantiated static data member of a
1162 /// class template specialization, returns the templated static data member
1163 /// from which it was instantiated.
1164 VarDecl *getInstantiatedFromStaticDataMember() const;
1166 /// \brief If this variable is an instantiation of a variable template or a
1167 /// static data member of a class template, determine what kind of
1168 /// template specialization or instantiation this is.
1169 TemplateSpecializationKind getTemplateSpecializationKind() const;
1171 /// \brief If this variable is an instantiation of a variable template or a
1172 /// static data member of a class template, determine its point of
1174 SourceLocation getPointOfInstantiation() const;
1176 /// \brief If this variable is an instantiation of a static data member of a
1177 /// class template specialization, retrieves the member specialization
1179 MemberSpecializationInfo *getMemberSpecializationInfo() const;
1181 /// \brief For a static data member that was instantiated from a static
1182 /// data member of a class template, set the template specialiation kind.
1183 void setTemplateSpecializationKind(TemplateSpecializationKind TSK,
1184 SourceLocation PointOfInstantiation = SourceLocation());
1186 /// \brief Specify that this variable is an instantiation of the
1187 /// static data member VD.
1188 void setInstantiationOfStaticDataMember(VarDecl *VD,
1189 TemplateSpecializationKind TSK);
1191 /// \brief Retrieves the variable template that is described by this
1192 /// variable declaration.
1194 /// Every variable template is represented as a VarTemplateDecl and a
1195 /// VarDecl. The former contains template properties (such as
1196 /// the template parameter lists) while the latter contains the
1197 /// actual description of the template's
1198 /// contents. VarTemplateDecl::getTemplatedDecl() retrieves the
1199 /// VarDecl that from a VarTemplateDecl, while
1200 /// getDescribedVarTemplate() retrieves the VarTemplateDecl from
1202 VarTemplateDecl *getDescribedVarTemplate() const;
1204 void setDescribedVarTemplate(VarTemplateDecl *Template);
1206 // Implement isa/cast/dyncast/etc.
1207 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1208 static bool classofKind(Kind K) { return K >= firstVar && K <= lastVar; }
1211 class ImplicitParamDecl : public VarDecl {
1212 void anchor() override;
1214 static ImplicitParamDecl *Create(ASTContext &C, DeclContext *DC,
1215 SourceLocation IdLoc, IdentifierInfo *Id,
1218 static ImplicitParamDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1220 ImplicitParamDecl(ASTContext &C, DeclContext *DC, SourceLocation IdLoc,
1221 IdentifierInfo *Id, QualType Type)
1222 : VarDecl(ImplicitParam, C, DC, IdLoc, IdLoc, Id, Type,
1223 /*tinfo*/ nullptr, SC_None) {
1227 // Implement isa/cast/dyncast/etc.
1228 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1229 static bool classofKind(Kind K) { return K == ImplicitParam; }
1232 /// ParmVarDecl - Represents a parameter to a function.
1233 class ParmVarDecl : public VarDecl {
1235 enum { MaxFunctionScopeDepth = 255 };
1236 enum { MaxFunctionScopeIndex = 255 };
1239 ParmVarDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
1240 SourceLocation IdLoc, IdentifierInfo *Id, QualType T,
1241 TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
1242 : VarDecl(DK, C, DC, StartLoc, IdLoc, Id, T, TInfo, S) {
1243 assert(ParmVarDeclBits.HasInheritedDefaultArg == false);
1244 assert(ParmVarDeclBits.IsKNRPromoted == false);
1245 assert(ParmVarDeclBits.IsObjCMethodParam == false);
1246 setDefaultArg(DefArg);
1250 static ParmVarDecl *Create(ASTContext &C, DeclContext *DC,
1251 SourceLocation StartLoc,
1252 SourceLocation IdLoc, IdentifierInfo *Id,
1253 QualType T, TypeSourceInfo *TInfo,
1254 StorageClass S, Expr *DefArg);
1256 static ParmVarDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1258 SourceRange getSourceRange() const override LLVM_READONLY;
1260 void setObjCMethodScopeInfo(unsigned parameterIndex) {
1261 ParmVarDeclBits.IsObjCMethodParam = true;
1262 setParameterIndex(parameterIndex);
1265 void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex) {
1266 assert(!ParmVarDeclBits.IsObjCMethodParam);
1268 ParmVarDeclBits.ScopeDepthOrObjCQuals = scopeDepth;
1269 assert(ParmVarDeclBits.ScopeDepthOrObjCQuals == scopeDepth
1272 setParameterIndex(parameterIndex);
1275 bool isObjCMethodParameter() const {
1276 return ParmVarDeclBits.IsObjCMethodParam;
1279 unsigned getFunctionScopeDepth() const {
1280 if (ParmVarDeclBits.IsObjCMethodParam) return 0;
1281 return ParmVarDeclBits.ScopeDepthOrObjCQuals;
1284 /// Returns the index of this parameter in its prototype or method scope.
1285 unsigned getFunctionScopeIndex() const {
1286 return getParameterIndex();
1289 ObjCDeclQualifier getObjCDeclQualifier() const {
1290 if (!ParmVarDeclBits.IsObjCMethodParam) return OBJC_TQ_None;
1291 return ObjCDeclQualifier(ParmVarDeclBits.ScopeDepthOrObjCQuals);
1293 void setObjCDeclQualifier(ObjCDeclQualifier QTVal) {
1294 assert(ParmVarDeclBits.IsObjCMethodParam);
1295 ParmVarDeclBits.ScopeDepthOrObjCQuals = QTVal;
1298 /// True if the value passed to this parameter must undergo
1299 /// K&R-style default argument promotion:
1302 /// If the expression that denotes the called function has a type
1303 /// that does not include a prototype, the integer promotions are
1304 /// performed on each argument, and arguments that have type float
1305 /// are promoted to double.
1306 bool isKNRPromoted() const {
1307 return ParmVarDeclBits.IsKNRPromoted;
1309 void setKNRPromoted(bool promoted) {
1310 ParmVarDeclBits.IsKNRPromoted = promoted;
1313 Expr *getDefaultArg();
1314 const Expr *getDefaultArg() const {
1315 return const_cast<ParmVarDecl *>(this)->getDefaultArg();
1318 void setDefaultArg(Expr *defarg) {
1319 Init = reinterpret_cast<Stmt *>(defarg);
1322 /// \brief Retrieve the source range that covers the entire default
1324 SourceRange getDefaultArgRange() const;
1325 void setUninstantiatedDefaultArg(Expr *arg) {
1326 Init = reinterpret_cast<UninstantiatedDefaultArgument *>(arg);
1328 Expr *getUninstantiatedDefaultArg() {
1329 return (Expr *)Init.get<UninstantiatedDefaultArgument *>();
1331 const Expr *getUninstantiatedDefaultArg() const {
1332 return (const Expr *)Init.get<UninstantiatedDefaultArgument *>();
1335 /// hasDefaultArg - Determines whether this parameter has a default argument,
1336 /// either parsed or not.
1337 bool hasDefaultArg() const {
1338 return getInit() || hasUnparsedDefaultArg() ||
1339 hasUninstantiatedDefaultArg();
1342 /// hasUnparsedDefaultArg - Determines whether this parameter has a
1343 /// default argument that has not yet been parsed. This will occur
1344 /// during the processing of a C++ class whose member functions have
1345 /// default arguments, e.g.,
1349 /// void f(int x = 17); // x has an unparsed default argument now
1350 /// }; // x has a regular default argument now
1352 bool hasUnparsedDefaultArg() const {
1353 return Init.is<UnparsedDefaultArgument*>();
1356 bool hasUninstantiatedDefaultArg() const {
1357 return Init.is<UninstantiatedDefaultArgument*>();
1360 /// setUnparsedDefaultArg - Specify that this parameter has an
1361 /// unparsed default argument. The argument will be replaced with a
1362 /// real default argument via setDefaultArg when the class
1363 /// definition enclosing the function declaration that owns this
1364 /// default argument is completed.
1365 void setUnparsedDefaultArg() { Init = (UnparsedDefaultArgument *)nullptr; }
1367 bool hasInheritedDefaultArg() const {
1368 return ParmVarDeclBits.HasInheritedDefaultArg;
1371 void setHasInheritedDefaultArg(bool I = true) {
1372 ParmVarDeclBits.HasInheritedDefaultArg = I;
1375 QualType getOriginalType() const;
1377 /// \brief Determine whether this parameter is actually a function
1379 bool isParameterPack() const;
1381 /// setOwningFunction - Sets the function declaration that owns this
1382 /// ParmVarDecl. Since ParmVarDecls are often created before the
1383 /// FunctionDecls that own them, this routine is required to update
1384 /// the DeclContext appropriately.
1385 void setOwningFunction(DeclContext *FD) { setDeclContext(FD); }
1387 // Implement isa/cast/dyncast/etc.
1388 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1389 static bool classofKind(Kind K) { return K == ParmVar; }
1392 enum { ParameterIndexSentinel = (1 << NumParameterIndexBits) - 1 };
1394 void setParameterIndex(unsigned parameterIndex) {
1395 if (parameterIndex >= ParameterIndexSentinel) {
1396 setParameterIndexLarge(parameterIndex);
1400 ParmVarDeclBits.ParameterIndex = parameterIndex;
1401 assert(ParmVarDeclBits.ParameterIndex == parameterIndex && "truncation!");
1403 unsigned getParameterIndex() const {
1404 unsigned d = ParmVarDeclBits.ParameterIndex;
1405 return d == ParameterIndexSentinel ? getParameterIndexLarge() : d;
1408 void setParameterIndexLarge(unsigned parameterIndex);
1409 unsigned getParameterIndexLarge() const;
1412 /// FunctionDecl - An instance of this class is created to represent a
1413 /// function declaration or definition.
1415 /// Since a given function can be declared several times in a program,
1416 /// there may be several FunctionDecls that correspond to that
1417 /// function. Only one of those FunctionDecls will be found when
1418 /// traversing the list of declarations in the context of the
1419 /// FunctionDecl (e.g., the translation unit); this FunctionDecl
1420 /// contains all of the information known about the function. Other,
1421 /// previous declarations of the function are available via the
1422 /// getPreviousDecl() chain.
1423 class FunctionDecl : public DeclaratorDecl, public DeclContext,
1424 public Redeclarable<FunctionDecl> {
1426 typedef clang::StorageClass StorageClass;
1428 /// \brief The kind of templated function a FunctionDecl can be.
1429 enum TemplatedKind {
1431 TK_FunctionTemplate,
1432 TK_MemberSpecialization,
1433 TK_FunctionTemplateSpecialization,
1434 TK_DependentFunctionTemplateSpecialization
1438 /// ParamInfo - new[]'d array of pointers to VarDecls for the formal
1439 /// parameters of this function. This is null if a prototype or if there are
1441 ParmVarDecl **ParamInfo;
1443 /// DeclsInPrototypeScope - Array of pointers to NamedDecls for
1444 /// decls defined in the function prototype that are not parameters. E.g.
1445 /// 'enum Y' in 'void f(enum Y {AA} x) {}'.
1446 ArrayRef<NamedDecl *> DeclsInPrototypeScope;
1448 LazyDeclStmtPtr Body;
1450 // FIXME: This can be packed into the bitfields in Decl.
1451 // NOTE: VC++ treats enums as signed, avoid using the StorageClass enum
1452 unsigned SClass : 2;
1454 bool IsInlineSpecified : 1;
1455 bool IsVirtualAsWritten : 1;
1457 bool HasInheritedPrototype : 1;
1458 bool HasWrittenPrototype : 1;
1460 bool IsTrivial : 1; // sunk from CXXMethodDecl
1461 bool IsDefaulted : 1; // sunk from CXXMethoDecl
1462 bool IsExplicitlyDefaulted : 1; //sunk from CXXMethodDecl
1463 bool HasImplicitReturnZero : 1;
1464 bool IsLateTemplateParsed : 1;
1465 bool IsConstexpr : 1;
1467 /// \brief Indicates if the function was a definition but its body was
1469 unsigned HasSkippedBody : 1;
1471 /// \brief End part of this FunctionDecl's source range.
1473 /// We could compute the full range in getSourceRange(). However, when we're
1474 /// dealing with a function definition deserialized from a PCH/AST file,
1475 /// we can only compute the full range once the function body has been
1476 /// de-serialized, so it's far better to have the (sometimes-redundant)
1478 SourceLocation EndRangeLoc;
1480 /// \brief The template or declaration that this declaration
1481 /// describes or was instantiated from, respectively.
1483 /// For non-templates, this value will be NULL. For function
1484 /// declarations that describe a function template, this will be a
1485 /// pointer to a FunctionTemplateDecl. For member functions
1486 /// of class template specializations, this will be a MemberSpecializationInfo
1487 /// pointer containing information about the specialization.
1488 /// For function template specializations, this will be a
1489 /// FunctionTemplateSpecializationInfo, which contains information about
1490 /// the template being specialized and the template arguments involved in
1491 /// that specialization.
1492 llvm::PointerUnion4<FunctionTemplateDecl *,
1493 MemberSpecializationInfo *,
1494 FunctionTemplateSpecializationInfo *,
1495 DependentFunctionTemplateSpecializationInfo *>
1496 TemplateOrSpecialization;
1498 /// DNLoc - Provides source/type location info for the
1499 /// declaration name embedded in the DeclaratorDecl base class.
1500 DeclarationNameLoc DNLoc;
1502 /// \brief Specify that this function declaration is actually a function
1503 /// template specialization.
1505 /// \param C the ASTContext.
1507 /// \param Template the function template that this function template
1508 /// specialization specializes.
1510 /// \param TemplateArgs the template arguments that produced this
1511 /// function template specialization from the template.
1513 /// \param InsertPos If non-NULL, the position in the function template
1514 /// specialization set where the function template specialization data will
1517 /// \param TSK the kind of template specialization this is.
1519 /// \param TemplateArgsAsWritten location info of template arguments.
1521 /// \param PointOfInstantiation point at which the function template
1522 /// specialization was first instantiated.
1523 void setFunctionTemplateSpecialization(ASTContext &C,
1524 FunctionTemplateDecl *Template,
1525 const TemplateArgumentList *TemplateArgs,
1527 TemplateSpecializationKind TSK,
1528 const TemplateArgumentListInfo *TemplateArgsAsWritten,
1529 SourceLocation PointOfInstantiation);
1531 /// \brief Specify that this record is an instantiation of the
1532 /// member function FD.
1533 void setInstantiationOfMemberFunction(ASTContext &C, FunctionDecl *FD,
1534 TemplateSpecializationKind TSK);
1536 void setParams(ASTContext &C, ArrayRef<ParmVarDecl *> NewParamInfo);
1539 FunctionDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
1540 const DeclarationNameInfo &NameInfo,
1541 QualType T, TypeSourceInfo *TInfo,
1542 StorageClass S, bool isInlineSpecified,
1543 bool isConstexprSpecified)
1544 : DeclaratorDecl(DK, DC, NameInfo.getLoc(), NameInfo.getName(), T, TInfo,
1547 redeclarable_base(C),
1548 ParamInfo(nullptr), Body(),
1550 IsInline(isInlineSpecified), IsInlineSpecified(isInlineSpecified),
1551 IsVirtualAsWritten(false), IsPure(false), HasInheritedPrototype(false),
1552 HasWrittenPrototype(true), IsDeleted(false), IsTrivial(false),
1553 IsDefaulted(false), IsExplicitlyDefaulted(false),
1554 HasImplicitReturnZero(false), IsLateTemplateParsed(false),
1555 IsConstexpr(isConstexprSpecified), HasSkippedBody(false),
1556 EndRangeLoc(NameInfo.getEndLoc()),
1557 TemplateOrSpecialization(),
1558 DNLoc(NameInfo.getInfo()) {}
1560 typedef Redeclarable<FunctionDecl> redeclarable_base;
1561 FunctionDecl *getNextRedeclarationImpl() override {
1562 return getNextRedeclaration();
1564 FunctionDecl *getPreviousDeclImpl() override {
1565 return getPreviousDecl();
1567 FunctionDecl *getMostRecentDeclImpl() override {
1568 return getMostRecentDecl();
1572 typedef redeclarable_base::redecl_range redecl_range;
1573 typedef redeclarable_base::redecl_iterator redecl_iterator;
1574 using redeclarable_base::redecls_begin;
1575 using redeclarable_base::redecls_end;
1576 using redeclarable_base::redecls;
1577 using redeclarable_base::getPreviousDecl;
1578 using redeclarable_base::getMostRecentDecl;
1579 using redeclarable_base::isFirstDecl;
1581 static FunctionDecl *Create(ASTContext &C, DeclContext *DC,
1582 SourceLocation StartLoc, SourceLocation NLoc,
1583 DeclarationName N, QualType T,
1584 TypeSourceInfo *TInfo,
1586 bool isInlineSpecified = false,
1587 bool hasWrittenPrototype = true,
1588 bool isConstexprSpecified = false) {
1589 DeclarationNameInfo NameInfo(N, NLoc);
1590 return FunctionDecl::Create(C, DC, StartLoc, NameInfo, T, TInfo,
1592 isInlineSpecified, hasWrittenPrototype,
1593 isConstexprSpecified);
1596 static FunctionDecl *Create(ASTContext &C, DeclContext *DC,
1597 SourceLocation StartLoc,
1598 const DeclarationNameInfo &NameInfo,
1599 QualType T, TypeSourceInfo *TInfo,
1601 bool isInlineSpecified,
1602 bool hasWrittenPrototype,
1603 bool isConstexprSpecified = false);
1605 static FunctionDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1607 DeclarationNameInfo getNameInfo() const {
1608 return DeclarationNameInfo(getDeclName(), getLocation(), DNLoc);
1611 void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy,
1612 bool Qualified) const override;
1614 void setRangeEnd(SourceLocation E) { EndRangeLoc = E; }
1616 SourceRange getSourceRange() const override LLVM_READONLY;
1618 /// \brief Returns true if the function has a body (definition). The
1619 /// function body might be in any of the (re-)declarations of this
1620 /// function. The variant that accepts a FunctionDecl pointer will
1621 /// set that function declaration to the actual declaration
1622 /// containing the body (if there is one).
1623 bool hasBody(const FunctionDecl *&Definition) const;
1625 bool hasBody() const override {
1626 const FunctionDecl* Definition;
1627 return hasBody(Definition);
1630 /// hasTrivialBody - Returns whether the function has a trivial body that does
1631 /// not require any specific codegen.
1632 bool hasTrivialBody() const;
1634 /// isDefined - Returns true if the function is defined at all, including
1635 /// a deleted definition. Except for the behavior when the function is
1636 /// deleted, behaves like hasBody.
1637 bool isDefined(const FunctionDecl *&Definition) const;
1639 virtual bool isDefined() const {
1640 const FunctionDecl* Definition;
1641 return isDefined(Definition);
1644 /// getBody - Retrieve the body (definition) of the function. The
1645 /// function body might be in any of the (re-)declarations of this
1646 /// function. The variant that accepts a FunctionDecl pointer will
1647 /// set that function declaration to the actual declaration
1648 /// containing the body (if there is one).
1649 /// NOTE: For checking if there is a body, use hasBody() instead, to avoid
1650 /// unnecessary AST de-serialization of the body.
1651 Stmt *getBody(const FunctionDecl *&Definition) const;
1653 Stmt *getBody() const override {
1654 const FunctionDecl* Definition;
1655 return getBody(Definition);
1658 /// isThisDeclarationADefinition - Returns whether this specific
1659 /// declaration of the function is also a definition. This does not
1660 /// determine whether the function has been defined (e.g., in a
1661 /// previous definition); for that information, use isDefined. Note
1662 /// that this returns false for a defaulted function unless that function
1663 /// has been implicitly defined (possibly as deleted).
1664 bool isThisDeclarationADefinition() const {
1665 return IsDeleted || Body || IsLateTemplateParsed;
1668 /// doesThisDeclarationHaveABody - Returns whether this specific
1669 /// declaration of the function has a body - that is, if it is a non-
1670 /// deleted definition.
1671 bool doesThisDeclarationHaveABody() const {
1672 return Body || IsLateTemplateParsed;
1675 void setBody(Stmt *B);
1676 void setLazyBody(uint64_t Offset) { Body = Offset; }
1678 /// Whether this function is variadic.
1679 bool isVariadic() const;
1681 /// Whether this function is marked as virtual explicitly.
1682 bool isVirtualAsWritten() const { return IsVirtualAsWritten; }
1683 void setVirtualAsWritten(bool V) { IsVirtualAsWritten = V; }
1685 /// Whether this virtual function is pure, i.e. makes the containing class
1687 bool isPure() const { return IsPure; }
1688 void setPure(bool P = true);
1690 /// Whether this templated function will be late parsed.
1691 bool isLateTemplateParsed() const { return IsLateTemplateParsed; }
1692 void setLateTemplateParsed(bool ILT = true) { IsLateTemplateParsed = ILT; }
1694 /// Whether this function is "trivial" in some specialized C++ senses.
1695 /// Can only be true for default constructors, copy constructors,
1696 /// copy assignment operators, and destructors. Not meaningful until
1697 /// the class has been fully built by Sema.
1698 bool isTrivial() const { return IsTrivial; }
1699 void setTrivial(bool IT) { IsTrivial = IT; }
1701 /// Whether this function is defaulted per C++0x. Only valid for
1702 /// special member functions.
1703 bool isDefaulted() const { return IsDefaulted; }
1704 void setDefaulted(bool D = true) { IsDefaulted = D; }
1706 /// Whether this function is explicitly defaulted per C++0x. Only valid
1707 /// for special member functions.
1708 bool isExplicitlyDefaulted() const { return IsExplicitlyDefaulted; }
1709 void setExplicitlyDefaulted(bool ED = true) { IsExplicitlyDefaulted = ED; }
1711 /// Whether falling off this function implicitly returns null/zero.
1712 /// If a more specific implicit return value is required, front-ends
1713 /// should synthesize the appropriate return statements.
1714 bool hasImplicitReturnZero() const { return HasImplicitReturnZero; }
1715 void setHasImplicitReturnZero(bool IRZ) { HasImplicitReturnZero = IRZ; }
1717 /// \brief Whether this function has a prototype, either because one
1718 /// was explicitly written or because it was "inherited" by merging
1719 /// a declaration without a prototype with a declaration that has a
1721 bool hasPrototype() const {
1722 return HasWrittenPrototype || HasInheritedPrototype;
1725 bool hasWrittenPrototype() const { return HasWrittenPrototype; }
1727 /// \brief Whether this function inherited its prototype from a
1728 /// previous declaration.
1729 bool hasInheritedPrototype() const { return HasInheritedPrototype; }
1730 void setHasInheritedPrototype(bool P = true) { HasInheritedPrototype = P; }
1732 /// Whether this is a (C++11) constexpr function or constexpr constructor.
1733 bool isConstexpr() const { return IsConstexpr; }
1734 void setConstexpr(bool IC) { IsConstexpr = IC; }
1736 /// \brief Whether this function has been deleted.
1738 /// A function that is "deleted" (via the C++0x "= delete" syntax)
1739 /// acts like a normal function, except that it cannot actually be
1740 /// called or have its address taken. Deleted functions are
1741 /// typically used in C++ overload resolution to attract arguments
1742 /// whose type or lvalue/rvalue-ness would permit the use of a
1743 /// different overload that would behave incorrectly. For example,
1744 /// one might use deleted functions to ban implicit conversion from
1745 /// a floating-point number to an Integer type:
1748 /// struct Integer {
1749 /// Integer(long); // construct from a long
1750 /// Integer(double) = delete; // no construction from float or double
1751 /// Integer(long double) = delete; // no construction from long double
1754 // If a function is deleted, its first declaration must be.
1755 bool isDeleted() const { return getCanonicalDecl()->IsDeleted; }
1756 bool isDeletedAsWritten() const { return IsDeleted && !IsDefaulted; }
1757 void setDeletedAsWritten(bool D = true) { IsDeleted = D; }
1759 /// \brief Determines whether this function is "main", which is the
1760 /// entry point into an executable program.
1761 bool isMain() const;
1763 /// \brief Determines whether this function is a MSVCRT user defined entry
1765 bool isMSVCRTEntryPoint() const;
1767 /// \brief Determines whether this operator new or delete is one
1768 /// of the reserved global placement operators:
1769 /// void *operator new(size_t, void *);
1770 /// void *operator new[](size_t, void *);
1771 /// void operator delete(void *, void *);
1772 /// void operator delete[](void *, void *);
1773 /// These functions have special behavior under [new.delete.placement]:
1774 /// These functions are reserved, a C++ program may not define
1775 /// functions that displace the versions in the Standard C++ library.
1776 /// The provisions of [basic.stc.dynamic] do not apply to these
1777 /// reserved placement forms of operator new and operator delete.
1779 /// This function must be an allocation or deallocation function.
1780 bool isReservedGlobalPlacementOperator() const;
1782 /// \brief Determines whether this function is one of the replaceable
1783 /// global allocation functions:
1784 /// void *operator new(size_t);
1785 /// void *operator new(size_t, const std::nothrow_t &) noexcept;
1786 /// void *operator new[](size_t);
1787 /// void *operator new[](size_t, const std::nothrow_t &) noexcept;
1788 /// void operator delete(void *) noexcept;
1789 /// void operator delete(void *, std::size_t) noexcept; [C++1y]
1790 /// void operator delete(void *, const std::nothrow_t &) noexcept;
1791 /// void operator delete[](void *) noexcept;
1792 /// void operator delete[](void *, std::size_t) noexcept; [C++1y]
1793 /// void operator delete[](void *, const std::nothrow_t &) noexcept;
1794 /// These functions have special behavior under C++1y [expr.new]:
1795 /// An implementation is allowed to omit a call to a replaceable global
1796 /// allocation function. [...]
1797 bool isReplaceableGlobalAllocationFunction() const;
1799 /// \brief Determine whether this function is a sized global deallocation
1800 /// function in C++1y. If so, find and return the corresponding unsized
1801 /// deallocation function.
1802 FunctionDecl *getCorrespondingUnsizedGlobalDeallocationFunction() const;
1804 /// Compute the language linkage.
1805 LanguageLinkage getLanguageLinkage() const;
1807 /// \brief Determines whether this function is a function with
1808 /// external, C linkage.
1809 bool isExternC() const;
1811 /// \brief Determines whether this function's context is, or is nested within,
1812 /// a C++ extern "C" linkage spec.
1813 bool isInExternCContext() const;
1815 /// \brief Determines whether this function's context is, or is nested within,
1816 /// a C++ extern "C++" linkage spec.
1817 bool isInExternCXXContext() const;
1819 /// \brief Determines whether this is a global function.
1820 bool isGlobal() const;
1822 /// \brief Determines whether this function is known to be 'noreturn', through
1823 /// an attribute on its declaration or its type.
1824 bool isNoReturn() const;
1826 /// \brief True if the function was a definition but its body was skipped.
1827 bool hasSkippedBody() const { return HasSkippedBody; }
1828 void setHasSkippedBody(bool Skipped = true) { HasSkippedBody = Skipped; }
1830 void setPreviousDeclaration(FunctionDecl * PrevDecl);
1832 virtual const FunctionDecl *getCanonicalDecl() const;
1833 FunctionDecl *getCanonicalDecl() override;
1835 unsigned getBuiltinID() const;
1837 // Iterator access to formal parameters.
1838 unsigned param_size() const { return getNumParams(); }
1839 typedef ParmVarDecl **param_iterator;
1840 typedef ParmVarDecl * const *param_const_iterator;
1841 typedef llvm::iterator_range<param_iterator> param_range;
1842 typedef llvm::iterator_range<param_const_iterator> param_const_range;
1844 param_iterator param_begin() { return param_iterator(ParamInfo); }
1845 param_iterator param_end() {
1846 return param_iterator(ParamInfo + param_size());
1848 param_range params() { return param_range(param_begin(), param_end()); }
1850 param_const_iterator param_begin() const {
1851 return param_const_iterator(ParamInfo);
1853 param_const_iterator param_end() const {
1854 return param_const_iterator(ParamInfo + param_size());
1856 param_const_range params() const {
1857 return param_const_range(param_begin(), param_end());
1860 /// getNumParams - Return the number of parameters this function must have
1861 /// based on its FunctionType. This is the length of the ParamInfo array
1862 /// after it has been created.
1863 unsigned getNumParams() const;
1865 const ParmVarDecl *getParamDecl(unsigned i) const {
1866 assert(i < getNumParams() && "Illegal param #");
1867 return ParamInfo[i];
1869 ParmVarDecl *getParamDecl(unsigned i) {
1870 assert(i < getNumParams() && "Illegal param #");
1871 return ParamInfo[i];
1873 void setParams(ArrayRef<ParmVarDecl *> NewParamInfo) {
1874 setParams(getASTContext(), NewParamInfo);
1877 // ArrayRef iterface to parameters.
1878 // FIXME: Should one day replace iterator interface.
1879 ArrayRef<ParmVarDecl*> parameters() const {
1880 return llvm::makeArrayRef(ParamInfo, getNumParams());
1883 const ArrayRef<NamedDecl *> &getDeclsInPrototypeScope() const {
1884 return DeclsInPrototypeScope;
1886 void setDeclsInPrototypeScope(ArrayRef<NamedDecl *> NewDecls);
1888 /// getMinRequiredArguments - Returns the minimum number of arguments
1889 /// needed to call this function. This may be fewer than the number of
1890 /// function parameters, if some of the parameters have default
1891 /// arguments (in C++).
1892 unsigned getMinRequiredArguments() const;
1894 QualType getReturnType() const {
1895 return getType()->getAs<FunctionType>()->getReturnType();
1898 /// \brief Attempt to compute an informative source range covering the
1899 /// function return type. This may omit qualifiers and other information with
1900 /// limited representation in the AST.
1901 SourceRange getReturnTypeSourceRange() const;
1903 /// \brief Determine the type of an expression that calls this function.
1904 QualType getCallResultType() const {
1905 return getType()->getAs<FunctionType>()->getCallResultType(getASTContext());
1908 /// \brief Returns the storage class as written in the source. For the
1909 /// computed linkage of symbol, see getLinkage.
1910 StorageClass getStorageClass() const { return StorageClass(SClass); }
1912 /// \brief Determine whether the "inline" keyword was specified for this
1914 bool isInlineSpecified() const { return IsInlineSpecified; }
1916 /// Set whether the "inline" keyword was specified for this function.
1917 void setInlineSpecified(bool I) {
1918 IsInlineSpecified = I;
1922 /// Flag that this function is implicitly inline.
1923 void setImplicitlyInline() {
1927 /// \brief Determine whether this function should be inlined, because it is
1928 /// either marked "inline" or "constexpr" or is a member function of a class
1929 /// that was defined in the class body.
1930 bool isInlined() const { return IsInline; }
1932 bool isInlineDefinitionExternallyVisible() const;
1934 bool isMSExternInline() const;
1936 bool doesDeclarationForceExternallyVisibleDefinition() const;
1938 /// isOverloadedOperator - Whether this function declaration
1939 /// represents an C++ overloaded operator, e.g., "operator+".
1940 bool isOverloadedOperator() const {
1941 return getOverloadedOperator() != OO_None;
1944 OverloadedOperatorKind getOverloadedOperator() const;
1946 const IdentifierInfo *getLiteralIdentifier() const;
1948 /// \brief If this function is an instantiation of a member function
1949 /// of a class template specialization, retrieves the function from
1950 /// which it was instantiated.
1952 /// This routine will return non-NULL for (non-templated) member
1953 /// functions of class templates and for instantiations of function
1954 /// templates. For example, given:
1957 /// template<typename T>
1963 /// The declaration for X<int>::f is a (non-templated) FunctionDecl
1964 /// whose parent is the class template specialization X<int>. For
1965 /// this declaration, getInstantiatedFromFunction() will return
1966 /// the FunctionDecl X<T>::A. When a complete definition of
1967 /// X<int>::A is required, it will be instantiated from the
1968 /// declaration returned by getInstantiatedFromMemberFunction().
1969 FunctionDecl *getInstantiatedFromMemberFunction() const;
1971 /// \brief What kind of templated function this is.
1972 TemplatedKind getTemplatedKind() const;
1974 /// \brief If this function is an instantiation of a member function of a
1975 /// class template specialization, retrieves the member specialization
1977 MemberSpecializationInfo *getMemberSpecializationInfo() const {
1978 return TemplateOrSpecialization.dyn_cast<MemberSpecializationInfo*>();
1981 /// \brief Specify that this record is an instantiation of the
1982 /// member function FD.
1983 void setInstantiationOfMemberFunction(FunctionDecl *FD,
1984 TemplateSpecializationKind TSK) {
1985 setInstantiationOfMemberFunction(getASTContext(), FD, TSK);
1988 /// \brief Retrieves the function template that is described by this
1989 /// function declaration.
1991 /// Every function template is represented as a FunctionTemplateDecl
1992 /// and a FunctionDecl (or something derived from FunctionDecl). The
1993 /// former contains template properties (such as the template
1994 /// parameter lists) while the latter contains the actual
1995 /// description of the template's
1996 /// contents. FunctionTemplateDecl::getTemplatedDecl() retrieves the
1997 /// FunctionDecl that describes the function template,
1998 /// getDescribedFunctionTemplate() retrieves the
1999 /// FunctionTemplateDecl from a FunctionDecl.
2000 FunctionTemplateDecl *getDescribedFunctionTemplate() const {
2001 return TemplateOrSpecialization.dyn_cast<FunctionTemplateDecl*>();
2004 void setDescribedFunctionTemplate(FunctionTemplateDecl *Template) {
2005 TemplateOrSpecialization = Template;
2008 /// \brief Determine whether this function is a function template
2010 bool isFunctionTemplateSpecialization() const {
2011 return getPrimaryTemplate() != nullptr;
2014 /// \brief Retrieve the class scope template pattern that this function
2015 /// template specialization is instantiated from.
2016 FunctionDecl *getClassScopeSpecializationPattern() const;
2018 /// \brief If this function is actually a function template specialization,
2019 /// retrieve information about this function template specialization.
2020 /// Otherwise, returns NULL.
2021 FunctionTemplateSpecializationInfo *getTemplateSpecializationInfo() const {
2022 return TemplateOrSpecialization.
2023 dyn_cast<FunctionTemplateSpecializationInfo*>();
2026 /// \brief Determines whether this function is a function template
2027 /// specialization or a member of a class template specialization that can
2028 /// be implicitly instantiated.
2029 bool isImplicitlyInstantiable() const;
2031 /// \brief Determines if the given function was instantiated from a
2032 /// function template.
2033 bool isTemplateInstantiation() const;
2035 /// \brief Retrieve the function declaration from which this function could
2036 /// be instantiated, if it is an instantiation (rather than a non-template
2037 /// or a specialization, for example).
2038 FunctionDecl *getTemplateInstantiationPattern() const;
2040 /// \brief Retrieve the primary template that this function template
2041 /// specialization either specializes or was instantiated from.
2043 /// If this function declaration is not a function template specialization,
2045 FunctionTemplateDecl *getPrimaryTemplate() const;
2047 /// \brief Retrieve the template arguments used to produce this function
2048 /// template specialization from the primary template.
2050 /// If this function declaration is not a function template specialization,
2052 const TemplateArgumentList *getTemplateSpecializationArgs() const;
2054 /// \brief Retrieve the template argument list as written in the sources,
2057 /// If this function declaration is not a function template specialization
2058 /// or if it had no explicit template argument list, returns NULL.
2059 /// Note that it an explicit template argument list may be written empty,
2060 /// e.g., template<> void foo<>(char* s);
2061 const ASTTemplateArgumentListInfo*
2062 getTemplateSpecializationArgsAsWritten() const;
2064 /// \brief Specify that this function declaration is actually a function
2065 /// template specialization.
2067 /// \param Template the function template that this function template
2068 /// specialization specializes.
2070 /// \param TemplateArgs the template arguments that produced this
2071 /// function template specialization from the template.
2073 /// \param InsertPos If non-NULL, the position in the function template
2074 /// specialization set where the function template specialization data will
2077 /// \param TSK the kind of template specialization this is.
2079 /// \param TemplateArgsAsWritten location info of template arguments.
2081 /// \param PointOfInstantiation point at which the function template
2082 /// specialization was first instantiated.
2083 void setFunctionTemplateSpecialization(FunctionTemplateDecl *Template,
2084 const TemplateArgumentList *TemplateArgs,
2086 TemplateSpecializationKind TSK = TSK_ImplicitInstantiation,
2087 const TemplateArgumentListInfo *TemplateArgsAsWritten = nullptr,
2088 SourceLocation PointOfInstantiation = SourceLocation()) {
2089 setFunctionTemplateSpecialization(getASTContext(), Template, TemplateArgs,
2090 InsertPos, TSK, TemplateArgsAsWritten,
2091 PointOfInstantiation);
2094 /// \brief Specifies that this function declaration is actually a
2095 /// dependent function template specialization.
2096 void setDependentTemplateSpecialization(ASTContext &Context,
2097 const UnresolvedSetImpl &Templates,
2098 const TemplateArgumentListInfo &TemplateArgs);
2100 DependentFunctionTemplateSpecializationInfo *
2101 getDependentSpecializationInfo() const {
2102 return TemplateOrSpecialization.
2103 dyn_cast<DependentFunctionTemplateSpecializationInfo*>();
2106 /// \brief Determine what kind of template instantiation this function
2108 TemplateSpecializationKind getTemplateSpecializationKind() const;
2110 /// \brief Determine what kind of template instantiation this function
2112 void setTemplateSpecializationKind(TemplateSpecializationKind TSK,
2113 SourceLocation PointOfInstantiation = SourceLocation());
2115 /// \brief Retrieve the (first) point of instantiation of a function template
2116 /// specialization or a member of a class template specialization.
2118 /// \returns the first point of instantiation, if this function was
2119 /// instantiated from a template; otherwise, returns an invalid source
2121 SourceLocation getPointOfInstantiation() const;
2123 /// \brief Determine whether this is or was instantiated from an out-of-line
2124 /// definition of a member function.
2125 bool isOutOfLine() const override;
2127 /// \brief Identify a memory copying or setting function.
2128 /// If the given function is a memory copy or setting function, returns
2129 /// the corresponding Builtin ID. If the function is not a memory function,
2131 unsigned getMemoryFunctionKind() const;
2133 // Implement isa/cast/dyncast/etc.
2134 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2135 static bool classofKind(Kind K) {
2136 return K >= firstFunction && K <= lastFunction;
2138 static DeclContext *castToDeclContext(const FunctionDecl *D) {
2139 return static_cast<DeclContext *>(const_cast<FunctionDecl*>(D));
2141 static FunctionDecl *castFromDeclContext(const DeclContext *DC) {
2142 return static_cast<FunctionDecl *>(const_cast<DeclContext*>(DC));
2145 friend class ASTDeclReader;
2146 friend class ASTDeclWriter;
2150 /// FieldDecl - An instance of this class is created by Sema::ActOnField to
2151 /// represent a member of a struct/union/class.
2152 class FieldDecl : public DeclaratorDecl, public Mergeable<FieldDecl> {
2153 // FIXME: This can be packed into the bitfields in Decl.
2155 mutable unsigned CachedFieldIndex : 31;
2157 /// \brief An InClassInitStyle value, and either a bit width expression (if
2158 /// the InClassInitStyle value is ICIS_NoInit), or a pointer to the in-class
2159 /// initializer for this field (otherwise).
2161 /// We can safely combine these two because in-class initializers are not
2162 /// permitted for bit-fields.
2164 /// If the InClassInitStyle is not ICIS_NoInit and the initializer is null,
2165 /// then this field has an in-class initializer which has not yet been parsed
2167 llvm::PointerIntPair<Expr *, 2, unsigned> InitializerOrBitWidth;
2169 FieldDecl(Kind DK, DeclContext *DC, SourceLocation StartLoc,
2170 SourceLocation IdLoc, IdentifierInfo *Id,
2171 QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable,
2172 InClassInitStyle InitStyle)
2173 : DeclaratorDecl(DK, DC, IdLoc, Id, T, TInfo, StartLoc),
2174 Mutable(Mutable), CachedFieldIndex(0),
2175 InitializerOrBitWidth(BW, InitStyle) {
2176 assert((!BW || InitStyle == ICIS_NoInit) && "got initializer for bitfield");
2180 static FieldDecl *Create(const ASTContext &C, DeclContext *DC,
2181 SourceLocation StartLoc, SourceLocation IdLoc,
2182 IdentifierInfo *Id, QualType T,
2183 TypeSourceInfo *TInfo, Expr *BW, bool Mutable,
2184 InClassInitStyle InitStyle);
2186 static FieldDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2188 /// getFieldIndex - Returns the index of this field within its record,
2189 /// as appropriate for passing to ASTRecordLayout::getFieldOffset.
2190 unsigned getFieldIndex() const;
2192 /// isMutable - Determines whether this field is mutable (C++ only).
2193 bool isMutable() const { return Mutable; }
2195 /// isBitfield - Determines whether this field is a bitfield.
2196 bool isBitField() const {
2197 return getInClassInitStyle() == ICIS_NoInit &&
2198 InitializerOrBitWidth.getPointer();
2201 /// @brief Determines whether this is an unnamed bitfield.
2202 bool isUnnamedBitfield() const { return isBitField() && !getDeclName(); }
2204 /// isAnonymousStructOrUnion - Determines whether this field is a
2205 /// representative for an anonymous struct or union. Such fields are
2206 /// unnamed and are implicitly generated by the implementation to
2207 /// store the data for the anonymous union or struct.
2208 bool isAnonymousStructOrUnion() const;
2210 Expr *getBitWidth() const {
2211 return isBitField() ? InitializerOrBitWidth.getPointer() : nullptr;
2213 unsigned getBitWidthValue(const ASTContext &Ctx) const;
2215 /// setBitWidth - Set the bit-field width for this member.
2216 // Note: used by some clients (i.e., do not remove it).
2217 void setBitWidth(Expr *Width);
2218 /// removeBitWidth - Remove the bit-field width from this member.
2219 // Note: used by some clients (i.e., do not remove it).
2220 void removeBitWidth() {
2221 assert(isBitField() && "no bitfield width to remove");
2222 InitializerOrBitWidth.setPointer(nullptr);
2225 /// getInClassInitStyle - Get the kind of (C++11) in-class initializer which
2227 InClassInitStyle getInClassInitStyle() const {
2228 return static_cast<InClassInitStyle>(InitializerOrBitWidth.getInt());
2231 /// hasInClassInitializer - Determine whether this member has a C++11 in-class
2233 bool hasInClassInitializer() const {
2234 return getInClassInitStyle() != ICIS_NoInit;
2236 /// getInClassInitializer - Get the C++11 in-class initializer for this
2237 /// member, or null if one has not been set. If a valid declaration has an
2238 /// in-class initializer, but this returns null, then we have not parsed and
2239 /// attached it yet.
2240 Expr *getInClassInitializer() const {
2241 return hasInClassInitializer() ? InitializerOrBitWidth.getPointer()
2244 /// setInClassInitializer - Set the C++11 in-class initializer for this
2246 void setInClassInitializer(Expr *Init);
2247 /// removeInClassInitializer - Remove the C++11 in-class initializer from this
2249 void removeInClassInitializer() {
2250 assert(hasInClassInitializer() && "no initializer to remove");
2251 InitializerOrBitWidth.setPointer(nullptr);
2252 InitializerOrBitWidth.setInt(ICIS_NoInit);
2255 /// getParent - Returns the parent of this field declaration, which
2256 /// is the struct in which this method is defined.
2257 const RecordDecl *getParent() const {
2258 return cast<RecordDecl>(getDeclContext());
2261 RecordDecl *getParent() {
2262 return cast<RecordDecl>(getDeclContext());
2265 SourceRange getSourceRange() const override LLVM_READONLY;
2267 /// Retrieves the canonical declaration of this field.
2268 FieldDecl *getCanonicalDecl() override { return getFirstDecl(); }
2269 const FieldDecl *getCanonicalDecl() const { return getFirstDecl(); }
2271 // Implement isa/cast/dyncast/etc.
2272 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2273 static bool classofKind(Kind K) { return K >= firstField && K <= lastField; }
2275 friend class ASTDeclReader;
2276 friend class ASTDeclWriter;
2279 /// EnumConstantDecl - An instance of this object exists for each enum constant
2280 /// that is defined. For example, in "enum X {a,b}", each of a/b are
2281 /// EnumConstantDecl's, X is an instance of EnumDecl, and the type of a/b is a
2282 /// TagType for the X EnumDecl.
2283 class EnumConstantDecl : public ValueDecl, public Mergeable<EnumConstantDecl> {
2284 Stmt *Init; // an integer constant expression
2285 llvm::APSInt Val; // The value.
2287 EnumConstantDecl(DeclContext *DC, SourceLocation L,
2288 IdentifierInfo *Id, QualType T, Expr *E,
2289 const llvm::APSInt &V)
2290 : ValueDecl(EnumConstant, DC, L, Id, T), Init((Stmt*)E), Val(V) {}
2294 static EnumConstantDecl *Create(ASTContext &C, EnumDecl *DC,
2295 SourceLocation L, IdentifierInfo *Id,
2296 QualType T, Expr *E,
2297 const llvm::APSInt &V);
2298 static EnumConstantDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2300 const Expr *getInitExpr() const { return (const Expr*) Init; }
2301 Expr *getInitExpr() { return (Expr*) Init; }
2302 const llvm::APSInt &getInitVal() const { return Val; }
2304 void setInitExpr(Expr *E) { Init = (Stmt*) E; }
2305 void setInitVal(const llvm::APSInt &V) { Val = V; }
2307 SourceRange getSourceRange() const override LLVM_READONLY;
2309 /// Retrieves the canonical declaration of this enumerator.
2310 EnumConstantDecl *getCanonicalDecl() override { return getFirstDecl(); }
2311 const EnumConstantDecl *getCanonicalDecl() const { return getFirstDecl(); }
2313 // Implement isa/cast/dyncast/etc.
2314 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2315 static bool classofKind(Kind K) { return K == EnumConstant; }
2317 friend class StmtIteratorBase;
2320 /// IndirectFieldDecl - An instance of this class is created to represent a
2321 /// field injected from an anonymous union/struct into the parent scope.
2322 /// IndirectFieldDecl are always implicit.
2323 class IndirectFieldDecl : public ValueDecl {
2324 void anchor() override;
2325 NamedDecl **Chaining;
2326 unsigned ChainingSize;
2328 IndirectFieldDecl(DeclContext *DC, SourceLocation L,
2329 DeclarationName N, QualType T,
2330 NamedDecl **CH, unsigned CHS)
2331 : ValueDecl(IndirectField, DC, L, N, T), Chaining(CH), ChainingSize(CHS) {}
2334 static IndirectFieldDecl *Create(ASTContext &C, DeclContext *DC,
2335 SourceLocation L, IdentifierInfo *Id,
2336 QualType T, NamedDecl **CH, unsigned CHS);
2338 static IndirectFieldDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2340 typedef NamedDecl * const *chain_iterator;
2341 typedef llvm::iterator_range<chain_iterator> chain_range;
2343 chain_range chain() const { return chain_range(chain_begin(), chain_end()); }
2344 chain_iterator chain_begin() const { return chain_iterator(Chaining); }
2345 chain_iterator chain_end() const {
2346 return chain_iterator(Chaining + ChainingSize);
2349 unsigned getChainingSize() const { return ChainingSize; }
2351 FieldDecl *getAnonField() const {
2352 assert(ChainingSize >= 2);
2353 return cast<FieldDecl>(Chaining[ChainingSize - 1]);
2356 VarDecl *getVarDecl() const {
2357 assert(ChainingSize >= 2);
2358 return dyn_cast<VarDecl>(*chain_begin());
2361 // Implement isa/cast/dyncast/etc.
2362 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2363 static bool classofKind(Kind K) { return K == IndirectField; }
2364 friend class ASTDeclReader;
2367 /// TypeDecl - Represents a declaration of a type.
2369 class TypeDecl : public NamedDecl {
2370 void anchor() override;
2371 /// TypeForDecl - This indicates the Type object that represents
2372 /// this TypeDecl. It is a cache maintained by
2373 /// ASTContext::getTypedefType, ASTContext::getTagDeclType, and
2374 /// ASTContext::getTemplateTypeParmType, and TemplateTypeParmDecl.
2375 mutable const Type *TypeForDecl;
2376 /// LocStart - The start of the source range for this declaration.
2377 SourceLocation LocStart;
2378 friend class ASTContext;
2381 TypeDecl(Kind DK, DeclContext *DC, SourceLocation L, IdentifierInfo *Id,
2382 SourceLocation StartL = SourceLocation())
2383 : NamedDecl(DK, DC, L, Id), TypeForDecl(nullptr), LocStart(StartL) {}
2386 // Low-level accessor. If you just want the type defined by this node,
2387 // check out ASTContext::getTypeDeclType or one of
2388 // ASTContext::getTypedefType, ASTContext::getRecordType, etc. if you
2389 // already know the specific kind of node this is.
2390 const Type *getTypeForDecl() const { return TypeForDecl; }
2391 void setTypeForDecl(const Type *TD) { TypeForDecl = TD; }
2393 SourceLocation getLocStart() const LLVM_READONLY { return LocStart; }
2394 void setLocStart(SourceLocation L) { LocStart = L; }
2395 SourceRange getSourceRange() const override LLVM_READONLY {
2396 if (LocStart.isValid())
2397 return SourceRange(LocStart, getLocation());
2399 return SourceRange(getLocation());
2402 // Implement isa/cast/dyncast/etc.
2403 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2404 static bool classofKind(Kind K) { return K >= firstType && K <= lastType; }
2408 /// Base class for declarations which introduce a typedef-name.
2409 class TypedefNameDecl : public TypeDecl, public Redeclarable<TypedefNameDecl> {
2410 void anchor() override;
2411 typedef std::pair<TypeSourceInfo*, QualType> ModedTInfo;
2412 llvm::PointerUnion<TypeSourceInfo*, ModedTInfo*> MaybeModedTInfo;
2415 TypedefNameDecl(Kind DK, ASTContext &C, DeclContext *DC,
2416 SourceLocation StartLoc, SourceLocation IdLoc,
2417 IdentifierInfo *Id, TypeSourceInfo *TInfo)
2418 : TypeDecl(DK, DC, IdLoc, Id, StartLoc), redeclarable_base(C),
2419 MaybeModedTInfo(TInfo) {}
2421 typedef Redeclarable<TypedefNameDecl> redeclarable_base;
2422 TypedefNameDecl *getNextRedeclarationImpl() override {
2423 return getNextRedeclaration();
2425 TypedefNameDecl *getPreviousDeclImpl() override {
2426 return getPreviousDecl();
2428 TypedefNameDecl *getMostRecentDeclImpl() override {
2429 return getMostRecentDecl();
2433 typedef redeclarable_base::redecl_range redecl_range;
2434 typedef redeclarable_base::redecl_iterator redecl_iterator;
2435 using redeclarable_base::redecls_begin;
2436 using redeclarable_base::redecls_end;
2437 using redeclarable_base::redecls;
2438 using redeclarable_base::getPreviousDecl;
2439 using redeclarable_base::getMostRecentDecl;
2440 using redeclarable_base::isFirstDecl;
2442 bool isModed() const { return MaybeModedTInfo.is<ModedTInfo*>(); }
2444 TypeSourceInfo *getTypeSourceInfo() const {
2446 ? MaybeModedTInfo.get<ModedTInfo*>()->first
2447 : MaybeModedTInfo.get<TypeSourceInfo*>();
2449 QualType getUnderlyingType() const {
2451 ? MaybeModedTInfo.get<ModedTInfo*>()->second
2452 : MaybeModedTInfo.get<TypeSourceInfo*>()->getType();
2454 void setTypeSourceInfo(TypeSourceInfo *newType) {
2455 MaybeModedTInfo = newType;
2457 void setModedTypeSourceInfo(TypeSourceInfo *unmodedTSI, QualType modedTy) {
2458 MaybeModedTInfo = new (getASTContext()) ModedTInfo(unmodedTSI, modedTy);
2461 /// Retrieves the canonical declaration of this typedef-name.
2462 TypedefNameDecl *getCanonicalDecl() override { return getFirstDecl(); }
2463 const TypedefNameDecl *getCanonicalDecl() const { return getFirstDecl(); }
2465 // Implement isa/cast/dyncast/etc.
2466 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2467 static bool classofKind(Kind K) {
2468 return K >= firstTypedefName && K <= lastTypedefName;
2472 /// TypedefDecl - Represents the declaration of a typedef-name via the 'typedef'
2474 class TypedefDecl : public TypedefNameDecl {
2475 TypedefDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
2476 SourceLocation IdLoc, IdentifierInfo *Id, TypeSourceInfo *TInfo)
2477 : TypedefNameDecl(Typedef, C, DC, StartLoc, IdLoc, Id, TInfo) {}
2480 static TypedefDecl *Create(ASTContext &C, DeclContext *DC,
2481 SourceLocation StartLoc, SourceLocation IdLoc,
2482 IdentifierInfo *Id, TypeSourceInfo *TInfo);
2483 static TypedefDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2485 SourceRange getSourceRange() const override LLVM_READONLY;
2487 // Implement isa/cast/dyncast/etc.
2488 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2489 static bool classofKind(Kind K) { return K == Typedef; }
2492 /// TypeAliasDecl - Represents the declaration of a typedef-name via a C++0x
2493 /// alias-declaration.
2494 class TypeAliasDecl : public TypedefNameDecl {
2495 TypeAliasDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
2496 SourceLocation IdLoc, IdentifierInfo *Id, TypeSourceInfo *TInfo)
2497 : TypedefNameDecl(TypeAlias, C, DC, StartLoc, IdLoc, Id, TInfo) {}
2500 static TypeAliasDecl *Create(ASTContext &C, DeclContext *DC,
2501 SourceLocation StartLoc, SourceLocation IdLoc,
2502 IdentifierInfo *Id, TypeSourceInfo *TInfo);
2503 static TypeAliasDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2505 SourceRange getSourceRange() const override LLVM_READONLY;
2507 // Implement isa/cast/dyncast/etc.
2508 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2509 static bool classofKind(Kind K) { return K == TypeAlias; }
2512 /// TagDecl - Represents the declaration of a struct/union/class/enum.
2514 : public TypeDecl, public DeclContext, public Redeclarable<TagDecl> {
2516 // This is really ugly.
2517 typedef TagTypeKind TagKind;
2520 // FIXME: This can be packed into the bitfields in Decl.
2521 /// TagDeclKind - The TagKind enum.
2522 unsigned TagDeclKind : 3;
2524 /// IsCompleteDefinition - True if this is a definition ("struct foo
2525 /// {};"), false if it is a declaration ("struct foo;"). It is not
2526 /// a definition until the definition has been fully processed.
2527 bool IsCompleteDefinition : 1;
2530 /// IsBeingDefined - True if this is currently being defined.
2531 bool IsBeingDefined : 1;
2534 /// IsEmbeddedInDeclarator - True if this tag declaration is
2535 /// "embedded" (i.e., defined or declared for the very first time)
2536 /// in the syntax of a declarator.
2537 bool IsEmbeddedInDeclarator : 1;
2539 /// \brief True if this tag is free standing, e.g. "struct foo;".
2540 bool IsFreeStanding : 1;
2543 // These are used by (and only defined for) EnumDecl.
2544 unsigned NumPositiveBits : 8;
2545 unsigned NumNegativeBits : 8;
2547 /// IsScoped - True if this tag declaration is a scoped enumeration. Only
2548 /// possible in C++11 mode.
2550 /// IsScopedUsingClassTag - If this tag declaration is a scoped enum,
2551 /// then this is true if the scoped enum was declared using the class
2552 /// tag, false if it was declared with the struct tag. No meaning is
2553 /// associated if this tag declaration is not a scoped enum.
2554 bool IsScopedUsingClassTag : 1;
2556 /// IsFixed - True if this is an enumeration with fixed underlying type. Only
2557 /// possible in C++11, Microsoft extensions, or Objective C mode.
2560 /// \brief Indicates whether it is possible for declarations of this kind
2561 /// to have an out-of-date definition.
2563 /// This option is only enabled when modules are enabled.
2564 bool MayHaveOutOfDateDef : 1;
2566 /// Has the full definition of this type been required by a use somewhere in
2568 bool IsCompleteDefinitionRequired : 1;
2570 SourceLocation RBraceLoc;
2572 // A struct representing syntactic qualifier info,
2573 // to be used for the (uncommon) case of out-of-line declarations.
2574 typedef QualifierInfo ExtInfo;
2576 /// \brief If the (out-of-line) tag declaration name
2577 /// is qualified, it points to the qualifier info (nns and range);
2578 /// otherwise, if the tag declaration is anonymous and it is part of
2579 /// a typedef or alias, it points to the TypedefNameDecl (used for mangling);
2580 /// otherwise, if the tag declaration is anonymous and it is used as a
2581 /// declaration specifier for variables, it points to the first VarDecl (used
2583 /// otherwise, it is a null (TypedefNameDecl) pointer.
2584 llvm::PointerUnion<NamedDecl *, ExtInfo *> NamedDeclOrQualifier;
2586 bool hasExtInfo() const { return NamedDeclOrQualifier.is<ExtInfo *>(); }
2587 ExtInfo *getExtInfo() { return NamedDeclOrQualifier.get<ExtInfo *>(); }
2588 const ExtInfo *getExtInfo() const {
2589 return NamedDeclOrQualifier.get<ExtInfo *>();
2593 TagDecl(Kind DK, TagKind TK, const ASTContext &C, DeclContext *DC,
2594 SourceLocation L, IdentifierInfo *Id, TagDecl *PrevDecl,
2595 SourceLocation StartL)
2596 : TypeDecl(DK, DC, L, Id, StartL), DeclContext(DK), redeclarable_base(C),
2597 TagDeclKind(TK), IsCompleteDefinition(false), IsBeingDefined(false),
2598 IsEmbeddedInDeclarator(false), IsFreeStanding(false),
2599 IsCompleteDefinitionRequired(false),
2600 NamedDeclOrQualifier((NamedDecl *)nullptr) {
2601 assert((DK != Enum || TK == TTK_Enum) &&
2602 "EnumDecl not matched with TTK_Enum");
2603 setPreviousDecl(PrevDecl);
2606 typedef Redeclarable<TagDecl> redeclarable_base;
2607 TagDecl *getNextRedeclarationImpl() override {
2608 return getNextRedeclaration();
2610 TagDecl *getPreviousDeclImpl() override {
2611 return getPreviousDecl();
2613 TagDecl *getMostRecentDeclImpl() override {
2614 return getMostRecentDecl();
2617 /// @brief Completes the definition of this tag declaration.
2619 /// This is a helper function for derived classes.
2620 void completeDefinition();
2623 typedef redeclarable_base::redecl_range redecl_range;
2624 typedef redeclarable_base::redecl_iterator redecl_iterator;
2625 using redeclarable_base::redecls_begin;
2626 using redeclarable_base::redecls_end;
2627 using redeclarable_base::redecls;
2628 using redeclarable_base::getPreviousDecl;
2629 using redeclarable_base::getMostRecentDecl;
2630 using redeclarable_base::isFirstDecl;
2632 SourceLocation getRBraceLoc() const { return RBraceLoc; }
2633 void setRBraceLoc(SourceLocation L) { RBraceLoc = L; }
2635 /// getInnerLocStart - Return SourceLocation representing start of source
2636 /// range ignoring outer template declarations.
2637 SourceLocation getInnerLocStart() const { return getLocStart(); }
2639 /// getOuterLocStart - Return SourceLocation representing start of source
2640 /// range taking into account any outer template declarations.
2641 SourceLocation getOuterLocStart() const;
2642 SourceRange getSourceRange() const override LLVM_READONLY;
2644 TagDecl *getCanonicalDecl() override;
2645 const TagDecl *getCanonicalDecl() const {
2646 return const_cast<TagDecl*>(this)->getCanonicalDecl();
2649 /// isThisDeclarationADefinition() - Return true if this declaration
2650 /// is a completion definintion of the type. Provided for consistency.
2651 bool isThisDeclarationADefinition() const {
2652 return isCompleteDefinition();
2655 /// isCompleteDefinition - Return true if this decl has its body
2656 /// fully specified.
2657 bool isCompleteDefinition() const {
2658 return IsCompleteDefinition;
2661 /// \brief Return true if this complete decl is
2662 /// required to be complete for some existing use.
2663 bool isCompleteDefinitionRequired() const {
2664 return IsCompleteDefinitionRequired;
2667 /// isBeingDefined - Return true if this decl is currently being defined.
2668 bool isBeingDefined() const {
2669 return IsBeingDefined;
2672 bool isEmbeddedInDeclarator() const {
2673 return IsEmbeddedInDeclarator;
2675 void setEmbeddedInDeclarator(bool isInDeclarator) {
2676 IsEmbeddedInDeclarator = isInDeclarator;
2679 bool isFreeStanding() const { return IsFreeStanding; }
2680 void setFreeStanding(bool isFreeStanding = true) {
2681 IsFreeStanding = isFreeStanding;
2684 /// \brief Whether this declaration declares a type that is
2685 /// dependent, i.e., a type that somehow depends on template
2687 bool isDependentType() const { return isDependentContext(); }
2689 /// @brief Starts the definition of this tag declaration.
2691 /// This method should be invoked at the beginning of the definition
2692 /// of this tag declaration. It will set the tag type into a state
2693 /// where it is in the process of being defined.
2694 void startDefinition();
2696 /// getDefinition - Returns the TagDecl that actually defines this
2697 /// struct/union/class/enum. When determining whether or not a
2698 /// struct/union/class/enum has a definition, one should use this
2699 /// method as opposed to 'isDefinition'. 'isDefinition' indicates
2700 /// whether or not a specific TagDecl is defining declaration, not
2701 /// whether or not the struct/union/class/enum type is defined.
2702 /// This method returns NULL if there is no TagDecl that defines
2703 /// the struct/union/class/enum.
2704 TagDecl *getDefinition() const;
2706 void setCompleteDefinition(bool V) { IsCompleteDefinition = V; }
2708 void setCompleteDefinitionRequired(bool V = true) {
2709 IsCompleteDefinitionRequired = V;
2712 StringRef getKindName() const {
2713 return TypeWithKeyword::getTagTypeKindName(getTagKind());
2716 TagKind getTagKind() const {
2717 return TagKind(TagDeclKind);
2720 void setTagKind(TagKind TK) { TagDeclKind = TK; }
2722 bool isStruct() const { return getTagKind() == TTK_Struct; }
2723 bool isInterface() const { return getTagKind() == TTK_Interface; }
2724 bool isClass() const { return getTagKind() == TTK_Class; }
2725 bool isUnion() const { return getTagKind() == TTK_Union; }
2726 bool isEnum() const { return getTagKind() == TTK_Enum; }
2728 /// Is this tag type named, either directly or via being defined in
2729 /// a typedef of this type?
2731 /// C++11 [basic.link]p8:
2732 /// A type is said to have linkage if and only if:
2733 /// - it is a class or enumeration type that is named (or has a
2734 /// name for linkage purposes) and the name has linkage; ...
2735 /// C++11 [dcl.typedef]p9:
2736 /// If the typedef declaration defines an unnamed class (or enum),
2737 /// the first typedef-name declared by the declaration to be that
2738 /// class type (or enum type) is used to denote the class type (or
2739 /// enum type) for linkage purposes only.
2741 /// C does not have an analogous rule, but the same concept is
2742 /// nonetheless useful in some places.
2743 bool hasNameForLinkage() const {
2744 return (getDeclName() || getTypedefNameForAnonDecl());
2747 bool hasDeclaratorForAnonDecl() const {
2748 return dyn_cast_or_null<DeclaratorDecl>(
2749 NamedDeclOrQualifier.get<NamedDecl *>());
2751 DeclaratorDecl *getDeclaratorForAnonDecl() const {
2752 return hasExtInfo() ? nullptr : dyn_cast_or_null<DeclaratorDecl>(
2753 NamedDeclOrQualifier.get<NamedDecl *>());
2756 TypedefNameDecl *getTypedefNameForAnonDecl() const {
2757 return hasExtInfo() ? nullptr : dyn_cast_or_null<TypedefNameDecl>(
2758 NamedDeclOrQualifier.get<NamedDecl *>());
2761 void setDeclaratorForAnonDecl(DeclaratorDecl *DD) { NamedDeclOrQualifier = DD; }
2763 void setTypedefNameForAnonDecl(TypedefNameDecl *TDD);
2765 /// \brief Retrieve the nested-name-specifier that qualifies the name of this
2766 /// declaration, if it was present in the source.
2767 NestedNameSpecifier *getQualifier() const {
2768 return hasExtInfo() ? getExtInfo()->QualifierLoc.getNestedNameSpecifier()
2772 /// \brief Retrieve the nested-name-specifier (with source-location
2773 /// information) that qualifies the name of this declaration, if it was
2774 /// present in the source.
2775 NestedNameSpecifierLoc getQualifierLoc() const {
2776 return hasExtInfo() ? getExtInfo()->QualifierLoc
2777 : NestedNameSpecifierLoc();
2780 void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc);
2782 unsigned getNumTemplateParameterLists() const {
2783 return hasExtInfo() ? getExtInfo()->NumTemplParamLists : 0;
2785 TemplateParameterList *getTemplateParameterList(unsigned i) const {
2786 assert(i < getNumTemplateParameterLists());
2787 return getExtInfo()->TemplParamLists[i];
2789 void setTemplateParameterListsInfo(ASTContext &Context, unsigned NumTPLists,
2790 TemplateParameterList **TPLists);
2792 // Implement isa/cast/dyncast/etc.
2793 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2794 static bool classofKind(Kind K) { return K >= firstTag && K <= lastTag; }
2796 static DeclContext *castToDeclContext(const TagDecl *D) {
2797 return static_cast<DeclContext *>(const_cast<TagDecl*>(D));
2799 static TagDecl *castFromDeclContext(const DeclContext *DC) {
2800 return static_cast<TagDecl *>(const_cast<DeclContext*>(DC));
2803 friend class ASTDeclReader;
2804 friend class ASTDeclWriter;
2807 /// EnumDecl - Represents an enum. In C++11, enums can be forward-declared
2808 /// with a fixed underlying type, and in C we allow them to be forward-declared
2809 /// with no underlying type as an extension.
2810 class EnumDecl : public TagDecl {
2811 void anchor() override;
2812 /// IntegerType - This represent the integer type that the enum corresponds
2813 /// to for code generation purposes. Note that the enumerator constants may
2814 /// have a different type than this does.
2816 /// If the underlying integer type was explicitly stated in the source
2817 /// code, this is a TypeSourceInfo* for that type. Otherwise this type
2818 /// was automatically deduced somehow, and this is a Type*.
2820 /// Normally if IsFixed(), this would contain a TypeSourceInfo*, but in
2821 /// some cases it won't.
2823 /// The underlying type of an enumeration never has any qualifiers, so
2824 /// we can get away with just storing a raw Type*, and thus save an
2825 /// extra pointer when TypeSourceInfo is needed.
2827 llvm::PointerUnion<const Type*, TypeSourceInfo*> IntegerType;
2829 /// PromotionType - The integer type that values of this type should
2830 /// promote to. In C, enumerators are generally of an integer type
2831 /// directly, but gcc-style large enumerators (and all enumerators
2832 /// in C++) are of the enum type instead.
2833 QualType PromotionType;
2835 /// \brief If this enumeration is an instantiation of a member enumeration
2836 /// of a class template specialization, this is the member specialization
2838 MemberSpecializationInfo *SpecializationInfo;
2840 EnumDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
2841 SourceLocation IdLoc, IdentifierInfo *Id, EnumDecl *PrevDecl,
2842 bool Scoped, bool ScopedUsingClassTag, bool Fixed)
2843 : TagDecl(Enum, TTK_Enum, C, DC, IdLoc, Id, PrevDecl, StartLoc),
2844 SpecializationInfo(nullptr) {
2845 assert(Scoped || !ScopedUsingClassTag);
2846 IntegerType = (const Type *)nullptr;
2847 NumNegativeBits = 0;
2848 NumPositiveBits = 0;
2850 IsScopedUsingClassTag = ScopedUsingClassTag;
2854 void setInstantiationOfMemberEnum(ASTContext &C, EnumDecl *ED,
2855 TemplateSpecializationKind TSK);
2857 EnumDecl *getCanonicalDecl() override {
2858 return cast<EnumDecl>(TagDecl::getCanonicalDecl());
2860 const EnumDecl *getCanonicalDecl() const {
2861 return const_cast<EnumDecl*>(this)->getCanonicalDecl();
2864 EnumDecl *getPreviousDecl() {
2865 return cast_or_null<EnumDecl>(
2866 static_cast<TagDecl *>(this)->getPreviousDecl());
2868 const EnumDecl *getPreviousDecl() const {
2869 return const_cast<EnumDecl*>(this)->getPreviousDecl();
2872 EnumDecl *getMostRecentDecl() {
2873 return cast<EnumDecl>(static_cast<TagDecl *>(this)->getMostRecentDecl());
2875 const EnumDecl *getMostRecentDecl() const {
2876 return const_cast<EnumDecl*>(this)->getMostRecentDecl();
2879 EnumDecl *getDefinition() const {
2880 return cast_or_null<EnumDecl>(TagDecl::getDefinition());
2883 static EnumDecl *Create(ASTContext &C, DeclContext *DC,
2884 SourceLocation StartLoc, SourceLocation IdLoc,
2885 IdentifierInfo *Id, EnumDecl *PrevDecl,
2886 bool IsScoped, bool IsScopedUsingClassTag,
2888 static EnumDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2890 /// completeDefinition - When created, the EnumDecl corresponds to a
2891 /// forward-declared enum. This method is used to mark the
2892 /// declaration as being defined; it's enumerators have already been
2893 /// added (via DeclContext::addDecl). NewType is the new underlying
2894 /// type of the enumeration type.
2895 void completeDefinition(QualType NewType,
2896 QualType PromotionType,
2897 unsigned NumPositiveBits,
2898 unsigned NumNegativeBits);
2900 // enumerator_iterator - Iterates through the enumerators of this
2902 typedef specific_decl_iterator<EnumConstantDecl> enumerator_iterator;
2903 typedef llvm::iterator_range<specific_decl_iterator<EnumConstantDecl>>
2906 enumerator_range enumerators() const {
2907 return enumerator_range(enumerator_begin(), enumerator_end());
2910 enumerator_iterator enumerator_begin() const {
2911 const EnumDecl *E = getDefinition();
2914 return enumerator_iterator(E->decls_begin());
2917 enumerator_iterator enumerator_end() const {
2918 const EnumDecl *E = getDefinition();
2921 return enumerator_iterator(E->decls_end());
2924 /// getPromotionType - Return the integer type that enumerators
2925 /// should promote to.
2926 QualType getPromotionType() const { return PromotionType; }
2928 /// \brief Set the promotion type.
2929 void setPromotionType(QualType T) { PromotionType = T; }
2931 /// getIntegerType - Return the integer type this enum decl corresponds to.
2932 /// This returns a null QualType for an enum forward definition with no fixed
2933 /// underlying type.
2934 QualType getIntegerType() const {
2937 if (const Type *T = IntegerType.dyn_cast<const Type*>())
2938 return QualType(T, 0);
2939 return IntegerType.get<TypeSourceInfo*>()->getType().getUnqualifiedType();
2942 /// \brief Set the underlying integer type.
2943 void setIntegerType(QualType T) { IntegerType = T.getTypePtrOrNull(); }
2945 /// \brief Set the underlying integer type source info.
2946 void setIntegerTypeSourceInfo(TypeSourceInfo *TInfo) { IntegerType = TInfo; }
2948 /// \brief Return the type source info for the underlying integer type,
2949 /// if no type source info exists, return 0.
2950 TypeSourceInfo *getIntegerTypeSourceInfo() const {
2951 return IntegerType.dyn_cast<TypeSourceInfo*>();
2954 /// \brief Retrieve the source range that covers the underlying type if
2956 SourceRange getIntegerTypeRange() const LLVM_READONLY;
2958 /// \brief Returns the width in bits required to store all the
2959 /// non-negative enumerators of this enum.
2960 unsigned getNumPositiveBits() const {
2961 return NumPositiveBits;
2963 void setNumPositiveBits(unsigned Num) {
2964 NumPositiveBits = Num;
2965 assert(NumPositiveBits == Num && "can't store this bitcount");
2968 /// \brief Returns the width in bits required to store all the
2969 /// negative enumerators of this enum. These widths include
2970 /// the rightmost leading 1; that is:
2972 /// MOST NEGATIVE ENUMERATOR PATTERN NUM NEGATIVE BITS
2973 /// ------------------------ ------- -----------------
2977 unsigned getNumNegativeBits() const {
2978 return NumNegativeBits;
2980 void setNumNegativeBits(unsigned Num) {
2981 NumNegativeBits = Num;
2984 /// \brief Returns true if this is a C++11 scoped enumeration.
2985 bool isScoped() const {
2989 /// \brief Returns true if this is a C++11 scoped enumeration.
2990 bool isScopedUsingClassTag() const {
2991 return IsScopedUsingClassTag;
2994 /// \brief Returns true if this is an Objective-C, C++11, or
2995 /// Microsoft-style enumeration with a fixed underlying type.
2996 bool isFixed() const {
3000 /// \brief Returns true if this can be considered a complete type.
3001 bool isComplete() const {
3002 return isCompleteDefinition() || isFixed();
3005 /// \brief Returns the enumeration (declared within the template)
3006 /// from which this enumeration type was instantiated, or NULL if
3007 /// this enumeration was not instantiated from any template.
3008 EnumDecl *getInstantiatedFromMemberEnum() const;
3010 /// \brief If this enumeration is a member of a specialization of a
3011 /// templated class, determine what kind of template specialization
3012 /// or instantiation this is.
3013 TemplateSpecializationKind getTemplateSpecializationKind() const;
3015 /// \brief For an enumeration member that was instantiated from a member
3016 /// enumeration of a templated class, set the template specialiation kind.
3017 void setTemplateSpecializationKind(TemplateSpecializationKind TSK,
3018 SourceLocation PointOfInstantiation = SourceLocation());
3020 /// \brief If this enumeration is an instantiation of a member enumeration of
3021 /// a class template specialization, retrieves the member specialization
3023 MemberSpecializationInfo *getMemberSpecializationInfo() const {
3024 return SpecializationInfo;
3027 /// \brief Specify that this enumeration is an instantiation of the
3028 /// member enumeration ED.
3029 void setInstantiationOfMemberEnum(EnumDecl *ED,
3030 TemplateSpecializationKind TSK) {
3031 setInstantiationOfMemberEnum(getASTContext(), ED, TSK);
3034 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3035 static bool classofKind(Kind K) { return K == Enum; }
3037 friend class ASTDeclReader;
3041 /// RecordDecl - Represents a struct/union/class. For example:
3042 /// struct X; // Forward declaration, no "body".
3043 /// union Y { int A, B; }; // Has body with members A and B (FieldDecls).
3044 /// This decl will be marked invalid if *any* members are invalid.
3046 class RecordDecl : public TagDecl {
3047 // FIXME: This can be packed into the bitfields in Decl.
3048 /// HasFlexibleArrayMember - This is true if this struct ends with a flexible
3049 /// array member (e.g. int X[]) or if this union contains a struct that does.
3050 /// If so, this cannot be contained in arrays or other structs as a member.
3051 bool HasFlexibleArrayMember : 1;
3053 /// AnonymousStructOrUnion - Whether this is the type of an anonymous struct
3055 bool AnonymousStructOrUnion : 1;
3057 /// HasObjectMember - This is true if this struct has at least one member
3058 /// containing an Objective-C object pointer type.
3059 bool HasObjectMember : 1;
3061 /// HasVolatileMember - This is true if struct has at least one member of
3062 /// 'volatile' type.
3063 bool HasVolatileMember : 1;
3065 /// \brief Whether the field declarations of this record have been loaded
3066 /// from external storage. To avoid unnecessary deserialization of
3067 /// methods/nested types we allow deserialization of just the fields
3069 mutable bool LoadedFieldsFromExternalStorage : 1;
3070 friend class DeclContext;
3073 RecordDecl(Kind DK, TagKind TK, const ASTContext &C, DeclContext *DC,
3074 SourceLocation StartLoc, SourceLocation IdLoc,
3075 IdentifierInfo *Id, RecordDecl *PrevDecl);
3078 static RecordDecl *Create(const ASTContext &C, TagKind TK, DeclContext *DC,
3079 SourceLocation StartLoc, SourceLocation IdLoc,
3080 IdentifierInfo *Id, RecordDecl* PrevDecl = nullptr);
3081 static RecordDecl *CreateDeserialized(const ASTContext &C, unsigned ID);
3083 RecordDecl *getPreviousDecl() {
3084 return cast_or_null<RecordDecl>(
3085 static_cast<TagDecl *>(this)->getPreviousDecl());
3087 const RecordDecl *getPreviousDecl() const {
3088 return const_cast<RecordDecl*>(this)->getPreviousDecl();
3091 RecordDecl *getMostRecentDecl() {
3092 return cast<RecordDecl>(static_cast<TagDecl *>(this)->getMostRecentDecl());
3094 const RecordDecl *getMostRecentDecl() const {
3095 return const_cast<RecordDecl*>(this)->getMostRecentDecl();
3098 bool hasFlexibleArrayMember() const { return HasFlexibleArrayMember; }
3099 void setHasFlexibleArrayMember(bool V) { HasFlexibleArrayMember = V; }
3101 /// isAnonymousStructOrUnion - Whether this is an anonymous struct
3102 /// or union. To be an anonymous struct or union, it must have been
3103 /// declared without a name and there must be no objects of this
3104 /// type declared, e.g.,
3106 /// union { int i; float f; };
3108 /// is an anonymous union but neither of the following are:
3110 /// union X { int i; float f; };
3111 /// union { int i; float f; } obj;
3113 bool isAnonymousStructOrUnion() const { return AnonymousStructOrUnion; }
3114 void setAnonymousStructOrUnion(bool Anon) {
3115 AnonymousStructOrUnion = Anon;
3118 bool hasObjectMember() const { return HasObjectMember; }
3119 void setHasObjectMember (bool val) { HasObjectMember = val; }
3121 bool hasVolatileMember() const { return HasVolatileMember; }
3122 void setHasVolatileMember (bool val) { HasVolatileMember = val; }
3124 /// \brief Determines whether this declaration represents the
3125 /// injected class name.
3127 /// The injected class name in C++ is the name of the class that
3128 /// appears inside the class itself. For example:
3132 /// // C is implicitly declared here as a synonym for the class name.
3135 /// C::C c; // same as "C c;"
3137 bool isInjectedClassName() const;
3139 /// getDefinition - Returns the RecordDecl that actually defines
3140 /// this struct/union/class. When determining whether or not a
3141 /// struct/union/class is completely defined, one should use this
3142 /// method as opposed to 'isCompleteDefinition'.
3143 /// 'isCompleteDefinition' indicates whether or not a specific
3144 /// RecordDecl is a completed definition, not whether or not the
3145 /// record type is defined. This method returns NULL if there is
3146 /// no RecordDecl that defines the struct/union/tag.
3147 RecordDecl *getDefinition() const {
3148 return cast_or_null<RecordDecl>(TagDecl::getDefinition());
3151 // Iterator access to field members. The field iterator only visits
3152 // the non-static data members of this class, ignoring any static
3153 // data members, functions, constructors, destructors, etc.
3154 typedef specific_decl_iterator<FieldDecl> field_iterator;
3155 typedef llvm::iterator_range<specific_decl_iterator<FieldDecl>> field_range;
3157 field_range fields() const { return field_range(field_begin(), field_end()); }
3158 field_iterator field_begin() const;
3160 field_iterator field_end() const {
3161 return field_iterator(decl_iterator());
3164 // field_empty - Whether there are any fields (non-static data
3165 // members) in this record.
3166 bool field_empty() const {
3167 return field_begin() == field_end();
3170 /// completeDefinition - Notes that the definition of this type is
3172 virtual void completeDefinition();
3174 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3175 static bool classofKind(Kind K) {
3176 return K >= firstRecord && K <= lastRecord;
3179 /// isMsStrust - Get whether or not this is an ms_struct which can
3180 /// be turned on with an attribute, pragma, or -mms-bitfields
3181 /// commandline option.
3182 bool isMsStruct(const ASTContext &C) const;
3185 /// \brief Deserialize just the fields.
3186 void LoadFieldsFromExternalStorage() const;
3189 class FileScopeAsmDecl : public Decl {
3190 virtual void anchor();
3191 StringLiteral *AsmString;
3192 SourceLocation RParenLoc;
3193 FileScopeAsmDecl(DeclContext *DC, StringLiteral *asmstring,
3194 SourceLocation StartL, SourceLocation EndL)
3195 : Decl(FileScopeAsm, DC, StartL), AsmString(asmstring), RParenLoc(EndL) {}
3197 static FileScopeAsmDecl *Create(ASTContext &C, DeclContext *DC,
3198 StringLiteral *Str, SourceLocation AsmLoc,
3199 SourceLocation RParenLoc);
3201 static FileScopeAsmDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3203 SourceLocation getAsmLoc() const { return getLocation(); }
3204 SourceLocation getRParenLoc() const { return RParenLoc; }
3205 void setRParenLoc(SourceLocation L) { RParenLoc = L; }
3206 SourceRange getSourceRange() const override LLVM_READONLY {
3207 return SourceRange(getAsmLoc(), getRParenLoc());
3210 const StringLiteral *getAsmString() const { return AsmString; }
3211 StringLiteral *getAsmString() { return AsmString; }
3212 void setAsmString(StringLiteral *Asm) { AsmString = Asm; }
3214 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3215 static bool classofKind(Kind K) { return K == FileScopeAsm; }
3218 /// BlockDecl - This represents a block literal declaration, which is like an
3219 /// unnamed FunctionDecl. For example:
3220 /// ^{ statement-body } or ^(int arg1, float arg2){ statement-body }
3222 class BlockDecl : public Decl, public DeclContext {
3224 /// A class which contains all the information about a particular
3232 /// The variable being captured.
3233 llvm::PointerIntPair<VarDecl*, 2> VariableAndFlags;
3235 /// The copy expression, expressed in terms of a DeclRef (or
3236 /// BlockDeclRef) to the captured variable. Only required if the
3237 /// variable has a C++ class type.
3241 Capture(VarDecl *variable, bool byRef, bool nested, Expr *copy)
3242 : VariableAndFlags(variable,
3243 (byRef ? flag_isByRef : 0) | (nested ? flag_isNested : 0)),
3246 /// The variable being captured.
3247 VarDecl *getVariable() const { return VariableAndFlags.getPointer(); }
3249 /// Whether this is a "by ref" capture, i.e. a capture of a __block
3251 bool isByRef() const { return VariableAndFlags.getInt() & flag_isByRef; }
3253 /// Whether this is a nested capture, i.e. the variable captured
3254 /// is not from outside the immediately enclosing function/block.
3255 bool isNested() const { return VariableAndFlags.getInt() & flag_isNested; }
3257 bool hasCopyExpr() const { return CopyExpr != nullptr; }
3258 Expr *getCopyExpr() const { return CopyExpr; }
3259 void setCopyExpr(Expr *e) { CopyExpr = e; }
3263 // FIXME: This can be packed into the bitfields in Decl.
3264 bool IsVariadic : 1;
3265 bool CapturesCXXThis : 1;
3266 bool BlockMissingReturnType : 1;
3267 bool IsConversionFromLambda : 1;
3268 /// ParamInfo - new[]'d array of pointers to ParmVarDecls for the formal
3269 /// parameters of this function. This is null if a prototype or if there are
3271 ParmVarDecl **ParamInfo;
3275 TypeSourceInfo *SignatureAsWritten;
3278 unsigned NumCaptures;
3280 unsigned ManglingNumber;
3281 Decl *ManglingContextDecl;
3284 BlockDecl(DeclContext *DC, SourceLocation CaretLoc)
3285 : Decl(Block, DC, CaretLoc), DeclContext(Block),
3286 IsVariadic(false), CapturesCXXThis(false),
3287 BlockMissingReturnType(true), IsConversionFromLambda(false),
3288 ParamInfo(nullptr), NumParams(0), Body(nullptr),
3289 SignatureAsWritten(nullptr), Captures(nullptr), NumCaptures(0),
3290 ManglingNumber(0), ManglingContextDecl(nullptr) {}
3293 static BlockDecl *Create(ASTContext &C, DeclContext *DC, SourceLocation L);
3294 static BlockDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3296 SourceLocation getCaretLocation() const { return getLocation(); }
3298 bool isVariadic() const { return IsVariadic; }
3299 void setIsVariadic(bool value) { IsVariadic = value; }
3301 CompoundStmt *getCompoundBody() const { return (CompoundStmt*) Body; }
3302 Stmt *getBody() const override { return (Stmt*) Body; }
3303 void setBody(CompoundStmt *B) { Body = (Stmt*) B; }
3305 void setSignatureAsWritten(TypeSourceInfo *Sig) { SignatureAsWritten = Sig; }
3306 TypeSourceInfo *getSignatureAsWritten() const { return SignatureAsWritten; }
3308 // Iterator access to formal parameters.
3309 unsigned param_size() const { return getNumParams(); }
3310 typedef ParmVarDecl **param_iterator;
3311 typedef ParmVarDecl * const *param_const_iterator;
3312 typedef llvm::iterator_range<param_iterator> param_range;
3313 typedef llvm::iterator_range<param_const_iterator> param_const_range;
3315 // ArrayRef access to formal parameters.
3316 // FIXME: Should eventual replace iterator access.
3317 ArrayRef<ParmVarDecl*> parameters() const {
3318 return llvm::makeArrayRef(ParamInfo, param_size());
3321 bool param_empty() const { return NumParams == 0; }
3322 param_range params() { return param_range(param_begin(), param_end()); }
3323 param_iterator param_begin() { return param_iterator(ParamInfo); }
3324 param_iterator param_end() {
3325 return param_iterator(ParamInfo + param_size());
3328 param_const_range params() const {
3329 return param_const_range(param_begin(), param_end());
3331 param_const_iterator param_begin() const {
3332 return param_const_iterator(ParamInfo);
3334 param_const_iterator param_end() const {
3335 return param_const_iterator(ParamInfo + param_size());
3338 unsigned getNumParams() const { return NumParams; }
3339 const ParmVarDecl *getParamDecl(unsigned i) const {
3340 assert(i < getNumParams() && "Illegal param #");
3341 return ParamInfo[i];
3343 ParmVarDecl *getParamDecl(unsigned i) {
3344 assert(i < getNumParams() && "Illegal param #");
3345 return ParamInfo[i];
3347 void setParams(ArrayRef<ParmVarDecl *> NewParamInfo);
3349 /// hasCaptures - True if this block (or its nested blocks) captures
3350 /// anything of local storage from its enclosing scopes.
3351 bool hasCaptures() const { return NumCaptures != 0 || CapturesCXXThis; }
3353 /// getNumCaptures - Returns the number of captured variables.
3354 /// Does not include an entry for 'this'.
3355 unsigned getNumCaptures() const { return NumCaptures; }
3357 typedef const Capture *capture_iterator;
3358 typedef const Capture *capture_const_iterator;
3359 typedef llvm::iterator_range<capture_iterator> capture_range;
3360 typedef llvm::iterator_range<capture_const_iterator> capture_const_range;
3362 capture_range captures() {
3363 return capture_range(capture_begin(), capture_end());
3365 capture_const_range captures() const {
3366 return capture_const_range(capture_begin(), capture_end());
3369 capture_iterator capture_begin() { return Captures; }
3370 capture_iterator capture_end() { return Captures + NumCaptures; }
3371 capture_const_iterator capture_begin() const { return Captures; }
3372 capture_const_iterator capture_end() const { return Captures + NumCaptures; }
3374 bool capturesCXXThis() const { return CapturesCXXThis; }
3375 bool blockMissingReturnType() const { return BlockMissingReturnType; }
3376 void setBlockMissingReturnType(bool val) { BlockMissingReturnType = val; }
3378 bool isConversionFromLambda() const { return IsConversionFromLambda; }
3379 void setIsConversionFromLambda(bool val) { IsConversionFromLambda = val; }
3381 bool capturesVariable(const VarDecl *var) const;
3383 void setCaptures(ASTContext &Context,
3384 const Capture *begin,
3386 bool capturesCXXThis);
3388 unsigned getBlockManglingNumber() const {
3389 return ManglingNumber;
3391 Decl *getBlockManglingContextDecl() const {
3392 return ManglingContextDecl;
3395 void setBlockMangling(unsigned Number, Decl *Ctx) {
3396 ManglingNumber = Number;
3397 ManglingContextDecl = Ctx;
3400 SourceRange getSourceRange() const override LLVM_READONLY;
3402 // Implement isa/cast/dyncast/etc.
3403 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3404 static bool classofKind(Kind K) { return K == Block; }
3405 static DeclContext *castToDeclContext(const BlockDecl *D) {
3406 return static_cast<DeclContext *>(const_cast<BlockDecl*>(D));
3408 static BlockDecl *castFromDeclContext(const DeclContext *DC) {
3409 return static_cast<BlockDecl *>(const_cast<DeclContext*>(DC));
3413 /// \brief This represents the body of a CapturedStmt, and serves as its
3415 class CapturedDecl : public Decl, public DeclContext {
3417 /// \brief The number of parameters to the outlined function.
3419 /// \brief The position of context parameter in list of parameters.
3420 unsigned ContextParam;
3421 /// \brief The body of the outlined function.
3422 llvm::PointerIntPair<Stmt *, 1, bool> BodyAndNothrow;
3424 explicit CapturedDecl(DeclContext *DC, unsigned NumParams)
3425 : Decl(Captured, DC, SourceLocation()), DeclContext(Captured),
3426 NumParams(NumParams), ContextParam(0), BodyAndNothrow(nullptr, false) { }
3428 ImplicitParamDecl **getParams() const {
3429 return reinterpret_cast<ImplicitParamDecl **>(
3430 const_cast<CapturedDecl *>(this) + 1);
3434 static CapturedDecl *Create(ASTContext &C, DeclContext *DC,
3435 unsigned NumParams);
3436 static CapturedDecl *CreateDeserialized(ASTContext &C, unsigned ID,
3437 unsigned NumParams);
3439 Stmt *getBody() const override { return BodyAndNothrow.getPointer(); }
3440 void setBody(Stmt *B) { BodyAndNothrow.setPointer(B); }
3442 bool isNothrow() const { return BodyAndNothrow.getInt(); }
3443 void setNothrow(bool Nothrow = true) { BodyAndNothrow.setInt(Nothrow); }
3445 unsigned getNumParams() const { return NumParams; }
3447 ImplicitParamDecl *getParam(unsigned i) const {
3448 assert(i < NumParams);
3449 return getParams()[i];
3451 void setParam(unsigned i, ImplicitParamDecl *P) {
3452 assert(i < NumParams);
3456 /// \brief Retrieve the parameter containing captured variables.
3457 ImplicitParamDecl *getContextParam() const {
3458 assert(ContextParam < NumParams);
3459 return getParam(ContextParam);
3461 void setContextParam(unsigned i, ImplicitParamDecl *P) {
3462 assert(i < NumParams);
3466 unsigned getContextParamPosition() const { return ContextParam; }
3468 typedef ImplicitParamDecl **param_iterator;
3469 typedef llvm::iterator_range<param_iterator> param_range;
3471 /// \brief Retrieve an iterator pointing to the first parameter decl.
3472 param_iterator param_begin() const { return getParams(); }
3473 /// \brief Retrieve an iterator one past the last parameter decl.
3474 param_iterator param_end() const { return getParams() + NumParams; }
3476 /// \brief Retrieve an iterator range for the parameter declarations.
3477 param_range params() const { return param_range(param_begin(), param_end()); }
3479 // Implement isa/cast/dyncast/etc.
3480 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3481 static bool classofKind(Kind K) { return K == Captured; }
3482 static DeclContext *castToDeclContext(const CapturedDecl *D) {
3483 return static_cast<DeclContext *>(const_cast<CapturedDecl *>(D));
3485 static CapturedDecl *castFromDeclContext(const DeclContext *DC) {
3486 return static_cast<CapturedDecl *>(const_cast<DeclContext *>(DC));
3489 friend class ASTDeclReader;
3490 friend class ASTDeclWriter;
3493 /// \brief Describes a module import declaration, which makes the contents
3494 /// of the named module visible in the current translation unit.
3496 /// An import declaration imports the named module (or submodule). For example:
3498 /// @import std.vector;
3501 /// Import declarations can also be implicitly generated from
3502 /// \#include/\#import directives.
3503 class ImportDecl : public Decl {
3504 /// \brief The imported module, along with a bit that indicates whether
3505 /// we have source-location information for each identifier in the module
3508 /// When the bit is false, we only have a single source location for the
3509 /// end of the import declaration.
3510 llvm::PointerIntPair<Module *, 1, bool> ImportedAndComplete;
3512 /// \brief The next import in the list of imports local to the translation
3513 /// unit being parsed (not loaded from an AST file).
3514 ImportDecl *NextLocalImport;
3516 friend class ASTReader;
3517 friend class ASTDeclReader;
3518 friend class ASTContext;
3520 ImportDecl(DeclContext *DC, SourceLocation StartLoc, Module *Imported,
3521 ArrayRef<SourceLocation> IdentifierLocs);
3523 ImportDecl(DeclContext *DC, SourceLocation StartLoc, Module *Imported,
3524 SourceLocation EndLoc);
3526 ImportDecl(EmptyShell Empty) : Decl(Import, Empty), NextLocalImport() { }
3529 /// \brief Create a new module import declaration.
3530 static ImportDecl *Create(ASTContext &C, DeclContext *DC,
3531 SourceLocation StartLoc, Module *Imported,
3532 ArrayRef<SourceLocation> IdentifierLocs);
3534 /// \brief Create a new module import declaration for an implicitly-generated
3536 static ImportDecl *CreateImplicit(ASTContext &C, DeclContext *DC,
3537 SourceLocation StartLoc, Module *Imported,
3538 SourceLocation EndLoc);
3540 /// \brief Create a new, deserialized module import declaration.
3541 static ImportDecl *CreateDeserialized(ASTContext &C, unsigned ID,
3542 unsigned NumLocations);
3544 /// \brief Retrieve the module that was imported by the import declaration.
3545 Module *getImportedModule() const { return ImportedAndComplete.getPointer(); }
3547 /// \brief Retrieves the locations of each of the identifiers that make up
3548 /// the complete module name in the import declaration.
3550 /// This will return an empty array if the locations of the individual
3551 /// identifiers aren't available.
3552 ArrayRef<SourceLocation> getIdentifierLocs() const;
3554 SourceRange getSourceRange() const override LLVM_READONLY;
3556 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3557 static bool classofKind(Kind K) { return K == Import; }
3560 /// \brief Represents an empty-declaration.
3561 class EmptyDecl : public Decl {
3562 virtual void anchor();
3563 EmptyDecl(DeclContext *DC, SourceLocation L)
3564 : Decl(Empty, DC, L) { }
3567 static EmptyDecl *Create(ASTContext &C, DeclContext *DC,
3569 static EmptyDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3571 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3572 static bool classofKind(Kind K) { return K == Empty; }
3575 /// Insertion operator for diagnostics. This allows sending NamedDecl's
3576 /// into a diagnostic with <<.
3577 inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
3578 const NamedDecl* ND) {
3579 DB.AddTaggedVal(reinterpret_cast<intptr_t>(ND),
3580 DiagnosticsEngine::ak_nameddecl);
3583 inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
3584 const NamedDecl* ND) {
3585 PD.AddTaggedVal(reinterpret_cast<intptr_t>(ND),
3586 DiagnosticsEngine::ak_nameddecl);
3590 template<typename decl_type>
3591 void Redeclarable<decl_type>::setPreviousDecl(decl_type *PrevDecl) {
3592 // Note: This routine is implemented here because we need both NamedDecl
3593 // and Redeclarable to be defined.
3594 assert(RedeclLink.NextIsLatest() &&
3595 "setPreviousDecl on a decl already in a redeclaration chain");
3600 // Point to previous. Make sure that this is actually the most recent
3601 // redeclaration, or we can build invalid chains. If the most recent
3602 // redeclaration is invalid, it won't be PrevDecl, but we want it anyway.
3603 First = PrevDecl->getFirstDecl();
3604 assert(First->RedeclLink.NextIsLatest() && "Expected first");
3605 decl_type *MostRecent = First->getNextRedeclaration();
3606 RedeclLink = PreviousDeclLink(cast<decl_type>(MostRecent));
3608 // If the declaration was previously visible, a redeclaration of it remains
3609 // visible even if it wouldn't be visible by itself.
3610 static_cast<decl_type*>(this)->IdentifierNamespace |=
3611 MostRecent->getIdentifierNamespace() &
3612 (Decl::IDNS_Ordinary | Decl::IDNS_Tag | Decl::IDNS_Type);
3615 First = static_cast<decl_type*>(this);
3618 // First one will point to this one as latest.
3619 First->RedeclLink.setLatest(static_cast<decl_type*>(this));
3621 assert(!isa<NamedDecl>(static_cast<decl_type*>(this)) ||
3622 cast<NamedDecl>(static_cast<decl_type*>(this))->isLinkageValid());
3625 // Inline function definitions.
3627 /// \brief Check if the given decl is complete.
3629 /// We use this function to break a cycle between the inline definitions in
3630 /// Type.h and Decl.h.
3631 inline bool IsEnumDeclComplete(EnumDecl *ED) {
3632 return ED->isComplete();
3635 /// \brief Check if the given decl is scoped.
3637 /// We use this function to break a cycle between the inline definitions in
3638 /// Type.h and Decl.h.
3639 inline bool IsEnumDeclScoped(EnumDecl *ED) {
3640 return ED->isScoped();
3643 } // end namespace clang