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/NestedNameSpecifier.h"
22 #include "clang/AST/Redeclarable.h"
23 #include "clang/AST/Type.h"
24 #include "clang/Basic/AddressSpaces.h"
25 #include "clang/Basic/Diagnostic.h"
26 #include "clang/Basic/IdentifierTable.h"
27 #include "clang/Basic/LLVM.h"
28 #include "clang/Basic/Linkage.h"
29 #include "clang/Basic/OperatorKinds.h"
30 #include "clang/Basic/PartialDiagnostic.h"
31 #include "clang/Basic/PragmaKinds.h"
32 #include "clang/Basic/SourceLocation.h"
33 #include "clang/Basic/Specifiers.h"
34 #include "clang/Basic/Visibility.h"
35 #include "llvm/ADT/APSInt.h"
36 #include "llvm/ADT/ArrayRef.h"
37 #include "llvm/ADT/Optional.h"
38 #include "llvm/ADT/PointerIntPair.h"
39 #include "llvm/ADT/PointerUnion.h"
40 #include "llvm/ADT/StringRef.h"
41 #include "llvm/ADT/iterator_range.h"
42 #include "llvm/Support/Casting.h"
43 #include "llvm/Support/Compiler.h"
44 #include "llvm/Support/TrailingObjects.h"
54 struct ASTTemplateArgumentListInfo;
57 class DependentFunctionTemplateSpecializationInfo;
60 class FunctionTemplateDecl;
61 class FunctionTemplateSpecializationInfo;
63 class MemberSpecializationInfo;
71 class TemplateArgumentList;
72 class TemplateArgumentListInfo;
73 class TemplateParameterList;
74 class TypeAliasTemplateDecl;
76 class UnresolvedSetImpl;
77 class VarTemplateDecl;
79 /// A container of type source information.
81 /// A client can read the relevant info using TypeLoc wrappers, e.g:
83 /// TypeLoc TL = TypeSourceInfo->getTypeLoc();
84 /// TL.getStartLoc().print(OS, SrcMgr);
86 class alignas(8) TypeSourceInfo {
87 // Contains a memory block after the class, used for type source information,
88 // allocated by ASTContext.
89 friend class ASTContext;
93 TypeSourceInfo(QualType ty) : Ty(ty) {}
96 /// Return the type wrapped by this type source info.
97 QualType getType() const { return Ty; }
99 /// Return the TypeLoc wrapper for the type source info.
100 TypeLoc getTypeLoc() const; // implemented in TypeLoc.h
102 /// Override the type stored in this TypeSourceInfo. Use with caution!
103 void overrideType(QualType T) { Ty = T; }
106 /// The top declaration context.
107 class TranslationUnitDecl : public Decl, public DeclContext {
110 /// The (most recently entered) anonymous namespace for this
111 /// translation unit, if one has been created.
112 NamespaceDecl *AnonymousNamespace = nullptr;
114 explicit TranslationUnitDecl(ASTContext &ctx);
116 virtual void anchor();
119 ASTContext &getASTContext() const { return Ctx; }
121 NamespaceDecl *getAnonymousNamespace() const { return AnonymousNamespace; }
122 void setAnonymousNamespace(NamespaceDecl *D) { AnonymousNamespace = D; }
124 static TranslationUnitDecl *Create(ASTContext &C);
126 // Implement isa/cast/dyncast/etc.
127 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
128 static bool classofKind(Kind K) { return K == TranslationUnit; }
129 static DeclContext *castToDeclContext(const TranslationUnitDecl *D) {
130 return static_cast<DeclContext *>(const_cast<TranslationUnitDecl*>(D));
132 static TranslationUnitDecl *castFromDeclContext(const DeclContext *DC) {
133 return static_cast<TranslationUnitDecl *>(const_cast<DeclContext*>(DC));
137 /// Represents a `#pragma comment` line. Always a child of
138 /// TranslationUnitDecl.
139 class PragmaCommentDecl final
141 private llvm::TrailingObjects<PragmaCommentDecl, char> {
142 friend class ASTDeclReader;
143 friend class ASTDeclWriter;
144 friend TrailingObjects;
146 PragmaMSCommentKind CommentKind;
148 PragmaCommentDecl(TranslationUnitDecl *TU, SourceLocation CommentLoc,
149 PragmaMSCommentKind CommentKind)
150 : Decl(PragmaComment, TU, CommentLoc), CommentKind(CommentKind) {}
152 virtual void anchor();
155 static PragmaCommentDecl *Create(const ASTContext &C, TranslationUnitDecl *DC,
156 SourceLocation CommentLoc,
157 PragmaMSCommentKind CommentKind,
159 static PragmaCommentDecl *CreateDeserialized(ASTContext &C, unsigned ID,
162 PragmaMSCommentKind getCommentKind() const { return CommentKind; }
164 StringRef getArg() const { return getTrailingObjects<char>(); }
166 // Implement isa/cast/dyncast/etc.
167 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
168 static bool classofKind(Kind K) { return K == PragmaComment; }
171 /// Represents a `#pragma detect_mismatch` line. Always a child of
172 /// TranslationUnitDecl.
173 class PragmaDetectMismatchDecl final
175 private llvm::TrailingObjects<PragmaDetectMismatchDecl, char> {
176 friend class ASTDeclReader;
177 friend class ASTDeclWriter;
178 friend TrailingObjects;
182 PragmaDetectMismatchDecl(TranslationUnitDecl *TU, SourceLocation Loc,
184 : Decl(PragmaDetectMismatch, TU, Loc), ValueStart(ValueStart) {}
186 virtual void anchor();
189 static PragmaDetectMismatchDecl *Create(const ASTContext &C,
190 TranslationUnitDecl *DC,
191 SourceLocation Loc, StringRef Name,
193 static PragmaDetectMismatchDecl *
194 CreateDeserialized(ASTContext &C, unsigned ID, unsigned NameValueSize);
196 StringRef getName() const { return getTrailingObjects<char>(); }
197 StringRef getValue() const { return getTrailingObjects<char>() + ValueStart; }
199 // Implement isa/cast/dyncast/etc.
200 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
201 static bool classofKind(Kind K) { return K == PragmaDetectMismatch; }
204 /// Declaration context for names declared as extern "C" in C++. This
205 /// is neither the semantic nor lexical context for such declarations, but is
206 /// used to check for conflicts with other extern "C" declarations. Example:
209 /// namespace N { extern "C" void f(); } // #1
210 /// void N::f() {} // #2
211 /// namespace M { extern "C" void f(); } // #3
214 /// The semantic context of #1 is namespace N and its lexical context is the
215 /// LinkageSpecDecl; the semantic context of #2 is namespace N and its lexical
216 /// context is the TU. However, both declarations are also visible in the
217 /// extern "C" context.
219 /// The declaration at #3 finds it is a redeclaration of \c N::f through
220 /// lookup in the extern "C" context.
221 class ExternCContextDecl : public Decl, public DeclContext {
222 explicit ExternCContextDecl(TranslationUnitDecl *TU)
223 : Decl(ExternCContext, TU, SourceLocation()),
224 DeclContext(ExternCContext) {}
226 virtual void anchor();
229 static ExternCContextDecl *Create(const ASTContext &C,
230 TranslationUnitDecl *TU);
232 // Implement isa/cast/dyncast/etc.
233 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
234 static bool classofKind(Kind K) { return K == ExternCContext; }
235 static DeclContext *castToDeclContext(const ExternCContextDecl *D) {
236 return static_cast<DeclContext *>(const_cast<ExternCContextDecl*>(D));
238 static ExternCContextDecl *castFromDeclContext(const DeclContext *DC) {
239 return static_cast<ExternCContextDecl *>(const_cast<DeclContext*>(DC));
243 /// This represents a decl that may have a name. Many decls have names such
244 /// as ObjCMethodDecl, but not \@class, etc.
246 /// Note that not every NamedDecl is actually named (e.g., a struct might
247 /// be anonymous), and not every name is an identifier.
248 class NamedDecl : public Decl {
249 /// The name of this declaration, which is typically a normal
250 /// identifier but may also be a special kind of name (C++
251 /// constructor, Objective-C selector, etc.)
252 DeclarationName Name;
254 virtual void anchor();
257 NamedDecl *getUnderlyingDeclImpl() LLVM_READONLY;
260 NamedDecl(Kind DK, DeclContext *DC, SourceLocation L, DeclarationName N)
261 : Decl(DK, DC, L), Name(N) {}
264 /// Get the identifier that names this declaration, if there is one.
266 /// This will return NULL if this declaration has no name (e.g., for
267 /// an unnamed class) or if the name is a special name (C++ constructor,
268 /// Objective-C selector, etc.).
269 IdentifierInfo *getIdentifier() const { return Name.getAsIdentifierInfo(); }
271 /// Get the name of identifier for this declaration as a StringRef.
273 /// This requires that the declaration have a name and that it be a simple
275 StringRef getName() const {
276 assert(Name.isIdentifier() && "Name is not a simple identifier");
277 return getIdentifier() ? getIdentifier()->getName() : "";
280 /// Get a human-readable name for the declaration, even if it is one of the
281 /// special kinds of names (C++ constructor, Objective-C selector, etc).
283 /// Creating this name requires expensive string manipulation, so it should
284 /// be called only when performance doesn't matter. For simple declarations,
285 /// getNameAsCString() should suffice.
287 // FIXME: This function should be renamed to indicate that it is not just an
288 // alternate form of getName(), and clients should move as appropriate.
290 // FIXME: Deprecated, move clients to getName().
291 std::string getNameAsString() const { return Name.getAsString(); }
293 virtual void printName(raw_ostream &os) const;
295 /// Get the actual, stored name of the declaration, which may be a special
297 DeclarationName getDeclName() const { return Name; }
299 /// Set the name of this declaration.
300 void setDeclName(DeclarationName N) { Name = N; }
302 /// Returns a human-readable qualified name for this declaration, like
303 /// A::B::i, for i being member of namespace A::B.
305 /// If the declaration is not a member of context which can be named (record,
306 /// namespace), it will return the same result as printName().
308 /// Creating this name is expensive, so it should be called only when
309 /// performance doesn't matter.
310 void printQualifiedName(raw_ostream &OS) const;
311 void printQualifiedName(raw_ostream &OS, const PrintingPolicy &Policy) const;
313 // FIXME: Remove string version.
314 std::string getQualifiedNameAsString() const;
316 /// Appends a human-readable name for this declaration into the given stream.
318 /// This is the method invoked by Sema when displaying a NamedDecl
319 /// in a diagnostic. It does not necessarily produce the same
320 /// result as printName(); for example, class template
321 /// specializations are printed with their template arguments.
322 virtual void getNameForDiagnostic(raw_ostream &OS,
323 const PrintingPolicy &Policy,
324 bool Qualified) const;
326 /// Determine whether this declaration, if known to be well-formed within
327 /// its context, will replace the declaration OldD if introduced into scope.
329 /// A declaration will replace another declaration if, for example, it is
330 /// a redeclaration of the same variable or function, but not if it is a
331 /// declaration of a different kind (function vs. class) or an overloaded
334 /// \param IsKnownNewer \c true if this declaration is known to be newer
335 /// than \p OldD (for instance, if this declaration is newly-created).
336 bool declarationReplaces(NamedDecl *OldD, bool IsKnownNewer = true) const;
338 /// Determine whether this declaration has linkage.
339 bool hasLinkage() const;
341 using Decl::isModulePrivate;
342 using Decl::setModulePrivate;
344 /// Determine whether this declaration is a C++ class member.
345 bool isCXXClassMember() const {
346 const DeclContext *DC = getDeclContext();
348 // C++0x [class.mem]p1:
349 // The enumerators of an unscoped enumeration defined in
350 // the class are members of the class.
351 if (isa<EnumDecl>(DC))
352 DC = DC->getRedeclContext();
354 return DC->isRecord();
357 /// Determine whether the given declaration is an instance member of
359 bool isCXXInstanceMember() const;
361 /// Determine what kind of linkage this entity has.
363 /// This is not the linkage as defined by the standard or the codegen notion
364 /// of linkage. It is just an implementation detail that is used to compute
366 Linkage getLinkageInternal() const;
368 /// Get the linkage from a semantic point of view. Entities in
369 /// anonymous namespaces are external (in c++98).
370 Linkage getFormalLinkage() const {
371 return clang::getFormalLinkage(getLinkageInternal());
374 /// True if this decl has external linkage.
375 bool hasExternalFormalLinkage() const {
376 return isExternalFormalLinkage(getLinkageInternal());
379 bool isExternallyVisible() const {
380 return clang::isExternallyVisible(getLinkageInternal());
383 /// Determine whether this declaration can be redeclared in a
384 /// different translation unit.
385 bool isExternallyDeclarable() const {
386 return isExternallyVisible() && !getOwningModuleForLinkage();
389 /// Determines the visibility of this entity.
390 Visibility getVisibility() const {
391 return getLinkageAndVisibility().getVisibility();
394 /// Determines the linkage and visibility of this entity.
395 LinkageInfo getLinkageAndVisibility() const;
397 /// Kinds of explicit visibility.
398 enum ExplicitVisibilityKind {
399 /// Do an LV computation for, ultimately, a type.
400 /// Visibility may be restricted by type visibility settings and
401 /// the visibility of template arguments.
404 /// Do an LV computation for, ultimately, a non-type declaration.
405 /// Visibility may be restricted by value visibility settings and
406 /// the visibility of template arguments.
410 /// If visibility was explicitly specified for this
411 /// declaration, return that visibility.
413 getExplicitVisibility(ExplicitVisibilityKind kind) const;
415 /// True if the computed linkage is valid. Used for consistency
416 /// checking. Should always return true.
417 bool isLinkageValid() const;
419 /// True if something has required us to compute the linkage
420 /// of this declaration.
422 /// Language features which can retroactively change linkage (like a
423 /// typedef name for linkage purposes) may need to consider this,
424 /// but hopefully only in transitory ways during parsing.
425 bool hasLinkageBeenComputed() const {
426 return hasCachedLinkage();
429 /// Looks through UsingDecls and ObjCCompatibleAliasDecls for
430 /// the underlying named decl.
431 NamedDecl *getUnderlyingDecl() {
432 // Fast-path the common case.
433 if (this->getKind() != UsingShadow &&
434 this->getKind() != ConstructorUsingShadow &&
435 this->getKind() != ObjCCompatibleAlias &&
436 this->getKind() != NamespaceAlias)
439 return getUnderlyingDeclImpl();
441 const NamedDecl *getUnderlyingDecl() const {
442 return const_cast<NamedDecl*>(this)->getUnderlyingDecl();
445 NamedDecl *getMostRecentDecl() {
446 return cast<NamedDecl>(static_cast<Decl *>(this)->getMostRecentDecl());
448 const NamedDecl *getMostRecentDecl() const {
449 return const_cast<NamedDecl*>(this)->getMostRecentDecl();
452 ObjCStringFormatFamily getObjCFStringFormattingFamily() const;
454 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
455 static bool classofKind(Kind K) { return K >= firstNamed && K <= lastNamed; }
458 inline raw_ostream &operator<<(raw_ostream &OS, const NamedDecl &ND) {
463 /// Represents the declaration of a label. Labels also have a
464 /// corresponding LabelStmt, which indicates the position that the label was
465 /// defined at. For normal labels, the location of the decl is the same as the
466 /// location of the statement. For GNU local labels (__label__), the decl
467 /// location is where the __label__ is.
468 class LabelDecl : public NamedDecl {
471 bool MSAsmNameResolved = false;
473 /// For normal labels, this is the same as the main declaration
474 /// label, i.e., the location of the identifier; for GNU local labels,
475 /// this is the location of the __label__ keyword.
476 SourceLocation LocStart;
478 LabelDecl(DeclContext *DC, SourceLocation IdentL, IdentifierInfo *II,
479 LabelStmt *S, SourceLocation StartL)
480 : NamedDecl(Label, DC, IdentL, II), TheStmt(S), LocStart(StartL) {}
482 void anchor() override;
485 static LabelDecl *Create(ASTContext &C, DeclContext *DC,
486 SourceLocation IdentL, IdentifierInfo *II);
487 static LabelDecl *Create(ASTContext &C, DeclContext *DC,
488 SourceLocation IdentL, IdentifierInfo *II,
489 SourceLocation GnuLabelL);
490 static LabelDecl *CreateDeserialized(ASTContext &C, unsigned ID);
492 LabelStmt *getStmt() const { return TheStmt; }
493 void setStmt(LabelStmt *T) { TheStmt = T; }
495 bool isGnuLocal() const { return LocStart != getLocation(); }
496 void setLocStart(SourceLocation L) { LocStart = L; }
498 SourceRange getSourceRange() const override LLVM_READONLY {
499 return SourceRange(LocStart, getLocation());
502 bool isMSAsmLabel() const { return !MSAsmName.empty(); }
503 bool isResolvedMSAsmLabel() const { return isMSAsmLabel() && MSAsmNameResolved; }
504 void setMSAsmLabel(StringRef Name);
505 StringRef getMSAsmLabel() const { return MSAsmName; }
506 void setMSAsmLabelResolved() { MSAsmNameResolved = true; }
508 // Implement isa/cast/dyncast/etc.
509 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
510 static bool classofKind(Kind K) { return K == Label; }
513 /// Represent a C++ namespace.
514 class NamespaceDecl : public NamedDecl, public DeclContext,
515 public Redeclarable<NamespaceDecl>
517 /// The starting location of the source range, pointing
518 /// to either the namespace or the inline keyword.
519 SourceLocation LocStart;
521 /// The ending location of the source range.
522 SourceLocation RBraceLoc;
524 /// A pointer to either the anonymous namespace that lives just inside
525 /// this namespace or to the first namespace in the chain (the latter case
526 /// only when this is not the first in the chain), along with a
527 /// boolean value indicating whether this is an inline namespace.
528 llvm::PointerIntPair<NamespaceDecl *, 1, bool> AnonOrFirstNamespaceAndInline;
530 NamespaceDecl(ASTContext &C, DeclContext *DC, bool Inline,
531 SourceLocation StartLoc, SourceLocation IdLoc,
532 IdentifierInfo *Id, NamespaceDecl *PrevDecl);
534 using redeclarable_base = Redeclarable<NamespaceDecl>;
536 NamespaceDecl *getNextRedeclarationImpl() override;
537 NamespaceDecl *getPreviousDeclImpl() override;
538 NamespaceDecl *getMostRecentDeclImpl() override;
541 friend class ASTDeclReader;
542 friend class ASTDeclWriter;
544 static NamespaceDecl *Create(ASTContext &C, DeclContext *DC,
545 bool Inline, SourceLocation StartLoc,
546 SourceLocation IdLoc, IdentifierInfo *Id,
547 NamespaceDecl *PrevDecl);
549 static NamespaceDecl *CreateDeserialized(ASTContext &C, unsigned ID);
551 using redecl_range = redeclarable_base::redecl_range;
552 using redecl_iterator = redeclarable_base::redecl_iterator;
554 using redeclarable_base::redecls_begin;
555 using redeclarable_base::redecls_end;
556 using redeclarable_base::redecls;
557 using redeclarable_base::getPreviousDecl;
558 using redeclarable_base::getMostRecentDecl;
559 using redeclarable_base::isFirstDecl;
561 /// Returns true if this is an anonymous namespace declaration.
569 /// q.v. C++ [namespace.unnamed]
570 bool isAnonymousNamespace() const {
571 return !getIdentifier();
574 /// Returns true if this is an inline namespace declaration.
575 bool isInline() const {
576 return AnonOrFirstNamespaceAndInline.getInt();
579 /// Set whether this is an inline namespace declaration.
580 void setInline(bool Inline) {
581 AnonOrFirstNamespaceAndInline.setInt(Inline);
584 /// Get the original (first) namespace declaration.
585 NamespaceDecl *getOriginalNamespace();
587 /// Get the original (first) namespace declaration.
588 const NamespaceDecl *getOriginalNamespace() const;
590 /// Return true if this declaration is an original (first) declaration
591 /// of the namespace. This is false for non-original (subsequent) namespace
592 /// declarations and anonymous namespaces.
593 bool isOriginalNamespace() const;
595 /// Retrieve the anonymous namespace nested inside this namespace,
597 NamespaceDecl *getAnonymousNamespace() const {
598 return getOriginalNamespace()->AnonOrFirstNamespaceAndInline.getPointer();
601 void setAnonymousNamespace(NamespaceDecl *D) {
602 getOriginalNamespace()->AnonOrFirstNamespaceAndInline.setPointer(D);
605 /// Retrieves the canonical declaration of this namespace.
606 NamespaceDecl *getCanonicalDecl() override {
607 return getOriginalNamespace();
609 const NamespaceDecl *getCanonicalDecl() const {
610 return getOriginalNamespace();
613 SourceRange getSourceRange() const override LLVM_READONLY {
614 return SourceRange(LocStart, RBraceLoc);
617 SourceLocation getLocStart() const LLVM_READONLY { return LocStart; }
618 SourceLocation getRBraceLoc() const { return RBraceLoc; }
619 void setLocStart(SourceLocation L) { LocStart = L; }
620 void setRBraceLoc(SourceLocation L) { RBraceLoc = L; }
622 // Implement isa/cast/dyncast/etc.
623 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
624 static bool classofKind(Kind K) { return K == Namespace; }
625 static DeclContext *castToDeclContext(const NamespaceDecl *D) {
626 return static_cast<DeclContext *>(const_cast<NamespaceDecl*>(D));
628 static NamespaceDecl *castFromDeclContext(const DeclContext *DC) {
629 return static_cast<NamespaceDecl *>(const_cast<DeclContext*>(DC));
633 /// Represent the declaration of a variable (in which case it is
634 /// an lvalue) a function (in which case it is a function designator) or
635 /// an enum constant.
636 class ValueDecl : public NamedDecl {
639 void anchor() override;
642 ValueDecl(Kind DK, DeclContext *DC, SourceLocation L,
643 DeclarationName N, QualType T)
644 : NamedDecl(DK, DC, L, N), DeclType(T) {}
647 QualType getType() const { return DeclType; }
648 void setType(QualType newType) { DeclType = newType; }
650 /// Determine whether this symbol is weakly-imported,
651 /// or declared with the weak or weak-ref attr.
654 // Implement isa/cast/dyncast/etc.
655 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
656 static bool classofKind(Kind K) { return K >= firstValue && K <= lastValue; }
659 /// A struct with extended info about a syntactic
660 /// name qualifier, to be used for the case of out-of-line declarations.
661 struct QualifierInfo {
662 NestedNameSpecifierLoc QualifierLoc;
664 /// The number of "outer" template parameter lists.
665 /// The count includes all of the template parameter lists that were matched
666 /// against the template-ids occurring into the NNS and possibly (in the
667 /// case of an explicit specialization) a final "template <>".
668 unsigned NumTemplParamLists = 0;
670 /// A new-allocated array of size NumTemplParamLists,
671 /// containing pointers to the "outer" template parameter lists.
672 /// It includes all of the template parameter lists that were matched
673 /// against the template-ids occurring into the NNS and possibly (in the
674 /// case of an explicit specialization) a final "template <>".
675 TemplateParameterList** TemplParamLists = nullptr;
677 QualifierInfo() = default;
678 QualifierInfo(const QualifierInfo &) = delete;
679 QualifierInfo& operator=(const QualifierInfo &) = delete;
681 /// Sets info about "outer" template parameter lists.
682 void setTemplateParameterListsInfo(ASTContext &Context,
683 ArrayRef<TemplateParameterList *> TPLists);
686 /// Represents a ValueDecl that came out of a declarator.
687 /// Contains type source information through TypeSourceInfo.
688 class DeclaratorDecl : public ValueDecl {
689 // A struct representing both a TInfo and a syntactic qualifier,
690 // to be used for the (uncommon) case of out-of-line declarations.
691 struct ExtInfo : public QualifierInfo {
692 TypeSourceInfo *TInfo;
695 llvm::PointerUnion<TypeSourceInfo *, ExtInfo *> DeclInfo;
697 /// The start of the source range for this declaration,
698 /// ignoring outer template declarations.
699 SourceLocation InnerLocStart;
701 bool hasExtInfo() const { return DeclInfo.is<ExtInfo*>(); }
702 ExtInfo *getExtInfo() { return DeclInfo.get<ExtInfo*>(); }
703 const ExtInfo *getExtInfo() const { return DeclInfo.get<ExtInfo*>(); }
706 DeclaratorDecl(Kind DK, DeclContext *DC, SourceLocation L,
707 DeclarationName N, QualType T, TypeSourceInfo *TInfo,
708 SourceLocation StartL)
709 : ValueDecl(DK, DC, L, N, T), DeclInfo(TInfo), InnerLocStart(StartL) {}
712 friend class ASTDeclReader;
713 friend class ASTDeclWriter;
715 TypeSourceInfo *getTypeSourceInfo() const {
717 ? getExtInfo()->TInfo
718 : DeclInfo.get<TypeSourceInfo*>();
721 void setTypeSourceInfo(TypeSourceInfo *TI) {
723 getExtInfo()->TInfo = TI;
728 /// Return start of source range ignoring outer template declarations.
729 SourceLocation getInnerLocStart() const { return InnerLocStart; }
730 void setInnerLocStart(SourceLocation L) { InnerLocStart = L; }
732 /// Return start of source range taking into account any outer template
734 SourceLocation getOuterLocStart() const;
736 SourceRange getSourceRange() const override LLVM_READONLY;
738 SourceLocation getLocStart() const LLVM_READONLY {
739 return getOuterLocStart();
742 /// Retrieve the nested-name-specifier that qualifies the name of this
743 /// declaration, if it was present in the source.
744 NestedNameSpecifier *getQualifier() const {
745 return hasExtInfo() ? getExtInfo()->QualifierLoc.getNestedNameSpecifier()
749 /// Retrieve the nested-name-specifier (with source-location
750 /// information) that qualifies the name of this declaration, if it was
751 /// present in the source.
752 NestedNameSpecifierLoc getQualifierLoc() const {
753 return hasExtInfo() ? getExtInfo()->QualifierLoc
754 : NestedNameSpecifierLoc();
757 void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc);
759 unsigned getNumTemplateParameterLists() const {
760 return hasExtInfo() ? getExtInfo()->NumTemplParamLists : 0;
763 TemplateParameterList *getTemplateParameterList(unsigned index) const {
764 assert(index < getNumTemplateParameterLists());
765 return getExtInfo()->TemplParamLists[index];
768 void setTemplateParameterListsInfo(ASTContext &Context,
769 ArrayRef<TemplateParameterList *> TPLists);
771 SourceLocation getTypeSpecStartLoc() const;
773 // Implement isa/cast/dyncast/etc.
774 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
775 static bool classofKind(Kind K) {
776 return K >= firstDeclarator && K <= lastDeclarator;
780 /// Structure used to store a statement, the constant value to
781 /// which it was evaluated (if any), and whether or not the statement
782 /// is an integral constant expression (if known).
783 struct EvaluatedStmt {
784 /// Whether this statement was already evaluated.
785 bool WasEvaluated : 1;
787 /// Whether this statement is being evaluated.
788 bool IsEvaluating : 1;
790 /// Whether we already checked whether this statement was an
791 /// integral constant expression.
794 /// Whether we are checking whether this statement is an
795 /// integral constant expression.
796 bool CheckingICE : 1;
798 /// Whether this statement is an integral constant expression,
799 /// or in C++11, whether the statement is a constant expression. Only
800 /// valid if CheckedICE is true.
806 EvaluatedStmt() : WasEvaluated(false), IsEvaluating(false), CheckedICE(false),
807 CheckingICE(false), IsICE(false) {}
811 /// Represents a variable declaration or definition.
812 class VarDecl : public DeclaratorDecl, public Redeclarable<VarDecl> {
814 /// Initialization styles.
815 enum InitializationStyle {
816 /// C-style initialization with assignment
819 /// Call-style initialization (C++98)
822 /// Direct list-initialization (C++11)
826 /// Kinds of thread-local storage.
828 /// Not a TLS variable.
831 /// TLS with a known-constant initializer.
834 /// TLS with a dynamic initializer.
838 /// Return the string used to specify the storage class \p SC.
840 /// It is illegal to call this function with SC == None.
841 static const char *getStorageClassSpecifierString(StorageClass SC);
844 // A pointer union of Stmt * and EvaluatedStmt *. When an EvaluatedStmt, we
845 // have allocated the auxiliary struct of information there.
847 // TODO: It is a bit unfortunate to use a PointerUnion inside the VarDecl for
848 // this as *many* VarDecls are ParmVarDecls that don't have default
849 // arguments. We could save some space by moving this pointer union to be
850 // allocated in trailing space when necessary.
851 using InitType = llvm::PointerUnion<Stmt *, EvaluatedStmt *>;
853 /// The initializer for this variable or, for a ParmVarDecl, the
854 /// C++ default argument.
855 mutable InitType Init;
858 friend class ASTDeclReader;
859 friend class ASTNodeImporter;
860 friend class StmtIteratorBase;
862 class VarDeclBitfields {
863 friend class ASTDeclReader;
864 friend class VarDecl;
867 unsigned TSCSpec : 2;
868 unsigned InitStyle : 2;
870 enum { NumVarDeclBits = 7 };
873 enum { NumParameterIndexBits = 8 };
875 enum DefaultArgKind {
882 class ParmVarDeclBitfields {
883 friend class ASTDeclReader;
884 friend class ParmVarDecl;
886 unsigned : NumVarDeclBits;
888 /// Whether this parameter inherits a default argument from a
889 /// prior declaration.
890 unsigned HasInheritedDefaultArg : 1;
892 /// Describes the kind of default argument for this parameter. By default
893 /// this is none. If this is normal, then the default argument is stored in
894 /// the \c VarDecl initializer expression unless we were unable to parse
895 /// (even an invalid) expression for the default argument.
896 unsigned DefaultArgKind : 2;
898 /// Whether this parameter undergoes K&R argument promotion.
899 unsigned IsKNRPromoted : 1;
901 /// Whether this parameter is an ObjC method parameter or not.
902 unsigned IsObjCMethodParam : 1;
904 /// If IsObjCMethodParam, a Decl::ObjCDeclQualifier.
905 /// Otherwise, the number of function parameter scopes enclosing
906 /// the function parameter scope in which this parameter was
908 unsigned ScopeDepthOrObjCQuals : 7;
910 /// The number of parameters preceding this parameter in the
911 /// function parameter scope in which it was declared.
912 unsigned ParameterIndex : NumParameterIndexBits;
915 class NonParmVarDeclBitfields {
916 friend class ASTDeclReader;
917 friend class ImplicitParamDecl;
918 friend class VarDecl;
920 unsigned : NumVarDeclBits;
922 // FIXME: We need something similar to CXXRecordDecl::DefinitionData.
923 /// Whether this variable is a definition which was demoted due to
925 unsigned IsThisDeclarationADemotedDefinition : 1;
927 /// Whether this variable is the exception variable in a C++ catch
928 /// or an Objective-C @catch statement.
929 unsigned ExceptionVar : 1;
931 /// Whether this local variable could be allocated in the return
932 /// slot of its function, enabling the named return value optimization
934 unsigned NRVOVariable : 1;
936 /// Whether this variable is the for-range-declaration in a C++0x
937 /// for-range statement.
938 unsigned CXXForRangeDecl : 1;
940 /// Whether this variable is the for-in loop declaration in Objective-C.
941 unsigned ObjCForDecl : 1;
943 /// Whether this variable is an ARC pseudo-__strong
944 /// variable; see isARCPseudoStrong() for details.
945 unsigned ARCPseudoStrong : 1;
947 /// Whether this variable is (C++1z) inline.
948 unsigned IsInline : 1;
950 /// Whether this variable has (C++1z) inline explicitly specified.
951 unsigned IsInlineSpecified : 1;
953 /// Whether this variable is (C++0x) constexpr.
954 unsigned IsConstexpr : 1;
956 /// Whether this variable is the implicit variable for a lambda
958 unsigned IsInitCapture : 1;
960 /// Whether this local extern variable's previous declaration was
961 /// declared in the same block scope. This controls whether we should merge
962 /// the type of this declaration with its previous declaration.
963 unsigned PreviousDeclInSameBlockScope : 1;
965 /// Defines kind of the ImplicitParamDecl: 'this', 'self', 'vtt', '_cmd' or
967 unsigned ImplicitParamKind : 3;
972 VarDeclBitfields VarDeclBits;
973 ParmVarDeclBitfields ParmVarDeclBits;
974 NonParmVarDeclBitfields NonParmVarDeclBits;
977 VarDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
978 SourceLocation IdLoc, IdentifierInfo *Id, QualType T,
979 TypeSourceInfo *TInfo, StorageClass SC);
981 using redeclarable_base = Redeclarable<VarDecl>;
983 VarDecl *getNextRedeclarationImpl() override {
984 return getNextRedeclaration();
987 VarDecl *getPreviousDeclImpl() override {
988 return getPreviousDecl();
991 VarDecl *getMostRecentDeclImpl() override {
992 return getMostRecentDecl();
996 using redecl_range = redeclarable_base::redecl_range;
997 using redecl_iterator = redeclarable_base::redecl_iterator;
999 using redeclarable_base::redecls_begin;
1000 using redeclarable_base::redecls_end;
1001 using redeclarable_base::redecls;
1002 using redeclarable_base::getPreviousDecl;
1003 using redeclarable_base::getMostRecentDecl;
1004 using redeclarable_base::isFirstDecl;
1006 static VarDecl *Create(ASTContext &C, DeclContext *DC,
1007 SourceLocation StartLoc, SourceLocation IdLoc,
1008 IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo,
1011 static VarDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1013 SourceRange getSourceRange() const override LLVM_READONLY;
1015 /// Returns the storage class as written in the source. For the
1016 /// computed linkage of symbol, see getLinkage.
1017 StorageClass getStorageClass() const {
1018 return (StorageClass) VarDeclBits.SClass;
1020 void setStorageClass(StorageClass SC);
1022 void setTSCSpec(ThreadStorageClassSpecifier TSC) {
1023 VarDeclBits.TSCSpec = TSC;
1024 assert(VarDeclBits.TSCSpec == TSC && "truncation");
1026 ThreadStorageClassSpecifier getTSCSpec() const {
1027 return static_cast<ThreadStorageClassSpecifier>(VarDeclBits.TSCSpec);
1029 TLSKind getTLSKind() const;
1031 /// Returns true if a variable with function scope is a non-static local
1033 bool hasLocalStorage() const {
1034 if (getStorageClass() == SC_None) {
1035 // OpenCL v1.2 s6.5.3: The __constant or constant address space name is
1036 // used to describe variables allocated in global memory and which are
1037 // accessed inside a kernel(s) as read-only variables. As such, variables
1038 // in constant address space cannot have local storage.
1039 if (getType().getAddressSpace() == LangAS::opencl_constant)
1041 // Second check is for C++11 [dcl.stc]p4.
1042 return !isFileVarDecl() && getTSCSpec() == TSCS_unspecified;
1045 // Global Named Register (GNU extension)
1046 if (getStorageClass() == SC_Register && !isLocalVarDeclOrParm())
1049 // Return true for: Auto, Register.
1050 // Return false for: Extern, Static, PrivateExtern, OpenCLWorkGroupLocal.
1052 return getStorageClass() >= SC_Auto;
1055 /// Returns true if a variable with function scope is a static local
1057 bool isStaticLocal() const {
1058 return (getStorageClass() == SC_Static ||
1059 // C++11 [dcl.stc]p4
1060 (getStorageClass() == SC_None && getTSCSpec() == TSCS_thread_local))
1061 && !isFileVarDecl();
1064 /// Returns true if a variable has extern or __private_extern__
1066 bool hasExternalStorage() const {
1067 return getStorageClass() == SC_Extern ||
1068 getStorageClass() == SC_PrivateExtern;
1071 /// Returns true for all variables that do not have local storage.
1073 /// This includes all global variables as well as static variables declared
1074 /// within a function.
1075 bool hasGlobalStorage() const { return !hasLocalStorage(); }
1077 /// Get the storage duration of this variable, per C++ [basic.stc].
1078 StorageDuration getStorageDuration() const {
1079 return hasLocalStorage() ? SD_Automatic :
1080 getTSCSpec() ? SD_Thread : SD_Static;
1083 /// Compute the language linkage.
1084 LanguageLinkage getLanguageLinkage() const;
1086 /// Determines whether this variable is a variable with external, C linkage.
1087 bool isExternC() const;
1089 /// Determines whether this variable's context is, or is nested within,
1090 /// a C++ extern "C" linkage spec.
1091 bool isInExternCContext() const;
1093 /// Determines whether this variable's context is, or is nested within,
1094 /// a C++ extern "C++" linkage spec.
1095 bool isInExternCXXContext() const;
1097 /// Returns true for local variable declarations other than parameters.
1098 /// Note that this includes static variables inside of functions. It also
1099 /// includes variables inside blocks.
1101 /// void foo() { int x; static int y; extern int z; }
1102 bool isLocalVarDecl() const {
1103 if (getKind() != Decl::Var && getKind() != Decl::Decomposition)
1105 if (const DeclContext *DC = getLexicalDeclContext())
1106 return DC->getRedeclContext()->isFunctionOrMethod();
1110 /// Similar to isLocalVarDecl but also includes parameters.
1111 bool isLocalVarDeclOrParm() const {
1112 return isLocalVarDecl() || getKind() == Decl::ParmVar;
1115 /// Similar to isLocalVarDecl, but excludes variables declared in blocks.
1116 bool isFunctionOrMethodVarDecl() const {
1117 if (getKind() != Decl::Var && getKind() != Decl::Decomposition)
1119 const DeclContext *DC = getLexicalDeclContext()->getRedeclContext();
1120 return DC->isFunctionOrMethod() && DC->getDeclKind() != Decl::Block;
1123 /// Determines whether this is a static data member.
1125 /// This will only be true in C++, and applies to, e.g., the
1126 /// variable 'x' in:
1132 bool isStaticDataMember() const {
1133 // If it wasn't static, it would be a FieldDecl.
1134 return getKind() != Decl::ParmVar && getDeclContext()->isRecord();
1137 VarDecl *getCanonicalDecl() override;
1138 const VarDecl *getCanonicalDecl() const {
1139 return const_cast<VarDecl*>(this)->getCanonicalDecl();
1142 enum DefinitionKind {
1143 /// This declaration is only a declaration.
1146 /// This declaration is a tentative definition.
1147 TentativeDefinition,
1149 /// This declaration is definitely a definition.
1153 /// Check whether this declaration is a definition. If this could be
1154 /// a tentative definition (in C), don't check whether there's an overriding
1156 DefinitionKind isThisDeclarationADefinition(ASTContext &) const;
1157 DefinitionKind isThisDeclarationADefinition() const {
1158 return isThisDeclarationADefinition(getASTContext());
1161 /// Check whether this variable is defined in this translation unit.
1162 DefinitionKind hasDefinition(ASTContext &) const;
1163 DefinitionKind hasDefinition() const {
1164 return hasDefinition(getASTContext());
1167 /// Get the tentative definition that acts as the real definition in a TU.
1168 /// Returns null if there is a proper definition available.
1169 VarDecl *getActingDefinition();
1170 const VarDecl *getActingDefinition() const {
1171 return const_cast<VarDecl*>(this)->getActingDefinition();
1174 /// Get the real (not just tentative) definition for this declaration.
1175 VarDecl *getDefinition(ASTContext &);
1176 const VarDecl *getDefinition(ASTContext &C) const {
1177 return const_cast<VarDecl*>(this)->getDefinition(C);
1179 VarDecl *getDefinition() {
1180 return getDefinition(getASTContext());
1182 const VarDecl *getDefinition() const {
1183 return const_cast<VarDecl*>(this)->getDefinition();
1186 /// Determine whether this is or was instantiated from an out-of-line
1187 /// definition of a static data member.
1188 bool isOutOfLine() const override;
1190 /// Returns true for file scoped variable declaration.
1191 bool isFileVarDecl() const {
1193 if (K == ParmVar || K == ImplicitParam)
1196 if (getLexicalDeclContext()->getRedeclContext()->isFileContext())
1199 if (isStaticDataMember())
1205 /// Get the initializer for this variable, no matter which
1206 /// declaration it is attached to.
1207 const Expr *getAnyInitializer() const {
1209 return getAnyInitializer(D);
1212 /// Get the initializer for this variable, no matter which
1213 /// declaration it is attached to. Also get that declaration.
1214 const Expr *getAnyInitializer(const VarDecl *&D) const;
1216 bool hasInit() const;
1217 const Expr *getInit() const {
1218 return const_cast<VarDecl *>(this)->getInit();
1222 /// Retrieve the address of the initializer expression.
1223 Stmt **getInitAddress();
1225 void setInit(Expr *I);
1227 /// Determine whether this variable's value can be used in a
1228 /// constant expression, according to the relevant language standard.
1229 /// This only checks properties of the declaration, and does not check
1230 /// whether the initializer is in fact a constant expression.
1231 bool isUsableInConstantExpressions(ASTContext &C) const;
1233 EvaluatedStmt *ensureEvaluatedStmt() const;
1235 /// Attempt to evaluate the value of the initializer attached to this
1236 /// declaration, and produce notes explaining why it cannot be evaluated or is
1237 /// not a constant expression. Returns a pointer to the value if evaluation
1238 /// succeeded, 0 otherwise.
1239 APValue *evaluateValue() const;
1240 APValue *evaluateValue(SmallVectorImpl<PartialDiagnosticAt> &Notes) const;
1242 /// Return the already-evaluated value of this variable's
1243 /// initializer, or NULL if the value is not yet known. Returns pointer
1244 /// to untyped APValue if the value could not be evaluated.
1245 APValue *getEvaluatedValue() const;
1247 /// Determines whether it is already known whether the
1248 /// initializer is an integral constant expression or not.
1249 bool isInitKnownICE() const;
1251 /// Determines whether the initializer is an integral constant
1252 /// expression, or in C++11, whether the initializer is a constant
1255 /// \pre isInitKnownICE()
1256 bool isInitICE() const;
1258 /// Determine whether the value of the initializer attached to this
1259 /// declaration is an integral constant expression.
1260 bool checkInitIsICE() const;
1262 void setInitStyle(InitializationStyle Style) {
1263 VarDeclBits.InitStyle = Style;
1266 /// The style of initialization for this declaration.
1268 /// C-style initialization is "int x = 1;". Call-style initialization is
1269 /// a C++98 direct-initializer, e.g. "int x(1);". The Init expression will be
1270 /// the expression inside the parens or a "ClassType(a,b,c)" class constructor
1271 /// expression for class types. List-style initialization is C++11 syntax,
1272 /// e.g. "int x{1};". Clients can distinguish between different forms of
1273 /// initialization by checking this value. In particular, "int x = {1};" is
1274 /// C-style, "int x({1})" is call-style, and "int x{1};" is list-style; the
1275 /// Init expression in all three cases is an InitListExpr.
1276 InitializationStyle getInitStyle() const {
1277 return static_cast<InitializationStyle>(VarDeclBits.InitStyle);
1280 /// Whether the initializer is a direct-initializer (list or call).
1281 bool isDirectInit() const {
1282 return getInitStyle() != CInit;
1285 /// If this definition should pretend to be a declaration.
1286 bool isThisDeclarationADemotedDefinition() const {
1287 return isa<ParmVarDecl>(this) ? false :
1288 NonParmVarDeclBits.IsThisDeclarationADemotedDefinition;
1291 /// This is a definition which should be demoted to a declaration.
1293 /// In some cases (mostly module merging) we can end up with two visible
1294 /// definitions one of which needs to be demoted to a declaration to keep
1295 /// the AST invariants.
1296 void demoteThisDefinitionToDeclaration() {
1297 assert(isThisDeclarationADefinition() && "Not a definition!");
1298 assert(!isa<ParmVarDecl>(this) && "Cannot demote ParmVarDecls!");
1299 NonParmVarDeclBits.IsThisDeclarationADemotedDefinition = 1;
1302 /// Determine whether this variable is the exception variable in a
1303 /// C++ catch statememt or an Objective-C \@catch statement.
1304 bool isExceptionVariable() const {
1305 return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.ExceptionVar;
1307 void setExceptionVariable(bool EV) {
1308 assert(!isa<ParmVarDecl>(this));
1309 NonParmVarDeclBits.ExceptionVar = EV;
1312 /// Determine whether this local variable can be used with the named
1313 /// return value optimization (NRVO).
1315 /// The named return value optimization (NRVO) works by marking certain
1316 /// non-volatile local variables of class type as NRVO objects. These
1317 /// locals can be allocated within the return slot of their containing
1318 /// function, in which case there is no need to copy the object to the
1319 /// return slot when returning from the function. Within the function body,
1320 /// each return that returns the NRVO object will have this variable as its
1322 bool isNRVOVariable() const {
1323 return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.NRVOVariable;
1325 void setNRVOVariable(bool NRVO) {
1326 assert(!isa<ParmVarDecl>(this));
1327 NonParmVarDeclBits.NRVOVariable = NRVO;
1330 /// Determine whether this variable is the for-range-declaration in
1331 /// a C++0x for-range statement.
1332 bool isCXXForRangeDecl() const {
1333 return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.CXXForRangeDecl;
1335 void setCXXForRangeDecl(bool FRD) {
1336 assert(!isa<ParmVarDecl>(this));
1337 NonParmVarDeclBits.CXXForRangeDecl = FRD;
1340 /// Determine whether this variable is a for-loop declaration for a
1341 /// for-in statement in Objective-C.
1342 bool isObjCForDecl() const {
1343 return NonParmVarDeclBits.ObjCForDecl;
1346 void setObjCForDecl(bool FRD) {
1347 NonParmVarDeclBits.ObjCForDecl = FRD;
1350 /// Determine whether this variable is an ARC pseudo-__strong
1351 /// variable. A pseudo-__strong variable has a __strong-qualified
1352 /// type but does not actually retain the object written into it.
1353 /// Generally such variables are also 'const' for safety.
1354 bool isARCPseudoStrong() const {
1355 return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.ARCPseudoStrong;
1357 void setARCPseudoStrong(bool ps) {
1358 assert(!isa<ParmVarDecl>(this));
1359 NonParmVarDeclBits.ARCPseudoStrong = ps;
1362 /// Whether this variable is (C++1z) inline.
1363 bool isInline() const {
1364 return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.IsInline;
1366 bool isInlineSpecified() const {
1367 return isa<ParmVarDecl>(this) ? false
1368 : NonParmVarDeclBits.IsInlineSpecified;
1370 void setInlineSpecified() {
1371 assert(!isa<ParmVarDecl>(this));
1372 NonParmVarDeclBits.IsInline = true;
1373 NonParmVarDeclBits.IsInlineSpecified = true;
1375 void setImplicitlyInline() {
1376 assert(!isa<ParmVarDecl>(this));
1377 NonParmVarDeclBits.IsInline = true;
1380 /// Whether this variable is (C++11) constexpr.
1381 bool isConstexpr() const {
1382 return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.IsConstexpr;
1384 void setConstexpr(bool IC) {
1385 assert(!isa<ParmVarDecl>(this));
1386 NonParmVarDeclBits.IsConstexpr = IC;
1389 /// Whether this variable is the implicit variable for a lambda init-capture.
1390 bool isInitCapture() const {
1391 return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.IsInitCapture;
1393 void setInitCapture(bool IC) {
1394 assert(!isa<ParmVarDecl>(this));
1395 NonParmVarDeclBits.IsInitCapture = IC;
1398 /// Whether this local extern variable declaration's previous declaration
1399 /// was declared in the same block scope. Only correct in C++.
1400 bool isPreviousDeclInSameBlockScope() const {
1401 return isa<ParmVarDecl>(this)
1403 : NonParmVarDeclBits.PreviousDeclInSameBlockScope;
1405 void setPreviousDeclInSameBlockScope(bool Same) {
1406 assert(!isa<ParmVarDecl>(this));
1407 NonParmVarDeclBits.PreviousDeclInSameBlockScope = Same;
1410 /// Retrieve the variable declaration from which this variable could
1411 /// be instantiated, if it is an instantiation (rather than a non-template).
1412 VarDecl *getTemplateInstantiationPattern() const;
1414 /// If this variable is an instantiated static data member of a
1415 /// class template specialization, returns the templated static data member
1416 /// from which it was instantiated.
1417 VarDecl *getInstantiatedFromStaticDataMember() const;
1419 /// If this variable is an instantiation of a variable template or a
1420 /// static data member of a class template, determine what kind of
1421 /// template specialization or instantiation this is.
1422 TemplateSpecializationKind getTemplateSpecializationKind() const;
1424 /// If this variable is an instantiation of a variable template or a
1425 /// static data member of a class template, determine its point of
1427 SourceLocation getPointOfInstantiation() const;
1429 /// If this variable is an instantiation of a static data member of a
1430 /// class template specialization, retrieves the member specialization
1432 MemberSpecializationInfo *getMemberSpecializationInfo() const;
1434 /// For a static data member that was instantiated from a static
1435 /// data member of a class template, set the template specialiation kind.
1436 void setTemplateSpecializationKind(TemplateSpecializationKind TSK,
1437 SourceLocation PointOfInstantiation = SourceLocation());
1439 /// Specify that this variable is an instantiation of the
1440 /// static data member VD.
1441 void setInstantiationOfStaticDataMember(VarDecl *VD,
1442 TemplateSpecializationKind TSK);
1444 /// Retrieves the variable template that is described by this
1445 /// variable declaration.
1447 /// Every variable template is represented as a VarTemplateDecl and a
1448 /// VarDecl. The former contains template properties (such as
1449 /// the template parameter lists) while the latter contains the
1450 /// actual description of the template's
1451 /// contents. VarTemplateDecl::getTemplatedDecl() retrieves the
1452 /// VarDecl that from a VarTemplateDecl, while
1453 /// getDescribedVarTemplate() retrieves the VarTemplateDecl from
1455 VarTemplateDecl *getDescribedVarTemplate() const;
1457 void setDescribedVarTemplate(VarTemplateDecl *Template);
1459 // Is this variable known to have a definition somewhere in the complete
1460 // program? This may be true even if the declaration has internal linkage and
1461 // has no definition within this source file.
1462 bool isKnownToBeDefined() const;
1464 // Implement isa/cast/dyncast/etc.
1465 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1466 static bool classofKind(Kind K) { return K >= firstVar && K <= lastVar; }
1469 class ImplicitParamDecl : public VarDecl {
1470 void anchor() override;
1473 /// Defines the kind of the implicit parameter: is this an implicit parameter
1474 /// with pointer to 'this', 'self', '_cmd', virtual table pointers, captured
1475 /// context or something else.
1476 enum ImplicitParamKind : unsigned {
1477 /// Parameter for Objective-C 'self' argument
1480 /// Parameter for Objective-C '_cmd' argument
1483 /// Parameter for C++ 'this' argument
1486 /// Parameter for C++ virtual table pointers
1489 /// Parameter for captured context
1492 /// Other implicit parameter
1496 /// Create implicit parameter.
1497 static ImplicitParamDecl *Create(ASTContext &C, DeclContext *DC,
1498 SourceLocation IdLoc, IdentifierInfo *Id,
1499 QualType T, ImplicitParamKind ParamKind);
1500 static ImplicitParamDecl *Create(ASTContext &C, QualType T,
1501 ImplicitParamKind ParamKind);
1503 static ImplicitParamDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1505 ImplicitParamDecl(ASTContext &C, DeclContext *DC, SourceLocation IdLoc,
1506 IdentifierInfo *Id, QualType Type,
1507 ImplicitParamKind ParamKind)
1508 : VarDecl(ImplicitParam, C, DC, IdLoc, IdLoc, Id, Type,
1509 /*TInfo=*/nullptr, SC_None) {
1510 NonParmVarDeclBits.ImplicitParamKind = ParamKind;
1514 ImplicitParamDecl(ASTContext &C, QualType Type, ImplicitParamKind ParamKind)
1515 : VarDecl(ImplicitParam, C, /*DC=*/nullptr, SourceLocation(),
1516 SourceLocation(), /*Id=*/nullptr, Type,
1517 /*TInfo=*/nullptr, SC_None) {
1518 NonParmVarDeclBits.ImplicitParamKind = ParamKind;
1522 /// Returns the implicit parameter kind.
1523 ImplicitParamKind getParameterKind() const {
1524 return static_cast<ImplicitParamKind>(NonParmVarDeclBits.ImplicitParamKind);
1527 // Implement isa/cast/dyncast/etc.
1528 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1529 static bool classofKind(Kind K) { return K == ImplicitParam; }
1532 /// Represents a parameter to a function.
1533 class ParmVarDecl : public VarDecl {
1535 enum { MaxFunctionScopeDepth = 255 };
1536 enum { MaxFunctionScopeIndex = 255 };
1539 ParmVarDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
1540 SourceLocation IdLoc, IdentifierInfo *Id, QualType T,
1541 TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
1542 : VarDecl(DK, C, DC, StartLoc, IdLoc, Id, T, TInfo, S) {
1543 assert(ParmVarDeclBits.HasInheritedDefaultArg == false);
1544 assert(ParmVarDeclBits.DefaultArgKind == DAK_None);
1545 assert(ParmVarDeclBits.IsKNRPromoted == false);
1546 assert(ParmVarDeclBits.IsObjCMethodParam == false);
1547 setDefaultArg(DefArg);
1551 static ParmVarDecl *Create(ASTContext &C, DeclContext *DC,
1552 SourceLocation StartLoc,
1553 SourceLocation IdLoc, IdentifierInfo *Id,
1554 QualType T, TypeSourceInfo *TInfo,
1555 StorageClass S, Expr *DefArg);
1557 static ParmVarDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1559 SourceRange getSourceRange() const override LLVM_READONLY;
1561 void setObjCMethodScopeInfo(unsigned parameterIndex) {
1562 ParmVarDeclBits.IsObjCMethodParam = true;
1563 setParameterIndex(parameterIndex);
1566 void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex) {
1567 assert(!ParmVarDeclBits.IsObjCMethodParam);
1569 ParmVarDeclBits.ScopeDepthOrObjCQuals = scopeDepth;
1570 assert(ParmVarDeclBits.ScopeDepthOrObjCQuals == scopeDepth
1573 setParameterIndex(parameterIndex);
1576 bool isObjCMethodParameter() const {
1577 return ParmVarDeclBits.IsObjCMethodParam;
1580 unsigned getFunctionScopeDepth() const {
1581 if (ParmVarDeclBits.IsObjCMethodParam) return 0;
1582 return ParmVarDeclBits.ScopeDepthOrObjCQuals;
1585 /// Returns the index of this parameter in its prototype or method scope.
1586 unsigned getFunctionScopeIndex() const {
1587 return getParameterIndex();
1590 ObjCDeclQualifier getObjCDeclQualifier() const {
1591 if (!ParmVarDeclBits.IsObjCMethodParam) return OBJC_TQ_None;
1592 return ObjCDeclQualifier(ParmVarDeclBits.ScopeDepthOrObjCQuals);
1594 void setObjCDeclQualifier(ObjCDeclQualifier QTVal) {
1595 assert(ParmVarDeclBits.IsObjCMethodParam);
1596 ParmVarDeclBits.ScopeDepthOrObjCQuals = QTVal;
1599 /// True if the value passed to this parameter must undergo
1600 /// K&R-style default argument promotion:
1603 /// If the expression that denotes the called function has a type
1604 /// that does not include a prototype, the integer promotions are
1605 /// performed on each argument, and arguments that have type float
1606 /// are promoted to double.
1607 bool isKNRPromoted() const {
1608 return ParmVarDeclBits.IsKNRPromoted;
1610 void setKNRPromoted(bool promoted) {
1611 ParmVarDeclBits.IsKNRPromoted = promoted;
1614 Expr *getDefaultArg();
1615 const Expr *getDefaultArg() const {
1616 return const_cast<ParmVarDecl *>(this)->getDefaultArg();
1619 void setDefaultArg(Expr *defarg);
1621 /// Retrieve the source range that covers the entire default
1623 SourceRange getDefaultArgRange() const;
1624 void setUninstantiatedDefaultArg(Expr *arg);
1625 Expr *getUninstantiatedDefaultArg();
1626 const Expr *getUninstantiatedDefaultArg() const {
1627 return const_cast<ParmVarDecl *>(this)->getUninstantiatedDefaultArg();
1630 /// Determines whether this parameter has a default argument,
1631 /// either parsed or not.
1632 bool hasDefaultArg() const;
1634 /// Determines whether this parameter has a default argument that has not
1635 /// yet been parsed. This will occur during the processing of a C++ class
1636 /// whose member functions have default arguments, e.g.,
1640 /// void f(int x = 17); // x has an unparsed default argument now
1641 /// }; // x has a regular default argument now
1643 bool hasUnparsedDefaultArg() const {
1644 return ParmVarDeclBits.DefaultArgKind == DAK_Unparsed;
1647 bool hasUninstantiatedDefaultArg() const {
1648 return ParmVarDeclBits.DefaultArgKind == DAK_Uninstantiated;
1651 /// Specify that this parameter has an unparsed default argument.
1652 /// The argument will be replaced with a real default argument via
1653 /// setDefaultArg when the class definition enclosing the function
1654 /// declaration that owns this default argument is completed.
1655 void setUnparsedDefaultArg() {
1656 ParmVarDeclBits.DefaultArgKind = DAK_Unparsed;
1659 bool hasInheritedDefaultArg() const {
1660 return ParmVarDeclBits.HasInheritedDefaultArg;
1663 void setHasInheritedDefaultArg(bool I = true) {
1664 ParmVarDeclBits.HasInheritedDefaultArg = I;
1667 QualType getOriginalType() const;
1669 /// Determine whether this parameter is actually a function
1671 bool isParameterPack() const;
1673 /// Sets the function declaration that owns this
1674 /// ParmVarDecl. Since ParmVarDecls are often created before the
1675 /// FunctionDecls that own them, this routine is required to update
1676 /// the DeclContext appropriately.
1677 void setOwningFunction(DeclContext *FD) { setDeclContext(FD); }
1679 // Implement isa/cast/dyncast/etc.
1680 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1681 static bool classofKind(Kind K) { return K == ParmVar; }
1684 enum { ParameterIndexSentinel = (1 << NumParameterIndexBits) - 1 };
1686 void setParameterIndex(unsigned parameterIndex) {
1687 if (parameterIndex >= ParameterIndexSentinel) {
1688 setParameterIndexLarge(parameterIndex);
1692 ParmVarDeclBits.ParameterIndex = parameterIndex;
1693 assert(ParmVarDeclBits.ParameterIndex == parameterIndex && "truncation!");
1695 unsigned getParameterIndex() const {
1696 unsigned d = ParmVarDeclBits.ParameterIndex;
1697 return d == ParameterIndexSentinel ? getParameterIndexLarge() : d;
1700 void setParameterIndexLarge(unsigned parameterIndex);
1701 unsigned getParameterIndexLarge() const;
1704 /// Represents a function declaration or definition.
1706 /// Since a given function can be declared several times in a program,
1707 /// there may be several FunctionDecls that correspond to that
1708 /// function. Only one of those FunctionDecls will be found when
1709 /// traversing the list of declarations in the context of the
1710 /// FunctionDecl (e.g., the translation unit); this FunctionDecl
1711 /// contains all of the information known about the function. Other,
1712 /// previous declarations of the function are available via the
1713 /// getPreviousDecl() chain.
1714 class FunctionDecl : public DeclaratorDecl, public DeclContext,
1715 public Redeclarable<FunctionDecl> {
1717 /// The kind of templated function a FunctionDecl can be.
1718 enum TemplatedKind {
1720 TK_FunctionTemplate,
1721 TK_MemberSpecialization,
1722 TK_FunctionTemplateSpecialization,
1723 TK_DependentFunctionTemplateSpecialization
1727 /// A new[]'d array of pointers to VarDecls for the formal
1728 /// parameters of this function. This is null if a prototype or if there are
1730 ParmVarDecl **ParamInfo = nullptr;
1732 LazyDeclStmtPtr Body;
1734 // FIXME: This can be packed into the bitfields in DeclContext.
1735 // NOTE: VC++ packs bitfields poorly if the types differ.
1736 unsigned SClass : 3;
1737 unsigned IsInline : 1;
1738 unsigned IsInlineSpecified : 1;
1741 // This is shared by CXXConstructorDecl, CXXConversionDecl, and
1742 // CXXDeductionGuideDecl.
1743 unsigned IsExplicitSpecified : 1;
1746 unsigned IsVirtualAsWritten : 1;
1747 unsigned IsPure : 1;
1748 unsigned HasInheritedPrototype : 1;
1749 unsigned HasWrittenPrototype : 1;
1750 unsigned IsDeleted : 1;
1751 unsigned IsTrivial : 1; // sunk from CXXMethodDecl
1753 /// This flag indicates whether this function is trivial for the purpose of
1754 /// calls. This is meaningful only when this function is a copy/move
1755 /// constructor or a destructor.
1756 unsigned IsTrivialForCall : 1;
1758 unsigned IsDefaulted : 1; // sunk from CXXMethoDecl
1759 unsigned IsExplicitlyDefaulted : 1; //sunk from CXXMethodDecl
1760 unsigned HasImplicitReturnZero : 1;
1761 unsigned IsLateTemplateParsed : 1;
1762 unsigned IsConstexpr : 1;
1763 unsigned InstantiationIsPending : 1;
1765 /// Indicates if the function uses __try.
1766 unsigned UsesSEHTry : 1;
1768 /// Indicates if the function was a definition but its body was
1770 unsigned HasSkippedBody : 1;
1772 /// Indicates if the function declaration will have a body, once we're done
1774 unsigned WillHaveBody : 1;
1776 /// Indicates that this function is a multiversioned function using attribute
1778 unsigned IsMultiVersion : 1;
1781 /// [C++17] Only used by CXXDeductionGuideDecl. Declared here to avoid
1782 /// increasing the size of CXXDeductionGuideDecl by the size of an unsigned
1783 /// int as opposed to adding a single bit to FunctionDecl.
1784 /// Indicates that the Deduction Guide is the implicitly generated 'copy
1785 /// deduction candidate' (is used during overload resolution).
1786 unsigned IsCopyDeductionCandidate : 1;
1790 /// Store the ODRHash after first calculation.
1791 unsigned HasODRHash : 1;
1794 /// End part of this FunctionDecl's source range.
1796 /// We could compute the full range in getSourceRange(). However, when we're
1797 /// dealing with a function definition deserialized from a PCH/AST file,
1798 /// we can only compute the full range once the function body has been
1799 /// de-serialized, so it's far better to have the (sometimes-redundant)
1801 SourceLocation EndRangeLoc;
1803 /// The template or declaration that this declaration
1804 /// describes or was instantiated from, respectively.
1806 /// For non-templates, this value will be NULL. For function
1807 /// declarations that describe a function template, this will be a
1808 /// pointer to a FunctionTemplateDecl. For member functions
1809 /// of class template specializations, this will be a MemberSpecializationInfo
1810 /// pointer containing information about the specialization.
1811 /// For function template specializations, this will be a
1812 /// FunctionTemplateSpecializationInfo, which contains information about
1813 /// the template being specialized and the template arguments involved in
1814 /// that specialization.
1815 llvm::PointerUnion4<FunctionTemplateDecl *,
1816 MemberSpecializationInfo *,
1817 FunctionTemplateSpecializationInfo *,
1818 DependentFunctionTemplateSpecializationInfo *>
1819 TemplateOrSpecialization;
1821 /// Provides source/type location info for the declaration name embedded in
1822 /// the DeclaratorDecl base class.
1823 DeclarationNameLoc DNLoc;
1825 /// Specify that this function declaration is actually a function
1826 /// template specialization.
1828 /// \param C the ASTContext.
1830 /// \param Template the function template that this function template
1831 /// specialization specializes.
1833 /// \param TemplateArgs the template arguments that produced this
1834 /// function template specialization from the template.
1836 /// \param InsertPos If non-NULL, the position in the function template
1837 /// specialization set where the function template specialization data will
1840 /// \param TSK the kind of template specialization this is.
1842 /// \param TemplateArgsAsWritten location info of template arguments.
1844 /// \param PointOfInstantiation point at which the function template
1845 /// specialization was first instantiated.
1846 void setFunctionTemplateSpecialization(ASTContext &C,
1847 FunctionTemplateDecl *Template,
1848 const TemplateArgumentList *TemplateArgs,
1850 TemplateSpecializationKind TSK,
1851 const TemplateArgumentListInfo *TemplateArgsAsWritten,
1852 SourceLocation PointOfInstantiation);
1854 /// Specify that this record is an instantiation of the
1855 /// member function FD.
1856 void setInstantiationOfMemberFunction(ASTContext &C, FunctionDecl *FD,
1857 TemplateSpecializationKind TSK);
1859 void setParams(ASTContext &C, ArrayRef<ParmVarDecl *> NewParamInfo);
1862 FunctionDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
1863 const DeclarationNameInfo &NameInfo, QualType T,
1864 TypeSourceInfo *TInfo, StorageClass S, bool isInlineSpecified,
1865 bool isConstexprSpecified)
1866 : DeclaratorDecl(DK, DC, NameInfo.getLoc(), NameInfo.getName(), T, TInfo,
1868 DeclContext(DK), redeclarable_base(C), SClass(S),
1869 IsInline(isInlineSpecified), IsInlineSpecified(isInlineSpecified),
1870 IsExplicitSpecified(false), IsVirtualAsWritten(false), IsPure(false),
1871 HasInheritedPrototype(false), HasWrittenPrototype(true),
1872 IsDeleted(false), IsTrivial(false), IsTrivialForCall(false),
1874 IsExplicitlyDefaulted(false), HasImplicitReturnZero(false),
1875 IsLateTemplateParsed(false), IsConstexpr(isConstexprSpecified),
1876 InstantiationIsPending(false), UsesSEHTry(false), HasSkippedBody(false),
1877 WillHaveBody(false), IsMultiVersion(false),
1878 IsCopyDeductionCandidate(false), HasODRHash(false), ODRHash(0),
1879 EndRangeLoc(NameInfo.getEndLoc()), DNLoc(NameInfo.getInfo()) {}
1881 using redeclarable_base = Redeclarable<FunctionDecl>;
1883 FunctionDecl *getNextRedeclarationImpl() override {
1884 return getNextRedeclaration();
1887 FunctionDecl *getPreviousDeclImpl() override {
1888 return getPreviousDecl();
1891 FunctionDecl *getMostRecentDeclImpl() override {
1892 return getMostRecentDecl();
1896 friend class ASTDeclReader;
1897 friend class ASTDeclWriter;
1899 using redecl_range = redeclarable_base::redecl_range;
1900 using redecl_iterator = redeclarable_base::redecl_iterator;
1902 using redeclarable_base::redecls_begin;
1903 using redeclarable_base::redecls_end;
1904 using redeclarable_base::redecls;
1905 using redeclarable_base::getPreviousDecl;
1906 using redeclarable_base::getMostRecentDecl;
1907 using redeclarable_base::isFirstDecl;
1909 static FunctionDecl *Create(ASTContext &C, DeclContext *DC,
1910 SourceLocation StartLoc, SourceLocation NLoc,
1911 DeclarationName N, QualType T,
1912 TypeSourceInfo *TInfo,
1914 bool isInlineSpecified = false,
1915 bool hasWrittenPrototype = true,
1916 bool isConstexprSpecified = false) {
1917 DeclarationNameInfo NameInfo(N, NLoc);
1918 return FunctionDecl::Create(C, DC, StartLoc, NameInfo, T, TInfo,
1920 isInlineSpecified, hasWrittenPrototype,
1921 isConstexprSpecified);
1924 static FunctionDecl *Create(ASTContext &C, DeclContext *DC,
1925 SourceLocation StartLoc,
1926 const DeclarationNameInfo &NameInfo,
1927 QualType T, TypeSourceInfo *TInfo,
1929 bool isInlineSpecified,
1930 bool hasWrittenPrototype,
1931 bool isConstexprSpecified = false);
1933 static FunctionDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1935 DeclarationNameInfo getNameInfo() const {
1936 return DeclarationNameInfo(getDeclName(), getLocation(), DNLoc);
1939 void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy,
1940 bool Qualified) const override;
1942 void setRangeEnd(SourceLocation E) { EndRangeLoc = E; }
1944 SourceRange getSourceRange() const override LLVM_READONLY;
1946 // Function definitions.
1948 // A function declaration may be:
1949 // - a non defining declaration,
1950 // - a definition. A function may be defined because:
1951 // - it has a body, or will have it in the case of late parsing.
1952 // - it has an uninstantiated body. The body does not exist because the
1953 // function is not used yet, but the declaration is considered a
1954 // definition and does not allow other definition of this function.
1955 // - it does not have a user specified body, but it does not allow
1956 // redefinition, because it is deleted/defaulted or is defined through
1957 // some other mechanism (alias, ifunc).
1959 /// Returns true if the function has a body.
1961 /// The function body might be in any of the (re-)declarations of this
1962 /// function. The variant that accepts a FunctionDecl pointer will set that
1963 /// function declaration to the actual declaration containing the body (if
1965 bool hasBody(const FunctionDecl *&Definition) const;
1967 bool hasBody() const override {
1968 const FunctionDecl* Definition;
1969 return hasBody(Definition);
1972 /// Returns whether the function has a trivial body that does not require any
1973 /// specific codegen.
1974 bool hasTrivialBody() const;
1976 /// Returns true if the function has a definition that does not need to be
1979 /// The variant that accepts a FunctionDecl pointer will set that function
1980 /// declaration to the declaration that is a definition (if there is one).
1981 bool isDefined(const FunctionDecl *&Definition) const;
1983 virtual bool isDefined() const {
1984 const FunctionDecl* Definition;
1985 return isDefined(Definition);
1988 /// Get the definition for this declaration.
1989 FunctionDecl *getDefinition() {
1990 const FunctionDecl *Definition;
1991 if (isDefined(Definition))
1992 return const_cast<FunctionDecl *>(Definition);
1995 const FunctionDecl *getDefinition() const {
1996 return const_cast<FunctionDecl *>(this)->getDefinition();
1999 /// Retrieve the body (definition) of the function. The function body might be
2000 /// in any of the (re-)declarations of this function. The variant that accepts
2001 /// a FunctionDecl pointer will set that function declaration to the actual
2002 /// declaration containing the body (if there is one).
2003 /// NOTE: For checking if there is a body, use hasBody() instead, to avoid
2004 /// unnecessary AST de-serialization of the body.
2005 Stmt *getBody(const FunctionDecl *&Definition) const;
2007 Stmt *getBody() const override {
2008 const FunctionDecl* Definition;
2009 return getBody(Definition);
2012 /// Returns whether this specific declaration of the function is also a
2013 /// definition that does not contain uninstantiated body.
2015 /// This does not determine whether the function has been defined (e.g., in a
2016 /// previous definition); for that information, use isDefined.
2017 bool isThisDeclarationADefinition() const {
2018 return IsDeleted || IsDefaulted || Body || HasSkippedBody ||
2019 IsLateTemplateParsed || WillHaveBody || hasDefiningAttr();
2022 /// Returns whether this specific declaration of the function has a body.
2023 bool doesThisDeclarationHaveABody() const {
2024 return Body || IsLateTemplateParsed;
2027 void setBody(Stmt *B);
2028 void setLazyBody(uint64_t Offset) { Body = Offset; }
2030 /// Whether this function is variadic.
2031 bool isVariadic() const;
2033 /// Whether this function is marked as virtual explicitly.
2034 bool isVirtualAsWritten() const { return IsVirtualAsWritten; }
2035 void setVirtualAsWritten(bool V) { IsVirtualAsWritten = V; }
2037 /// Whether this virtual function is pure, i.e. makes the containing class
2039 bool isPure() const { return IsPure; }
2040 void setPure(bool P = true);
2042 /// Whether this templated function will be late parsed.
2043 bool isLateTemplateParsed() const { return IsLateTemplateParsed; }
2044 void setLateTemplateParsed(bool ILT = true) { IsLateTemplateParsed = ILT; }
2046 /// Whether this function is "trivial" in some specialized C++ senses.
2047 /// Can only be true for default constructors, copy constructors,
2048 /// copy assignment operators, and destructors. Not meaningful until
2049 /// the class has been fully built by Sema.
2050 bool isTrivial() const { return IsTrivial; }
2051 void setTrivial(bool IT) { IsTrivial = IT; }
2053 bool isTrivialForCall() const { return IsTrivialForCall; }
2054 void setTrivialForCall(bool IT) { IsTrivialForCall = IT; }
2056 /// Whether this function is defaulted per C++0x. Only valid for
2057 /// special member functions.
2058 bool isDefaulted() const { return IsDefaulted; }
2059 void setDefaulted(bool D = true) { IsDefaulted = D; }
2061 /// Whether this function is explicitly defaulted per C++0x. Only valid
2062 /// for special member functions.
2063 bool isExplicitlyDefaulted() const { return IsExplicitlyDefaulted; }
2064 void setExplicitlyDefaulted(bool ED = true) { IsExplicitlyDefaulted = ED; }
2066 /// Whether falling off this function implicitly returns null/zero.
2067 /// If a more specific implicit return value is required, front-ends
2068 /// should synthesize the appropriate return statements.
2069 bool hasImplicitReturnZero() const { return HasImplicitReturnZero; }
2070 void setHasImplicitReturnZero(bool IRZ) { HasImplicitReturnZero = IRZ; }
2072 /// Whether this function has a prototype, either because one
2073 /// was explicitly written or because it was "inherited" by merging
2074 /// a declaration without a prototype with a declaration that has a
2076 bool hasPrototype() const {
2077 return HasWrittenPrototype || HasInheritedPrototype;
2080 bool hasWrittenPrototype() const { return HasWrittenPrototype; }
2082 /// Whether this function inherited its prototype from a
2083 /// previous declaration.
2084 bool hasInheritedPrototype() const { return HasInheritedPrototype; }
2085 void setHasInheritedPrototype(bool P = true) { HasInheritedPrototype = P; }
2087 /// Whether this is a (C++11) constexpr function or constexpr constructor.
2088 bool isConstexpr() const { return IsConstexpr; }
2089 void setConstexpr(bool IC) { IsConstexpr = IC; }
2091 /// Whether the instantiation of this function is pending.
2092 /// This bit is set when the decision to instantiate this function is made
2093 /// and unset if and when the function body is created. That leaves out
2094 /// cases where instantiation did not happen because the template definition
2095 /// was not seen in this TU. This bit remains set in those cases, under the
2096 /// assumption that the instantiation will happen in some other TU.
2097 bool instantiationIsPending() const { return InstantiationIsPending; }
2098 void setInstantiationIsPending(bool IC) { InstantiationIsPending = IC; }
2100 /// Indicates the function uses __try.
2101 bool usesSEHTry() const { return UsesSEHTry; }
2102 void setUsesSEHTry(bool UST) { UsesSEHTry = UST; }
2104 /// Whether this function has been deleted.
2106 /// A function that is "deleted" (via the C++0x "= delete" syntax)
2107 /// acts like a normal function, except that it cannot actually be
2108 /// called or have its address taken. Deleted functions are
2109 /// typically used in C++ overload resolution to attract arguments
2110 /// whose type or lvalue/rvalue-ness would permit the use of a
2111 /// different overload that would behave incorrectly. For example,
2112 /// one might use deleted functions to ban implicit conversion from
2113 /// a floating-point number to an Integer type:
2116 /// struct Integer {
2117 /// Integer(long); // construct from a long
2118 /// Integer(double) = delete; // no construction from float or double
2119 /// Integer(long double) = delete; // no construction from long double
2122 // If a function is deleted, its first declaration must be.
2123 bool isDeleted() const { return getCanonicalDecl()->IsDeleted; }
2124 bool isDeletedAsWritten() const { return IsDeleted && !IsDefaulted; }
2125 void setDeletedAsWritten(bool D = true) { IsDeleted = D; }
2127 /// Determines whether this function is "main", which is the
2128 /// entry point into an executable program.
2129 bool isMain() const;
2131 /// Determines whether this function is a MSVCRT user defined entry
2133 bool isMSVCRTEntryPoint() const;
2135 /// Determines whether this operator new or delete is one
2136 /// of the reserved global placement operators:
2137 /// void *operator new(size_t, void *);
2138 /// void *operator new[](size_t, void *);
2139 /// void operator delete(void *, void *);
2140 /// void operator delete[](void *, void *);
2141 /// These functions have special behavior under [new.delete.placement]:
2142 /// These functions are reserved, a C++ program may not define
2143 /// functions that displace the versions in the Standard C++ library.
2144 /// The provisions of [basic.stc.dynamic] do not apply to these
2145 /// reserved placement forms of operator new and operator delete.
2147 /// This function must be an allocation or deallocation function.
2148 bool isReservedGlobalPlacementOperator() const;
2150 /// Determines whether this function is one of the replaceable
2151 /// global allocation functions:
2152 /// void *operator new(size_t);
2153 /// void *operator new(size_t, const std::nothrow_t &) noexcept;
2154 /// void *operator new[](size_t);
2155 /// void *operator new[](size_t, const std::nothrow_t &) noexcept;
2156 /// void operator delete(void *) noexcept;
2157 /// void operator delete(void *, std::size_t) noexcept; [C++1y]
2158 /// void operator delete(void *, const std::nothrow_t &) noexcept;
2159 /// void operator delete[](void *) noexcept;
2160 /// void operator delete[](void *, std::size_t) noexcept; [C++1y]
2161 /// void operator delete[](void *, const std::nothrow_t &) noexcept;
2162 /// These functions have special behavior under C++1y [expr.new]:
2163 /// An implementation is allowed to omit a call to a replaceable global
2164 /// allocation function. [...]
2166 /// If this function is an aligned allocation/deallocation function, return
2167 /// true through IsAligned.
2168 bool isReplaceableGlobalAllocationFunction(bool *IsAligned = nullptr) const;
2170 /// Determine whether this is a destroying operator delete.
2171 bool isDestroyingOperatorDelete() const;
2173 /// Compute the language linkage.
2174 LanguageLinkage getLanguageLinkage() const;
2176 /// Determines whether this function is a function with
2177 /// external, C linkage.
2178 bool isExternC() const;
2180 /// Determines whether this function's context is, or is nested within,
2181 /// a C++ extern "C" linkage spec.
2182 bool isInExternCContext() const;
2184 /// Determines whether this function's context is, or is nested within,
2185 /// a C++ extern "C++" linkage spec.
2186 bool isInExternCXXContext() const;
2188 /// Determines whether this is a global function.
2189 bool isGlobal() const;
2191 /// Determines whether this function is known to be 'noreturn', through
2192 /// an attribute on its declaration or its type.
2193 bool isNoReturn() const;
2195 /// True if the function was a definition but its body was skipped.
2196 bool hasSkippedBody() const { return HasSkippedBody; }
2197 void setHasSkippedBody(bool Skipped = true) { HasSkippedBody = Skipped; }
2199 /// True if this function will eventually have a body, once it's fully parsed.
2200 bool willHaveBody() const { return WillHaveBody; }
2201 void setWillHaveBody(bool V = true) { WillHaveBody = V; }
2203 /// True if this function is considered a multiversioned function.
2204 bool isMultiVersion() const { return getCanonicalDecl()->IsMultiVersion; }
2206 /// Sets the multiversion state for this declaration and all of its
2208 void setIsMultiVersion(bool V = true) {
2209 getCanonicalDecl()->IsMultiVersion = V;
2212 /// True if this function is a multiversioned dispatch function as a part of
2213 /// the cpu_specific/cpu_dispatch functionality.
2214 bool isCPUDispatchMultiVersion() const;
2215 /// True if this function is a multiversioned processor specific function as a
2216 /// part of the cpu_specific/cpu_dispatch functionality.
2217 bool isCPUSpecificMultiVersion() const;
2219 void setPreviousDeclaration(FunctionDecl * PrevDecl);
2221 FunctionDecl *getCanonicalDecl() override;
2222 const FunctionDecl *getCanonicalDecl() const {
2223 return const_cast<FunctionDecl*>(this)->getCanonicalDecl();
2226 unsigned getBuiltinID() const;
2228 // ArrayRef interface to parameters.
2229 ArrayRef<ParmVarDecl *> parameters() const {
2230 return {ParamInfo, getNumParams()};
2232 MutableArrayRef<ParmVarDecl *> parameters() {
2233 return {ParamInfo, getNumParams()};
2236 // Iterator access to formal parameters.
2237 using param_iterator = MutableArrayRef<ParmVarDecl *>::iterator;
2238 using param_const_iterator = ArrayRef<ParmVarDecl *>::const_iterator;
2240 bool param_empty() const { return parameters().empty(); }
2241 param_iterator param_begin() { return parameters().begin(); }
2242 param_iterator param_end() { return parameters().end(); }
2243 param_const_iterator param_begin() const { return parameters().begin(); }
2244 param_const_iterator param_end() const { return parameters().end(); }
2245 size_t param_size() const { return parameters().size(); }
2247 /// Return the number of parameters this function must have based on its
2248 /// FunctionType. This is the length of the ParamInfo array after it has been
2250 unsigned getNumParams() const;
2252 const ParmVarDecl *getParamDecl(unsigned i) const {
2253 assert(i < getNumParams() && "Illegal param #");
2254 return ParamInfo[i];
2256 ParmVarDecl *getParamDecl(unsigned i) {
2257 assert(i < getNumParams() && "Illegal param #");
2258 return ParamInfo[i];
2260 void setParams(ArrayRef<ParmVarDecl *> NewParamInfo) {
2261 setParams(getASTContext(), NewParamInfo);
2264 /// Returns the minimum number of arguments needed to call this function. This
2265 /// may be fewer than the number of function parameters, if some of the
2266 /// parameters have default arguments (in C++).
2267 unsigned getMinRequiredArguments() const;
2269 QualType getReturnType() const {
2270 assert(getType()->getAs<FunctionType>() && "Expected a FunctionType!");
2271 return getType()->getAs<FunctionType>()->getReturnType();
2274 /// Attempt to compute an informative source range covering the
2275 /// function return type. This may omit qualifiers and other information with
2276 /// limited representation in the AST.
2277 SourceRange getReturnTypeSourceRange() const;
2279 /// Attempt to compute an informative source range covering the
2280 /// function exception specification, if any.
2281 SourceRange getExceptionSpecSourceRange() const;
2283 /// Determine the type of an expression that calls this function.
2284 QualType getCallResultType() const {
2285 assert(getType()->getAs<FunctionType>() && "Expected a FunctionType!");
2286 return getType()->getAs<FunctionType>()->getCallResultType(getASTContext());
2289 /// Returns the WarnUnusedResultAttr that is either declared on this
2290 /// function, or its return type declaration.
2291 const Attr *getUnusedResultAttr() const;
2293 /// Returns true if this function or its return type has the
2294 /// warn_unused_result attribute.
2295 bool hasUnusedResultAttr() const { return getUnusedResultAttr() != nullptr; }
2297 /// Returns the storage class as written in the source. For the
2298 /// computed linkage of symbol, see getLinkage.
2299 StorageClass getStorageClass() const { return StorageClass(SClass); }
2301 /// Determine whether the "inline" keyword was specified for this
2303 bool isInlineSpecified() const { return IsInlineSpecified; }
2305 /// Set whether the "inline" keyword was specified for this function.
2306 void setInlineSpecified(bool I) {
2307 IsInlineSpecified = I;
2311 /// Flag that this function is implicitly inline.
2312 void setImplicitlyInline() {
2316 /// Determine whether this function should be inlined, because it is
2317 /// either marked "inline" or "constexpr" or is a member function of a class
2318 /// that was defined in the class body.
2319 bool isInlined() const { return IsInline; }
2321 bool isInlineDefinitionExternallyVisible() const;
2323 bool isMSExternInline() const;
2325 bool doesDeclarationForceExternallyVisibleDefinition() const;
2327 /// Whether this function declaration represents an C++ overloaded
2328 /// operator, e.g., "operator+".
2329 bool isOverloadedOperator() const {
2330 return getOverloadedOperator() != OO_None;
2333 OverloadedOperatorKind getOverloadedOperator() const;
2335 const IdentifierInfo *getLiteralIdentifier() const;
2337 /// If this function is an instantiation of a member function
2338 /// of a class template specialization, retrieves the function from
2339 /// which it was instantiated.
2341 /// This routine will return non-NULL for (non-templated) member
2342 /// functions of class templates and for instantiations of function
2343 /// templates. For example, given:
2346 /// template<typename T>
2352 /// The declaration for X<int>::f is a (non-templated) FunctionDecl
2353 /// whose parent is the class template specialization X<int>. For
2354 /// this declaration, getInstantiatedFromFunction() will return
2355 /// the FunctionDecl X<T>::A. When a complete definition of
2356 /// X<int>::A is required, it will be instantiated from the
2357 /// declaration returned by getInstantiatedFromMemberFunction().
2358 FunctionDecl *getInstantiatedFromMemberFunction() const;
2360 /// What kind of templated function this is.
2361 TemplatedKind getTemplatedKind() const;
2363 /// If this function is an instantiation of a member function of a
2364 /// class template specialization, retrieves the member specialization
2366 MemberSpecializationInfo *getMemberSpecializationInfo() const;
2368 /// Specify that this record is an instantiation of the
2369 /// member function FD.
2370 void setInstantiationOfMemberFunction(FunctionDecl *FD,
2371 TemplateSpecializationKind TSK) {
2372 setInstantiationOfMemberFunction(getASTContext(), FD, TSK);
2375 /// Retrieves the function template that is described by this
2376 /// function declaration.
2378 /// Every function template is represented as a FunctionTemplateDecl
2379 /// and a FunctionDecl (or something derived from FunctionDecl). The
2380 /// former contains template properties (such as the template
2381 /// parameter lists) while the latter contains the actual
2382 /// description of the template's
2383 /// contents. FunctionTemplateDecl::getTemplatedDecl() retrieves the
2384 /// FunctionDecl that describes the function template,
2385 /// getDescribedFunctionTemplate() retrieves the
2386 /// FunctionTemplateDecl from a FunctionDecl.
2387 FunctionTemplateDecl *getDescribedFunctionTemplate() const;
2389 void setDescribedFunctionTemplate(FunctionTemplateDecl *Template);
2391 /// Determine whether this function is a function template
2393 bool isFunctionTemplateSpecialization() const {
2394 return getPrimaryTemplate() != nullptr;
2397 /// Retrieve the class scope template pattern that this function
2398 /// template specialization is instantiated from.
2399 FunctionDecl *getClassScopeSpecializationPattern() const;
2401 /// If this function is actually a function template specialization,
2402 /// retrieve information about this function template specialization.
2403 /// Otherwise, returns NULL.
2404 FunctionTemplateSpecializationInfo *getTemplateSpecializationInfo() const;
2406 /// Determines whether this function is a function template
2407 /// specialization or a member of a class template specialization that can
2408 /// be implicitly instantiated.
2409 bool isImplicitlyInstantiable() const;
2411 /// Determines if the given function was instantiated from a
2412 /// function template.
2413 bool isTemplateInstantiation() const;
2415 /// Retrieve the function declaration from which this function could
2416 /// be instantiated, if it is an instantiation (rather than a non-template
2417 /// or a specialization, for example).
2418 FunctionDecl *getTemplateInstantiationPattern() const;
2420 /// Retrieve the primary template that this function template
2421 /// specialization either specializes or was instantiated from.
2423 /// If this function declaration is not a function template specialization,
2425 FunctionTemplateDecl *getPrimaryTemplate() const;
2427 /// Retrieve the template arguments used to produce this function
2428 /// template specialization from the primary template.
2430 /// If this function declaration is not a function template specialization,
2432 const TemplateArgumentList *getTemplateSpecializationArgs() const;
2434 /// Retrieve the template argument list as written in the sources,
2437 /// If this function declaration is not a function template specialization
2438 /// or if it had no explicit template argument list, returns NULL.
2439 /// Note that it an explicit template argument list may be written empty,
2440 /// e.g., template<> void foo<>(char* s);
2441 const ASTTemplateArgumentListInfo*
2442 getTemplateSpecializationArgsAsWritten() const;
2444 /// Specify that this function declaration is actually a function
2445 /// template specialization.
2447 /// \param Template the function template that this function template
2448 /// specialization specializes.
2450 /// \param TemplateArgs the template arguments that produced this
2451 /// function template specialization from the template.
2453 /// \param InsertPos If non-NULL, the position in the function template
2454 /// specialization set where the function template specialization data will
2457 /// \param TSK the kind of template specialization this is.
2459 /// \param TemplateArgsAsWritten location info of template arguments.
2461 /// \param PointOfInstantiation point at which the function template
2462 /// specialization was first instantiated.
2463 void setFunctionTemplateSpecialization(FunctionTemplateDecl *Template,
2464 const TemplateArgumentList *TemplateArgs,
2466 TemplateSpecializationKind TSK = TSK_ImplicitInstantiation,
2467 const TemplateArgumentListInfo *TemplateArgsAsWritten = nullptr,
2468 SourceLocation PointOfInstantiation = SourceLocation()) {
2469 setFunctionTemplateSpecialization(getASTContext(), Template, TemplateArgs,
2470 InsertPos, TSK, TemplateArgsAsWritten,
2471 PointOfInstantiation);
2474 /// Specifies that this function declaration is actually a
2475 /// dependent function template specialization.
2476 void setDependentTemplateSpecialization(ASTContext &Context,
2477 const UnresolvedSetImpl &Templates,
2478 const TemplateArgumentListInfo &TemplateArgs);
2480 DependentFunctionTemplateSpecializationInfo *
2481 getDependentSpecializationInfo() const;
2483 /// Determine what kind of template instantiation this function
2485 TemplateSpecializationKind getTemplateSpecializationKind() const;
2487 /// Determine what kind of template instantiation this function
2489 void setTemplateSpecializationKind(TemplateSpecializationKind TSK,
2490 SourceLocation PointOfInstantiation = SourceLocation());
2492 /// Retrieve the (first) point of instantiation of a function template
2493 /// specialization or a member of a class template specialization.
2495 /// \returns the first point of instantiation, if this function was
2496 /// instantiated from a template; otherwise, returns an invalid source
2498 SourceLocation getPointOfInstantiation() const;
2500 /// Determine whether this is or was instantiated from an out-of-line
2501 /// definition of a member function.
2502 bool isOutOfLine() const override;
2504 /// Identify a memory copying or setting function.
2505 /// If the given function is a memory copy or setting function, returns
2506 /// the corresponding Builtin ID. If the function is not a memory function,
2508 unsigned getMemoryFunctionKind() const;
2510 /// Returns ODRHash of the function. This value is calculated and
2511 /// stored on first call, then the stored value returned on the other calls.
2512 unsigned getODRHash();
2514 /// Returns cached ODRHash of the function. This must have been previously
2515 /// computed and stored.
2516 unsigned getODRHash() const;
2518 // Implement isa/cast/dyncast/etc.
2519 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2520 static bool classofKind(Kind K) {
2521 return K >= firstFunction && K <= lastFunction;
2523 static DeclContext *castToDeclContext(const FunctionDecl *D) {
2524 return static_cast<DeclContext *>(const_cast<FunctionDecl*>(D));
2526 static FunctionDecl *castFromDeclContext(const DeclContext *DC) {
2527 return static_cast<FunctionDecl *>(const_cast<DeclContext*>(DC));
2531 /// Represents a member of a struct/union/class.
2532 class FieldDecl : public DeclaratorDecl, public Mergeable<FieldDecl> {
2533 unsigned BitField : 1;
2534 unsigned Mutable : 1;
2535 mutable unsigned CachedFieldIndex : 30;
2537 /// The kinds of value we can store in InitializerOrBitWidth.
2539 /// Note that this is compatible with InClassInitStyle except for
2540 /// ISK_CapturedVLAType.
2541 enum InitStorageKind {
2542 /// If the pointer is null, there's nothing special. Otherwise,
2543 /// this is a bitfield and the pointer is the Expr* storing the
2545 ISK_NoInit = (unsigned) ICIS_NoInit,
2547 /// The pointer is an (optional due to delayed parsing) Expr*
2548 /// holding the copy-initializer.
2549 ISK_InClassCopyInit = (unsigned) ICIS_CopyInit,
2551 /// The pointer is an (optional due to delayed parsing) Expr*
2552 /// holding the list-initializer.
2553 ISK_InClassListInit = (unsigned) ICIS_ListInit,
2555 /// The pointer is a VariableArrayType* that's been captured;
2556 /// the enclosing context is a lambda or captured statement.
2557 ISK_CapturedVLAType,
2560 /// If this is a bitfield with a default member initializer, this
2561 /// structure is used to represent the two expressions.
2562 struct InitAndBitWidth {
2567 /// Storage for either the bit-width, the in-class initializer, or
2568 /// both (via InitAndBitWidth), or the captured variable length array bound.
2570 /// If the storage kind is ISK_InClassCopyInit or
2571 /// ISK_InClassListInit, but the initializer is null, then this
2572 /// field has an in-class initializer that has not yet been parsed
2574 // FIXME: Tail-allocate this to reduce the size of FieldDecl in the
2575 // overwhelmingly common case that we have none of these things.
2576 llvm::PointerIntPair<void *, 2, InitStorageKind> InitStorage;
2579 FieldDecl(Kind DK, DeclContext *DC, SourceLocation StartLoc,
2580 SourceLocation IdLoc, IdentifierInfo *Id,
2581 QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable,
2582 InClassInitStyle InitStyle)
2583 : DeclaratorDecl(DK, DC, IdLoc, Id, T, TInfo, StartLoc),
2584 BitField(false), Mutable(Mutable), CachedFieldIndex(0),
2585 InitStorage(nullptr, (InitStorageKind) InitStyle) {
2591 friend class ASTDeclReader;
2592 friend class ASTDeclWriter;
2594 static FieldDecl *Create(const ASTContext &C, DeclContext *DC,
2595 SourceLocation StartLoc, SourceLocation IdLoc,
2596 IdentifierInfo *Id, QualType T,
2597 TypeSourceInfo *TInfo, Expr *BW, bool Mutable,
2598 InClassInitStyle InitStyle);
2600 static FieldDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2602 /// Returns the index of this field within its record,
2603 /// as appropriate for passing to ASTRecordLayout::getFieldOffset.
2604 unsigned getFieldIndex() const;
2606 /// Determines whether this field is mutable (C++ only).
2607 bool isMutable() const { return Mutable; }
2609 /// Determines whether this field is a bitfield.
2610 bool isBitField() const { return BitField; }
2612 /// Determines whether this is an unnamed bitfield.
2613 bool isUnnamedBitfield() const { return isBitField() && !getDeclName(); }
2615 /// Determines whether this field is a
2616 /// representative for an anonymous struct or union. Such fields are
2617 /// unnamed and are implicitly generated by the implementation to
2618 /// store the data for the anonymous union or struct.
2619 bool isAnonymousStructOrUnion() const;
2621 Expr *getBitWidth() const {
2624 void *Ptr = InitStorage.getPointer();
2625 if (getInClassInitStyle())
2626 return static_cast<InitAndBitWidth*>(Ptr)->BitWidth;
2627 return static_cast<Expr*>(Ptr);
2630 unsigned getBitWidthValue(const ASTContext &Ctx) const;
2632 /// Set the bit-field width for this member.
2633 // Note: used by some clients (i.e., do not remove it).
2634 void setBitWidth(Expr *Width) {
2635 assert(!hasCapturedVLAType() && !BitField &&
2636 "bit width or captured type already set");
2637 assert(Width && "no bit width specified");
2638 InitStorage.setPointer(
2639 InitStorage.getInt()
2640 ? new (getASTContext())
2641 InitAndBitWidth{getInClassInitializer(), Width}
2642 : static_cast<void*>(Width));
2646 /// Remove the bit-field width from this member.
2647 // Note: used by some clients (i.e., do not remove it).
2648 void removeBitWidth() {
2649 assert(isBitField() && "no bitfield width to remove");
2650 InitStorage.setPointer(getInClassInitializer());
2654 /// Is this a zero-length bit-field? Such bit-fields aren't really bit-fields
2655 /// at all and instead act as a separator between contiguous runs of other
2657 bool isZeroLengthBitField(const ASTContext &Ctx) const;
2659 /// Get the kind of (C++11) default member initializer that this field has.
2660 InClassInitStyle getInClassInitStyle() const {
2661 InitStorageKind storageKind = InitStorage.getInt();
2662 return (storageKind == ISK_CapturedVLAType
2663 ? ICIS_NoInit : (InClassInitStyle) storageKind);
2666 /// Determine whether this member has a C++11 default member initializer.
2667 bool hasInClassInitializer() const {
2668 return getInClassInitStyle() != ICIS_NoInit;
2671 /// Get the C++11 default member initializer for this member, or null if one
2672 /// has not been set. If a valid declaration has a default member initializer,
2673 /// but this returns null, then we have not parsed and attached it yet.
2674 Expr *getInClassInitializer() const {
2675 if (!hasInClassInitializer())
2677 void *Ptr = InitStorage.getPointer();
2679 return static_cast<InitAndBitWidth*>(Ptr)->Init;
2680 return static_cast<Expr*>(Ptr);
2683 /// Set the C++11 in-class initializer for this member.
2684 void setInClassInitializer(Expr *Init) {
2685 assert(hasInClassInitializer() && !getInClassInitializer());
2687 static_cast<InitAndBitWidth*>(InitStorage.getPointer())->Init = Init;
2689 InitStorage.setPointer(Init);
2692 /// Remove the C++11 in-class initializer from this member.
2693 void removeInClassInitializer() {
2694 assert(hasInClassInitializer() && "no initializer to remove");
2695 InitStorage.setPointerAndInt(getBitWidth(), ISK_NoInit);
2698 /// Determine whether this member captures the variable length array
2700 bool hasCapturedVLAType() const {
2701 return InitStorage.getInt() == ISK_CapturedVLAType;
2704 /// Get the captured variable length array type.
2705 const VariableArrayType *getCapturedVLAType() const {
2706 return hasCapturedVLAType() ? static_cast<const VariableArrayType *>(
2707 InitStorage.getPointer())
2711 /// Set the captured variable length array type for this field.
2712 void setCapturedVLAType(const VariableArrayType *VLAType);
2714 /// Returns the parent of this field declaration, which
2715 /// is the struct in which this field is defined.
2716 const RecordDecl *getParent() const {
2717 return cast<RecordDecl>(getDeclContext());
2720 RecordDecl *getParent() {
2721 return cast<RecordDecl>(getDeclContext());
2724 SourceRange getSourceRange() const override LLVM_READONLY;
2726 /// Retrieves the canonical declaration of this field.
2727 FieldDecl *getCanonicalDecl() override { return getFirstDecl(); }
2728 const FieldDecl *getCanonicalDecl() const { return getFirstDecl(); }
2730 // Implement isa/cast/dyncast/etc.
2731 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2732 static bool classofKind(Kind K) { return K >= firstField && K <= lastField; }
2735 /// An instance of this object exists for each enum constant
2736 /// that is defined. For example, in "enum X {a,b}", each of a/b are
2737 /// EnumConstantDecl's, X is an instance of EnumDecl, and the type of a/b is a
2738 /// TagType for the X EnumDecl.
2739 class EnumConstantDecl : public ValueDecl, public Mergeable<EnumConstantDecl> {
2740 Stmt *Init; // an integer constant expression
2741 llvm::APSInt Val; // The value.
2744 EnumConstantDecl(DeclContext *DC, SourceLocation L,
2745 IdentifierInfo *Id, QualType T, Expr *E,
2746 const llvm::APSInt &V)
2747 : ValueDecl(EnumConstant, DC, L, Id, T), Init((Stmt*)E), Val(V) {}
2750 friend class StmtIteratorBase;
2752 static EnumConstantDecl *Create(ASTContext &C, EnumDecl *DC,
2753 SourceLocation L, IdentifierInfo *Id,
2754 QualType T, Expr *E,
2755 const llvm::APSInt &V);
2756 static EnumConstantDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2758 const Expr *getInitExpr() const { return (const Expr*) Init; }
2759 Expr *getInitExpr() { return (Expr*) Init; }
2760 const llvm::APSInt &getInitVal() const { return Val; }
2762 void setInitExpr(Expr *E) { Init = (Stmt*) E; }
2763 void setInitVal(const llvm::APSInt &V) { Val = V; }
2765 SourceRange getSourceRange() const override LLVM_READONLY;
2767 /// Retrieves the canonical declaration of this enumerator.
2768 EnumConstantDecl *getCanonicalDecl() override { return getFirstDecl(); }
2769 const EnumConstantDecl *getCanonicalDecl() const { return getFirstDecl(); }
2771 // Implement isa/cast/dyncast/etc.
2772 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2773 static bool classofKind(Kind K) { return K == EnumConstant; }
2776 /// Represents a field injected from an anonymous union/struct into the parent
2777 /// scope. These are always implicit.
2778 class IndirectFieldDecl : public ValueDecl,
2779 public Mergeable<IndirectFieldDecl> {
2780 NamedDecl **Chaining;
2781 unsigned ChainingSize;
2783 IndirectFieldDecl(ASTContext &C, DeclContext *DC, SourceLocation L,
2784 DeclarationName N, QualType T,
2785 MutableArrayRef<NamedDecl *> CH);
2787 void anchor() override;
2790 friend class ASTDeclReader;
2792 static IndirectFieldDecl *Create(ASTContext &C, DeclContext *DC,
2793 SourceLocation L, IdentifierInfo *Id,
2794 QualType T, llvm::MutableArrayRef<NamedDecl *> CH);
2796 static IndirectFieldDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2798 using chain_iterator = ArrayRef<NamedDecl *>::const_iterator;
2800 ArrayRef<NamedDecl *> chain() const {
2801 return llvm::makeArrayRef(Chaining, ChainingSize);
2803 chain_iterator chain_begin() const { return chain().begin(); }
2804 chain_iterator chain_end() const { return chain().end(); }
2806 unsigned getChainingSize() const { return ChainingSize; }
2808 FieldDecl *getAnonField() const {
2809 assert(chain().size() >= 2);
2810 return cast<FieldDecl>(chain().back());
2813 VarDecl *getVarDecl() const {
2814 assert(chain().size() >= 2);
2815 return dyn_cast<VarDecl>(chain().front());
2818 IndirectFieldDecl *getCanonicalDecl() override { return getFirstDecl(); }
2819 const IndirectFieldDecl *getCanonicalDecl() const { return getFirstDecl(); }
2821 // Implement isa/cast/dyncast/etc.
2822 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2823 static bool classofKind(Kind K) { return K == IndirectField; }
2826 /// Represents a declaration of a type.
2827 class TypeDecl : public NamedDecl {
2828 friend class ASTContext;
2830 /// This indicates the Type object that represents
2831 /// this TypeDecl. It is a cache maintained by
2832 /// ASTContext::getTypedefType, ASTContext::getTagDeclType, and
2833 /// ASTContext::getTemplateTypeParmType, and TemplateTypeParmDecl.
2834 mutable const Type *TypeForDecl = nullptr;
2836 /// The start of the source range for this declaration.
2837 SourceLocation LocStart;
2839 void anchor() override;
2842 TypeDecl(Kind DK, DeclContext *DC, SourceLocation L, IdentifierInfo *Id,
2843 SourceLocation StartL = SourceLocation())
2844 : NamedDecl(DK, DC, L, Id), LocStart(StartL) {}
2847 // Low-level accessor. If you just want the type defined by this node,
2848 // check out ASTContext::getTypeDeclType or one of
2849 // ASTContext::getTypedefType, ASTContext::getRecordType, etc. if you
2850 // already know the specific kind of node this is.
2851 const Type *getTypeForDecl() const { return TypeForDecl; }
2852 void setTypeForDecl(const Type *TD) { TypeForDecl = TD; }
2854 SourceLocation getLocStart() const LLVM_READONLY { return LocStart; }
2855 void setLocStart(SourceLocation L) { LocStart = L; }
2856 SourceRange getSourceRange() const override LLVM_READONLY {
2857 if (LocStart.isValid())
2858 return SourceRange(LocStart, getLocation());
2860 return SourceRange(getLocation());
2863 // Implement isa/cast/dyncast/etc.
2864 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2865 static bool classofKind(Kind K) { return K >= firstType && K <= lastType; }
2868 /// Base class for declarations which introduce a typedef-name.
2869 class TypedefNameDecl : public TypeDecl, public Redeclarable<TypedefNameDecl> {
2870 struct alignas(8) ModedTInfo {
2871 TypeSourceInfo *first;
2875 /// If int part is 0, we have not computed IsTransparentTag.
2876 /// Otherwise, IsTransparentTag is (getInt() >> 1).
2877 mutable llvm::PointerIntPair<
2878 llvm::PointerUnion<TypeSourceInfo *, ModedTInfo *>, 2>
2881 void anchor() override;
2884 TypedefNameDecl(Kind DK, ASTContext &C, DeclContext *DC,
2885 SourceLocation StartLoc, SourceLocation IdLoc,
2886 IdentifierInfo *Id, TypeSourceInfo *TInfo)
2887 : TypeDecl(DK, DC, IdLoc, Id, StartLoc), redeclarable_base(C),
2888 MaybeModedTInfo(TInfo, 0) {}
2890 using redeclarable_base = Redeclarable<TypedefNameDecl>;
2892 TypedefNameDecl *getNextRedeclarationImpl() override {
2893 return getNextRedeclaration();
2896 TypedefNameDecl *getPreviousDeclImpl() override {
2897 return getPreviousDecl();
2900 TypedefNameDecl *getMostRecentDeclImpl() override {
2901 return getMostRecentDecl();
2905 using redecl_range = redeclarable_base::redecl_range;
2906 using redecl_iterator = redeclarable_base::redecl_iterator;
2908 using redeclarable_base::redecls_begin;
2909 using redeclarable_base::redecls_end;
2910 using redeclarable_base::redecls;
2911 using redeclarable_base::getPreviousDecl;
2912 using redeclarable_base::getMostRecentDecl;
2913 using redeclarable_base::isFirstDecl;
2915 bool isModed() const {
2916 return MaybeModedTInfo.getPointer().is<ModedTInfo *>();
2919 TypeSourceInfo *getTypeSourceInfo() const {
2920 return isModed() ? MaybeModedTInfo.getPointer().get<ModedTInfo *>()->first
2921 : MaybeModedTInfo.getPointer().get<TypeSourceInfo *>();
2924 QualType getUnderlyingType() const {
2925 return isModed() ? MaybeModedTInfo.getPointer().get<ModedTInfo *>()->second
2926 : MaybeModedTInfo.getPointer()
2927 .get<TypeSourceInfo *>()
2931 void setTypeSourceInfo(TypeSourceInfo *newType) {
2932 MaybeModedTInfo.setPointer(newType);
2935 void setModedTypeSourceInfo(TypeSourceInfo *unmodedTSI, QualType modedTy) {
2936 MaybeModedTInfo.setPointer(new (getASTContext(), 8)
2937 ModedTInfo({unmodedTSI, modedTy}));
2940 /// Retrieves the canonical declaration of this typedef-name.
2941 TypedefNameDecl *getCanonicalDecl() override { return getFirstDecl(); }
2942 const TypedefNameDecl *getCanonicalDecl() const { return getFirstDecl(); }
2944 /// Retrieves the tag declaration for which this is the typedef name for
2945 /// linkage purposes, if any.
2947 /// \param AnyRedecl Look for the tag declaration in any redeclaration of
2948 /// this typedef declaration.
2949 TagDecl *getAnonDeclWithTypedefName(bool AnyRedecl = false) const;
2951 /// Determines if this typedef shares a name and spelling location with its
2952 /// underlying tag type, as is the case with the NS_ENUM macro.
2953 bool isTransparentTag() const {
2954 if (MaybeModedTInfo.getInt())
2955 return MaybeModedTInfo.getInt() & 0x2;
2956 return isTransparentTagSlow();
2959 // Implement isa/cast/dyncast/etc.
2960 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2961 static bool classofKind(Kind K) {
2962 return K >= firstTypedefName && K <= lastTypedefName;
2966 bool isTransparentTagSlow() const;
2969 /// Represents the declaration of a typedef-name via the 'typedef'
2971 class TypedefDecl : public TypedefNameDecl {
2972 TypedefDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
2973 SourceLocation IdLoc, IdentifierInfo *Id, TypeSourceInfo *TInfo)
2974 : TypedefNameDecl(Typedef, C, DC, StartLoc, IdLoc, Id, TInfo) {}
2977 static TypedefDecl *Create(ASTContext &C, DeclContext *DC,
2978 SourceLocation StartLoc, SourceLocation IdLoc,
2979 IdentifierInfo *Id, TypeSourceInfo *TInfo);
2980 static TypedefDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2982 SourceRange getSourceRange() const override LLVM_READONLY;
2984 // Implement isa/cast/dyncast/etc.
2985 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2986 static bool classofKind(Kind K) { return K == Typedef; }
2989 /// Represents the declaration of a typedef-name via a C++11
2990 /// alias-declaration.
2991 class TypeAliasDecl : public TypedefNameDecl {
2992 /// The template for which this is the pattern, if any.
2993 TypeAliasTemplateDecl *Template;
2995 TypeAliasDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
2996 SourceLocation IdLoc, IdentifierInfo *Id, TypeSourceInfo *TInfo)
2997 : TypedefNameDecl(TypeAlias, C, DC, StartLoc, IdLoc, Id, TInfo),
2998 Template(nullptr) {}
3001 static TypeAliasDecl *Create(ASTContext &C, DeclContext *DC,
3002 SourceLocation StartLoc, SourceLocation IdLoc,
3003 IdentifierInfo *Id, TypeSourceInfo *TInfo);
3004 static TypeAliasDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3006 SourceRange getSourceRange() const override LLVM_READONLY;
3008 TypeAliasTemplateDecl *getDescribedAliasTemplate() const { return Template; }
3009 void setDescribedAliasTemplate(TypeAliasTemplateDecl *TAT) { Template = TAT; }
3011 // Implement isa/cast/dyncast/etc.
3012 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3013 static bool classofKind(Kind K) { return K == TypeAlias; }
3016 /// Represents the declaration of a struct/union/class/enum.
3018 : public TypeDecl, public DeclContext, public Redeclarable<TagDecl> {
3020 // This is really ugly.
3021 using TagKind = TagTypeKind;
3024 // FIXME: This can be packed into the bitfields in Decl.
3025 /// The TagKind enum.
3026 unsigned TagDeclKind : 3;
3028 /// True if this is a definition ("struct foo {};"), false if it is a
3029 /// declaration ("struct foo;"). It is not considered a definition
3030 /// until the definition has been fully processed.
3031 unsigned IsCompleteDefinition : 1;
3034 /// True if this is currently being defined.
3035 unsigned IsBeingDefined : 1;
3038 /// True if this tag declaration is "embedded" (i.e., defined or declared
3039 /// for the very first time) in the syntax of a declarator.
3040 unsigned IsEmbeddedInDeclarator : 1;
3042 /// True if this tag is free standing, e.g. "struct foo;".
3043 unsigned IsFreeStanding : 1;
3046 // These are used by (and only defined for) EnumDecl.
3047 unsigned NumPositiveBits : 8;
3048 unsigned NumNegativeBits : 8;
3050 /// True if this tag declaration is a scoped enumeration. Only
3051 /// possible in C++11 mode.
3052 unsigned IsScoped : 1;
3054 /// If this tag declaration is a scoped enum,
3055 /// then this is true if the scoped enum was declared using the class
3056 /// tag, false if it was declared with the struct tag. No meaning is
3057 /// associated if this tag declaration is not a scoped enum.
3058 unsigned IsScopedUsingClassTag : 1;
3060 /// True if this is an enumeration with fixed underlying type. Only
3061 /// possible in C++11, Microsoft extensions, or Objective C mode.
3062 unsigned IsFixed : 1;
3064 /// Indicates whether it is possible for declarations of this kind
3065 /// to have an out-of-date definition.
3067 /// This option is only enabled when modules are enabled.
3068 unsigned MayHaveOutOfDateDef : 1;
3070 /// Has the full definition of this type been required by a use somewhere in
3072 unsigned IsCompleteDefinitionRequired : 1;
3075 SourceRange BraceRange;
3077 // A struct representing syntactic qualifier info,
3078 // to be used for the (uncommon) case of out-of-line declarations.
3079 using ExtInfo = QualifierInfo;
3081 /// If the (out-of-line) tag declaration name
3082 /// is qualified, it points to the qualifier info (nns and range);
3083 /// otherwise, if the tag declaration is anonymous and it is part of
3084 /// a typedef or alias, it points to the TypedefNameDecl (used for mangling);
3085 /// otherwise, if the tag declaration is anonymous and it is used as a
3086 /// declaration specifier for variables, it points to the first VarDecl (used
3088 /// otherwise, it is a null (TypedefNameDecl) pointer.
3089 llvm::PointerUnion<TypedefNameDecl *, ExtInfo *> TypedefNameDeclOrQualifier;
3091 bool hasExtInfo() const { return TypedefNameDeclOrQualifier.is<ExtInfo *>(); }
3092 ExtInfo *getExtInfo() { return TypedefNameDeclOrQualifier.get<ExtInfo *>(); }
3093 const ExtInfo *getExtInfo() const {
3094 return TypedefNameDeclOrQualifier.get<ExtInfo *>();
3098 TagDecl(Kind DK, TagKind TK, const ASTContext &C, DeclContext *DC,
3099 SourceLocation L, IdentifierInfo *Id, TagDecl *PrevDecl,
3100 SourceLocation StartL)
3101 : TypeDecl(DK, DC, L, Id, StartL), DeclContext(DK), redeclarable_base(C),
3102 TagDeclKind(TK), IsCompleteDefinition(false), IsBeingDefined(false),
3103 IsEmbeddedInDeclarator(false), IsFreeStanding(false),
3104 IsCompleteDefinitionRequired(false),
3105 TypedefNameDeclOrQualifier((TypedefNameDecl *)nullptr) {
3106 assert((DK != Enum || TK == TTK_Enum) &&
3107 "EnumDecl not matched with TTK_Enum");
3108 setPreviousDecl(PrevDecl);
3111 using redeclarable_base = Redeclarable<TagDecl>;
3113 TagDecl *getNextRedeclarationImpl() override {
3114 return getNextRedeclaration();
3117 TagDecl *getPreviousDeclImpl() override {
3118 return getPreviousDecl();
3121 TagDecl *getMostRecentDeclImpl() override {
3122 return getMostRecentDecl();
3125 /// Completes the definition of this tag declaration.
3127 /// This is a helper function for derived classes.
3128 void completeDefinition();
3131 friend class ASTDeclReader;
3132 friend class ASTDeclWriter;
3134 using redecl_range = redeclarable_base::redecl_range;
3135 using redecl_iterator = redeclarable_base::redecl_iterator;
3137 using redeclarable_base::redecls_begin;
3138 using redeclarable_base::redecls_end;
3139 using redeclarable_base::redecls;
3140 using redeclarable_base::getPreviousDecl;
3141 using redeclarable_base::getMostRecentDecl;
3142 using redeclarable_base::isFirstDecl;
3144 SourceRange getBraceRange() const { return BraceRange; }
3145 void setBraceRange(SourceRange R) { BraceRange = R; }
3147 /// Return SourceLocation representing start of source
3148 /// range ignoring outer template declarations.
3149 SourceLocation getInnerLocStart() const { return getLocStart(); }
3151 /// Return SourceLocation representing start of source
3152 /// range taking into account any outer template declarations.
3153 SourceLocation getOuterLocStart() const;
3154 SourceRange getSourceRange() const override LLVM_READONLY;
3156 TagDecl *getCanonicalDecl() override;
3157 const TagDecl *getCanonicalDecl() const {
3158 return const_cast<TagDecl*>(this)->getCanonicalDecl();
3161 /// Return true if this declaration is a completion definition of the type.
3162 /// Provided for consistency.
3163 bool isThisDeclarationADefinition() const {
3164 return isCompleteDefinition();
3167 /// Return true if this decl has its body fully specified.
3168 bool isCompleteDefinition() const {
3169 return IsCompleteDefinition;
3172 /// Return true if this complete decl is
3173 /// required to be complete for some existing use.
3174 bool isCompleteDefinitionRequired() const {
3175 return IsCompleteDefinitionRequired;
3178 /// Return true if this decl is currently being defined.
3179 bool isBeingDefined() const {
3180 return IsBeingDefined;
3183 bool isEmbeddedInDeclarator() const {
3184 return IsEmbeddedInDeclarator;
3186 void setEmbeddedInDeclarator(bool isInDeclarator) {
3187 IsEmbeddedInDeclarator = isInDeclarator;
3190 bool isFreeStanding() const { return IsFreeStanding; }
3191 void setFreeStanding(bool isFreeStanding = true) {
3192 IsFreeStanding = isFreeStanding;
3195 /// Whether this declaration declares a type that is
3196 /// dependent, i.e., a type that somehow depends on template
3198 bool isDependentType() const { return isDependentContext(); }
3200 /// Starts the definition of this tag declaration.
3202 /// This method should be invoked at the beginning of the definition
3203 /// of this tag declaration. It will set the tag type into a state
3204 /// where it is in the process of being defined.
3205 void startDefinition();
3207 /// Returns the TagDecl that actually defines this
3208 /// struct/union/class/enum. When determining whether or not a
3209 /// struct/union/class/enum has a definition, one should use this
3210 /// method as opposed to 'isDefinition'. 'isDefinition' indicates
3211 /// whether or not a specific TagDecl is defining declaration, not
3212 /// whether or not the struct/union/class/enum type is defined.
3213 /// This method returns NULL if there is no TagDecl that defines
3214 /// the struct/union/class/enum.
3215 TagDecl *getDefinition() const;
3217 void setCompleteDefinition(bool V) { IsCompleteDefinition = V; }
3219 void setCompleteDefinitionRequired(bool V = true) {
3220 IsCompleteDefinitionRequired = V;
3223 StringRef getKindName() const {
3224 return TypeWithKeyword::getTagTypeKindName(getTagKind());
3227 TagKind getTagKind() const {
3228 return TagKind(TagDeclKind);
3231 void setTagKind(TagKind TK) { TagDeclKind = TK; }
3233 bool isStruct() const { return getTagKind() == TTK_Struct; }
3234 bool isInterface() const { return getTagKind() == TTK_Interface; }
3235 bool isClass() const { return getTagKind() == TTK_Class; }
3236 bool isUnion() const { return getTagKind() == TTK_Union; }
3237 bool isEnum() const { return getTagKind() == TTK_Enum; }
3239 /// Is this tag type named, either directly or via being defined in
3240 /// a typedef of this type?
3242 /// C++11 [basic.link]p8:
3243 /// A type is said to have linkage if and only if:
3244 /// - it is a class or enumeration type that is named (or has a
3245 /// name for linkage purposes) and the name has linkage; ...
3246 /// C++11 [dcl.typedef]p9:
3247 /// If the typedef declaration defines an unnamed class (or enum),
3248 /// the first typedef-name declared by the declaration to be that
3249 /// class type (or enum type) is used to denote the class type (or
3250 /// enum type) for linkage purposes only.
3252 /// C does not have an analogous rule, but the same concept is
3253 /// nonetheless useful in some places.
3254 bool hasNameForLinkage() const {
3255 return (getDeclName() || getTypedefNameForAnonDecl());
3258 TypedefNameDecl *getTypedefNameForAnonDecl() const {
3259 return hasExtInfo() ? nullptr
3260 : TypedefNameDeclOrQualifier.get<TypedefNameDecl *>();
3263 void setTypedefNameForAnonDecl(TypedefNameDecl *TDD);
3265 /// Retrieve the nested-name-specifier that qualifies the name of this
3266 /// declaration, if it was present in the source.
3267 NestedNameSpecifier *getQualifier() const {
3268 return hasExtInfo() ? getExtInfo()->QualifierLoc.getNestedNameSpecifier()
3272 /// Retrieve the nested-name-specifier (with source-location
3273 /// information) that qualifies the name of this declaration, if it was
3274 /// present in the source.
3275 NestedNameSpecifierLoc getQualifierLoc() const {
3276 return hasExtInfo() ? getExtInfo()->QualifierLoc
3277 : NestedNameSpecifierLoc();
3280 void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc);
3282 unsigned getNumTemplateParameterLists() const {
3283 return hasExtInfo() ? getExtInfo()->NumTemplParamLists : 0;
3286 TemplateParameterList *getTemplateParameterList(unsigned i) const {
3287 assert(i < getNumTemplateParameterLists());
3288 return getExtInfo()->TemplParamLists[i];
3291 void setTemplateParameterListsInfo(ASTContext &Context,
3292 ArrayRef<TemplateParameterList *> TPLists);
3294 // Implement isa/cast/dyncast/etc.
3295 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3296 static bool classofKind(Kind K) { return K >= firstTag && K <= lastTag; }
3298 static DeclContext *castToDeclContext(const TagDecl *D) {
3299 return static_cast<DeclContext *>(const_cast<TagDecl*>(D));
3302 static TagDecl *castFromDeclContext(const DeclContext *DC) {
3303 return static_cast<TagDecl *>(const_cast<DeclContext*>(DC));
3307 /// Represents an enum. In C++11, enums can be forward-declared
3308 /// with a fixed underlying type, and in C we allow them to be forward-declared
3309 /// with no underlying type as an extension.
3310 class EnumDecl : public TagDecl {
3311 /// This represent the integer type that the enum corresponds
3312 /// to for code generation purposes. Note that the enumerator constants may
3313 /// have a different type than this does.
3315 /// If the underlying integer type was explicitly stated in the source
3316 /// code, this is a TypeSourceInfo* for that type. Otherwise this type
3317 /// was automatically deduced somehow, and this is a Type*.
3319 /// Normally if IsFixed(), this would contain a TypeSourceInfo*, but in
3320 /// some cases it won't.
3322 /// The underlying type of an enumeration never has any qualifiers, so
3323 /// we can get away with just storing a raw Type*, and thus save an
3324 /// extra pointer when TypeSourceInfo is needed.
3325 llvm::PointerUnion<const Type *, TypeSourceInfo *> IntegerType;
3327 /// The integer type that values of this type should
3328 /// promote to. In C, enumerators are generally of an integer type
3329 /// directly, but gcc-style large enumerators (and all enumerators
3330 /// in C++) are of the enum type instead.
3331 QualType PromotionType;
3333 /// If this enumeration is an instantiation of a member enumeration
3334 /// of a class template specialization, this is the member specialization
3336 MemberSpecializationInfo *SpecializationInfo = nullptr;
3338 /// Store the ODRHash after first calculation.
3339 unsigned HasODRHash : 1;
3342 EnumDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
3343 SourceLocation IdLoc, IdentifierInfo *Id, EnumDecl *PrevDecl,
3344 bool Scoped, bool ScopedUsingClassTag, bool Fixed)
3345 : TagDecl(Enum, TTK_Enum, C, DC, IdLoc, Id, PrevDecl, StartLoc) {
3346 assert(Scoped || !ScopedUsingClassTag);
3347 IntegerType = (const Type *)nullptr;
3348 NumNegativeBits = 0;
3349 NumPositiveBits = 0;
3351 IsScopedUsingClassTag = ScopedUsingClassTag;
3357 void anchor() override;
3359 void setInstantiationOfMemberEnum(ASTContext &C, EnumDecl *ED,
3360 TemplateSpecializationKind TSK);
3362 friend class ASTDeclReader;
3364 EnumDecl *getCanonicalDecl() override {
3365 return cast<EnumDecl>(TagDecl::getCanonicalDecl());
3367 const EnumDecl *getCanonicalDecl() const {
3368 return const_cast<EnumDecl*>(this)->getCanonicalDecl();
3371 EnumDecl *getPreviousDecl() {
3372 return cast_or_null<EnumDecl>(
3373 static_cast<TagDecl *>(this)->getPreviousDecl());
3375 const EnumDecl *getPreviousDecl() const {
3376 return const_cast<EnumDecl*>(this)->getPreviousDecl();
3379 EnumDecl *getMostRecentDecl() {
3380 return cast<EnumDecl>(static_cast<TagDecl *>(this)->getMostRecentDecl());
3382 const EnumDecl *getMostRecentDecl() const {
3383 return const_cast<EnumDecl*>(this)->getMostRecentDecl();
3386 EnumDecl *getDefinition() const {
3387 return cast_or_null<EnumDecl>(TagDecl::getDefinition());
3390 static EnumDecl *Create(ASTContext &C, DeclContext *DC,
3391 SourceLocation StartLoc, SourceLocation IdLoc,
3392 IdentifierInfo *Id, EnumDecl *PrevDecl,
3393 bool IsScoped, bool IsScopedUsingClassTag,
3395 static EnumDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3397 /// When created, the EnumDecl corresponds to a
3398 /// forward-declared enum. This method is used to mark the
3399 /// declaration as being defined; its enumerators have already been
3400 /// added (via DeclContext::addDecl). NewType is the new underlying
3401 /// type of the enumeration type.
3402 void completeDefinition(QualType NewType,
3403 QualType PromotionType,
3404 unsigned NumPositiveBits,
3405 unsigned NumNegativeBits);
3407 // Iterates through the enumerators of this enumeration.
3408 using enumerator_iterator = specific_decl_iterator<EnumConstantDecl>;
3409 using enumerator_range =
3410 llvm::iterator_range<specific_decl_iterator<EnumConstantDecl>>;
3412 enumerator_range enumerators() const {
3413 return enumerator_range(enumerator_begin(), enumerator_end());
3416 enumerator_iterator enumerator_begin() const {
3417 const EnumDecl *E = getDefinition();
3420 return enumerator_iterator(E->decls_begin());
3423 enumerator_iterator enumerator_end() const {
3424 const EnumDecl *E = getDefinition();
3427 return enumerator_iterator(E->decls_end());
3430 /// Return the integer type that enumerators should promote to.
3431 QualType getPromotionType() const { return PromotionType; }
3433 /// Set the promotion type.
3434 void setPromotionType(QualType T) { PromotionType = T; }
3436 /// Return the integer type this enum decl corresponds to.
3437 /// This returns a null QualType for an enum forward definition with no fixed
3438 /// underlying type.
3439 QualType getIntegerType() const {
3442 if (const Type *T = IntegerType.dyn_cast<const Type*>())
3443 return QualType(T, 0);
3444 return IntegerType.get<TypeSourceInfo*>()->getType().getUnqualifiedType();
3447 /// Set the underlying integer type.
3448 void setIntegerType(QualType T) { IntegerType = T.getTypePtrOrNull(); }
3450 /// Set the underlying integer type source info.
3451 void setIntegerTypeSourceInfo(TypeSourceInfo *TInfo) { IntegerType = TInfo; }
3453 /// Return the type source info for the underlying integer type,
3454 /// if no type source info exists, return 0.
3455 TypeSourceInfo *getIntegerTypeSourceInfo() const {
3456 return IntegerType.dyn_cast<TypeSourceInfo*>();
3459 /// Retrieve the source range that covers the underlying type if
3461 SourceRange getIntegerTypeRange() const LLVM_READONLY;
3463 /// Returns the width in bits required to store all the
3464 /// non-negative enumerators of this enum.
3465 unsigned getNumPositiveBits() const {
3466 return NumPositiveBits;
3468 void setNumPositiveBits(unsigned Num) {
3469 NumPositiveBits = Num;
3470 assert(NumPositiveBits == Num && "can't store this bitcount");
3473 /// Returns the width in bits required to store all the
3474 /// negative enumerators of this enum. These widths include
3475 /// the rightmost leading 1; that is:
3477 /// MOST NEGATIVE ENUMERATOR PATTERN NUM NEGATIVE BITS
3478 /// ------------------------ ------- -----------------
3482 unsigned getNumNegativeBits() const {
3483 return NumNegativeBits;
3485 void setNumNegativeBits(unsigned Num) {
3486 NumNegativeBits = Num;
3489 /// Returns true if this is a C++11 scoped enumeration.
3490 bool isScoped() const {
3494 /// Returns true if this is a C++11 scoped enumeration.
3495 bool isScopedUsingClassTag() const {
3496 return IsScopedUsingClassTag;
3499 /// Returns true if this is an Objective-C, C++11, or
3500 /// Microsoft-style enumeration with a fixed underlying type.
3501 bool isFixed() const {
3505 unsigned getODRHash();
3507 /// Returns true if this can be considered a complete type.
3508 bool isComplete() const {
3509 // IntegerType is set for fixed type enums and non-fixed but implicitly
3510 // int-sized Microsoft enums.
3511 return isCompleteDefinition() || IntegerType;
3514 /// Returns true if this enum is either annotated with
3515 /// enum_extensibility(closed) or isn't annotated with enum_extensibility.
3516 bool isClosed() const;
3518 /// Returns true if this enum is annotated with flag_enum and isn't annotated
3519 /// with enum_extensibility(open).
3520 bool isClosedFlag() const;
3522 /// Returns true if this enum is annotated with neither flag_enum nor
3523 /// enum_extensibility(open).
3524 bool isClosedNonFlag() const;
3526 /// Retrieve the enum definition from which this enumeration could
3527 /// be instantiated, if it is an instantiation (rather than a non-template).
3528 EnumDecl *getTemplateInstantiationPattern() const;
3530 /// Returns the enumeration (declared within the template)
3531 /// from which this enumeration type was instantiated, or NULL if
3532 /// this enumeration was not instantiated from any template.
3533 EnumDecl *getInstantiatedFromMemberEnum() const;
3535 /// If this enumeration is a member of a specialization of a
3536 /// templated class, determine what kind of template specialization
3537 /// or instantiation this is.
3538 TemplateSpecializationKind getTemplateSpecializationKind() const;
3540 /// For an enumeration member that was instantiated from a member
3541 /// enumeration of a templated class, set the template specialiation kind.
3542 void setTemplateSpecializationKind(TemplateSpecializationKind TSK,
3543 SourceLocation PointOfInstantiation = SourceLocation());
3545 /// If this enumeration is an instantiation of a member enumeration of
3546 /// a class template specialization, retrieves the member specialization
3548 MemberSpecializationInfo *getMemberSpecializationInfo() const {
3549 return SpecializationInfo;
3552 /// Specify that this enumeration is an instantiation of the
3553 /// member enumeration ED.
3554 void setInstantiationOfMemberEnum(EnumDecl *ED,
3555 TemplateSpecializationKind TSK) {
3556 setInstantiationOfMemberEnum(getASTContext(), ED, TSK);
3559 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3560 static bool classofKind(Kind K) { return K == Enum; }
3563 /// Represents a struct/union/class. For example:
3564 /// struct X; // Forward declaration, no "body".
3565 /// union Y { int A, B; }; // Has body with members A and B (FieldDecls).
3566 /// This decl will be marked invalid if *any* members are invalid.
3567 class RecordDecl : public TagDecl {
3569 /// Enum that represents the different ways arguments are passed to and
3570 /// returned from function calls. This takes into account the target-specific
3571 /// and version-specific rules along with the rules determined by the
3573 enum ArgPassingKind : unsigned {
3574 /// The argument of this type can be passed directly in registers.
3577 /// The argument of this type cannot be passed directly in registers.
3578 /// Records containing this type as a subobject are not forced to be passed
3579 /// indirectly. This value is used only in C++. This value is required by
3580 /// C++ because, in uncommon situations, it is possible for a class to have
3581 /// only trivial copy/move constructors even when one of its subobjects has
3582 /// a non-trivial copy/move constructor (if e.g. the corresponding copy/move
3583 /// constructor in the derived class is deleted).
3584 APK_CannotPassInRegs,
3586 /// The argument of this type cannot be passed directly in registers.
3587 /// Records containing this type as a subobject are forced to be passed
3589 APK_CanNeverPassInRegs
3593 friend class DeclContext;
3595 // FIXME: This can be packed into the bitfields in Decl.
3596 /// This is true if this struct ends with a flexible
3597 /// array member (e.g. int X[]) or if this union contains a struct that does.
3598 /// If so, this cannot be contained in arrays or other structs as a member.
3599 unsigned HasFlexibleArrayMember : 1;
3601 /// Whether this is the type of an anonymous struct or union.
3602 unsigned AnonymousStructOrUnion : 1;
3604 /// This is true if this struct has at least one member
3605 /// containing an Objective-C object pointer type.
3606 unsigned HasObjectMember : 1;
3608 /// This is true if struct has at least one member of
3609 /// 'volatile' type.
3610 unsigned HasVolatileMember : 1;
3612 /// Whether the field declarations of this record have been loaded
3613 /// from external storage. To avoid unnecessary deserialization of
3614 /// methods/nested types we allow deserialization of just the fields
3616 mutable unsigned LoadedFieldsFromExternalStorage : 1;
3618 /// Basic properties of non-trivial C structs.
3619 unsigned NonTrivialToPrimitiveDefaultInitialize : 1;
3620 unsigned NonTrivialToPrimitiveCopy : 1;
3621 unsigned NonTrivialToPrimitiveDestroy : 1;
3623 /// Indicates whether this struct is destroyed in the callee.
3625 /// Please note that MSVC won't merge adjacent bitfields if they don't have
3627 unsigned ParamDestroyedInCallee : 1;
3629 /// Represents the way this type is passed to a function.
3630 unsigned ArgPassingRestrictions : 2;
3633 RecordDecl(Kind DK, TagKind TK, const ASTContext &C, DeclContext *DC,
3634 SourceLocation StartLoc, SourceLocation IdLoc,
3635 IdentifierInfo *Id, RecordDecl *PrevDecl);
3638 static RecordDecl *Create(const ASTContext &C, TagKind TK, DeclContext *DC,
3639 SourceLocation StartLoc, SourceLocation IdLoc,
3640 IdentifierInfo *Id, RecordDecl* PrevDecl = nullptr);
3641 static RecordDecl *CreateDeserialized(const ASTContext &C, unsigned ID);
3643 RecordDecl *getPreviousDecl() {
3644 return cast_or_null<RecordDecl>(
3645 static_cast<TagDecl *>(this)->getPreviousDecl());
3647 const RecordDecl *getPreviousDecl() const {
3648 return const_cast<RecordDecl*>(this)->getPreviousDecl();
3651 RecordDecl *getMostRecentDecl() {
3652 return cast<RecordDecl>(static_cast<TagDecl *>(this)->getMostRecentDecl());
3654 const RecordDecl *getMostRecentDecl() const {
3655 return const_cast<RecordDecl*>(this)->getMostRecentDecl();
3658 bool hasFlexibleArrayMember() const { return HasFlexibleArrayMember; }
3659 void setHasFlexibleArrayMember(bool V) { HasFlexibleArrayMember = V; }
3661 /// Whether this is an anonymous struct or union. To be an anonymous
3662 /// struct or union, it must have been declared without a name and
3663 /// there must be no objects of this type declared, e.g.,
3665 /// union { int i; float f; };
3667 /// is an anonymous union but neither of the following are:
3669 /// union X { int i; float f; };
3670 /// union { int i; float f; } obj;
3672 bool isAnonymousStructOrUnion() const { return AnonymousStructOrUnion; }
3673 void setAnonymousStructOrUnion(bool Anon) {
3674 AnonymousStructOrUnion = Anon;
3677 bool hasObjectMember() const { return HasObjectMember; }
3678 void setHasObjectMember (bool val) { HasObjectMember = val; }
3680 bool hasVolatileMember() const { return HasVolatileMember; }
3681 void setHasVolatileMember (bool val) { HasVolatileMember = val; }
3683 bool hasLoadedFieldsFromExternalStorage() const {
3684 return LoadedFieldsFromExternalStorage;
3686 void setHasLoadedFieldsFromExternalStorage(bool val) {
3687 LoadedFieldsFromExternalStorage = val;
3690 /// Functions to query basic properties of non-trivial C structs.
3691 bool isNonTrivialToPrimitiveDefaultInitialize() const {
3692 return NonTrivialToPrimitiveDefaultInitialize;
3695 void setNonTrivialToPrimitiveDefaultInitialize(bool V) {
3696 NonTrivialToPrimitiveDefaultInitialize = V;
3699 bool isNonTrivialToPrimitiveCopy() const {
3700 return NonTrivialToPrimitiveCopy;
3703 void setNonTrivialToPrimitiveCopy(bool V) {
3704 NonTrivialToPrimitiveCopy = V;
3707 bool isNonTrivialToPrimitiveDestroy() const {
3708 return NonTrivialToPrimitiveDestroy;
3711 void setNonTrivialToPrimitiveDestroy(bool V) {
3712 NonTrivialToPrimitiveDestroy = V;
3715 /// Determine whether this class can be passed in registers. In C++ mode,
3716 /// it must have at least one trivial, non-deleted copy or move constructor.
3717 /// FIXME: This should be set as part of completeDefinition.
3718 bool canPassInRegisters() const {
3719 return getArgPassingRestrictions() == APK_CanPassInRegs;
3722 ArgPassingKind getArgPassingRestrictions() const {
3723 return static_cast<ArgPassingKind>(ArgPassingRestrictions);
3726 void setArgPassingRestrictions(ArgPassingKind Kind) {
3727 ArgPassingRestrictions = static_cast<uint8_t>(Kind);
3730 bool isParamDestroyedInCallee() const {
3731 return ParamDestroyedInCallee;
3734 void setParamDestroyedInCallee(bool V) {
3735 ParamDestroyedInCallee = V;
3738 /// Determines whether this declaration represents the
3739 /// injected class name.
3741 /// The injected class name in C++ is the name of the class that
3742 /// appears inside the class itself. For example:
3746 /// // C is implicitly declared here as a synonym for the class name.
3749 /// C::C c; // same as "C c;"
3751 bool isInjectedClassName() const;
3753 /// Determine whether this record is a class describing a lambda
3754 /// function object.
3755 bool isLambda() const;
3757 /// Determine whether this record is a record for captured variables in
3758 /// CapturedStmt construct.
3759 bool isCapturedRecord() const;
3761 /// Mark the record as a record for captured variables in CapturedStmt
3763 void setCapturedRecord();
3765 /// Returns the RecordDecl that actually defines
3766 /// this struct/union/class. When determining whether or not a
3767 /// struct/union/class is completely defined, one should use this
3768 /// method as opposed to 'isCompleteDefinition'.
3769 /// 'isCompleteDefinition' indicates whether or not a specific
3770 /// RecordDecl is a completed definition, not whether or not the
3771 /// record type is defined. This method returns NULL if there is
3772 /// no RecordDecl that defines the struct/union/tag.
3773 RecordDecl *getDefinition() const {
3774 return cast_or_null<RecordDecl>(TagDecl::getDefinition());
3777 // Iterator access to field members. The field iterator only visits
3778 // the non-static data members of this class, ignoring any static
3779 // data members, functions, constructors, destructors, etc.
3780 using field_iterator = specific_decl_iterator<FieldDecl>;
3781 using field_range = llvm::iterator_range<specific_decl_iterator<FieldDecl>>;
3783 field_range fields() const { return field_range(field_begin(), field_end()); }
3784 field_iterator field_begin() const;
3786 field_iterator field_end() const {
3787 return field_iterator(decl_iterator());
3790 // Whether there are any fields (non-static data members) in this record.
3791 bool field_empty() const {
3792 return field_begin() == field_end();
3795 /// Note that the definition of this type is now complete.
3796 virtual void completeDefinition();
3798 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3799 static bool classofKind(Kind K) {
3800 return K >= firstRecord && K <= lastRecord;
3803 /// Get whether or not this is an ms_struct which can
3804 /// be turned on with an attribute, pragma, or -mms-bitfields
3805 /// commandline option.
3806 bool isMsStruct(const ASTContext &C) const;
3808 /// Whether we are allowed to insert extra padding between fields.
3809 /// These padding are added to help AddressSanitizer detect
3810 /// intra-object-overflow bugs.
3811 bool mayInsertExtraPadding(bool EmitRemark = false) const;
3813 /// Finds the first data member which has a name.
3814 /// nullptr is returned if no named data member exists.
3815 const FieldDecl *findFirstNamedDataMember() const;
3818 /// Deserialize just the fields.
3819 void LoadFieldsFromExternalStorage() const;
3822 class FileScopeAsmDecl : public Decl {
3823 StringLiteral *AsmString;
3824 SourceLocation RParenLoc;
3826 FileScopeAsmDecl(DeclContext *DC, StringLiteral *asmstring,
3827 SourceLocation StartL, SourceLocation EndL)
3828 : Decl(FileScopeAsm, DC, StartL), AsmString(asmstring), RParenLoc(EndL) {}
3830 virtual void anchor();
3833 static FileScopeAsmDecl *Create(ASTContext &C, DeclContext *DC,
3834 StringLiteral *Str, SourceLocation AsmLoc,
3835 SourceLocation RParenLoc);
3837 static FileScopeAsmDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3839 SourceLocation getAsmLoc() const { return getLocation(); }
3840 SourceLocation getRParenLoc() const { return RParenLoc; }
3841 void setRParenLoc(SourceLocation L) { RParenLoc = L; }
3842 SourceRange getSourceRange() const override LLVM_READONLY {
3843 return SourceRange(getAsmLoc(), getRParenLoc());
3846 const StringLiteral *getAsmString() const { return AsmString; }
3847 StringLiteral *getAsmString() { return AsmString; }
3848 void setAsmString(StringLiteral *Asm) { AsmString = Asm; }
3850 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3851 static bool classofKind(Kind K) { return K == FileScopeAsm; }
3854 /// Pepresents a block literal declaration, which is like an
3855 /// unnamed FunctionDecl. For example:
3856 /// ^{ statement-body } or ^(int arg1, float arg2){ statement-body }
3857 class BlockDecl : public Decl, public DeclContext {
3859 /// A class which contains all the information about a particular
3867 /// The variable being captured.
3868 llvm::PointerIntPair<VarDecl*, 2> VariableAndFlags;
3870 /// The copy expression, expressed in terms of a DeclRef (or
3871 /// BlockDeclRef) to the captured variable. Only required if the
3872 /// variable has a C++ class type.
3876 Capture(VarDecl *variable, bool byRef, bool nested, Expr *copy)
3877 : VariableAndFlags(variable,
3878 (byRef ? flag_isByRef : 0) | (nested ? flag_isNested : 0)),
3881 /// The variable being captured.
3882 VarDecl *getVariable() const { return VariableAndFlags.getPointer(); }
3884 /// Whether this is a "by ref" capture, i.e. a capture of a __block
3886 bool isByRef() const { return VariableAndFlags.getInt() & flag_isByRef; }
3888 /// Whether this is a nested capture, i.e. the variable captured
3889 /// is not from outside the immediately enclosing function/block.
3890 bool isNested() const { return VariableAndFlags.getInt() & flag_isNested; }
3892 bool hasCopyExpr() const { return CopyExpr != nullptr; }
3893 Expr *getCopyExpr() const { return CopyExpr; }
3894 void setCopyExpr(Expr *e) { CopyExpr = e; }
3898 // FIXME: This can be packed into the bitfields in Decl.
3899 bool IsVariadic : 1;
3900 bool CapturesCXXThis : 1;
3901 bool BlockMissingReturnType : 1;
3902 bool IsConversionFromLambda : 1;
3904 /// A bit that indicates this block is passed directly to a function as a
3905 /// non-escaping parameter.
3906 bool DoesNotEscape : 1;
3908 /// A new[]'d array of pointers to ParmVarDecls for the formal
3909 /// parameters of this function. This is null if a prototype or if there are
3911 ParmVarDecl **ParamInfo = nullptr;
3912 unsigned NumParams = 0;
3914 Stmt *Body = nullptr;
3915 TypeSourceInfo *SignatureAsWritten = nullptr;
3917 const Capture *Captures = nullptr;
3918 unsigned NumCaptures = 0;
3920 unsigned ManglingNumber = 0;
3921 Decl *ManglingContextDecl = nullptr;
3924 BlockDecl(DeclContext *DC, SourceLocation CaretLoc)
3925 : Decl(Block, DC, CaretLoc), DeclContext(Block), IsVariadic(false),
3926 CapturesCXXThis(false), BlockMissingReturnType(true),
3927 IsConversionFromLambda(false), DoesNotEscape(false) {}
3930 static BlockDecl *Create(ASTContext &C, DeclContext *DC, SourceLocation L);
3931 static BlockDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3933 SourceLocation getCaretLocation() const { return getLocation(); }
3935 bool isVariadic() const { return IsVariadic; }
3936 void setIsVariadic(bool value) { IsVariadic = value; }
3938 CompoundStmt *getCompoundBody() const { return (CompoundStmt*) Body; }
3939 Stmt *getBody() const override { return (Stmt*) Body; }
3940 void setBody(CompoundStmt *B) { Body = (Stmt*) B; }
3942 void setSignatureAsWritten(TypeSourceInfo *Sig) { SignatureAsWritten = Sig; }
3943 TypeSourceInfo *getSignatureAsWritten() const { return SignatureAsWritten; }
3945 // ArrayRef access to formal parameters.
3946 ArrayRef<ParmVarDecl *> parameters() const {
3947 return {ParamInfo, getNumParams()};
3949 MutableArrayRef<ParmVarDecl *> parameters() {
3950 return {ParamInfo, getNumParams()};
3953 // Iterator access to formal parameters.
3954 using param_iterator = MutableArrayRef<ParmVarDecl *>::iterator;
3955 using param_const_iterator = ArrayRef<ParmVarDecl *>::const_iterator;
3957 bool param_empty() const { return parameters().empty(); }
3958 param_iterator param_begin() { return parameters().begin(); }
3959 param_iterator param_end() { return parameters().end(); }
3960 param_const_iterator param_begin() const { return parameters().begin(); }
3961 param_const_iterator param_end() const { return parameters().end(); }
3962 size_t param_size() const { return parameters().size(); }
3964 unsigned getNumParams() const { return NumParams; }
3966 const ParmVarDecl *getParamDecl(unsigned i) const {
3967 assert(i < getNumParams() && "Illegal param #");
3968 return ParamInfo[i];
3970 ParmVarDecl *getParamDecl(unsigned i) {
3971 assert(i < getNumParams() && "Illegal param #");
3972 return ParamInfo[i];
3975 void setParams(ArrayRef<ParmVarDecl *> NewParamInfo);
3977 /// True if this block (or its nested blocks) captures
3978 /// anything of local storage from its enclosing scopes.
3979 bool hasCaptures() const { return NumCaptures != 0 || CapturesCXXThis; }
3981 /// Returns the number of captured variables.
3982 /// Does not include an entry for 'this'.
3983 unsigned getNumCaptures() const { return NumCaptures; }
3985 using capture_const_iterator = ArrayRef<Capture>::const_iterator;
3987 ArrayRef<Capture> captures() const { return {Captures, NumCaptures}; }
3989 capture_const_iterator capture_begin() const { return captures().begin(); }
3990 capture_const_iterator capture_end() const { return captures().end(); }
3992 bool capturesCXXThis() const { return CapturesCXXThis; }
3993 bool blockMissingReturnType() const { return BlockMissingReturnType; }
3994 void setBlockMissingReturnType(bool val) { BlockMissingReturnType = val; }
3996 bool isConversionFromLambda() const { return IsConversionFromLambda; }
3997 void setIsConversionFromLambda(bool val) { IsConversionFromLambda = val; }
3999 bool doesNotEscape() const { return DoesNotEscape; }
4000 void setDoesNotEscape() { DoesNotEscape = true; }
4002 bool capturesVariable(const VarDecl *var) const;
4004 void setCaptures(ASTContext &Context, ArrayRef<Capture> Captures,
4005 bool CapturesCXXThis);
4007 unsigned getBlockManglingNumber() const {
4008 return ManglingNumber;
4011 Decl *getBlockManglingContextDecl() const {
4012 return ManglingContextDecl;
4015 void setBlockMangling(unsigned Number, Decl *Ctx) {
4016 ManglingNumber = Number;
4017 ManglingContextDecl = Ctx;
4020 SourceRange getSourceRange() const override LLVM_READONLY;
4022 // Implement isa/cast/dyncast/etc.
4023 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
4024 static bool classofKind(Kind K) { return K == Block; }
4025 static DeclContext *castToDeclContext(const BlockDecl *D) {
4026 return static_cast<DeclContext *>(const_cast<BlockDecl*>(D));
4028 static BlockDecl *castFromDeclContext(const DeclContext *DC) {
4029 return static_cast<BlockDecl *>(const_cast<DeclContext*>(DC));
4033 /// Represents the body of a CapturedStmt, and serves as its DeclContext.
4034 class CapturedDecl final
4037 private llvm::TrailingObjects<CapturedDecl, ImplicitParamDecl *> {
4039 size_t numTrailingObjects(OverloadToken<ImplicitParamDecl>) {
4044 /// The number of parameters to the outlined function.
4047 /// The position of context parameter in list of parameters.
4048 unsigned ContextParam;
4050 /// The body of the outlined function.
4051 llvm::PointerIntPair<Stmt *, 1, bool> BodyAndNothrow;
4053 explicit CapturedDecl(DeclContext *DC, unsigned NumParams);
4055 ImplicitParamDecl *const *getParams() const {
4056 return getTrailingObjects<ImplicitParamDecl *>();
4059 ImplicitParamDecl **getParams() {
4060 return getTrailingObjects<ImplicitParamDecl *>();
4064 friend class ASTDeclReader;
4065 friend class ASTDeclWriter;
4066 friend TrailingObjects;
4068 static CapturedDecl *Create(ASTContext &C, DeclContext *DC,
4069 unsigned NumParams);
4070 static CapturedDecl *CreateDeserialized(ASTContext &C, unsigned ID,
4071 unsigned NumParams);
4073 Stmt *getBody() const override;
4074 void setBody(Stmt *B);
4076 bool isNothrow() const;
4077 void setNothrow(bool Nothrow = true);
4079 unsigned getNumParams() const { return NumParams; }
4081 ImplicitParamDecl *getParam(unsigned i) const {
4082 assert(i < NumParams);
4083 return getParams()[i];
4085 void setParam(unsigned i, ImplicitParamDecl *P) {
4086 assert(i < NumParams);
4090 // ArrayRef interface to parameters.
4091 ArrayRef<ImplicitParamDecl *> parameters() const {
4092 return {getParams(), getNumParams()};
4094 MutableArrayRef<ImplicitParamDecl *> parameters() {
4095 return {getParams(), getNumParams()};
4098 /// Retrieve the parameter containing captured variables.
4099 ImplicitParamDecl *getContextParam() const {
4100 assert(ContextParam < NumParams);
4101 return getParam(ContextParam);
4103 void setContextParam(unsigned i, ImplicitParamDecl *P) {
4104 assert(i < NumParams);
4108 unsigned getContextParamPosition() const { return ContextParam; }
4110 using param_iterator = ImplicitParamDecl *const *;
4111 using param_range = llvm::iterator_range<param_iterator>;
4113 /// Retrieve an iterator pointing to the first parameter decl.
4114 param_iterator param_begin() const { return getParams(); }
4115 /// Retrieve an iterator one past the last parameter decl.
4116 param_iterator param_end() const { return getParams() + NumParams; }
4118 // Implement isa/cast/dyncast/etc.
4119 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
4120 static bool classofKind(Kind K) { return K == Captured; }
4121 static DeclContext *castToDeclContext(const CapturedDecl *D) {
4122 return static_cast<DeclContext *>(const_cast<CapturedDecl *>(D));
4124 static CapturedDecl *castFromDeclContext(const DeclContext *DC) {
4125 return static_cast<CapturedDecl *>(const_cast<DeclContext *>(DC));
4129 /// Describes a module import declaration, which makes the contents
4130 /// of the named module visible in the current translation unit.
4132 /// An import declaration imports the named module (or submodule). For example:
4134 /// @import std.vector;
4137 /// Import declarations can also be implicitly generated from
4138 /// \#include/\#import directives.
4139 class ImportDecl final : public Decl,
4140 llvm::TrailingObjects<ImportDecl, SourceLocation> {
4141 friend class ASTContext;
4142 friend class ASTDeclReader;
4143 friend class ASTReader;
4144 friend TrailingObjects;
4146 /// The imported module, along with a bit that indicates whether
4147 /// we have source-location information for each identifier in the module
4150 /// When the bit is false, we only have a single source location for the
4151 /// end of the import declaration.
4152 llvm::PointerIntPair<Module *, 1, bool> ImportedAndComplete;
4154 /// The next import in the list of imports local to the translation
4155 /// unit being parsed (not loaded from an AST file).
4156 ImportDecl *NextLocalImport = nullptr;
4158 ImportDecl(DeclContext *DC, SourceLocation StartLoc, Module *Imported,
4159 ArrayRef<SourceLocation> IdentifierLocs);
4161 ImportDecl(DeclContext *DC, SourceLocation StartLoc, Module *Imported,
4162 SourceLocation EndLoc);
4164 ImportDecl(EmptyShell Empty) : Decl(Import, Empty) {}
4167 /// Create a new module import declaration.
4168 static ImportDecl *Create(ASTContext &C, DeclContext *DC,
4169 SourceLocation StartLoc, Module *Imported,
4170 ArrayRef<SourceLocation> IdentifierLocs);
4172 /// Create a new module import declaration for an implicitly-generated
4174 static ImportDecl *CreateImplicit(ASTContext &C, DeclContext *DC,
4175 SourceLocation StartLoc, Module *Imported,
4176 SourceLocation EndLoc);
4178 /// Create a new, deserialized module import declaration.
4179 static ImportDecl *CreateDeserialized(ASTContext &C, unsigned ID,
4180 unsigned NumLocations);
4182 /// Retrieve the module that was imported by the import declaration.
4183 Module *getImportedModule() const { return ImportedAndComplete.getPointer(); }
4185 /// Retrieves the locations of each of the identifiers that make up
4186 /// the complete module name in the import declaration.
4188 /// This will return an empty array if the locations of the individual
4189 /// identifiers aren't available.
4190 ArrayRef<SourceLocation> getIdentifierLocs() const;
4192 SourceRange getSourceRange() const override LLVM_READONLY;
4194 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
4195 static bool classofKind(Kind K) { return K == Import; }
4198 /// Represents a C++ Modules TS module export declaration.
4202 /// export void foo();
4204 class ExportDecl final : public Decl, public DeclContext {
4205 virtual void anchor();
4208 friend class ASTDeclReader;
4210 /// The source location for the right brace (if valid).
4211 SourceLocation RBraceLoc;
4213 ExportDecl(DeclContext *DC, SourceLocation ExportLoc)
4214 : Decl(Export, DC, ExportLoc), DeclContext(Export),
4215 RBraceLoc(SourceLocation()) {}
4218 static ExportDecl *Create(ASTContext &C, DeclContext *DC,
4219 SourceLocation ExportLoc);
4220 static ExportDecl *CreateDeserialized(ASTContext &C, unsigned ID);
4222 SourceLocation getExportLoc() const { return getLocation(); }
4223 SourceLocation getRBraceLoc() const { return RBraceLoc; }
4224 void setRBraceLoc(SourceLocation L) { RBraceLoc = L; }
4226 SourceLocation getLocEnd() const LLVM_READONLY {
4227 if (RBraceLoc.isValid())
4229 // No braces: get the end location of the (only) declaration in context
4231 return decls_empty() ? getLocation() : decls_begin()->getLocEnd();
4234 SourceRange getSourceRange() const override LLVM_READONLY {
4235 return SourceRange(getLocation(), getLocEnd());
4238 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
4239 static bool classofKind(Kind K) { return K == Export; }
4240 static DeclContext *castToDeclContext(const ExportDecl *D) {
4241 return static_cast<DeclContext *>(const_cast<ExportDecl*>(D));
4243 static ExportDecl *castFromDeclContext(const DeclContext *DC) {
4244 return static_cast<ExportDecl *>(const_cast<DeclContext*>(DC));
4248 /// Represents an empty-declaration.
4249 class EmptyDecl : public Decl {
4250 EmptyDecl(DeclContext *DC, SourceLocation L) : Decl(Empty, DC, L) {}
4252 virtual void anchor();
4255 static EmptyDecl *Create(ASTContext &C, DeclContext *DC,
4257 static EmptyDecl *CreateDeserialized(ASTContext &C, unsigned ID);
4259 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
4260 static bool classofKind(Kind K) { return K == Empty; }
4263 /// Insertion operator for diagnostics. This allows sending NamedDecl's
4264 /// into a diagnostic with <<.
4265 inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
4266 const NamedDecl* ND) {
4267 DB.AddTaggedVal(reinterpret_cast<intptr_t>(ND),
4268 DiagnosticsEngine::ak_nameddecl);
4271 inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
4272 const NamedDecl* ND) {
4273 PD.AddTaggedVal(reinterpret_cast<intptr_t>(ND),
4274 DiagnosticsEngine::ak_nameddecl);
4278 template<typename decl_type>
4279 void Redeclarable<decl_type>::setPreviousDecl(decl_type *PrevDecl) {
4280 // Note: This routine is implemented here because we need both NamedDecl
4281 // and Redeclarable to be defined.
4282 assert(RedeclLink.isFirst() &&
4283 "setPreviousDecl on a decl already in a redeclaration chain");
4286 // Point to previous. Make sure that this is actually the most recent
4287 // redeclaration, or we can build invalid chains. If the most recent
4288 // redeclaration is invalid, it won't be PrevDecl, but we want it anyway.
4289 First = PrevDecl->getFirstDecl();
4290 assert(First->RedeclLink.isFirst() && "Expected first");
4291 decl_type *MostRecent = First->getNextRedeclaration();
4292 RedeclLink = PreviousDeclLink(cast<decl_type>(MostRecent));
4294 // If the declaration was previously visible, a redeclaration of it remains
4295 // visible even if it wouldn't be visible by itself.
4296 static_cast<decl_type*>(this)->IdentifierNamespace |=
4297 MostRecent->getIdentifierNamespace() &
4298 (Decl::IDNS_Ordinary | Decl::IDNS_Tag | Decl::IDNS_Type);
4301 First = static_cast<decl_type*>(this);
4304 // First one will point to this one as latest.
4305 First->RedeclLink.setLatest(static_cast<decl_type*>(this));
4307 assert(!isa<NamedDecl>(static_cast<decl_type*>(this)) ||
4308 cast<NamedDecl>(static_cast<decl_type*>(this))->isLinkageValid());
4311 // Inline function definitions.
4313 /// Check if the given decl is complete.
4315 /// We use this function to break a cycle between the inline definitions in
4316 /// Type.h and Decl.h.
4317 inline bool IsEnumDeclComplete(EnumDecl *ED) {
4318 return ED->isComplete();
4321 /// Check if the given decl is scoped.
4323 /// We use this function to break a cycle between the inline definitions in
4324 /// Type.h and Decl.h.
4325 inline bool IsEnumDeclScoped(EnumDecl *ED) {
4326 return ED->isScoped();
4329 } // namespace clang
4331 #endif // LLVM_CLANG_AST_DECL_H