1 //===--- Decl.h - Classes for representing declarations ---------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the Decl subclasses.
12 //===----------------------------------------------------------------------===//
14 #ifndef LLVM_CLANG_AST_DECL_H
15 #define LLVM_CLANG_AST_DECL_H
17 #include "clang/AST/APValue.h"
18 #include "clang/AST/DeclBase.h"
19 #include "clang/AST/DeclarationName.h"
20 #include "clang/AST/ExternalASTSource.h"
21 #include "clang/AST/Redeclarable.h"
22 #include "clang/AST/Type.h"
23 #include "clang/Basic/Linkage.h"
24 #include "clang/Basic/Module.h"
25 #include "clang/Basic/OperatorKinds.h"
26 #include "clang/Basic/PragmaKinds.h"
27 #include "llvm/ADT/ArrayRef.h"
28 #include "llvm/ADT/Optional.h"
29 #include "llvm/Support/Compiler.h"
30 #include "llvm/Support/raw_ostream.h"
31 #include "llvm/Support/TrailingObjects.h"
34 struct ASTTemplateArgumentListInfo;
37 class DependentFunctionTemplateSpecializationInfo;
39 class FunctionTemplateDecl;
40 class FunctionTemplateSpecializationInfo;
42 class MemberSpecializationInfo;
43 class NestedNameSpecifier;
47 class TemplateArgumentList;
48 class TemplateParameterList;
49 class TypeAliasTemplateDecl;
51 class UnresolvedSetImpl;
52 class VarTemplateDecl;
54 /// \brief A container of type source information.
56 /// A client can read the relevant info using TypeLoc wrappers, e.g:
58 /// TypeLoc TL = TypeSourceInfo->getTypeLoc();
59 /// TL.getStartLoc().print(OS, SrcMgr);
62 class TypeSourceInfo {
64 // Contains a memory block after the class, used for type source information,
65 // allocated by ASTContext.
66 friend class ASTContext;
67 TypeSourceInfo(QualType ty) : Ty(ty) { }
69 /// \brief Return the type wrapped by this type source info.
70 QualType getType() const { return Ty; }
72 /// \brief Return the TypeLoc wrapper for the type source info.
73 TypeLoc getTypeLoc() const; // implemented in TypeLoc.h
75 /// \brief Override the type stored in this TypeSourceInfo. Use with caution!
76 void overrideType(QualType T) { Ty = T; }
79 /// TranslationUnitDecl - The top declaration context.
80 class TranslationUnitDecl : public Decl, public DeclContext {
81 virtual void anchor();
84 /// The (most recently entered) anonymous namespace for this
85 /// translation unit, if one has been created.
86 NamespaceDecl *AnonymousNamespace;
88 explicit TranslationUnitDecl(ASTContext &ctx);
90 ASTContext &getASTContext() const { return Ctx; }
92 NamespaceDecl *getAnonymousNamespace() const { return AnonymousNamespace; }
93 void setAnonymousNamespace(NamespaceDecl *D) { AnonymousNamespace = D; }
95 static TranslationUnitDecl *Create(ASTContext &C);
96 // Implement isa/cast/dyncast/etc.
97 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
98 static bool classofKind(Kind K) { return K == TranslationUnit; }
99 static DeclContext *castToDeclContext(const TranslationUnitDecl *D) {
100 return static_cast<DeclContext *>(const_cast<TranslationUnitDecl*>(D));
102 static TranslationUnitDecl *castFromDeclContext(const DeclContext *DC) {
103 return static_cast<TranslationUnitDecl *>(const_cast<DeclContext*>(DC));
107 /// \brief Represents a `#pragma comment` line. Always a child of
108 /// TranslationUnitDecl.
109 class PragmaCommentDecl final
111 private llvm::TrailingObjects<PragmaCommentDecl, char> {
112 virtual void anchor();
114 PragmaMSCommentKind CommentKind;
116 friend TrailingObjects;
117 friend class ASTDeclReader;
118 friend class ASTDeclWriter;
120 PragmaCommentDecl(TranslationUnitDecl *TU, SourceLocation CommentLoc,
121 PragmaMSCommentKind CommentKind)
122 : Decl(PragmaComment, TU, CommentLoc), CommentKind(CommentKind) {}
125 static PragmaCommentDecl *Create(const ASTContext &C, TranslationUnitDecl *DC,
126 SourceLocation CommentLoc,
127 PragmaMSCommentKind CommentKind,
129 static PragmaCommentDecl *CreateDeserialized(ASTContext &C, unsigned ID,
132 PragmaMSCommentKind getCommentKind() const { return CommentKind; }
134 StringRef getArg() const { return getTrailingObjects<char>(); }
136 // Implement isa/cast/dyncast/etc.
137 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
138 static bool classofKind(Kind K) { return K == PragmaComment; }
141 /// \brief Represents a `#pragma detect_mismatch` line. Always a child of
142 /// TranslationUnitDecl.
143 class PragmaDetectMismatchDecl final
145 private llvm::TrailingObjects<PragmaDetectMismatchDecl, char> {
146 virtual void anchor();
150 friend TrailingObjects;
151 friend class ASTDeclReader;
152 friend class ASTDeclWriter;
154 PragmaDetectMismatchDecl(TranslationUnitDecl *TU, SourceLocation Loc,
156 : Decl(PragmaDetectMismatch, TU, Loc), ValueStart(ValueStart) {}
159 static PragmaDetectMismatchDecl *Create(const ASTContext &C,
160 TranslationUnitDecl *DC,
161 SourceLocation Loc, StringRef Name,
163 static PragmaDetectMismatchDecl *
164 CreateDeserialized(ASTContext &C, unsigned ID, unsigned NameValueSize);
166 StringRef getName() const { return getTrailingObjects<char>(); }
167 StringRef getValue() const { return getTrailingObjects<char>() + ValueStart; }
169 // Implement isa/cast/dyncast/etc.
170 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
171 static bool classofKind(Kind K) { return K == PragmaDetectMismatch; }
174 /// \brief Declaration context for names declared as extern "C" in C++. This
175 /// is neither the semantic nor lexical context for such declarations, but is
176 /// used to check for conflicts with other extern "C" declarations. Example:
179 /// namespace N { extern "C" void f(); } // #1
180 /// void N::f() {} // #2
181 /// namespace M { extern "C" void f(); } // #3
184 /// The semantic context of #1 is namespace N and its lexical context is the
185 /// LinkageSpecDecl; the semantic context of #2 is namespace N and its lexical
186 /// context is the TU. However, both declarations are also visible in the
187 /// extern "C" context.
189 /// The declaration at #3 finds it is a redeclaration of \c N::f through
190 /// lookup in the extern "C" context.
191 class ExternCContextDecl : public Decl, public DeclContext {
192 virtual void anchor();
194 explicit ExternCContextDecl(TranslationUnitDecl *TU)
195 : Decl(ExternCContext, TU, SourceLocation()),
196 DeclContext(ExternCContext) {}
198 static ExternCContextDecl *Create(const ASTContext &C,
199 TranslationUnitDecl *TU);
200 // Implement isa/cast/dyncast/etc.
201 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
202 static bool classofKind(Kind K) { return K == ExternCContext; }
203 static DeclContext *castToDeclContext(const ExternCContextDecl *D) {
204 return static_cast<DeclContext *>(const_cast<ExternCContextDecl*>(D));
206 static ExternCContextDecl *castFromDeclContext(const DeclContext *DC) {
207 return static_cast<ExternCContextDecl *>(const_cast<DeclContext*>(DC));
211 /// NamedDecl - This represents a decl with a name. Many decls have names such
212 /// as ObjCMethodDecl, but not \@class, etc.
213 class NamedDecl : public Decl {
214 virtual void anchor();
215 /// Name - The name of this declaration, which is typically a normal
216 /// identifier but may also be a special kind of name (C++
217 /// constructor, Objective-C selector, etc.)
218 DeclarationName Name;
221 NamedDecl *getUnderlyingDeclImpl() LLVM_READONLY;
224 NamedDecl(Kind DK, DeclContext *DC, SourceLocation L, DeclarationName N)
225 : Decl(DK, DC, L), Name(N) { }
228 /// getIdentifier - Get the identifier that names this declaration,
229 /// if there is one. This will return NULL if this declaration has
230 /// no name (e.g., for an unnamed class) or if the name is a special
231 /// name (C++ constructor, Objective-C selector, etc.).
232 IdentifierInfo *getIdentifier() const { return Name.getAsIdentifierInfo(); }
234 /// getName - Get the name of identifier for this declaration as a StringRef.
235 /// This requires that the declaration have a name and that it be a simple
237 StringRef getName() const {
238 assert(Name.isIdentifier() && "Name is not a simple identifier");
239 return getIdentifier() ? getIdentifier()->getName() : "";
242 /// getNameAsString - Get a human-readable name for the declaration, even if
243 /// it is one of the special kinds of names (C++ constructor, Objective-C
244 /// selector, etc). Creating this name requires expensive string
245 /// manipulation, so it should be called only when performance doesn't matter.
246 /// For simple declarations, getNameAsCString() should suffice.
248 // FIXME: This function should be renamed to indicate that it is not just an
249 // alternate form of getName(), and clients should move as appropriate.
251 // FIXME: Deprecated, move clients to getName().
252 std::string getNameAsString() const { return Name.getAsString(); }
254 virtual void printName(raw_ostream &os) const;
256 /// getDeclName - Get the actual, stored name of the declaration,
257 /// which may be a special name.
258 DeclarationName getDeclName() const { return Name; }
260 /// \brief Set the name of this declaration.
261 void setDeclName(DeclarationName N) { Name = N; }
263 /// printQualifiedName - Returns human-readable qualified name for
264 /// declaration, like A::B::i, for i being member of namespace A::B.
265 /// If declaration is not member of context which can be named (record,
266 /// namespace), it will return same result as printName().
267 /// Creating this name is expensive, so it should be called only when
268 /// performance doesn't matter.
269 void printQualifiedName(raw_ostream &OS) const;
270 void printQualifiedName(raw_ostream &OS, const PrintingPolicy &Policy) const;
272 // FIXME: Remove string version.
273 std::string getQualifiedNameAsString() const;
275 /// getNameForDiagnostic - Appends a human-readable name for this
276 /// declaration into the given stream.
278 /// This is the method invoked by Sema when displaying a NamedDecl
279 /// in a diagnostic. It does not necessarily produce the same
280 /// result as printName(); for example, class template
281 /// specializations are printed with their template arguments.
282 virtual void getNameForDiagnostic(raw_ostream &OS,
283 const PrintingPolicy &Policy,
284 bool Qualified) const;
286 /// \brief Determine whether this declaration, if
287 /// known to be well-formed within its context, will replace the
288 /// declaration OldD if introduced into scope. A declaration will
289 /// replace another declaration if, for example, it is a
290 /// redeclaration of the same variable or function, but not if it is
291 /// a declaration of a different kind (function vs. class) or an
292 /// overloaded function.
294 /// \param IsKnownNewer \c true if this declaration is known to be newer
295 /// than \p OldD (for instance, if this declaration is newly-created).
296 bool declarationReplaces(NamedDecl *OldD, bool IsKnownNewer = true) const;
298 /// \brief Determine whether this declaration has linkage.
299 bool hasLinkage() const;
301 using Decl::isModulePrivate;
302 using Decl::setModulePrivate;
304 /// \brief Determine whether this declaration is a C++ class member.
305 bool isCXXClassMember() const {
306 const DeclContext *DC = getDeclContext();
308 // C++0x [class.mem]p1:
309 // The enumerators of an unscoped enumeration defined in
310 // the class are members of the class.
311 if (isa<EnumDecl>(DC))
312 DC = DC->getRedeclContext();
314 return DC->isRecord();
317 /// \brief Determine whether the given declaration is an instance member of
319 bool isCXXInstanceMember() const;
321 /// \brief Determine what kind of linkage this entity has.
322 /// This is not the linkage as defined by the standard or the codegen notion
323 /// of linkage. It is just an implementation detail that is used to compute
325 Linkage getLinkageInternal() const;
327 /// \brief Get the linkage from a semantic point of view. Entities in
328 /// anonymous namespaces are external (in c++98).
329 Linkage getFormalLinkage() const {
330 return clang::getFormalLinkage(getLinkageInternal());
333 /// \brief True if this decl has external linkage.
334 bool hasExternalFormalLinkage() const {
335 return isExternalFormalLinkage(getLinkageInternal());
338 bool isExternallyVisible() const {
339 return clang::isExternallyVisible(getLinkageInternal());
342 /// \brief Determines the visibility of this entity.
343 Visibility getVisibility() const {
344 return getLinkageAndVisibility().getVisibility();
347 /// \brief Determines the linkage and visibility of this entity.
348 LinkageInfo getLinkageAndVisibility() const;
350 /// Kinds of explicit visibility.
351 enum ExplicitVisibilityKind {
356 /// \brief If visibility was explicitly specified for this
357 /// declaration, return that visibility.
359 getExplicitVisibility(ExplicitVisibilityKind kind) const;
361 /// \brief True if the computed linkage is valid. Used for consistency
362 /// checking. Should always return true.
363 bool isLinkageValid() const;
365 /// \brief True if something has required us to compute the linkage
366 /// of this declaration.
368 /// Language features which can retroactively change linkage (like a
369 /// typedef name for linkage purposes) may need to consider this,
370 /// but hopefully only in transitory ways during parsing.
371 bool hasLinkageBeenComputed() const {
372 return hasCachedLinkage();
375 /// \brief Looks through UsingDecls and ObjCCompatibleAliasDecls for
376 /// the underlying named decl.
377 NamedDecl *getUnderlyingDecl() {
378 // Fast-path the common case.
379 if (this->getKind() != UsingShadow &&
380 this->getKind() != ConstructorUsingShadow &&
381 this->getKind() != ObjCCompatibleAlias &&
382 this->getKind() != NamespaceAlias)
385 return getUnderlyingDeclImpl();
387 const NamedDecl *getUnderlyingDecl() const {
388 return const_cast<NamedDecl*>(this)->getUnderlyingDecl();
391 NamedDecl *getMostRecentDecl() {
392 return cast<NamedDecl>(static_cast<Decl *>(this)->getMostRecentDecl());
394 const NamedDecl *getMostRecentDecl() const {
395 return const_cast<NamedDecl*>(this)->getMostRecentDecl();
398 ObjCStringFormatFamily getObjCFStringFormattingFamily() const;
400 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
401 static bool classofKind(Kind K) { return K >= firstNamed && K <= lastNamed; }
404 inline raw_ostream &operator<<(raw_ostream &OS, const NamedDecl &ND) {
409 /// LabelDecl - Represents the declaration of a label. Labels also have a
410 /// corresponding LabelStmt, which indicates the position that the label was
411 /// defined at. For normal labels, the location of the decl is the same as the
412 /// location of the statement. For GNU local labels (__label__), the decl
413 /// location is where the __label__ is.
414 class LabelDecl : public NamedDecl {
415 void anchor() override;
418 bool MSAsmNameResolved;
419 /// LocStart - For normal labels, this is the same as the main declaration
420 /// label, i.e., the location of the identifier; for GNU local labels,
421 /// this is the location of the __label__ keyword.
422 SourceLocation LocStart;
424 LabelDecl(DeclContext *DC, SourceLocation IdentL, IdentifierInfo *II,
425 LabelStmt *S, SourceLocation StartL)
426 : NamedDecl(Label, DC, IdentL, II),
428 MSAsmNameResolved(false),
432 static LabelDecl *Create(ASTContext &C, DeclContext *DC,
433 SourceLocation IdentL, IdentifierInfo *II);
434 static LabelDecl *Create(ASTContext &C, DeclContext *DC,
435 SourceLocation IdentL, IdentifierInfo *II,
436 SourceLocation GnuLabelL);
437 static LabelDecl *CreateDeserialized(ASTContext &C, unsigned ID);
439 LabelStmt *getStmt() const { return TheStmt; }
440 void setStmt(LabelStmt *T) { TheStmt = T; }
442 bool isGnuLocal() const { return LocStart != getLocation(); }
443 void setLocStart(SourceLocation L) { LocStart = L; }
445 SourceRange getSourceRange() const override LLVM_READONLY {
446 return SourceRange(LocStart, getLocation());
449 bool isMSAsmLabel() const { return MSAsmName.size() != 0; }
450 bool isResolvedMSAsmLabel() const { return isMSAsmLabel() && MSAsmNameResolved; }
451 void setMSAsmLabel(StringRef Name);
452 StringRef getMSAsmLabel() const { return MSAsmName; }
453 void setMSAsmLabelResolved() { MSAsmNameResolved = true; }
455 // Implement isa/cast/dyncast/etc.
456 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
457 static bool classofKind(Kind K) { return K == Label; }
460 /// NamespaceDecl - Represent a C++ namespace.
461 class NamespaceDecl : public NamedDecl, public DeclContext,
462 public Redeclarable<NamespaceDecl>
464 /// LocStart - The starting location of the source range, pointing
465 /// to either the namespace or the inline keyword.
466 SourceLocation LocStart;
467 /// RBraceLoc - The ending location of the source range.
468 SourceLocation RBraceLoc;
470 /// \brief A pointer to either the anonymous namespace that lives just inside
471 /// this namespace or to the first namespace in the chain (the latter case
472 /// only when this is not the first in the chain), along with a
473 /// boolean value indicating whether this is an inline namespace.
474 llvm::PointerIntPair<NamespaceDecl *, 1, bool> AnonOrFirstNamespaceAndInline;
476 NamespaceDecl(ASTContext &C, DeclContext *DC, bool Inline,
477 SourceLocation StartLoc, SourceLocation IdLoc,
478 IdentifierInfo *Id, NamespaceDecl *PrevDecl);
480 typedef Redeclarable<NamespaceDecl> redeclarable_base;
481 NamespaceDecl *getNextRedeclarationImpl() override;
482 NamespaceDecl *getPreviousDeclImpl() override;
483 NamespaceDecl *getMostRecentDeclImpl() override;
486 static NamespaceDecl *Create(ASTContext &C, DeclContext *DC,
487 bool Inline, SourceLocation StartLoc,
488 SourceLocation IdLoc, IdentifierInfo *Id,
489 NamespaceDecl *PrevDecl);
491 static NamespaceDecl *CreateDeserialized(ASTContext &C, unsigned ID);
493 typedef redeclarable_base::redecl_range redecl_range;
494 typedef redeclarable_base::redecl_iterator redecl_iterator;
495 using redeclarable_base::redecls_begin;
496 using redeclarable_base::redecls_end;
497 using redeclarable_base::redecls;
498 using redeclarable_base::getPreviousDecl;
499 using redeclarable_base::getMostRecentDecl;
500 using redeclarable_base::isFirstDecl;
502 /// \brief Returns true if this is an anonymous namespace declaration.
510 /// q.v. C++ [namespace.unnamed]
511 bool isAnonymousNamespace() const {
512 return !getIdentifier();
515 /// \brief Returns true if this is an inline namespace declaration.
516 bool isInline() const {
517 return AnonOrFirstNamespaceAndInline.getInt();
520 /// \brief Set whether this is an inline namespace declaration.
521 void setInline(bool Inline) {
522 AnonOrFirstNamespaceAndInline.setInt(Inline);
525 /// \brief Get the original (first) namespace declaration.
526 NamespaceDecl *getOriginalNamespace();
528 /// \brief Get the original (first) namespace declaration.
529 const NamespaceDecl *getOriginalNamespace() const;
531 /// \brief Return true if this declaration is an original (first) declaration
532 /// of the namespace. This is false for non-original (subsequent) namespace
533 /// declarations and anonymous namespaces.
534 bool isOriginalNamespace() const;
536 /// \brief Retrieve the anonymous namespace nested inside this namespace,
538 NamespaceDecl *getAnonymousNamespace() const {
539 return getOriginalNamespace()->AnonOrFirstNamespaceAndInline.getPointer();
542 void setAnonymousNamespace(NamespaceDecl *D) {
543 getOriginalNamespace()->AnonOrFirstNamespaceAndInline.setPointer(D);
546 /// Retrieves the canonical declaration of this namespace.
547 NamespaceDecl *getCanonicalDecl() override {
548 return getOriginalNamespace();
550 const NamespaceDecl *getCanonicalDecl() const {
551 return getOriginalNamespace();
554 SourceRange getSourceRange() const override LLVM_READONLY {
555 return SourceRange(LocStart, RBraceLoc);
558 SourceLocation getLocStart() const LLVM_READONLY { return LocStart; }
559 SourceLocation getRBraceLoc() const { return RBraceLoc; }
560 void setLocStart(SourceLocation L) { LocStart = L; }
561 void setRBraceLoc(SourceLocation L) { RBraceLoc = L; }
563 // Implement isa/cast/dyncast/etc.
564 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
565 static bool classofKind(Kind K) { return K == Namespace; }
566 static DeclContext *castToDeclContext(const NamespaceDecl *D) {
567 return static_cast<DeclContext *>(const_cast<NamespaceDecl*>(D));
569 static NamespaceDecl *castFromDeclContext(const DeclContext *DC) {
570 return static_cast<NamespaceDecl *>(const_cast<DeclContext*>(DC));
573 friend class ASTDeclReader;
574 friend class ASTDeclWriter;
577 /// ValueDecl - Represent the declaration of a variable (in which case it is
578 /// an lvalue) a function (in which case it is a function designator) or
579 /// an enum constant.
580 class ValueDecl : public NamedDecl {
581 void anchor() override;
585 ValueDecl(Kind DK, DeclContext *DC, SourceLocation L,
586 DeclarationName N, QualType T)
587 : NamedDecl(DK, DC, L, N), DeclType(T) {}
589 QualType getType() const { return DeclType; }
590 void setType(QualType newType) { DeclType = newType; }
592 /// \brief Determine whether this symbol is weakly-imported,
593 /// or declared with the weak or weak-ref attr.
596 // Implement isa/cast/dyncast/etc.
597 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
598 static bool classofKind(Kind K) { return K >= firstValue && K <= lastValue; }
601 /// QualifierInfo - A struct with extended info about a syntactic
602 /// name qualifier, to be used for the case of out-of-line declarations.
603 struct QualifierInfo {
604 NestedNameSpecifierLoc QualifierLoc;
606 /// NumTemplParamLists - The number of "outer" template parameter lists.
607 /// The count includes all of the template parameter lists that were matched
608 /// against the template-ids occurring into the NNS and possibly (in the
609 /// case of an explicit specialization) a final "template <>".
610 unsigned NumTemplParamLists;
612 /// TemplParamLists - A new-allocated array of size NumTemplParamLists,
613 /// containing pointers to the "outer" template parameter lists.
614 /// It includes all of the template parameter lists that were matched
615 /// against the template-ids occurring into the NNS and possibly (in the
616 /// case of an explicit specialization) a final "template <>".
617 TemplateParameterList** TemplParamLists;
619 /// Default constructor.
621 : QualifierLoc(), NumTemplParamLists(0), TemplParamLists(nullptr) {}
623 /// setTemplateParameterListsInfo - Sets info about "outer" template
625 void setTemplateParameterListsInfo(ASTContext &Context,
626 ArrayRef<TemplateParameterList *> TPLists);
629 // Copy constructor and copy assignment are disabled.
630 QualifierInfo(const QualifierInfo&) = delete;
631 QualifierInfo& operator=(const QualifierInfo&) = delete;
634 /// \brief Represents a ValueDecl that came out of a declarator.
635 /// Contains type source information through TypeSourceInfo.
636 class DeclaratorDecl : public ValueDecl {
637 // A struct representing both a TInfo and a syntactic qualifier,
638 // to be used for the (uncommon) case of out-of-line declarations.
639 struct ExtInfo : public QualifierInfo {
640 TypeSourceInfo *TInfo;
643 llvm::PointerUnion<TypeSourceInfo*, ExtInfo*> DeclInfo;
645 /// InnerLocStart - The start of the source range for this declaration,
646 /// ignoring outer template declarations.
647 SourceLocation InnerLocStart;
649 bool hasExtInfo() const { return DeclInfo.is<ExtInfo*>(); }
650 ExtInfo *getExtInfo() { return DeclInfo.get<ExtInfo*>(); }
651 const ExtInfo *getExtInfo() const { return DeclInfo.get<ExtInfo*>(); }
654 DeclaratorDecl(Kind DK, DeclContext *DC, SourceLocation L,
655 DeclarationName N, QualType T, TypeSourceInfo *TInfo,
656 SourceLocation StartL)
657 : ValueDecl(DK, DC, L, N, T), DeclInfo(TInfo), InnerLocStart(StartL) {
661 TypeSourceInfo *getTypeSourceInfo() const {
663 ? getExtInfo()->TInfo
664 : DeclInfo.get<TypeSourceInfo*>();
666 void setTypeSourceInfo(TypeSourceInfo *TI) {
668 getExtInfo()->TInfo = TI;
673 /// getInnerLocStart - Return SourceLocation representing start of source
674 /// range ignoring outer template declarations.
675 SourceLocation getInnerLocStart() const { return InnerLocStart; }
676 void setInnerLocStart(SourceLocation L) { InnerLocStart = L; }
678 /// getOuterLocStart - Return SourceLocation representing start of source
679 /// range taking into account any outer template declarations.
680 SourceLocation getOuterLocStart() const;
682 SourceRange getSourceRange() const override LLVM_READONLY;
683 SourceLocation getLocStart() const LLVM_READONLY {
684 return getOuterLocStart();
687 /// \brief Retrieve the nested-name-specifier that qualifies the name of this
688 /// declaration, if it was present in the source.
689 NestedNameSpecifier *getQualifier() const {
690 return hasExtInfo() ? getExtInfo()->QualifierLoc.getNestedNameSpecifier()
694 /// \brief Retrieve the nested-name-specifier (with source-location
695 /// information) that qualifies the name of this declaration, if it was
696 /// present in the source.
697 NestedNameSpecifierLoc getQualifierLoc() const {
698 return hasExtInfo() ? getExtInfo()->QualifierLoc
699 : NestedNameSpecifierLoc();
702 void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc);
704 unsigned getNumTemplateParameterLists() const {
705 return hasExtInfo() ? getExtInfo()->NumTemplParamLists : 0;
707 TemplateParameterList *getTemplateParameterList(unsigned index) const {
708 assert(index < getNumTemplateParameterLists());
709 return getExtInfo()->TemplParamLists[index];
711 void setTemplateParameterListsInfo(ASTContext &Context,
712 ArrayRef<TemplateParameterList *> TPLists);
714 SourceLocation getTypeSpecStartLoc() const;
716 // Implement isa/cast/dyncast/etc.
717 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
718 static bool classofKind(Kind K) {
719 return K >= firstDeclarator && K <= lastDeclarator;
722 friend class ASTDeclReader;
723 friend class ASTDeclWriter;
726 /// \brief Structure used to store a statement, the constant value to
727 /// which it was evaluated (if any), and whether or not the statement
728 /// is an integral constant expression (if known).
729 struct EvaluatedStmt {
730 EvaluatedStmt() : WasEvaluated(false), IsEvaluating(false), CheckedICE(false),
731 CheckingICE(false), IsICE(false) { }
733 /// \brief Whether this statement was already evaluated.
734 bool WasEvaluated : 1;
736 /// \brief Whether this statement is being evaluated.
737 bool IsEvaluating : 1;
739 /// \brief Whether we already checked whether this statement was an
740 /// integral constant expression.
743 /// \brief Whether we are checking whether this statement is an
744 /// integral constant expression.
745 bool CheckingICE : 1;
747 /// \brief Whether this statement is an integral constant expression,
748 /// or in C++11, whether the statement is a constant expression. Only
749 /// valid if CheckedICE is true.
756 /// VarDecl - An instance of this class is created to represent a variable
757 /// declaration or definition.
758 class VarDecl : public DeclaratorDecl, public Redeclarable<VarDecl> {
760 /// getStorageClassSpecifierString - Return the string used to
761 /// specify the storage class \p SC.
763 /// It is illegal to call this function with SC == None.
764 static const char *getStorageClassSpecifierString(StorageClass SC);
766 /// \brief Initialization styles.
767 enum InitializationStyle {
768 CInit, ///< C-style initialization with assignment
769 CallInit, ///< Call-style initialization (C++98)
770 ListInit ///< Direct list-initialization (C++11)
773 /// \brief Kinds of thread-local storage.
775 TLS_None, ///< Not a TLS variable.
776 TLS_Static, ///< TLS with a known-constant initializer.
777 TLS_Dynamic ///< TLS with a dynamic initializer.
781 // A pointer union of Stmt * and EvaluatedStmt *. When an EvaluatedStmt, we
782 // have allocated the auxiliary struct of information there.
784 // TODO: It is a bit unfortunate to use a PointerUnion inside the VarDecl for
785 // this as *many* VarDecls are ParmVarDecls that don't have default
786 // arguments. We could save some space by moving this pointer union to be
787 // allocated in trailing space when necessary.
788 typedef llvm::PointerUnion<Stmt *, EvaluatedStmt *> InitType;
790 /// \brief The initializer for this variable or, for a ParmVarDecl, the
791 /// C++ default argument.
792 mutable InitType Init;
795 class VarDeclBitfields {
796 friend class VarDecl;
797 friend class ASTDeclReader;
800 unsigned TSCSpec : 2;
801 unsigned InitStyle : 2;
803 enum { NumVarDeclBits = 7 };
805 friend class ASTDeclReader;
806 friend class StmtIteratorBase;
807 friend class ASTNodeImporter;
810 enum { NumParameterIndexBits = 8 };
812 enum DefaultArgKind {
819 class ParmVarDeclBitfields {
820 friend class ParmVarDecl;
821 friend class ASTDeclReader;
823 unsigned : NumVarDeclBits;
825 /// Whether this parameter inherits a default argument from a
826 /// prior declaration.
827 unsigned HasInheritedDefaultArg : 1;
829 /// Describes the kind of default argument for this parameter. By default
830 /// this is none. If this is normal, then the default argument is stored in
831 /// the \c VarDecl initializer expression unless we were unable to parse
832 /// (even an invalid) expression for the default argument.
833 unsigned DefaultArgKind : 2;
835 /// Whether this parameter undergoes K&R argument promotion.
836 unsigned IsKNRPromoted : 1;
838 /// Whether this parameter is an ObjC method parameter or not.
839 unsigned IsObjCMethodParam : 1;
841 /// If IsObjCMethodParam, a Decl::ObjCDeclQualifier.
842 /// Otherwise, the number of function parameter scopes enclosing
843 /// the function parameter scope in which this parameter was
845 unsigned ScopeDepthOrObjCQuals : 7;
847 /// The number of parameters preceding this parameter in the
848 /// function parameter scope in which it was declared.
849 unsigned ParameterIndex : NumParameterIndexBits;
852 class NonParmVarDeclBitfields {
853 friend class VarDecl;
854 friend class ImplicitParamDecl;
855 friend class ASTDeclReader;
857 unsigned : NumVarDeclBits;
859 // FIXME: We need something similar to CXXRecordDecl::DefinitionData.
860 /// \brief Whether this variable is a definition which was demoted due to
862 unsigned IsThisDeclarationADemotedDefinition : 1;
864 /// \brief Whether this variable is the exception variable in a C++ catch
865 /// or an Objective-C @catch statement.
866 unsigned ExceptionVar : 1;
868 /// \brief Whether this local variable could be allocated in the return
869 /// slot of its function, enabling the named return value optimization
871 unsigned NRVOVariable : 1;
873 /// \brief Whether this variable is the for-range-declaration in a C++0x
874 /// for-range statement.
875 unsigned CXXForRangeDecl : 1;
877 /// \brief Whether this variable is an ARC pseudo-__strong
878 /// variable; see isARCPseudoStrong() for details.
879 unsigned ARCPseudoStrong : 1;
881 /// \brief Whether this variable is (C++1z) inline.
882 unsigned IsInline : 1;
884 /// \brief Whether this variable has (C++1z) inline explicitly specified.
885 unsigned IsInlineSpecified : 1;
887 /// \brief Whether this variable is (C++0x) constexpr.
888 unsigned IsConstexpr : 1;
890 /// \brief Whether this variable is the implicit variable for a lambda
892 unsigned IsInitCapture : 1;
894 /// \brief Whether this local extern variable's previous declaration was
895 /// declared in the same block scope. This controls whether we should merge
896 /// the type of this declaration with its previous declaration.
897 unsigned PreviousDeclInSameBlockScope : 1;
899 /// Defines kind of the ImplicitParamDecl: 'this', 'self', 'vtt', '_cmd' or
901 unsigned ImplicitParamKind : 3;
906 VarDeclBitfields VarDeclBits;
907 ParmVarDeclBitfields ParmVarDeclBits;
908 NonParmVarDeclBitfields NonParmVarDeclBits;
911 VarDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
912 SourceLocation IdLoc, IdentifierInfo *Id, QualType T,
913 TypeSourceInfo *TInfo, StorageClass SC);
915 typedef Redeclarable<VarDecl> redeclarable_base;
916 VarDecl *getNextRedeclarationImpl() override {
917 return getNextRedeclaration();
919 VarDecl *getPreviousDeclImpl() override {
920 return getPreviousDecl();
922 VarDecl *getMostRecentDeclImpl() override {
923 return getMostRecentDecl();
927 typedef redeclarable_base::redecl_range redecl_range;
928 typedef redeclarable_base::redecl_iterator redecl_iterator;
929 using redeclarable_base::redecls_begin;
930 using redeclarable_base::redecls_end;
931 using redeclarable_base::redecls;
932 using redeclarable_base::getPreviousDecl;
933 using redeclarable_base::getMostRecentDecl;
934 using redeclarable_base::isFirstDecl;
936 static VarDecl *Create(ASTContext &C, DeclContext *DC,
937 SourceLocation StartLoc, SourceLocation IdLoc,
938 IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo,
941 static VarDecl *CreateDeserialized(ASTContext &C, unsigned ID);
943 SourceRange getSourceRange() const override LLVM_READONLY;
945 /// \brief Returns the storage class as written in the source. For the
946 /// computed linkage of symbol, see getLinkage.
947 StorageClass getStorageClass() const {
948 return (StorageClass) VarDeclBits.SClass;
950 void setStorageClass(StorageClass SC);
952 void setTSCSpec(ThreadStorageClassSpecifier TSC) {
953 VarDeclBits.TSCSpec = TSC;
954 assert(VarDeclBits.TSCSpec == TSC && "truncation");
956 ThreadStorageClassSpecifier getTSCSpec() const {
957 return static_cast<ThreadStorageClassSpecifier>(VarDeclBits.TSCSpec);
959 TLSKind getTLSKind() const;
961 /// hasLocalStorage - Returns true if a variable with function scope
962 /// is a non-static local variable.
963 bool hasLocalStorage() const {
964 if (getStorageClass() == SC_None) {
965 // OpenCL v1.2 s6.5.3: The __constant or constant address space name is
966 // used to describe variables allocated in global memory and which are
967 // accessed inside a kernel(s) as read-only variables. As such, variables
968 // in constant address space cannot have local storage.
969 if (getType().getAddressSpace() == LangAS::opencl_constant)
971 // Second check is for C++11 [dcl.stc]p4.
972 return !isFileVarDecl() && getTSCSpec() == TSCS_unspecified;
975 // Global Named Register (GNU extension)
976 if (getStorageClass() == SC_Register && !isLocalVarDeclOrParm())
979 // Return true for: Auto, Register.
980 // Return false for: Extern, Static, PrivateExtern, OpenCLWorkGroupLocal.
982 return getStorageClass() >= SC_Auto;
985 /// isStaticLocal - Returns true if a variable with function scope is a
986 /// static local variable.
987 bool isStaticLocal() const {
988 return (getStorageClass() == SC_Static ||
990 (getStorageClass() == SC_None && getTSCSpec() == TSCS_thread_local))
994 /// \brief Returns true if a variable has extern or __private_extern__
996 bool hasExternalStorage() const {
997 return getStorageClass() == SC_Extern ||
998 getStorageClass() == SC_PrivateExtern;
1001 /// \brief Returns true for all variables that do not have local storage.
1003 /// This includes all global variables as well as static variables declared
1004 /// within a function.
1005 bool hasGlobalStorage() const { return !hasLocalStorage(); }
1007 /// \brief Get the storage duration of this variable, per C++ [basic.stc].
1008 StorageDuration getStorageDuration() const {
1009 return hasLocalStorage() ? SD_Automatic :
1010 getTSCSpec() ? SD_Thread : SD_Static;
1013 /// \brief Compute the language linkage.
1014 LanguageLinkage getLanguageLinkage() const;
1016 /// \brief Determines whether this variable is a variable with
1017 /// external, C linkage.
1018 bool isExternC() const;
1020 /// \brief Determines whether this variable's context is, or is nested within,
1021 /// a C++ extern "C" linkage spec.
1022 bool isInExternCContext() const;
1024 /// \brief Determines whether this variable's context is, or is nested within,
1025 /// a C++ extern "C++" linkage spec.
1026 bool isInExternCXXContext() const;
1028 /// isLocalVarDecl - Returns true for local variable declarations
1029 /// other than parameters. Note that this includes static variables
1030 /// inside of functions. It also includes variables inside blocks.
1032 /// void foo() { int x; static int y; extern int z; }
1034 bool isLocalVarDecl() const {
1035 if (getKind() != Decl::Var && getKind() != Decl::Decomposition)
1037 if (const DeclContext *DC = getLexicalDeclContext())
1038 return DC->getRedeclContext()->isFunctionOrMethod();
1042 /// \brief Similar to isLocalVarDecl but also includes parameters.
1043 bool isLocalVarDeclOrParm() const {
1044 return isLocalVarDecl() || getKind() == Decl::ParmVar;
1047 /// isFunctionOrMethodVarDecl - Similar to isLocalVarDecl, but
1048 /// excludes variables declared in blocks.
1049 bool isFunctionOrMethodVarDecl() const {
1050 if (getKind() != Decl::Var && getKind() != Decl::Decomposition)
1052 const DeclContext *DC = getLexicalDeclContext()->getRedeclContext();
1053 return DC->isFunctionOrMethod() && DC->getDeclKind() != Decl::Block;
1056 /// \brief Determines whether this is a static data member.
1058 /// This will only be true in C++, and applies to, e.g., the
1059 /// variable 'x' in:
1065 bool isStaticDataMember() const {
1066 // If it wasn't static, it would be a FieldDecl.
1067 return getKind() != Decl::ParmVar && getDeclContext()->isRecord();
1070 VarDecl *getCanonicalDecl() override;
1071 const VarDecl *getCanonicalDecl() const {
1072 return const_cast<VarDecl*>(this)->getCanonicalDecl();
1075 enum DefinitionKind {
1076 DeclarationOnly, ///< This declaration is only a declaration.
1077 TentativeDefinition, ///< This declaration is a tentative definition.
1078 Definition ///< This declaration is definitely a definition.
1081 /// \brief Check whether this declaration is a definition. If this could be
1082 /// a tentative definition (in C), don't check whether there's an overriding
1084 DefinitionKind isThisDeclarationADefinition(ASTContext &) const;
1085 DefinitionKind isThisDeclarationADefinition() const {
1086 return isThisDeclarationADefinition(getASTContext());
1089 /// \brief Check whether this variable is defined in this
1090 /// translation unit.
1091 DefinitionKind hasDefinition(ASTContext &) const;
1092 DefinitionKind hasDefinition() const {
1093 return hasDefinition(getASTContext());
1096 /// \brief Get the tentative definition that acts as the real definition in
1097 /// a TU. Returns null if there is a proper definition available.
1098 VarDecl *getActingDefinition();
1099 const VarDecl *getActingDefinition() const {
1100 return const_cast<VarDecl*>(this)->getActingDefinition();
1103 /// \brief Get the real (not just tentative) definition for this declaration.
1104 VarDecl *getDefinition(ASTContext &);
1105 const VarDecl *getDefinition(ASTContext &C) const {
1106 return const_cast<VarDecl*>(this)->getDefinition(C);
1108 VarDecl *getDefinition() {
1109 return getDefinition(getASTContext());
1111 const VarDecl *getDefinition() const {
1112 return const_cast<VarDecl*>(this)->getDefinition();
1115 /// \brief Determine whether this is or was instantiated from an out-of-line
1116 /// definition of a static data member.
1117 bool isOutOfLine() const override;
1119 /// isFileVarDecl - Returns true for file scoped variable declaration.
1120 bool isFileVarDecl() const {
1122 if (K == ParmVar || K == ImplicitParam)
1125 if (getLexicalDeclContext()->getRedeclContext()->isFileContext())
1128 if (isStaticDataMember())
1134 /// getAnyInitializer - Get the initializer for this variable, no matter which
1135 /// declaration it is attached to.
1136 const Expr *getAnyInitializer() const {
1138 return getAnyInitializer(D);
1141 /// getAnyInitializer - Get the initializer for this variable, no matter which
1142 /// declaration it is attached to. Also get that declaration.
1143 const Expr *getAnyInitializer(const VarDecl *&D) const;
1145 bool hasInit() const;
1146 const Expr *getInit() const {
1147 return const_cast<VarDecl *>(this)->getInit();
1151 /// \brief Retrieve the address of the initializer expression.
1152 Stmt **getInitAddress();
1154 void setInit(Expr *I);
1156 /// \brief Determine whether this variable's value can be used in a
1157 /// constant expression, according to the relevant language standard.
1158 /// This only checks properties of the declaration, and does not check
1159 /// whether the initializer is in fact a constant expression.
1160 bool isUsableInConstantExpressions(ASTContext &C) const;
1162 EvaluatedStmt *ensureEvaluatedStmt() const;
1164 /// \brief Attempt to evaluate the value of the initializer attached to this
1165 /// declaration, and produce notes explaining why it cannot be evaluated or is
1166 /// not a constant expression. Returns a pointer to the value if evaluation
1167 /// succeeded, 0 otherwise.
1168 APValue *evaluateValue() const;
1169 APValue *evaluateValue(SmallVectorImpl<PartialDiagnosticAt> &Notes) const;
1171 /// \brief Return the already-evaluated value of this variable's
1172 /// initializer, or NULL if the value is not yet known. Returns pointer
1173 /// to untyped APValue if the value could not be evaluated.
1174 APValue *getEvaluatedValue() const;
1176 /// \brief Determines whether it is already known whether the
1177 /// initializer is an integral constant expression or not.
1178 bool isInitKnownICE() const;
1180 /// \brief Determines whether the initializer is an integral constant
1181 /// expression, or in C++11, whether the initializer is a constant
1184 /// \pre isInitKnownICE()
1185 bool isInitICE() const;
1187 /// \brief Determine whether the value of the initializer attached to this
1188 /// declaration is an integral constant expression.
1189 bool checkInitIsICE() const;
1191 void setInitStyle(InitializationStyle Style) {
1192 VarDeclBits.InitStyle = Style;
1195 /// \brief The style of initialization for this declaration.
1197 /// C-style initialization is "int x = 1;". Call-style initialization is
1198 /// a C++98 direct-initializer, e.g. "int x(1);". The Init expression will be
1199 /// the expression inside the parens or a "ClassType(a,b,c)" class constructor
1200 /// expression for class types. List-style initialization is C++11 syntax,
1201 /// e.g. "int x{1};". Clients can distinguish between different forms of
1202 /// initialization by checking this value. In particular, "int x = {1};" is
1203 /// C-style, "int x({1})" is call-style, and "int x{1};" is list-style; the
1204 /// Init expression in all three cases is an InitListExpr.
1205 InitializationStyle getInitStyle() const {
1206 return static_cast<InitializationStyle>(VarDeclBits.InitStyle);
1208 /// \brief Whether the initializer is a direct-initializer (list or call).
1209 bool isDirectInit() const {
1210 return getInitStyle() != CInit;
1213 /// \brief If this definition should pretend to be a declaration.
1214 bool isThisDeclarationADemotedDefinition() const {
1215 return isa<ParmVarDecl>(this) ? false :
1216 NonParmVarDeclBits.IsThisDeclarationADemotedDefinition;
1219 /// \brief This is a definition which should be demoted to a declaration.
1221 /// In some cases (mostly module merging) we can end up with two visible
1222 /// definitions one of which needs to be demoted to a declaration to keep
1223 /// the AST invariants.
1224 void demoteThisDefinitionToDeclaration() {
1225 assert (isThisDeclarationADefinition() && "Not a definition!");
1226 assert (!isa<ParmVarDecl>(this) && "Cannot demote ParmVarDecls!");
1227 NonParmVarDeclBits.IsThisDeclarationADemotedDefinition = 1;
1230 /// \brief Determine whether this variable is the exception variable in a
1231 /// C++ catch statememt or an Objective-C \@catch statement.
1232 bool isExceptionVariable() const {
1233 return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.ExceptionVar;
1235 void setExceptionVariable(bool EV) {
1236 assert(!isa<ParmVarDecl>(this));
1237 NonParmVarDeclBits.ExceptionVar = EV;
1240 /// \brief Determine whether this local variable can be used with the named
1241 /// return value optimization (NRVO).
1243 /// The named return value optimization (NRVO) works by marking certain
1244 /// non-volatile local variables of class type as NRVO objects. These
1245 /// locals can be allocated within the return slot of their containing
1246 /// function, in which case there is no need to copy the object to the
1247 /// return slot when returning from the function. Within the function body,
1248 /// each return that returns the NRVO object will have this variable as its
1250 bool isNRVOVariable() const {
1251 return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.NRVOVariable;
1253 void setNRVOVariable(bool NRVO) {
1254 assert(!isa<ParmVarDecl>(this));
1255 NonParmVarDeclBits.NRVOVariable = NRVO;
1258 /// \brief Determine whether this variable is the for-range-declaration in
1259 /// a C++0x for-range statement.
1260 bool isCXXForRangeDecl() const {
1261 return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.CXXForRangeDecl;
1263 void setCXXForRangeDecl(bool FRD) {
1264 assert(!isa<ParmVarDecl>(this));
1265 NonParmVarDeclBits.CXXForRangeDecl = FRD;
1268 /// \brief Determine whether this variable is an ARC pseudo-__strong
1269 /// variable. A pseudo-__strong variable has a __strong-qualified
1270 /// type but does not actually retain the object written into it.
1271 /// Generally such variables are also 'const' for safety.
1272 bool isARCPseudoStrong() const {
1273 return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.ARCPseudoStrong;
1275 void setARCPseudoStrong(bool ps) {
1276 assert(!isa<ParmVarDecl>(this));
1277 NonParmVarDeclBits.ARCPseudoStrong = ps;
1280 /// Whether this variable is (C++1z) inline.
1281 bool isInline() const {
1282 return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.IsInline;
1284 bool isInlineSpecified() const {
1285 return isa<ParmVarDecl>(this) ? false
1286 : NonParmVarDeclBits.IsInlineSpecified;
1288 void setInlineSpecified() {
1289 assert(!isa<ParmVarDecl>(this));
1290 NonParmVarDeclBits.IsInline = true;
1291 NonParmVarDeclBits.IsInlineSpecified = true;
1293 void setImplicitlyInline() {
1294 assert(!isa<ParmVarDecl>(this));
1295 NonParmVarDeclBits.IsInline = true;
1298 /// Whether this variable is (C++11) constexpr.
1299 bool isConstexpr() const {
1300 return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.IsConstexpr;
1302 void setConstexpr(bool IC) {
1303 assert(!isa<ParmVarDecl>(this));
1304 NonParmVarDeclBits.IsConstexpr = IC;
1307 /// Whether this variable is the implicit variable for a lambda init-capture.
1308 bool isInitCapture() const {
1309 return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.IsInitCapture;
1311 void setInitCapture(bool IC) {
1312 assert(!isa<ParmVarDecl>(this));
1313 NonParmVarDeclBits.IsInitCapture = IC;
1316 /// Whether this local extern variable declaration's previous declaration
1317 /// was declared in the same block scope. Only correct in C++.
1318 bool isPreviousDeclInSameBlockScope() const {
1319 return isa<ParmVarDecl>(this)
1321 : NonParmVarDeclBits.PreviousDeclInSameBlockScope;
1323 void setPreviousDeclInSameBlockScope(bool Same) {
1324 assert(!isa<ParmVarDecl>(this));
1325 NonParmVarDeclBits.PreviousDeclInSameBlockScope = Same;
1328 /// \brief Retrieve the variable declaration from which this variable could
1329 /// be instantiated, if it is an instantiation (rather than a non-template).
1330 VarDecl *getTemplateInstantiationPattern() const;
1332 /// \brief If this variable is an instantiated static data member of a
1333 /// class template specialization, returns the templated static data member
1334 /// from which it was instantiated.
1335 VarDecl *getInstantiatedFromStaticDataMember() const;
1337 /// \brief If this variable is an instantiation of a variable template or a
1338 /// static data member of a class template, determine what kind of
1339 /// template specialization or instantiation this is.
1340 TemplateSpecializationKind getTemplateSpecializationKind() const;
1342 /// \brief If this variable is an instantiation of a variable template or a
1343 /// static data member of a class template, determine its point of
1345 SourceLocation getPointOfInstantiation() const;
1347 /// \brief If this variable is an instantiation of a static data member of a
1348 /// class template specialization, retrieves the member specialization
1350 MemberSpecializationInfo *getMemberSpecializationInfo() const;
1352 /// \brief For a static data member that was instantiated from a static
1353 /// data member of a class template, set the template specialiation kind.
1354 void setTemplateSpecializationKind(TemplateSpecializationKind TSK,
1355 SourceLocation PointOfInstantiation = SourceLocation());
1357 /// \brief Specify that this variable is an instantiation of the
1358 /// static data member VD.
1359 void setInstantiationOfStaticDataMember(VarDecl *VD,
1360 TemplateSpecializationKind TSK);
1362 /// \brief Retrieves the variable template that is described by this
1363 /// variable declaration.
1365 /// Every variable template is represented as a VarTemplateDecl and a
1366 /// VarDecl. The former contains template properties (such as
1367 /// the template parameter lists) while the latter contains the
1368 /// actual description of the template's
1369 /// contents. VarTemplateDecl::getTemplatedDecl() retrieves the
1370 /// VarDecl that from a VarTemplateDecl, while
1371 /// getDescribedVarTemplate() retrieves the VarTemplateDecl from
1373 VarTemplateDecl *getDescribedVarTemplate() const;
1375 void setDescribedVarTemplate(VarTemplateDecl *Template);
1377 // Implement isa/cast/dyncast/etc.
1378 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1379 static bool classofKind(Kind K) { return K >= firstVar && K <= lastVar; }
1382 class ImplicitParamDecl : public VarDecl {
1383 void anchor() override;
1386 /// Defines the kind of the implicit parameter: is this an implicit parameter
1387 /// with pointer to 'this', 'self', '_cmd', virtual table pointers, captured
1388 /// context or something else.
1389 enum ImplicitParamKind : unsigned {
1390 ObjCSelf, /// Parameter for Objective-C 'self' argument
1391 ObjCCmd, /// Parameter for Objective-C '_cmd' argument
1392 CXXThis, /// Parameter for C++ 'this' argument
1393 CXXVTT, /// Parameter for C++ virtual table pointers
1394 CapturedContext, /// Parameter for captured context
1395 Other, /// Other implicit parameter
1398 /// Create implicit parameter.
1399 static ImplicitParamDecl *Create(ASTContext &C, DeclContext *DC,
1400 SourceLocation IdLoc, IdentifierInfo *Id,
1401 QualType T, ImplicitParamKind ParamKind);
1402 static ImplicitParamDecl *Create(ASTContext &C, QualType T,
1403 ImplicitParamKind ParamKind);
1405 static ImplicitParamDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1407 ImplicitParamDecl(ASTContext &C, DeclContext *DC, SourceLocation IdLoc,
1408 IdentifierInfo *Id, QualType Type,
1409 ImplicitParamKind ParamKind)
1410 : VarDecl(ImplicitParam, C, DC, IdLoc, IdLoc, Id, Type,
1411 /*TInfo=*/nullptr, SC_None) {
1412 NonParmVarDeclBits.ImplicitParamKind = ParamKind;
1416 ImplicitParamDecl(ASTContext &C, QualType Type, ImplicitParamKind ParamKind)
1417 : VarDecl(ImplicitParam, C, /*DC=*/nullptr, SourceLocation(),
1418 SourceLocation(), /*Id=*/nullptr, Type,
1419 /*TInfo=*/nullptr, SC_None) {
1420 NonParmVarDeclBits.ImplicitParamKind = ParamKind;
1424 /// Returns the implicit parameter kind.
1425 ImplicitParamKind getParameterKind() const {
1426 return static_cast<ImplicitParamKind>(NonParmVarDeclBits.ImplicitParamKind);
1428 // Implement isa/cast/dyncast/etc.
1429 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1430 static bool classofKind(Kind K) { return K == ImplicitParam; }
1433 /// ParmVarDecl - Represents a parameter to a function.
1434 class ParmVarDecl : public VarDecl {
1436 enum { MaxFunctionScopeDepth = 255 };
1437 enum { MaxFunctionScopeIndex = 255 };
1440 ParmVarDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
1441 SourceLocation IdLoc, IdentifierInfo *Id, QualType T,
1442 TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
1443 : VarDecl(DK, C, DC, StartLoc, IdLoc, Id, T, TInfo, S) {
1444 assert(ParmVarDeclBits.HasInheritedDefaultArg == false);
1445 assert(ParmVarDeclBits.DefaultArgKind == DAK_None);
1446 assert(ParmVarDeclBits.IsKNRPromoted == false);
1447 assert(ParmVarDeclBits.IsObjCMethodParam == false);
1448 setDefaultArg(DefArg);
1452 static ParmVarDecl *Create(ASTContext &C, DeclContext *DC,
1453 SourceLocation StartLoc,
1454 SourceLocation IdLoc, IdentifierInfo *Id,
1455 QualType T, TypeSourceInfo *TInfo,
1456 StorageClass S, Expr *DefArg);
1458 static ParmVarDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1460 SourceRange getSourceRange() const override LLVM_READONLY;
1462 void setObjCMethodScopeInfo(unsigned parameterIndex) {
1463 ParmVarDeclBits.IsObjCMethodParam = true;
1464 setParameterIndex(parameterIndex);
1467 void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex) {
1468 assert(!ParmVarDeclBits.IsObjCMethodParam);
1470 ParmVarDeclBits.ScopeDepthOrObjCQuals = scopeDepth;
1471 assert(ParmVarDeclBits.ScopeDepthOrObjCQuals == scopeDepth
1474 setParameterIndex(parameterIndex);
1477 bool isObjCMethodParameter() const {
1478 return ParmVarDeclBits.IsObjCMethodParam;
1481 unsigned getFunctionScopeDepth() const {
1482 if (ParmVarDeclBits.IsObjCMethodParam) return 0;
1483 return ParmVarDeclBits.ScopeDepthOrObjCQuals;
1486 /// Returns the index of this parameter in its prototype or method scope.
1487 unsigned getFunctionScopeIndex() const {
1488 return getParameterIndex();
1491 ObjCDeclQualifier getObjCDeclQualifier() const {
1492 if (!ParmVarDeclBits.IsObjCMethodParam) return OBJC_TQ_None;
1493 return ObjCDeclQualifier(ParmVarDeclBits.ScopeDepthOrObjCQuals);
1495 void setObjCDeclQualifier(ObjCDeclQualifier QTVal) {
1496 assert(ParmVarDeclBits.IsObjCMethodParam);
1497 ParmVarDeclBits.ScopeDepthOrObjCQuals = QTVal;
1500 /// True if the value passed to this parameter must undergo
1501 /// K&R-style default argument promotion:
1504 /// If the expression that denotes the called function has a type
1505 /// that does not include a prototype, the integer promotions are
1506 /// performed on each argument, and arguments that have type float
1507 /// are promoted to double.
1508 bool isKNRPromoted() const {
1509 return ParmVarDeclBits.IsKNRPromoted;
1511 void setKNRPromoted(bool promoted) {
1512 ParmVarDeclBits.IsKNRPromoted = promoted;
1515 Expr *getDefaultArg();
1516 const Expr *getDefaultArg() const {
1517 return const_cast<ParmVarDecl *>(this)->getDefaultArg();
1520 void setDefaultArg(Expr *defarg);
1522 /// \brief Retrieve the source range that covers the entire default
1524 SourceRange getDefaultArgRange() const;
1525 void setUninstantiatedDefaultArg(Expr *arg);
1526 Expr *getUninstantiatedDefaultArg();
1527 const Expr *getUninstantiatedDefaultArg() const {
1528 return const_cast<ParmVarDecl *>(this)->getUninstantiatedDefaultArg();
1531 /// hasDefaultArg - Determines whether this parameter has a default argument,
1532 /// either parsed or not.
1533 bool hasDefaultArg() const;
1535 /// hasUnparsedDefaultArg - Determines whether this parameter has a
1536 /// default argument that has not yet been parsed. This will occur
1537 /// during the processing of a C++ class whose member functions have
1538 /// default arguments, e.g.,
1542 /// void f(int x = 17); // x has an unparsed default argument now
1543 /// }; // x has a regular default argument now
1545 bool hasUnparsedDefaultArg() const {
1546 return ParmVarDeclBits.DefaultArgKind == DAK_Unparsed;
1549 bool hasUninstantiatedDefaultArg() const {
1550 return ParmVarDeclBits.DefaultArgKind == DAK_Uninstantiated;
1553 /// setUnparsedDefaultArg - Specify that this parameter has an
1554 /// unparsed default argument. The argument will be replaced with a
1555 /// real default argument via setDefaultArg when the class
1556 /// definition enclosing the function declaration that owns this
1557 /// default argument is completed.
1558 void setUnparsedDefaultArg() {
1559 ParmVarDeclBits.DefaultArgKind = DAK_Unparsed;
1562 bool hasInheritedDefaultArg() const {
1563 return ParmVarDeclBits.HasInheritedDefaultArg;
1566 void setHasInheritedDefaultArg(bool I = true) {
1567 ParmVarDeclBits.HasInheritedDefaultArg = I;
1570 QualType getOriginalType() const;
1572 /// \brief Determine whether this parameter is actually a function
1574 bool isParameterPack() const;
1576 /// setOwningFunction - Sets the function declaration that owns this
1577 /// ParmVarDecl. Since ParmVarDecls are often created before the
1578 /// FunctionDecls that own them, this routine is required to update
1579 /// the DeclContext appropriately.
1580 void setOwningFunction(DeclContext *FD) { setDeclContext(FD); }
1582 // Implement isa/cast/dyncast/etc.
1583 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1584 static bool classofKind(Kind K) { return K == ParmVar; }
1587 enum { ParameterIndexSentinel = (1 << NumParameterIndexBits) - 1 };
1589 void setParameterIndex(unsigned parameterIndex) {
1590 if (parameterIndex >= ParameterIndexSentinel) {
1591 setParameterIndexLarge(parameterIndex);
1595 ParmVarDeclBits.ParameterIndex = parameterIndex;
1596 assert(ParmVarDeclBits.ParameterIndex == parameterIndex && "truncation!");
1598 unsigned getParameterIndex() const {
1599 unsigned d = ParmVarDeclBits.ParameterIndex;
1600 return d == ParameterIndexSentinel ? getParameterIndexLarge() : d;
1603 void setParameterIndexLarge(unsigned parameterIndex);
1604 unsigned getParameterIndexLarge() const;
1607 /// FunctionDecl - An instance of this class is created to represent a
1608 /// function declaration or definition.
1610 /// Since a given function can be declared several times in a program,
1611 /// there may be several FunctionDecls that correspond to that
1612 /// function. Only one of those FunctionDecls will be found when
1613 /// traversing the list of declarations in the context of the
1614 /// FunctionDecl (e.g., the translation unit); this FunctionDecl
1615 /// contains all of the information known about the function. Other,
1616 /// previous declarations of the function are available via the
1617 /// getPreviousDecl() chain.
1618 class FunctionDecl : public DeclaratorDecl, public DeclContext,
1619 public Redeclarable<FunctionDecl> {
1621 /// \brief The kind of templated function a FunctionDecl can be.
1622 enum TemplatedKind {
1624 TK_FunctionTemplate,
1625 TK_MemberSpecialization,
1626 TK_FunctionTemplateSpecialization,
1627 TK_DependentFunctionTemplateSpecialization
1631 /// ParamInfo - new[]'d array of pointers to VarDecls for the formal
1632 /// parameters of this function. This is null if a prototype or if there are
1634 ParmVarDecl **ParamInfo;
1636 LazyDeclStmtPtr Body;
1638 // FIXME: This can be packed into the bitfields in DeclContext.
1639 // NOTE: VC++ packs bitfields poorly if the types differ.
1640 unsigned SClass : 3;
1641 unsigned IsInline : 1;
1642 unsigned IsInlineSpecified : 1;
1644 // This is shared by CXXConstructorDecl, CXXConversionDecl, and
1645 // CXXDeductionGuideDecl.
1646 unsigned IsExplicitSpecified : 1;
1648 unsigned IsVirtualAsWritten : 1;
1649 unsigned IsPure : 1;
1650 unsigned HasInheritedPrototype : 1;
1651 unsigned HasWrittenPrototype : 1;
1652 unsigned IsDeleted : 1;
1653 unsigned IsTrivial : 1; // sunk from CXXMethodDecl
1654 unsigned IsDefaulted : 1; // sunk from CXXMethoDecl
1655 unsigned IsExplicitlyDefaulted : 1; //sunk from CXXMethodDecl
1656 unsigned HasImplicitReturnZero : 1;
1657 unsigned IsLateTemplateParsed : 1;
1658 unsigned IsConstexpr : 1;
1660 /// \brief Indicates if the function uses __try.
1661 unsigned UsesSEHTry : 1;
1663 /// \brief Indicates if the function was a definition but its body was
1665 unsigned HasSkippedBody : 1;
1667 /// Indicates if the function declaration will have a body, once we're done
1668 /// parsing it. (We don't set it to false when we're done parsing, in the
1669 /// hopes this is simpler.)
1670 unsigned WillHaveBody : 1;
1672 /// \brief End part of this FunctionDecl's source range.
1674 /// We could compute the full range in getSourceRange(). However, when we're
1675 /// dealing with a function definition deserialized from a PCH/AST file,
1676 /// we can only compute the full range once the function body has been
1677 /// de-serialized, so it's far better to have the (sometimes-redundant)
1679 SourceLocation EndRangeLoc;
1681 /// \brief The template or declaration that this declaration
1682 /// describes or was instantiated from, respectively.
1684 /// For non-templates, this value will be NULL. For function
1685 /// declarations that describe a function template, this will be a
1686 /// pointer to a FunctionTemplateDecl. For member functions
1687 /// of class template specializations, this will be a MemberSpecializationInfo
1688 /// pointer containing information about the specialization.
1689 /// For function template specializations, this will be a
1690 /// FunctionTemplateSpecializationInfo, which contains information about
1691 /// the template being specialized and the template arguments involved in
1692 /// that specialization.
1693 llvm::PointerUnion4<FunctionTemplateDecl *,
1694 MemberSpecializationInfo *,
1695 FunctionTemplateSpecializationInfo *,
1696 DependentFunctionTemplateSpecializationInfo *>
1697 TemplateOrSpecialization;
1699 /// DNLoc - Provides source/type location info for the
1700 /// declaration name embedded in the DeclaratorDecl base class.
1701 DeclarationNameLoc DNLoc;
1703 /// \brief Specify that this function declaration is actually a function
1704 /// template specialization.
1706 /// \param C the ASTContext.
1708 /// \param Template the function template that this function template
1709 /// specialization specializes.
1711 /// \param TemplateArgs the template arguments that produced this
1712 /// function template specialization from the template.
1714 /// \param InsertPos If non-NULL, the position in the function template
1715 /// specialization set where the function template specialization data will
1718 /// \param TSK the kind of template specialization this is.
1720 /// \param TemplateArgsAsWritten location info of template arguments.
1722 /// \param PointOfInstantiation point at which the function template
1723 /// specialization was first instantiated.
1724 void setFunctionTemplateSpecialization(ASTContext &C,
1725 FunctionTemplateDecl *Template,
1726 const TemplateArgumentList *TemplateArgs,
1728 TemplateSpecializationKind TSK,
1729 const TemplateArgumentListInfo *TemplateArgsAsWritten,
1730 SourceLocation PointOfInstantiation);
1732 /// \brief Specify that this record is an instantiation of the
1733 /// member function FD.
1734 void setInstantiationOfMemberFunction(ASTContext &C, FunctionDecl *FD,
1735 TemplateSpecializationKind TSK);
1737 void setParams(ASTContext &C, ArrayRef<ParmVarDecl *> NewParamInfo);
1740 FunctionDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
1741 const DeclarationNameInfo &NameInfo, QualType T,
1742 TypeSourceInfo *TInfo, StorageClass S, bool isInlineSpecified,
1743 bool isConstexprSpecified)
1744 : DeclaratorDecl(DK, DC, NameInfo.getLoc(), NameInfo.getName(), T, TInfo,
1746 DeclContext(DK), redeclarable_base(C), ParamInfo(nullptr), Body(),
1747 SClass(S), IsInline(isInlineSpecified),
1748 IsInlineSpecified(isInlineSpecified), IsExplicitSpecified(false),
1749 IsVirtualAsWritten(false), IsPure(false),
1750 HasInheritedPrototype(false), HasWrittenPrototype(true),
1751 IsDeleted(false), IsTrivial(false), IsDefaulted(false),
1752 IsExplicitlyDefaulted(false), HasImplicitReturnZero(false),
1753 IsLateTemplateParsed(false), IsConstexpr(isConstexprSpecified),
1754 UsesSEHTry(false), HasSkippedBody(false), WillHaveBody(false),
1755 EndRangeLoc(NameInfo.getEndLoc()), TemplateOrSpecialization(),
1756 DNLoc(NameInfo.getInfo()) {}
1758 typedef Redeclarable<FunctionDecl> redeclarable_base;
1759 FunctionDecl *getNextRedeclarationImpl() override {
1760 return getNextRedeclaration();
1762 FunctionDecl *getPreviousDeclImpl() override {
1763 return getPreviousDecl();
1765 FunctionDecl *getMostRecentDeclImpl() override {
1766 return getMostRecentDecl();
1770 typedef redeclarable_base::redecl_range redecl_range;
1771 typedef redeclarable_base::redecl_iterator redecl_iterator;
1772 using redeclarable_base::redecls_begin;
1773 using redeclarable_base::redecls_end;
1774 using redeclarable_base::redecls;
1775 using redeclarable_base::getPreviousDecl;
1776 using redeclarable_base::getMostRecentDecl;
1777 using redeclarable_base::isFirstDecl;
1779 static FunctionDecl *Create(ASTContext &C, DeclContext *DC,
1780 SourceLocation StartLoc, SourceLocation NLoc,
1781 DeclarationName N, QualType T,
1782 TypeSourceInfo *TInfo,
1784 bool isInlineSpecified = false,
1785 bool hasWrittenPrototype = true,
1786 bool isConstexprSpecified = false) {
1787 DeclarationNameInfo NameInfo(N, NLoc);
1788 return FunctionDecl::Create(C, DC, StartLoc, NameInfo, T, TInfo,
1790 isInlineSpecified, hasWrittenPrototype,
1791 isConstexprSpecified);
1794 static FunctionDecl *Create(ASTContext &C, DeclContext *DC,
1795 SourceLocation StartLoc,
1796 const DeclarationNameInfo &NameInfo,
1797 QualType T, TypeSourceInfo *TInfo,
1799 bool isInlineSpecified,
1800 bool hasWrittenPrototype,
1801 bool isConstexprSpecified = false);
1803 static FunctionDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1805 DeclarationNameInfo getNameInfo() const {
1806 return DeclarationNameInfo(getDeclName(), getLocation(), DNLoc);
1809 void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy,
1810 bool Qualified) const override;
1812 void setRangeEnd(SourceLocation E) { EndRangeLoc = E; }
1814 SourceRange getSourceRange() const override LLVM_READONLY;
1816 /// \brief Returns true if the function has a body (definition). The
1817 /// function body might be in any of the (re-)declarations of this
1818 /// function. The variant that accepts a FunctionDecl pointer will
1819 /// set that function declaration to the actual declaration
1820 /// containing the body (if there is one).
1821 bool hasBody(const FunctionDecl *&Definition) const;
1823 bool hasBody() const override {
1824 const FunctionDecl* Definition;
1825 return hasBody(Definition);
1828 /// hasTrivialBody - Returns whether the function has a trivial body that does
1829 /// not require any specific codegen.
1830 bool hasTrivialBody() const;
1832 /// isDefined - Returns true if the function is defined at all, including
1833 /// a deleted definition. Except for the behavior when the function is
1834 /// deleted, behaves like hasBody.
1835 bool isDefined(const FunctionDecl *&Definition) const;
1837 virtual bool isDefined() const {
1838 const FunctionDecl* Definition;
1839 return isDefined(Definition);
1842 /// \brief Get the definition for this declaration.
1843 FunctionDecl *getDefinition() {
1844 const FunctionDecl *Definition;
1845 if (isDefined(Definition))
1846 return const_cast<FunctionDecl *>(Definition);
1849 const FunctionDecl *getDefinition() const {
1850 return const_cast<FunctionDecl *>(this)->getDefinition();
1853 /// getBody - Retrieve the body (definition) of the function. The
1854 /// function body might be in any of the (re-)declarations of this
1855 /// function. The variant that accepts a FunctionDecl pointer will
1856 /// set that function declaration to the actual declaration
1857 /// containing the body (if there is one).
1858 /// NOTE: For checking if there is a body, use hasBody() instead, to avoid
1859 /// unnecessary AST de-serialization of the body.
1860 Stmt *getBody(const FunctionDecl *&Definition) const;
1862 Stmt *getBody() const override {
1863 const FunctionDecl* Definition;
1864 return getBody(Definition);
1867 /// Returns whether this specific declaration of the function is also a
1868 /// definition that does not contain uninstantiated body.
1870 /// This does not determine whether the function has been defined (e.g., in a
1871 /// previous definition); for that information, use isDefined.
1873 bool isThisDeclarationADefinition() const {
1874 return IsDeleted || IsDefaulted || Body || IsLateTemplateParsed ||
1878 /// doesThisDeclarationHaveABody - Returns whether this specific
1879 /// declaration of the function has a body - that is, if it is a non-
1880 /// deleted definition.
1881 bool doesThisDeclarationHaveABody() const {
1882 return Body || IsLateTemplateParsed;
1885 void setBody(Stmt *B);
1886 void setLazyBody(uint64_t Offset) { Body = Offset; }
1888 /// Whether this function is variadic.
1889 bool isVariadic() const;
1891 /// Whether this function is marked as virtual explicitly.
1892 bool isVirtualAsWritten() const { return IsVirtualAsWritten; }
1893 void setVirtualAsWritten(bool V) { IsVirtualAsWritten = V; }
1895 /// Whether this virtual function is pure, i.e. makes the containing class
1897 bool isPure() const { return IsPure; }
1898 void setPure(bool P = true);
1900 /// Whether this templated function will be late parsed.
1901 bool isLateTemplateParsed() const { return IsLateTemplateParsed; }
1902 void setLateTemplateParsed(bool ILT = true) { IsLateTemplateParsed = ILT; }
1904 /// Whether this function is "trivial" in some specialized C++ senses.
1905 /// Can only be true for default constructors, copy constructors,
1906 /// copy assignment operators, and destructors. Not meaningful until
1907 /// the class has been fully built by Sema.
1908 bool isTrivial() const { return IsTrivial; }
1909 void setTrivial(bool IT) { IsTrivial = IT; }
1911 /// Whether this function is defaulted per C++0x. Only valid for
1912 /// special member functions.
1913 bool isDefaulted() const { return IsDefaulted; }
1914 void setDefaulted(bool D = true) { IsDefaulted = D; }
1916 /// Whether this function is explicitly defaulted per C++0x. Only valid
1917 /// for special member functions.
1918 bool isExplicitlyDefaulted() const { return IsExplicitlyDefaulted; }
1919 void setExplicitlyDefaulted(bool ED = true) { IsExplicitlyDefaulted = ED; }
1921 /// Whether falling off this function implicitly returns null/zero.
1922 /// If a more specific implicit return value is required, front-ends
1923 /// should synthesize the appropriate return statements.
1924 bool hasImplicitReturnZero() const { return HasImplicitReturnZero; }
1925 void setHasImplicitReturnZero(bool IRZ) { HasImplicitReturnZero = IRZ; }
1927 /// \brief Whether this function has a prototype, either because one
1928 /// was explicitly written or because it was "inherited" by merging
1929 /// a declaration without a prototype with a declaration that has a
1931 bool hasPrototype() const {
1932 return HasWrittenPrototype || HasInheritedPrototype;
1935 bool hasWrittenPrototype() const { return HasWrittenPrototype; }
1937 /// \brief Whether this function inherited its prototype from a
1938 /// previous declaration.
1939 bool hasInheritedPrototype() const { return HasInheritedPrototype; }
1940 void setHasInheritedPrototype(bool P = true) { HasInheritedPrototype = P; }
1942 /// Whether this is a (C++11) constexpr function or constexpr constructor.
1943 bool isConstexpr() const { return IsConstexpr; }
1944 void setConstexpr(bool IC) { IsConstexpr = IC; }
1946 /// \brief Indicates the function uses __try.
1947 bool usesSEHTry() const { return UsesSEHTry; }
1948 void setUsesSEHTry(bool UST) { UsesSEHTry = UST; }
1950 /// \brief Whether this function has been deleted.
1952 /// A function that is "deleted" (via the C++0x "= delete" syntax)
1953 /// acts like a normal function, except that it cannot actually be
1954 /// called or have its address taken. Deleted functions are
1955 /// typically used in C++ overload resolution to attract arguments
1956 /// whose type or lvalue/rvalue-ness would permit the use of a
1957 /// different overload that would behave incorrectly. For example,
1958 /// one might use deleted functions to ban implicit conversion from
1959 /// a floating-point number to an Integer type:
1962 /// struct Integer {
1963 /// Integer(long); // construct from a long
1964 /// Integer(double) = delete; // no construction from float or double
1965 /// Integer(long double) = delete; // no construction from long double
1968 // If a function is deleted, its first declaration must be.
1969 bool isDeleted() const { return getCanonicalDecl()->IsDeleted; }
1970 bool isDeletedAsWritten() const { return IsDeleted && !IsDefaulted; }
1971 void setDeletedAsWritten(bool D = true) { IsDeleted = D; }
1973 /// \brief Determines whether this function is "main", which is the
1974 /// entry point into an executable program.
1975 bool isMain() const;
1977 /// \brief Determines whether this function is a MSVCRT user defined entry
1979 bool isMSVCRTEntryPoint() const;
1981 /// \brief Determines whether this operator new or delete is one
1982 /// of the reserved global placement operators:
1983 /// void *operator new(size_t, void *);
1984 /// void *operator new[](size_t, void *);
1985 /// void operator delete(void *, void *);
1986 /// void operator delete[](void *, void *);
1987 /// These functions have special behavior under [new.delete.placement]:
1988 /// These functions are reserved, a C++ program may not define
1989 /// functions that displace the versions in the Standard C++ library.
1990 /// The provisions of [basic.stc.dynamic] do not apply to these
1991 /// reserved placement forms of operator new and operator delete.
1993 /// This function must be an allocation or deallocation function.
1994 bool isReservedGlobalPlacementOperator() const;
1996 /// \brief Determines whether this function is one of the replaceable
1997 /// global allocation functions:
1998 /// void *operator new(size_t);
1999 /// void *operator new(size_t, const std::nothrow_t &) noexcept;
2000 /// void *operator new[](size_t);
2001 /// void *operator new[](size_t, const std::nothrow_t &) noexcept;
2002 /// void operator delete(void *) noexcept;
2003 /// void operator delete(void *, std::size_t) noexcept; [C++1y]
2004 /// void operator delete(void *, const std::nothrow_t &) noexcept;
2005 /// void operator delete[](void *) noexcept;
2006 /// void operator delete[](void *, std::size_t) noexcept; [C++1y]
2007 /// void operator delete[](void *, const std::nothrow_t &) noexcept;
2008 /// These functions have special behavior under C++1y [expr.new]:
2009 /// An implementation is allowed to omit a call to a replaceable global
2010 /// allocation function. [...]
2011 bool isReplaceableGlobalAllocationFunction() const;
2013 /// Compute the language linkage.
2014 LanguageLinkage getLanguageLinkage() const;
2016 /// \brief Determines whether this function is a function with
2017 /// external, C linkage.
2018 bool isExternC() const;
2020 /// \brief Determines whether this function's context is, or is nested within,
2021 /// a C++ extern "C" linkage spec.
2022 bool isInExternCContext() const;
2024 /// \brief Determines whether this function's context is, or is nested within,
2025 /// a C++ extern "C++" linkage spec.
2026 bool isInExternCXXContext() const;
2028 /// \brief Determines whether this is a global function.
2029 bool isGlobal() const;
2031 /// \brief Determines whether this function is known to be 'noreturn', through
2032 /// an attribute on its declaration or its type.
2033 bool isNoReturn() const;
2035 /// \brief True if the function was a definition but its body was skipped.
2036 bool hasSkippedBody() const { return HasSkippedBody; }
2037 void setHasSkippedBody(bool Skipped = true) { HasSkippedBody = Skipped; }
2039 /// True if this function will eventually have a body, once it's fully parsed.
2040 bool willHaveBody() const { return WillHaveBody; }
2041 void setWillHaveBody(bool V = true) { WillHaveBody = V; }
2043 void setPreviousDeclaration(FunctionDecl * PrevDecl);
2045 FunctionDecl *getCanonicalDecl() override;
2046 const FunctionDecl *getCanonicalDecl() const {
2047 return const_cast<FunctionDecl*>(this)->getCanonicalDecl();
2050 unsigned getBuiltinID() const;
2052 // ArrayRef interface to parameters.
2053 ArrayRef<ParmVarDecl *> parameters() const {
2054 return {ParamInfo, getNumParams()};
2056 MutableArrayRef<ParmVarDecl *> parameters() {
2057 return {ParamInfo, getNumParams()};
2060 // Iterator access to formal parameters.
2061 typedef MutableArrayRef<ParmVarDecl *>::iterator param_iterator;
2062 typedef ArrayRef<ParmVarDecl *>::const_iterator param_const_iterator;
2063 bool param_empty() const { return parameters().empty(); }
2064 param_iterator param_begin() { return parameters().begin(); }
2065 param_iterator param_end() { return parameters().end(); }
2066 param_const_iterator param_begin() const { return parameters().begin(); }
2067 param_const_iterator param_end() const { return parameters().end(); }
2068 size_t param_size() const { return parameters().size(); }
2070 /// getNumParams - Return the number of parameters this function must have
2071 /// based on its FunctionType. This is the length of the ParamInfo array
2072 /// after it has been created.
2073 unsigned getNumParams() const;
2075 const ParmVarDecl *getParamDecl(unsigned i) const {
2076 assert(i < getNumParams() && "Illegal param #");
2077 return ParamInfo[i];
2079 ParmVarDecl *getParamDecl(unsigned i) {
2080 assert(i < getNumParams() && "Illegal param #");
2081 return ParamInfo[i];
2083 void setParams(ArrayRef<ParmVarDecl *> NewParamInfo) {
2084 setParams(getASTContext(), NewParamInfo);
2087 /// getMinRequiredArguments - Returns the minimum number of arguments
2088 /// needed to call this function. This may be fewer than the number of
2089 /// function parameters, if some of the parameters have default
2090 /// arguments (in C++).
2091 unsigned getMinRequiredArguments() const;
2093 QualType getReturnType() const {
2094 assert(getType()->getAs<FunctionType>() && "Expected a FunctionType!");
2095 return getType()->getAs<FunctionType>()->getReturnType();
2098 /// \brief Attempt to compute an informative source range covering the
2099 /// function return type. This may omit qualifiers and other information with
2100 /// limited representation in the AST.
2101 SourceRange getReturnTypeSourceRange() const;
2103 /// \brief Attempt to compute an informative source range covering the
2104 /// function exception specification, if any.
2105 SourceRange getExceptionSpecSourceRange() const;
2107 /// \brief Determine the type of an expression that calls this function.
2108 QualType getCallResultType() const {
2109 assert(getType()->getAs<FunctionType>() && "Expected a FunctionType!");
2110 return getType()->getAs<FunctionType>()->getCallResultType(getASTContext());
2113 /// \brief Returns the WarnUnusedResultAttr that is either declared on this
2114 /// function, or its return type declaration.
2115 const Attr *getUnusedResultAttr() const;
2117 /// \brief Returns true if this function or its return type has the
2118 /// warn_unused_result attribute.
2119 bool hasUnusedResultAttr() const { return getUnusedResultAttr() != nullptr; }
2121 /// \brief Returns the storage class as written in the source. For the
2122 /// computed linkage of symbol, see getLinkage.
2123 StorageClass getStorageClass() const { return StorageClass(SClass); }
2125 /// \brief Determine whether the "inline" keyword was specified for this
2127 bool isInlineSpecified() const { return IsInlineSpecified; }
2129 /// Set whether the "inline" keyword was specified for this function.
2130 void setInlineSpecified(bool I) {
2131 IsInlineSpecified = I;
2135 /// Flag that this function is implicitly inline.
2136 void setImplicitlyInline() {
2140 /// \brief Determine whether this function should be inlined, because it is
2141 /// either marked "inline" or "constexpr" or is a member function of a class
2142 /// that was defined in the class body.
2143 bool isInlined() const { return IsInline; }
2145 bool isInlineDefinitionExternallyVisible() const;
2147 bool isMSExternInline() const;
2149 bool doesDeclarationForceExternallyVisibleDefinition() const;
2151 /// isOverloadedOperator - Whether this function declaration
2152 /// represents an C++ overloaded operator, e.g., "operator+".
2153 bool isOverloadedOperator() const {
2154 return getOverloadedOperator() != OO_None;
2157 OverloadedOperatorKind getOverloadedOperator() const;
2159 const IdentifierInfo *getLiteralIdentifier() const;
2161 /// \brief If this function is an instantiation of a member function
2162 /// of a class template specialization, retrieves the function from
2163 /// which it was instantiated.
2165 /// This routine will return non-NULL for (non-templated) member
2166 /// functions of class templates and for instantiations of function
2167 /// templates. For example, given:
2170 /// template<typename T>
2176 /// The declaration for X<int>::f is a (non-templated) FunctionDecl
2177 /// whose parent is the class template specialization X<int>. For
2178 /// this declaration, getInstantiatedFromFunction() will return
2179 /// the FunctionDecl X<T>::A. When a complete definition of
2180 /// X<int>::A is required, it will be instantiated from the
2181 /// declaration returned by getInstantiatedFromMemberFunction().
2182 FunctionDecl *getInstantiatedFromMemberFunction() const;
2184 /// \brief What kind of templated function this is.
2185 TemplatedKind getTemplatedKind() const;
2187 /// \brief If this function is an instantiation of a member function of a
2188 /// class template specialization, retrieves the member specialization
2190 MemberSpecializationInfo *getMemberSpecializationInfo() const;
2192 /// \brief Specify that this record is an instantiation of the
2193 /// member function FD.
2194 void setInstantiationOfMemberFunction(FunctionDecl *FD,
2195 TemplateSpecializationKind TSK) {
2196 setInstantiationOfMemberFunction(getASTContext(), FD, TSK);
2199 /// \brief Retrieves the function template that is described by this
2200 /// function declaration.
2202 /// Every function template is represented as a FunctionTemplateDecl
2203 /// and a FunctionDecl (or something derived from FunctionDecl). The
2204 /// former contains template properties (such as the template
2205 /// parameter lists) while the latter contains the actual
2206 /// description of the template's
2207 /// contents. FunctionTemplateDecl::getTemplatedDecl() retrieves the
2208 /// FunctionDecl that describes the function template,
2209 /// getDescribedFunctionTemplate() retrieves the
2210 /// FunctionTemplateDecl from a FunctionDecl.
2211 FunctionTemplateDecl *getDescribedFunctionTemplate() const;
2213 void setDescribedFunctionTemplate(FunctionTemplateDecl *Template);
2215 /// \brief Determine whether this function is a function template
2217 bool isFunctionTemplateSpecialization() const {
2218 return getPrimaryTemplate() != nullptr;
2221 /// \brief Retrieve the class scope template pattern that this function
2222 /// template specialization is instantiated from.
2223 FunctionDecl *getClassScopeSpecializationPattern() const;
2225 /// \brief If this function is actually a function template specialization,
2226 /// retrieve information about this function template specialization.
2227 /// Otherwise, returns NULL.
2228 FunctionTemplateSpecializationInfo *getTemplateSpecializationInfo() const;
2230 /// \brief Determines whether this function is a function template
2231 /// specialization or a member of a class template specialization that can
2232 /// be implicitly instantiated.
2233 bool isImplicitlyInstantiable() const;
2235 /// \brief Determines if the given function was instantiated from a
2236 /// function template.
2237 bool isTemplateInstantiation() const;
2239 /// \brief Retrieve the function declaration from which this function could
2240 /// be instantiated, if it is an instantiation (rather than a non-template
2241 /// or a specialization, for example).
2242 FunctionDecl *getTemplateInstantiationPattern() const;
2244 /// \brief Retrieve the primary template that this function template
2245 /// specialization either specializes or was instantiated from.
2247 /// If this function declaration is not a function template specialization,
2249 FunctionTemplateDecl *getPrimaryTemplate() const;
2251 /// \brief Retrieve the template arguments used to produce this function
2252 /// template specialization from the primary template.
2254 /// If this function declaration is not a function template specialization,
2256 const TemplateArgumentList *getTemplateSpecializationArgs() const;
2258 /// \brief Retrieve the template argument list as written in the sources,
2261 /// If this function declaration is not a function template specialization
2262 /// or if it had no explicit template argument list, returns NULL.
2263 /// Note that it an explicit template argument list may be written empty,
2264 /// e.g., template<> void foo<>(char* s);
2265 const ASTTemplateArgumentListInfo*
2266 getTemplateSpecializationArgsAsWritten() const;
2268 /// \brief Specify that this function declaration is actually a function
2269 /// template specialization.
2271 /// \param Template the function template that this function template
2272 /// specialization specializes.
2274 /// \param TemplateArgs the template arguments that produced this
2275 /// function template specialization from the template.
2277 /// \param InsertPos If non-NULL, the position in the function template
2278 /// specialization set where the function template specialization data will
2281 /// \param TSK the kind of template specialization this is.
2283 /// \param TemplateArgsAsWritten location info of template arguments.
2285 /// \param PointOfInstantiation point at which the function template
2286 /// specialization was first instantiated.
2287 void setFunctionTemplateSpecialization(FunctionTemplateDecl *Template,
2288 const TemplateArgumentList *TemplateArgs,
2290 TemplateSpecializationKind TSK = TSK_ImplicitInstantiation,
2291 const TemplateArgumentListInfo *TemplateArgsAsWritten = nullptr,
2292 SourceLocation PointOfInstantiation = SourceLocation()) {
2293 setFunctionTemplateSpecialization(getASTContext(), Template, TemplateArgs,
2294 InsertPos, TSK, TemplateArgsAsWritten,
2295 PointOfInstantiation);
2298 /// \brief Specifies that this function declaration is actually a
2299 /// dependent function template specialization.
2300 void setDependentTemplateSpecialization(ASTContext &Context,
2301 const UnresolvedSetImpl &Templates,
2302 const TemplateArgumentListInfo &TemplateArgs);
2304 DependentFunctionTemplateSpecializationInfo *
2305 getDependentSpecializationInfo() const;
2307 /// \brief Determine what kind of template instantiation this function
2309 TemplateSpecializationKind getTemplateSpecializationKind() const;
2311 /// \brief Determine what kind of template instantiation this function
2313 void setTemplateSpecializationKind(TemplateSpecializationKind TSK,
2314 SourceLocation PointOfInstantiation = SourceLocation());
2316 /// \brief Retrieve the (first) point of instantiation of a function template
2317 /// specialization or a member of a class template specialization.
2319 /// \returns the first point of instantiation, if this function was
2320 /// instantiated from a template; otherwise, returns an invalid source
2322 SourceLocation getPointOfInstantiation() const;
2324 /// \brief Determine whether this is or was instantiated from an out-of-line
2325 /// definition of a member function.
2326 bool isOutOfLine() const override;
2328 /// \brief Identify a memory copying or setting function.
2329 /// If the given function is a memory copy or setting function, returns
2330 /// the corresponding Builtin ID. If the function is not a memory function,
2332 unsigned getMemoryFunctionKind() const;
2334 // Implement isa/cast/dyncast/etc.
2335 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2336 static bool classofKind(Kind K) {
2337 return K >= firstFunction && K <= lastFunction;
2339 static DeclContext *castToDeclContext(const FunctionDecl *D) {
2340 return static_cast<DeclContext *>(const_cast<FunctionDecl*>(D));
2342 static FunctionDecl *castFromDeclContext(const DeclContext *DC) {
2343 return static_cast<FunctionDecl *>(const_cast<DeclContext*>(DC));
2346 friend class ASTDeclReader;
2347 friend class ASTDeclWriter;
2351 /// FieldDecl - An instance of this class is created by Sema::ActOnField to
2352 /// represent a member of a struct/union/class.
2353 class FieldDecl : public DeclaratorDecl, public Mergeable<FieldDecl> {
2354 // FIXME: This can be packed into the bitfields in Decl.
2355 unsigned Mutable : 1;
2356 mutable unsigned CachedFieldIndex : 31;
2358 /// The kinds of value we can store in InitializerOrBitWidth.
2360 /// Note that this is compatible with InClassInitStyle except for
2361 /// ISK_CapturedVLAType.
2362 enum InitStorageKind {
2363 /// If the pointer is null, there's nothing special. Otherwise,
2364 /// this is a bitfield and the pointer is the Expr* storing the
2366 ISK_BitWidthOrNothing = (unsigned) ICIS_NoInit,
2368 /// The pointer is an (optional due to delayed parsing) Expr*
2369 /// holding the copy-initializer.
2370 ISK_InClassCopyInit = (unsigned) ICIS_CopyInit,
2372 /// The pointer is an (optional due to delayed parsing) Expr*
2373 /// holding the list-initializer.
2374 ISK_InClassListInit = (unsigned) ICIS_ListInit,
2376 /// The pointer is a VariableArrayType* that's been captured;
2377 /// the enclosing context is a lambda or captured statement.
2378 ISK_CapturedVLAType,
2381 /// \brief Storage for either the bit-width, the in-class
2382 /// initializer, or the captured variable length array bound.
2384 /// We can safely combine these because in-class initializers are
2385 /// not permitted for bit-fields, and both are exclusive with VLA
2388 /// If the storage kind is ISK_InClassCopyInit or
2389 /// ISK_InClassListInit, but the initializer is null, then this
2390 /// field has an in-class initializer which has not yet been parsed
2392 llvm::PointerIntPair<void *, 2, InitStorageKind> InitStorage;
2394 FieldDecl(Kind DK, DeclContext *DC, SourceLocation StartLoc,
2395 SourceLocation IdLoc, IdentifierInfo *Id,
2396 QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable,
2397 InClassInitStyle InitStyle)
2398 : DeclaratorDecl(DK, DC, IdLoc, Id, T, TInfo, StartLoc),
2399 Mutable(Mutable), CachedFieldIndex(0),
2400 InitStorage(BW, (InitStorageKind) InitStyle) {
2401 assert((!BW || InitStyle == ICIS_NoInit) && "got initializer for bitfield");
2405 static FieldDecl *Create(const ASTContext &C, DeclContext *DC,
2406 SourceLocation StartLoc, SourceLocation IdLoc,
2407 IdentifierInfo *Id, QualType T,
2408 TypeSourceInfo *TInfo, Expr *BW, bool Mutable,
2409 InClassInitStyle InitStyle);
2411 static FieldDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2413 /// getFieldIndex - Returns the index of this field within its record,
2414 /// as appropriate for passing to ASTRecordLayout::getFieldOffset.
2415 unsigned getFieldIndex() const;
2417 /// isMutable - Determines whether this field is mutable (C++ only).
2418 bool isMutable() const { return Mutable; }
2420 /// \brief Determines whether this field is a bitfield.
2421 bool isBitField() const {
2422 return InitStorage.getInt() == ISK_BitWidthOrNothing &&
2423 InitStorage.getPointer() != nullptr;
2426 /// @brief Determines whether this is an unnamed bitfield.
2427 bool isUnnamedBitfield() const { return isBitField() && !getDeclName(); }
2429 /// isAnonymousStructOrUnion - Determines whether this field is a
2430 /// representative for an anonymous struct or union. Such fields are
2431 /// unnamed and are implicitly generated by the implementation to
2432 /// store the data for the anonymous union or struct.
2433 bool isAnonymousStructOrUnion() const;
2435 Expr *getBitWidth() const {
2437 ? static_cast<Expr *>(InitStorage.getPointer())
2440 unsigned getBitWidthValue(const ASTContext &Ctx) const;
2442 /// setBitWidth - Set the bit-field width for this member.
2443 // Note: used by some clients (i.e., do not remove it).
2444 void setBitWidth(Expr *Width) {
2445 assert(InitStorage.getInt() == ISK_BitWidthOrNothing &&
2446 InitStorage.getPointer() == nullptr &&
2447 "bit width, initializer or captured type already set");
2448 InitStorage.setPointerAndInt(Width, ISK_BitWidthOrNothing);
2451 /// removeBitWidth - Remove the bit-field width from this member.
2452 // Note: used by some clients (i.e., do not remove it).
2453 void removeBitWidth() {
2454 assert(isBitField() && "no bitfield width to remove");
2455 InitStorage.setPointerAndInt(nullptr, ISK_BitWidthOrNothing);
2458 /// getInClassInitStyle - Get the kind of (C++11) in-class initializer which
2460 InClassInitStyle getInClassInitStyle() const {
2461 InitStorageKind storageKind = InitStorage.getInt();
2462 return (storageKind == ISK_CapturedVLAType
2463 ? ICIS_NoInit : (InClassInitStyle) storageKind);
2466 /// hasInClassInitializer - Determine whether this member has a C++11 in-class
2468 bool hasInClassInitializer() const {
2469 return getInClassInitStyle() != ICIS_NoInit;
2472 /// getInClassInitializer - Get the C++11 in-class initializer for this
2473 /// member, or null if one has not been set. If a valid declaration has an
2474 /// in-class initializer, but this returns null, then we have not parsed and
2475 /// attached it yet.
2476 Expr *getInClassInitializer() const {
2477 return hasInClassInitializer()
2478 ? static_cast<Expr *>(InitStorage.getPointer())
2482 /// setInClassInitializer - Set the C++11 in-class initializer for this
2484 void setInClassInitializer(Expr *Init) {
2485 assert(hasInClassInitializer() &&
2486 InitStorage.getPointer() == nullptr &&
2487 "bit width, initializer or captured type already set");
2488 InitStorage.setPointer(Init);
2491 /// removeInClassInitializer - Remove the C++11 in-class initializer from this
2493 void removeInClassInitializer() {
2494 assert(hasInClassInitializer() && "no initializer to remove");
2495 InitStorage.setPointerAndInt(nullptr, ISK_BitWidthOrNothing);
2498 /// \brief Determine whether this member captures the variable length array
2500 bool hasCapturedVLAType() const {
2501 return InitStorage.getInt() == ISK_CapturedVLAType;
2504 /// \brief Get the captured variable length array type.
2505 const VariableArrayType *getCapturedVLAType() const {
2506 return hasCapturedVLAType() ? static_cast<const VariableArrayType *>(
2507 InitStorage.getPointer())
2510 /// \brief Set the captured variable length array type for this field.
2511 void setCapturedVLAType(const VariableArrayType *VLAType);
2513 /// getParent - Returns the parent of this field declaration, which
2514 /// is the struct in which this field is defined.
2515 const RecordDecl *getParent() const {
2516 return cast<RecordDecl>(getDeclContext());
2519 RecordDecl *getParent() {
2520 return cast<RecordDecl>(getDeclContext());
2523 SourceRange getSourceRange() const override LLVM_READONLY;
2525 /// Retrieves the canonical declaration of this field.
2526 FieldDecl *getCanonicalDecl() override { return getFirstDecl(); }
2527 const FieldDecl *getCanonicalDecl() const { return getFirstDecl(); }
2529 // Implement isa/cast/dyncast/etc.
2530 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2531 static bool classofKind(Kind K) { return K >= firstField && K <= lastField; }
2533 friend class ASTDeclReader;
2534 friend class ASTDeclWriter;
2537 /// EnumConstantDecl - An instance of this object exists for each enum constant
2538 /// that is defined. For example, in "enum X {a,b}", each of a/b are
2539 /// EnumConstantDecl's, X is an instance of EnumDecl, and the type of a/b is a
2540 /// TagType for the X EnumDecl.
2541 class EnumConstantDecl : public ValueDecl, public Mergeable<EnumConstantDecl> {
2542 Stmt *Init; // an integer constant expression
2543 llvm::APSInt Val; // The value.
2545 EnumConstantDecl(DeclContext *DC, SourceLocation L,
2546 IdentifierInfo *Id, QualType T, Expr *E,
2547 const llvm::APSInt &V)
2548 : ValueDecl(EnumConstant, DC, L, Id, T), Init((Stmt*)E), Val(V) {}
2552 static EnumConstantDecl *Create(ASTContext &C, EnumDecl *DC,
2553 SourceLocation L, IdentifierInfo *Id,
2554 QualType T, Expr *E,
2555 const llvm::APSInt &V);
2556 static EnumConstantDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2558 const Expr *getInitExpr() const { return (const Expr*) Init; }
2559 Expr *getInitExpr() { return (Expr*) Init; }
2560 const llvm::APSInt &getInitVal() const { return Val; }
2562 void setInitExpr(Expr *E) { Init = (Stmt*) E; }
2563 void setInitVal(const llvm::APSInt &V) { Val = V; }
2565 SourceRange getSourceRange() const override LLVM_READONLY;
2567 /// Retrieves the canonical declaration of this enumerator.
2568 EnumConstantDecl *getCanonicalDecl() override { return getFirstDecl(); }
2569 const EnumConstantDecl *getCanonicalDecl() const { return getFirstDecl(); }
2571 // Implement isa/cast/dyncast/etc.
2572 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2573 static bool classofKind(Kind K) { return K == EnumConstant; }
2575 friend class StmtIteratorBase;
2578 /// IndirectFieldDecl - An instance of this class is created to represent a
2579 /// field injected from an anonymous union/struct into the parent scope.
2580 /// IndirectFieldDecl are always implicit.
2581 class IndirectFieldDecl : public ValueDecl,
2582 public Mergeable<IndirectFieldDecl> {
2583 void anchor() override;
2584 NamedDecl **Chaining;
2585 unsigned ChainingSize;
2587 IndirectFieldDecl(ASTContext &C, DeclContext *DC, SourceLocation L,
2588 DeclarationName N, QualType T,
2589 MutableArrayRef<NamedDecl *> CH);
2592 static IndirectFieldDecl *Create(ASTContext &C, DeclContext *DC,
2593 SourceLocation L, IdentifierInfo *Id,
2594 QualType T, llvm::MutableArrayRef<NamedDecl *> CH);
2596 static IndirectFieldDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2598 typedef ArrayRef<NamedDecl *>::const_iterator chain_iterator;
2600 ArrayRef<NamedDecl *> chain() const {
2601 return llvm::makeArrayRef(Chaining, ChainingSize);
2603 chain_iterator chain_begin() const { return chain().begin(); }
2604 chain_iterator chain_end() const { return chain().end(); }
2606 unsigned getChainingSize() const { return ChainingSize; }
2608 FieldDecl *getAnonField() const {
2609 assert(chain().size() >= 2);
2610 return cast<FieldDecl>(chain().back());
2613 VarDecl *getVarDecl() const {
2614 assert(chain().size() >= 2);
2615 return dyn_cast<VarDecl>(chain().front());
2618 IndirectFieldDecl *getCanonicalDecl() override { return getFirstDecl(); }
2619 const IndirectFieldDecl *getCanonicalDecl() const { return getFirstDecl(); }
2621 // Implement isa/cast/dyncast/etc.
2622 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2623 static bool classofKind(Kind K) { return K == IndirectField; }
2624 friend class ASTDeclReader;
2627 /// TypeDecl - Represents a declaration of a type.
2629 class TypeDecl : public NamedDecl {
2630 void anchor() override;
2631 /// TypeForDecl - This indicates the Type object that represents
2632 /// this TypeDecl. It is a cache maintained by
2633 /// ASTContext::getTypedefType, ASTContext::getTagDeclType, and
2634 /// ASTContext::getTemplateTypeParmType, and TemplateTypeParmDecl.
2635 mutable const Type *TypeForDecl;
2636 /// LocStart - The start of the source range for this declaration.
2637 SourceLocation LocStart;
2638 friend class ASTContext;
2641 TypeDecl(Kind DK, DeclContext *DC, SourceLocation L, IdentifierInfo *Id,
2642 SourceLocation StartL = SourceLocation())
2643 : NamedDecl(DK, DC, L, Id), TypeForDecl(nullptr), LocStart(StartL) {}
2646 // Low-level accessor. If you just want the type defined by this node,
2647 // check out ASTContext::getTypeDeclType or one of
2648 // ASTContext::getTypedefType, ASTContext::getRecordType, etc. if you
2649 // already know the specific kind of node this is.
2650 const Type *getTypeForDecl() const { return TypeForDecl; }
2651 void setTypeForDecl(const Type *TD) { TypeForDecl = TD; }
2653 SourceLocation getLocStart() const LLVM_READONLY { return LocStart; }
2654 void setLocStart(SourceLocation L) { LocStart = L; }
2655 SourceRange getSourceRange() const override LLVM_READONLY {
2656 if (LocStart.isValid())
2657 return SourceRange(LocStart, getLocation());
2659 return SourceRange(getLocation());
2662 // Implement isa/cast/dyncast/etc.
2663 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2664 static bool classofKind(Kind K) { return K >= firstType && K <= lastType; }
2668 /// Base class for declarations which introduce a typedef-name.
2669 class TypedefNameDecl : public TypeDecl, public Redeclarable<TypedefNameDecl> {
2670 void anchor() override;
2671 typedef std::pair<TypeSourceInfo*, QualType> ModedTInfo;
2672 llvm::PointerUnion<TypeSourceInfo*, ModedTInfo*> MaybeModedTInfo;
2674 // FIXME: This can be packed into the bitfields in Decl.
2675 /// If 0, we have not computed IsTransparentTag.
2676 /// Otherwise, IsTransparentTag is (CacheIsTransparentTag >> 1).
2677 mutable unsigned CacheIsTransparentTag : 2;
2680 TypedefNameDecl(Kind DK, ASTContext &C, DeclContext *DC,
2681 SourceLocation StartLoc, SourceLocation IdLoc,
2682 IdentifierInfo *Id, TypeSourceInfo *TInfo)
2683 : TypeDecl(DK, DC, IdLoc, Id, StartLoc), redeclarable_base(C),
2684 MaybeModedTInfo(TInfo), CacheIsTransparentTag(0) {}
2686 typedef Redeclarable<TypedefNameDecl> redeclarable_base;
2687 TypedefNameDecl *getNextRedeclarationImpl() override {
2688 return getNextRedeclaration();
2690 TypedefNameDecl *getPreviousDeclImpl() override {
2691 return getPreviousDecl();
2693 TypedefNameDecl *getMostRecentDeclImpl() override {
2694 return getMostRecentDecl();
2698 typedef redeclarable_base::redecl_range redecl_range;
2699 typedef redeclarable_base::redecl_iterator redecl_iterator;
2700 using redeclarable_base::redecls_begin;
2701 using redeclarable_base::redecls_end;
2702 using redeclarable_base::redecls;
2703 using redeclarable_base::getPreviousDecl;
2704 using redeclarable_base::getMostRecentDecl;
2705 using redeclarable_base::isFirstDecl;
2707 bool isModed() const { return MaybeModedTInfo.is<ModedTInfo*>(); }
2709 TypeSourceInfo *getTypeSourceInfo() const {
2711 ? MaybeModedTInfo.get<ModedTInfo*>()->first
2712 : MaybeModedTInfo.get<TypeSourceInfo*>();
2714 QualType getUnderlyingType() const {
2716 ? MaybeModedTInfo.get<ModedTInfo*>()->second
2717 : MaybeModedTInfo.get<TypeSourceInfo*>()->getType();
2719 void setTypeSourceInfo(TypeSourceInfo *newType) {
2720 MaybeModedTInfo = newType;
2722 void setModedTypeSourceInfo(TypeSourceInfo *unmodedTSI, QualType modedTy) {
2723 MaybeModedTInfo = new (getASTContext()) ModedTInfo(unmodedTSI, modedTy);
2726 /// Retrieves the canonical declaration of this typedef-name.
2727 TypedefNameDecl *getCanonicalDecl() override { return getFirstDecl(); }
2728 const TypedefNameDecl *getCanonicalDecl() const { return getFirstDecl(); }
2730 /// Retrieves the tag declaration for which this is the typedef name for
2731 /// linkage purposes, if any.
2733 /// \param AnyRedecl Look for the tag declaration in any redeclaration of
2734 /// this typedef declaration.
2735 TagDecl *getAnonDeclWithTypedefName(bool AnyRedecl = false) const;
2737 /// Determines if this typedef shares a name and spelling location with its
2738 /// underlying tag type, as is the case with the NS_ENUM macro.
2739 bool isTransparentTag() const {
2740 if (CacheIsTransparentTag)
2741 return CacheIsTransparentTag & 0x2;
2742 return isTransparentTagSlow();
2745 // Implement isa/cast/dyncast/etc.
2746 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2747 static bool classofKind(Kind K) {
2748 return K >= firstTypedefName && K <= lastTypedefName;
2752 bool isTransparentTagSlow() const;
2755 /// TypedefDecl - Represents the declaration of a typedef-name via the 'typedef'
2757 class TypedefDecl : public TypedefNameDecl {
2758 TypedefDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
2759 SourceLocation IdLoc, IdentifierInfo *Id, TypeSourceInfo *TInfo)
2760 : TypedefNameDecl(Typedef, C, DC, StartLoc, IdLoc, Id, TInfo) {}
2763 static TypedefDecl *Create(ASTContext &C, DeclContext *DC,
2764 SourceLocation StartLoc, SourceLocation IdLoc,
2765 IdentifierInfo *Id, TypeSourceInfo *TInfo);
2766 static TypedefDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2768 SourceRange getSourceRange() const override LLVM_READONLY;
2770 // Implement isa/cast/dyncast/etc.
2771 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2772 static bool classofKind(Kind K) { return K == Typedef; }
2775 /// TypeAliasDecl - Represents the declaration of a typedef-name via a C++0x
2776 /// alias-declaration.
2777 class TypeAliasDecl : public TypedefNameDecl {
2778 /// The template for which this is the pattern, if any.
2779 TypeAliasTemplateDecl *Template;
2781 TypeAliasDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
2782 SourceLocation IdLoc, IdentifierInfo *Id, TypeSourceInfo *TInfo)
2783 : TypedefNameDecl(TypeAlias, C, DC, StartLoc, IdLoc, Id, TInfo),
2784 Template(nullptr) {}
2787 static TypeAliasDecl *Create(ASTContext &C, DeclContext *DC,
2788 SourceLocation StartLoc, SourceLocation IdLoc,
2789 IdentifierInfo *Id, TypeSourceInfo *TInfo);
2790 static TypeAliasDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2792 SourceRange getSourceRange() const override LLVM_READONLY;
2794 TypeAliasTemplateDecl *getDescribedAliasTemplate() const { return Template; }
2795 void setDescribedAliasTemplate(TypeAliasTemplateDecl *TAT) { Template = TAT; }
2797 // Implement isa/cast/dyncast/etc.
2798 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2799 static bool classofKind(Kind K) { return K == TypeAlias; }
2802 /// TagDecl - Represents the declaration of a struct/union/class/enum.
2804 : public TypeDecl, public DeclContext, public Redeclarable<TagDecl> {
2806 // This is really ugly.
2807 typedef TagTypeKind TagKind;
2810 // FIXME: This can be packed into the bitfields in Decl.
2811 /// TagDeclKind - The TagKind enum.
2812 unsigned TagDeclKind : 3;
2814 /// IsCompleteDefinition - True if this is a definition ("struct foo
2815 /// {};"), false if it is a declaration ("struct foo;"). It is not
2816 /// a definition until the definition has been fully processed.
2817 unsigned IsCompleteDefinition : 1;
2820 /// IsBeingDefined - True if this is currently being defined.
2821 unsigned IsBeingDefined : 1;
2824 /// IsEmbeddedInDeclarator - True if this tag declaration is
2825 /// "embedded" (i.e., defined or declared for the very first time)
2826 /// in the syntax of a declarator.
2827 unsigned IsEmbeddedInDeclarator : 1;
2829 /// \brief True if this tag is free standing, e.g. "struct foo;".
2830 unsigned IsFreeStanding : 1;
2833 // These are used by (and only defined for) EnumDecl.
2834 unsigned NumPositiveBits : 8;
2835 unsigned NumNegativeBits : 8;
2837 /// IsScoped - True if this tag declaration is a scoped enumeration. Only
2838 /// possible in C++11 mode.
2839 unsigned IsScoped : 1;
2840 /// IsScopedUsingClassTag - If this tag declaration is a scoped enum,
2841 /// then this is true if the scoped enum was declared using the class
2842 /// tag, false if it was declared with the struct tag. No meaning is
2843 /// associated if this tag declaration is not a scoped enum.
2844 unsigned IsScopedUsingClassTag : 1;
2846 /// IsFixed - True if this is an enumeration with fixed underlying type. Only
2847 /// possible in C++11, Microsoft extensions, or Objective C mode.
2848 unsigned IsFixed : 1;
2850 /// \brief Indicates whether it is possible for declarations of this kind
2851 /// to have an out-of-date definition.
2853 /// This option is only enabled when modules are enabled.
2854 unsigned MayHaveOutOfDateDef : 1;
2856 /// Has the full definition of this type been required by a use somewhere in
2858 unsigned IsCompleteDefinitionRequired : 1;
2860 SourceRange BraceRange;
2862 // A struct representing syntactic qualifier info,
2863 // to be used for the (uncommon) case of out-of-line declarations.
2864 typedef QualifierInfo ExtInfo;
2866 /// \brief If the (out-of-line) tag declaration name
2867 /// is qualified, it points to the qualifier info (nns and range);
2868 /// otherwise, if the tag declaration is anonymous and it is part of
2869 /// a typedef or alias, it points to the TypedefNameDecl (used for mangling);
2870 /// otherwise, if the tag declaration is anonymous and it is used as a
2871 /// declaration specifier for variables, it points to the first VarDecl (used
2873 /// otherwise, it is a null (TypedefNameDecl) pointer.
2874 llvm::PointerUnion<TypedefNameDecl *, ExtInfo *> TypedefNameDeclOrQualifier;
2876 bool hasExtInfo() const { return TypedefNameDeclOrQualifier.is<ExtInfo *>(); }
2877 ExtInfo *getExtInfo() { return TypedefNameDeclOrQualifier.get<ExtInfo *>(); }
2878 const ExtInfo *getExtInfo() const {
2879 return TypedefNameDeclOrQualifier.get<ExtInfo *>();
2883 TagDecl(Kind DK, TagKind TK, const ASTContext &C, DeclContext *DC,
2884 SourceLocation L, IdentifierInfo *Id, TagDecl *PrevDecl,
2885 SourceLocation StartL)
2886 : TypeDecl(DK, DC, L, Id, StartL), DeclContext(DK), redeclarable_base(C),
2887 TagDeclKind(TK), IsCompleteDefinition(false), IsBeingDefined(false),
2888 IsEmbeddedInDeclarator(false), IsFreeStanding(false),
2889 IsCompleteDefinitionRequired(false),
2890 TypedefNameDeclOrQualifier((TypedefNameDecl *)nullptr) {
2891 assert((DK != Enum || TK == TTK_Enum) &&
2892 "EnumDecl not matched with TTK_Enum");
2893 setPreviousDecl(PrevDecl);
2896 typedef Redeclarable<TagDecl> redeclarable_base;
2897 TagDecl *getNextRedeclarationImpl() override {
2898 return getNextRedeclaration();
2900 TagDecl *getPreviousDeclImpl() override {
2901 return getPreviousDecl();
2903 TagDecl *getMostRecentDeclImpl() override {
2904 return getMostRecentDecl();
2907 /// @brief Completes the definition of this tag declaration.
2909 /// This is a helper function for derived classes.
2910 void completeDefinition();
2913 typedef redeclarable_base::redecl_range redecl_range;
2914 typedef redeclarable_base::redecl_iterator redecl_iterator;
2915 using redeclarable_base::redecls_begin;
2916 using redeclarable_base::redecls_end;
2917 using redeclarable_base::redecls;
2918 using redeclarable_base::getPreviousDecl;
2919 using redeclarable_base::getMostRecentDecl;
2920 using redeclarable_base::isFirstDecl;
2922 SourceRange getBraceRange() const { return BraceRange; }
2923 void setBraceRange(SourceRange R) { BraceRange = R; }
2925 /// getInnerLocStart - Return SourceLocation representing start of source
2926 /// range ignoring outer template declarations.
2927 SourceLocation getInnerLocStart() const { return getLocStart(); }
2929 /// getOuterLocStart - Return SourceLocation representing start of source
2930 /// range taking into account any outer template declarations.
2931 SourceLocation getOuterLocStart() const;
2932 SourceRange getSourceRange() const override LLVM_READONLY;
2934 TagDecl *getCanonicalDecl() override;
2935 const TagDecl *getCanonicalDecl() const {
2936 return const_cast<TagDecl*>(this)->getCanonicalDecl();
2939 /// isThisDeclarationADefinition() - Return true if this declaration
2940 /// is a completion definition of the type. Provided for consistency.
2941 bool isThisDeclarationADefinition() const {
2942 return isCompleteDefinition();
2945 /// isCompleteDefinition - Return true if this decl has its body
2946 /// fully specified.
2947 bool isCompleteDefinition() const {
2948 return IsCompleteDefinition;
2951 /// \brief Return true if this complete decl is
2952 /// required to be complete for some existing use.
2953 bool isCompleteDefinitionRequired() const {
2954 return IsCompleteDefinitionRequired;
2957 /// isBeingDefined - Return true if this decl is currently being defined.
2958 bool isBeingDefined() const {
2959 return IsBeingDefined;
2962 bool isEmbeddedInDeclarator() const {
2963 return IsEmbeddedInDeclarator;
2965 void setEmbeddedInDeclarator(bool isInDeclarator) {
2966 IsEmbeddedInDeclarator = isInDeclarator;
2969 bool isFreeStanding() const { return IsFreeStanding; }
2970 void setFreeStanding(bool isFreeStanding = true) {
2971 IsFreeStanding = isFreeStanding;
2974 /// \brief Whether this declaration declares a type that is
2975 /// dependent, i.e., a type that somehow depends on template
2977 bool isDependentType() const { return isDependentContext(); }
2979 /// @brief Starts the definition of this tag declaration.
2981 /// This method should be invoked at the beginning of the definition
2982 /// of this tag declaration. It will set the tag type into a state
2983 /// where it is in the process of being defined.
2984 void startDefinition();
2986 /// getDefinition - Returns the TagDecl that actually defines this
2987 /// struct/union/class/enum. When determining whether or not a
2988 /// struct/union/class/enum has a definition, one should use this
2989 /// method as opposed to 'isDefinition'. 'isDefinition' indicates
2990 /// whether or not a specific TagDecl is defining declaration, not
2991 /// whether or not the struct/union/class/enum type is defined.
2992 /// This method returns NULL if there is no TagDecl that defines
2993 /// the struct/union/class/enum.
2994 TagDecl *getDefinition() const;
2996 void setCompleteDefinition(bool V) { IsCompleteDefinition = V; }
2998 void setCompleteDefinitionRequired(bool V = true) {
2999 IsCompleteDefinitionRequired = V;
3002 StringRef getKindName() const {
3003 return TypeWithKeyword::getTagTypeKindName(getTagKind());
3006 TagKind getTagKind() const {
3007 return TagKind(TagDeclKind);
3010 void setTagKind(TagKind TK) { TagDeclKind = TK; }
3012 bool isStruct() const { return getTagKind() == TTK_Struct; }
3013 bool isInterface() const { return getTagKind() == TTK_Interface; }
3014 bool isClass() const { return getTagKind() == TTK_Class; }
3015 bool isUnion() const { return getTagKind() == TTK_Union; }
3016 bool isEnum() const { return getTagKind() == TTK_Enum; }
3018 /// Is this tag type named, either directly or via being defined in
3019 /// a typedef of this type?
3021 /// C++11 [basic.link]p8:
3022 /// A type is said to have linkage if and only if:
3023 /// - it is a class or enumeration type that is named (or has a
3024 /// name for linkage purposes) and the name has linkage; ...
3025 /// C++11 [dcl.typedef]p9:
3026 /// If the typedef declaration defines an unnamed class (or enum),
3027 /// the first typedef-name declared by the declaration to be that
3028 /// class type (or enum type) is used to denote the class type (or
3029 /// enum type) for linkage purposes only.
3031 /// C does not have an analogous rule, but the same concept is
3032 /// nonetheless useful in some places.
3033 bool hasNameForLinkage() const {
3034 return (getDeclName() || getTypedefNameForAnonDecl());
3037 TypedefNameDecl *getTypedefNameForAnonDecl() const {
3038 return hasExtInfo() ? nullptr
3039 : TypedefNameDeclOrQualifier.get<TypedefNameDecl *>();
3042 void setTypedefNameForAnonDecl(TypedefNameDecl *TDD);
3044 /// \brief Retrieve the nested-name-specifier that qualifies the name of this
3045 /// declaration, if it was present in the source.
3046 NestedNameSpecifier *getQualifier() const {
3047 return hasExtInfo() ? getExtInfo()->QualifierLoc.getNestedNameSpecifier()
3051 /// \brief Retrieve the nested-name-specifier (with source-location
3052 /// information) that qualifies the name of this declaration, if it was
3053 /// present in the source.
3054 NestedNameSpecifierLoc getQualifierLoc() const {
3055 return hasExtInfo() ? getExtInfo()->QualifierLoc
3056 : NestedNameSpecifierLoc();
3059 void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc);
3061 unsigned getNumTemplateParameterLists() const {
3062 return hasExtInfo() ? getExtInfo()->NumTemplParamLists : 0;
3064 TemplateParameterList *getTemplateParameterList(unsigned i) const {
3065 assert(i < getNumTemplateParameterLists());
3066 return getExtInfo()->TemplParamLists[i];
3068 void setTemplateParameterListsInfo(ASTContext &Context,
3069 ArrayRef<TemplateParameterList *> TPLists);
3071 // Implement isa/cast/dyncast/etc.
3072 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3073 static bool classofKind(Kind K) { return K >= firstTag && K <= lastTag; }
3075 static DeclContext *castToDeclContext(const TagDecl *D) {
3076 return static_cast<DeclContext *>(const_cast<TagDecl*>(D));
3078 static TagDecl *castFromDeclContext(const DeclContext *DC) {
3079 return static_cast<TagDecl *>(const_cast<DeclContext*>(DC));
3082 friend class ASTDeclReader;
3083 friend class ASTDeclWriter;
3086 /// EnumDecl - Represents an enum. In C++11, enums can be forward-declared
3087 /// with a fixed underlying type, and in C we allow them to be forward-declared
3088 /// with no underlying type as an extension.
3089 class EnumDecl : public TagDecl {
3090 void anchor() override;
3091 /// IntegerType - This represent the integer type that the enum corresponds
3092 /// to for code generation purposes. Note that the enumerator constants may
3093 /// have a different type than this does.
3095 /// If the underlying integer type was explicitly stated in the source
3096 /// code, this is a TypeSourceInfo* for that type. Otherwise this type
3097 /// was automatically deduced somehow, and this is a Type*.
3099 /// Normally if IsFixed(), this would contain a TypeSourceInfo*, but in
3100 /// some cases it won't.
3102 /// The underlying type of an enumeration never has any qualifiers, so
3103 /// we can get away with just storing a raw Type*, and thus save an
3104 /// extra pointer when TypeSourceInfo is needed.
3106 llvm::PointerUnion<const Type*, TypeSourceInfo*> IntegerType;
3108 /// PromotionType - The integer type that values of this type should
3109 /// promote to. In C, enumerators are generally of an integer type
3110 /// directly, but gcc-style large enumerators (and all enumerators
3111 /// in C++) are of the enum type instead.
3112 QualType PromotionType;
3114 /// \brief If this enumeration is an instantiation of a member enumeration
3115 /// of a class template specialization, this is the member specialization
3117 MemberSpecializationInfo *SpecializationInfo;
3119 EnumDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
3120 SourceLocation IdLoc, IdentifierInfo *Id, EnumDecl *PrevDecl,
3121 bool Scoped, bool ScopedUsingClassTag, bool Fixed)
3122 : TagDecl(Enum, TTK_Enum, C, DC, IdLoc, Id, PrevDecl, StartLoc),
3123 SpecializationInfo(nullptr) {
3124 assert(Scoped || !ScopedUsingClassTag);
3125 IntegerType = (const Type *)nullptr;
3126 NumNegativeBits = 0;
3127 NumPositiveBits = 0;
3129 IsScopedUsingClassTag = ScopedUsingClassTag;
3133 void setInstantiationOfMemberEnum(ASTContext &C, EnumDecl *ED,
3134 TemplateSpecializationKind TSK);
3136 EnumDecl *getCanonicalDecl() override {
3137 return cast<EnumDecl>(TagDecl::getCanonicalDecl());
3139 const EnumDecl *getCanonicalDecl() const {
3140 return const_cast<EnumDecl*>(this)->getCanonicalDecl();
3143 EnumDecl *getPreviousDecl() {
3144 return cast_or_null<EnumDecl>(
3145 static_cast<TagDecl *>(this)->getPreviousDecl());
3147 const EnumDecl *getPreviousDecl() const {
3148 return const_cast<EnumDecl*>(this)->getPreviousDecl();
3151 EnumDecl *getMostRecentDecl() {
3152 return cast<EnumDecl>(static_cast<TagDecl *>(this)->getMostRecentDecl());
3154 const EnumDecl *getMostRecentDecl() const {
3155 return const_cast<EnumDecl*>(this)->getMostRecentDecl();
3158 EnumDecl *getDefinition() const {
3159 return cast_or_null<EnumDecl>(TagDecl::getDefinition());
3162 static EnumDecl *Create(ASTContext &C, DeclContext *DC,
3163 SourceLocation StartLoc, SourceLocation IdLoc,
3164 IdentifierInfo *Id, EnumDecl *PrevDecl,
3165 bool IsScoped, bool IsScopedUsingClassTag,
3167 static EnumDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3169 /// completeDefinition - When created, the EnumDecl corresponds to a
3170 /// forward-declared enum. This method is used to mark the
3171 /// declaration as being defined; it's enumerators have already been
3172 /// added (via DeclContext::addDecl). NewType is the new underlying
3173 /// type of the enumeration type.
3174 void completeDefinition(QualType NewType,
3175 QualType PromotionType,
3176 unsigned NumPositiveBits,
3177 unsigned NumNegativeBits);
3179 // enumerator_iterator - Iterates through the enumerators of this
3181 typedef specific_decl_iterator<EnumConstantDecl> enumerator_iterator;
3182 typedef llvm::iterator_range<specific_decl_iterator<EnumConstantDecl>>
3185 enumerator_range enumerators() const {
3186 return enumerator_range(enumerator_begin(), enumerator_end());
3189 enumerator_iterator enumerator_begin() const {
3190 const EnumDecl *E = getDefinition();
3193 return enumerator_iterator(E->decls_begin());
3196 enumerator_iterator enumerator_end() const {
3197 const EnumDecl *E = getDefinition();
3200 return enumerator_iterator(E->decls_end());
3203 /// getPromotionType - Return the integer type that enumerators
3204 /// should promote to.
3205 QualType getPromotionType() const { return PromotionType; }
3207 /// \brief Set the promotion type.
3208 void setPromotionType(QualType T) { PromotionType = T; }
3210 /// getIntegerType - Return the integer type this enum decl corresponds to.
3211 /// This returns a null QualType for an enum forward definition with no fixed
3212 /// underlying type.
3213 QualType getIntegerType() const {
3216 if (const Type *T = IntegerType.dyn_cast<const Type*>())
3217 return QualType(T, 0);
3218 return IntegerType.get<TypeSourceInfo*>()->getType().getUnqualifiedType();
3221 /// \brief Set the underlying integer type.
3222 void setIntegerType(QualType T) { IntegerType = T.getTypePtrOrNull(); }
3224 /// \brief Set the underlying integer type source info.
3225 void setIntegerTypeSourceInfo(TypeSourceInfo *TInfo) { IntegerType = TInfo; }
3227 /// \brief Return the type source info for the underlying integer type,
3228 /// if no type source info exists, return 0.
3229 TypeSourceInfo *getIntegerTypeSourceInfo() const {
3230 return IntegerType.dyn_cast<TypeSourceInfo*>();
3233 /// \brief Retrieve the source range that covers the underlying type if
3235 SourceRange getIntegerTypeRange() const LLVM_READONLY;
3237 /// \brief Returns the width in bits required to store all the
3238 /// non-negative enumerators of this enum.
3239 unsigned getNumPositiveBits() const {
3240 return NumPositiveBits;
3242 void setNumPositiveBits(unsigned Num) {
3243 NumPositiveBits = Num;
3244 assert(NumPositiveBits == Num && "can't store this bitcount");
3247 /// \brief Returns the width in bits required to store all the
3248 /// negative enumerators of this enum. These widths include
3249 /// the rightmost leading 1; that is:
3251 /// MOST NEGATIVE ENUMERATOR PATTERN NUM NEGATIVE BITS
3252 /// ------------------------ ------- -----------------
3256 unsigned getNumNegativeBits() const {
3257 return NumNegativeBits;
3259 void setNumNegativeBits(unsigned Num) {
3260 NumNegativeBits = Num;
3263 /// \brief Returns true if this is a C++11 scoped enumeration.
3264 bool isScoped() const {
3268 /// \brief Returns true if this is a C++11 scoped enumeration.
3269 bool isScopedUsingClassTag() const {
3270 return IsScopedUsingClassTag;
3273 /// \brief Returns true if this is an Objective-C, C++11, or
3274 /// Microsoft-style enumeration with a fixed underlying type.
3275 bool isFixed() const {
3279 /// \brief Returns true if this can be considered a complete type.
3280 bool isComplete() const {
3281 return isCompleteDefinition() || isFixed();
3284 /// Returns true if this enum is either annotated with
3285 /// enum_extensibility(closed) or isn't annotated with enum_extensibility.
3286 bool isClosed() const;
3288 /// Returns true if this enum is annotated with flag_enum and isn't annotated
3289 /// with enum_extensibility(open).
3290 bool isClosedFlag() const;
3292 /// Returns true if this enum is annotated with neither flag_enum nor
3293 /// enum_extensibility(open).
3294 bool isClosedNonFlag() const;
3296 /// \brief Retrieve the enum definition from which this enumeration could
3297 /// be instantiated, if it is an instantiation (rather than a non-template).
3298 EnumDecl *getTemplateInstantiationPattern() const;
3300 /// \brief Returns the enumeration (declared within the template)
3301 /// from which this enumeration type was instantiated, or NULL if
3302 /// this enumeration was not instantiated from any template.
3303 EnumDecl *getInstantiatedFromMemberEnum() const;
3305 /// \brief If this enumeration is a member of a specialization of a
3306 /// templated class, determine what kind of template specialization
3307 /// or instantiation this is.
3308 TemplateSpecializationKind getTemplateSpecializationKind() const;
3310 /// \brief For an enumeration member that was instantiated from a member
3311 /// enumeration of a templated class, set the template specialiation kind.
3312 void setTemplateSpecializationKind(TemplateSpecializationKind TSK,
3313 SourceLocation PointOfInstantiation = SourceLocation());
3315 /// \brief If this enumeration is an instantiation of a member enumeration of
3316 /// a class template specialization, retrieves the member specialization
3318 MemberSpecializationInfo *getMemberSpecializationInfo() const {
3319 return SpecializationInfo;
3322 /// \brief Specify that this enumeration is an instantiation of the
3323 /// member enumeration ED.
3324 void setInstantiationOfMemberEnum(EnumDecl *ED,
3325 TemplateSpecializationKind TSK) {
3326 setInstantiationOfMemberEnum(getASTContext(), ED, TSK);
3329 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3330 static bool classofKind(Kind K) { return K == Enum; }
3332 friend class ASTDeclReader;
3336 /// RecordDecl - Represents a struct/union/class. For example:
3337 /// struct X; // Forward declaration, no "body".
3338 /// union Y { int A, B; }; // Has body with members A and B (FieldDecls).
3339 /// This decl will be marked invalid if *any* members are invalid.
3341 class RecordDecl : public TagDecl {
3342 // FIXME: This can be packed into the bitfields in Decl.
3343 /// HasFlexibleArrayMember - This is true if this struct ends with a flexible
3344 /// array member (e.g. int X[]) or if this union contains a struct that does.
3345 /// If so, this cannot be contained in arrays or other structs as a member.
3346 bool HasFlexibleArrayMember : 1;
3348 /// AnonymousStructOrUnion - Whether this is the type of an anonymous struct
3350 bool AnonymousStructOrUnion : 1;
3352 /// HasObjectMember - This is true if this struct has at least one member
3353 /// containing an Objective-C object pointer type.
3354 bool HasObjectMember : 1;
3356 /// HasVolatileMember - This is true if struct has at least one member of
3357 /// 'volatile' type.
3358 bool HasVolatileMember : 1;
3360 /// \brief Whether the field declarations of this record have been loaded
3361 /// from external storage. To avoid unnecessary deserialization of
3362 /// methods/nested types we allow deserialization of just the fields
3364 mutable bool LoadedFieldsFromExternalStorage : 1;
3365 friend class DeclContext;
3368 RecordDecl(Kind DK, TagKind TK, const ASTContext &C, DeclContext *DC,
3369 SourceLocation StartLoc, SourceLocation IdLoc,
3370 IdentifierInfo *Id, RecordDecl *PrevDecl);
3373 static RecordDecl *Create(const ASTContext &C, TagKind TK, DeclContext *DC,
3374 SourceLocation StartLoc, SourceLocation IdLoc,
3375 IdentifierInfo *Id, RecordDecl* PrevDecl = nullptr);
3376 static RecordDecl *CreateDeserialized(const ASTContext &C, unsigned ID);
3378 RecordDecl *getPreviousDecl() {
3379 return cast_or_null<RecordDecl>(
3380 static_cast<TagDecl *>(this)->getPreviousDecl());
3382 const RecordDecl *getPreviousDecl() const {
3383 return const_cast<RecordDecl*>(this)->getPreviousDecl();
3386 RecordDecl *getMostRecentDecl() {
3387 return cast<RecordDecl>(static_cast<TagDecl *>(this)->getMostRecentDecl());
3389 const RecordDecl *getMostRecentDecl() const {
3390 return const_cast<RecordDecl*>(this)->getMostRecentDecl();
3393 bool hasFlexibleArrayMember() const { return HasFlexibleArrayMember; }
3394 void setHasFlexibleArrayMember(bool V) { HasFlexibleArrayMember = V; }
3396 /// isAnonymousStructOrUnion - Whether this is an anonymous struct
3397 /// or union. To be an anonymous struct or union, it must have been
3398 /// declared without a name and there must be no objects of this
3399 /// type declared, e.g.,
3401 /// union { int i; float f; };
3403 /// is an anonymous union but neither of the following are:
3405 /// union X { int i; float f; };
3406 /// union { int i; float f; } obj;
3408 bool isAnonymousStructOrUnion() const { return AnonymousStructOrUnion; }
3409 void setAnonymousStructOrUnion(bool Anon) {
3410 AnonymousStructOrUnion = Anon;
3413 bool hasObjectMember() const { return HasObjectMember; }
3414 void setHasObjectMember (bool val) { HasObjectMember = val; }
3416 bool hasVolatileMember() const { return HasVolatileMember; }
3417 void setHasVolatileMember (bool val) { HasVolatileMember = val; }
3419 bool hasLoadedFieldsFromExternalStorage() const {
3420 return LoadedFieldsFromExternalStorage;
3422 void setHasLoadedFieldsFromExternalStorage(bool val) {
3423 LoadedFieldsFromExternalStorage = val;
3426 /// \brief Determines whether this declaration represents the
3427 /// injected class name.
3429 /// The injected class name in C++ is the name of the class that
3430 /// appears inside the class itself. For example:
3434 /// // C is implicitly declared here as a synonym for the class name.
3437 /// C::C c; // same as "C c;"
3439 bool isInjectedClassName() const;
3441 /// \brief Determine whether this record is a class describing a lambda
3442 /// function object.
3443 bool isLambda() const;
3445 /// \brief Determine whether this record is a record for captured variables in
3446 /// CapturedStmt construct.
3447 bool isCapturedRecord() const;
3448 /// \brief Mark the record as a record for captured variables in CapturedStmt
3450 void setCapturedRecord();
3452 /// getDefinition - Returns the RecordDecl that actually defines
3453 /// this struct/union/class. When determining whether or not a
3454 /// struct/union/class is completely defined, one should use this
3455 /// method as opposed to 'isCompleteDefinition'.
3456 /// 'isCompleteDefinition' indicates whether or not a specific
3457 /// RecordDecl is a completed definition, not whether or not the
3458 /// record type is defined. This method returns NULL if there is
3459 /// no RecordDecl that defines the struct/union/tag.
3460 RecordDecl *getDefinition() const {
3461 return cast_or_null<RecordDecl>(TagDecl::getDefinition());
3464 // Iterator access to field members. The field iterator only visits
3465 // the non-static data members of this class, ignoring any static
3466 // data members, functions, constructors, destructors, etc.
3467 typedef specific_decl_iterator<FieldDecl> field_iterator;
3468 typedef llvm::iterator_range<specific_decl_iterator<FieldDecl>> field_range;
3470 field_range fields() const { return field_range(field_begin(), field_end()); }
3471 field_iterator field_begin() const;
3473 field_iterator field_end() const {
3474 return field_iterator(decl_iterator());
3477 // field_empty - Whether there are any fields (non-static data
3478 // members) in this record.
3479 bool field_empty() const {
3480 return field_begin() == field_end();
3483 /// completeDefinition - Notes that the definition of this type is
3485 virtual void completeDefinition();
3487 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3488 static bool classofKind(Kind K) {
3489 return K >= firstRecord && K <= lastRecord;
3492 /// isMsStrust - Get whether or not this is an ms_struct which can
3493 /// be turned on with an attribute, pragma, or -mms-bitfields
3494 /// commandline option.
3495 bool isMsStruct(const ASTContext &C) const;
3497 /// \brief Whether we are allowed to insert extra padding between fields.
3498 /// These padding are added to help AddressSanitizer detect
3499 /// intra-object-overflow bugs.
3500 bool mayInsertExtraPadding(bool EmitRemark = false) const;
3502 /// Finds the first data member which has a name.
3503 /// nullptr is returned if no named data member exists.
3504 const FieldDecl *findFirstNamedDataMember() const;
3507 /// \brief Deserialize just the fields.
3508 void LoadFieldsFromExternalStorage() const;
3511 class FileScopeAsmDecl : public Decl {
3512 virtual void anchor();
3513 StringLiteral *AsmString;
3514 SourceLocation RParenLoc;
3515 FileScopeAsmDecl(DeclContext *DC, StringLiteral *asmstring,
3516 SourceLocation StartL, SourceLocation EndL)
3517 : Decl(FileScopeAsm, DC, StartL), AsmString(asmstring), RParenLoc(EndL) {}
3519 static FileScopeAsmDecl *Create(ASTContext &C, DeclContext *DC,
3520 StringLiteral *Str, SourceLocation AsmLoc,
3521 SourceLocation RParenLoc);
3523 static FileScopeAsmDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3525 SourceLocation getAsmLoc() const { return getLocation(); }
3526 SourceLocation getRParenLoc() const { return RParenLoc; }
3527 void setRParenLoc(SourceLocation L) { RParenLoc = L; }
3528 SourceRange getSourceRange() const override LLVM_READONLY {
3529 return SourceRange(getAsmLoc(), getRParenLoc());
3532 const StringLiteral *getAsmString() const { return AsmString; }
3533 StringLiteral *getAsmString() { return AsmString; }
3534 void setAsmString(StringLiteral *Asm) { AsmString = Asm; }
3536 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3537 static bool classofKind(Kind K) { return K == FileScopeAsm; }
3540 /// BlockDecl - This represents a block literal declaration, which is like an
3541 /// unnamed FunctionDecl. For example:
3542 /// ^{ statement-body } or ^(int arg1, float arg2){ statement-body }
3544 class BlockDecl : public Decl, public DeclContext {
3546 /// A class which contains all the information about a particular
3554 /// The variable being captured.
3555 llvm::PointerIntPair<VarDecl*, 2> VariableAndFlags;
3557 /// The copy expression, expressed in terms of a DeclRef (or
3558 /// BlockDeclRef) to the captured variable. Only required if the
3559 /// variable has a C++ class type.
3563 Capture(VarDecl *variable, bool byRef, bool nested, Expr *copy)
3564 : VariableAndFlags(variable,
3565 (byRef ? flag_isByRef : 0) | (nested ? flag_isNested : 0)),
3568 /// The variable being captured.
3569 VarDecl *getVariable() const { return VariableAndFlags.getPointer(); }
3571 /// Whether this is a "by ref" capture, i.e. a capture of a __block
3573 bool isByRef() const { return VariableAndFlags.getInt() & flag_isByRef; }
3575 /// Whether this is a nested capture, i.e. the variable captured
3576 /// is not from outside the immediately enclosing function/block.
3577 bool isNested() const { return VariableAndFlags.getInt() & flag_isNested; }
3579 bool hasCopyExpr() const { return CopyExpr != nullptr; }
3580 Expr *getCopyExpr() const { return CopyExpr; }
3581 void setCopyExpr(Expr *e) { CopyExpr = e; }
3585 // FIXME: This can be packed into the bitfields in Decl.
3586 bool IsVariadic : 1;
3587 bool CapturesCXXThis : 1;
3588 bool BlockMissingReturnType : 1;
3589 bool IsConversionFromLambda : 1;
3590 /// ParamInfo - new[]'d array of pointers to ParmVarDecls for the formal
3591 /// parameters of this function. This is null if a prototype or if there are
3593 ParmVarDecl **ParamInfo;
3597 TypeSourceInfo *SignatureAsWritten;
3599 const Capture *Captures;
3600 unsigned NumCaptures;
3602 unsigned ManglingNumber;
3603 Decl *ManglingContextDecl;
3606 BlockDecl(DeclContext *DC, SourceLocation CaretLoc)
3607 : Decl(Block, DC, CaretLoc), DeclContext(Block),
3608 IsVariadic(false), CapturesCXXThis(false),
3609 BlockMissingReturnType(true), IsConversionFromLambda(false),
3610 ParamInfo(nullptr), NumParams(0), Body(nullptr),
3611 SignatureAsWritten(nullptr), Captures(nullptr), NumCaptures(0),
3612 ManglingNumber(0), ManglingContextDecl(nullptr) {}
3615 static BlockDecl *Create(ASTContext &C, DeclContext *DC, SourceLocation L);
3616 static BlockDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3618 SourceLocation getCaretLocation() const { return getLocation(); }
3620 bool isVariadic() const { return IsVariadic; }
3621 void setIsVariadic(bool value) { IsVariadic = value; }
3623 CompoundStmt *getCompoundBody() const { return (CompoundStmt*) Body; }
3624 Stmt *getBody() const override { return (Stmt*) Body; }
3625 void setBody(CompoundStmt *B) { Body = (Stmt*) B; }
3627 void setSignatureAsWritten(TypeSourceInfo *Sig) { SignatureAsWritten = Sig; }
3628 TypeSourceInfo *getSignatureAsWritten() const { return SignatureAsWritten; }
3630 // ArrayRef access to formal parameters.
3631 ArrayRef<ParmVarDecl *> parameters() const {
3632 return {ParamInfo, getNumParams()};
3634 MutableArrayRef<ParmVarDecl *> parameters() {
3635 return {ParamInfo, getNumParams()};
3638 // Iterator access to formal parameters.
3639 typedef MutableArrayRef<ParmVarDecl *>::iterator param_iterator;
3640 typedef ArrayRef<ParmVarDecl *>::const_iterator param_const_iterator;
3641 bool param_empty() const { return parameters().empty(); }
3642 param_iterator param_begin() { return parameters().begin(); }
3643 param_iterator param_end() { return parameters().end(); }
3644 param_const_iterator param_begin() const { return parameters().begin(); }
3645 param_const_iterator param_end() const { return parameters().end(); }
3646 size_t param_size() const { return parameters().size(); }
3648 unsigned getNumParams() const { return NumParams; }
3649 const ParmVarDecl *getParamDecl(unsigned i) const {
3650 assert(i < getNumParams() && "Illegal param #");
3651 return ParamInfo[i];
3653 ParmVarDecl *getParamDecl(unsigned i) {
3654 assert(i < getNumParams() && "Illegal param #");
3655 return ParamInfo[i];
3657 void setParams(ArrayRef<ParmVarDecl *> NewParamInfo);
3659 /// hasCaptures - True if this block (or its nested blocks) captures
3660 /// anything of local storage from its enclosing scopes.
3661 bool hasCaptures() const { return NumCaptures != 0 || CapturesCXXThis; }
3663 /// getNumCaptures - Returns the number of captured variables.
3664 /// Does not include an entry for 'this'.
3665 unsigned getNumCaptures() const { return NumCaptures; }
3667 typedef ArrayRef<Capture>::const_iterator capture_const_iterator;
3669 ArrayRef<Capture> captures() const { return {Captures, NumCaptures}; }
3671 capture_const_iterator capture_begin() const { return captures().begin(); }
3672 capture_const_iterator capture_end() const { return captures().end(); }
3674 bool capturesCXXThis() const { return CapturesCXXThis; }
3675 bool blockMissingReturnType() const { return BlockMissingReturnType; }
3676 void setBlockMissingReturnType(bool val) { BlockMissingReturnType = val; }
3678 bool isConversionFromLambda() const { return IsConversionFromLambda; }
3679 void setIsConversionFromLambda(bool val) { IsConversionFromLambda = val; }
3681 bool capturesVariable(const VarDecl *var) const;
3683 void setCaptures(ASTContext &Context, ArrayRef<Capture> Captures,
3684 bool CapturesCXXThis);
3686 unsigned getBlockManglingNumber() const {
3687 return ManglingNumber;
3689 Decl *getBlockManglingContextDecl() const {
3690 return ManglingContextDecl;
3693 void setBlockMangling(unsigned Number, Decl *Ctx) {
3694 ManglingNumber = Number;
3695 ManglingContextDecl = Ctx;
3698 SourceRange getSourceRange() const override LLVM_READONLY;
3700 // Implement isa/cast/dyncast/etc.
3701 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3702 static bool classofKind(Kind K) { return K == Block; }
3703 static DeclContext *castToDeclContext(const BlockDecl *D) {
3704 return static_cast<DeclContext *>(const_cast<BlockDecl*>(D));
3706 static BlockDecl *castFromDeclContext(const DeclContext *DC) {
3707 return static_cast<BlockDecl *>(const_cast<DeclContext*>(DC));
3711 /// \brief This represents the body of a CapturedStmt, and serves as its
3713 class CapturedDecl final
3716 private llvm::TrailingObjects<CapturedDecl, ImplicitParamDecl *> {
3718 size_t numTrailingObjects(OverloadToken<ImplicitParamDecl>) {
3723 /// \brief The number of parameters to the outlined function.
3725 /// \brief The position of context parameter in list of parameters.
3726 unsigned ContextParam;
3727 /// \brief The body of the outlined function.
3728 llvm::PointerIntPair<Stmt *, 1, bool> BodyAndNothrow;
3730 explicit CapturedDecl(DeclContext *DC, unsigned NumParams);
3732 ImplicitParamDecl *const *getParams() const {
3733 return getTrailingObjects<ImplicitParamDecl *>();
3736 ImplicitParamDecl **getParams() {
3737 return getTrailingObjects<ImplicitParamDecl *>();
3741 static CapturedDecl *Create(ASTContext &C, DeclContext *DC,
3742 unsigned NumParams);
3743 static CapturedDecl *CreateDeserialized(ASTContext &C, unsigned ID,
3744 unsigned NumParams);
3746 Stmt *getBody() const override;
3747 void setBody(Stmt *B);
3749 bool isNothrow() const;
3750 void setNothrow(bool Nothrow = true);
3752 unsigned getNumParams() const { return NumParams; }
3754 ImplicitParamDecl *getParam(unsigned i) const {
3755 assert(i < NumParams);
3756 return getParams()[i];
3758 void setParam(unsigned i, ImplicitParamDecl *P) {
3759 assert(i < NumParams);
3763 // ArrayRef interface to parameters.
3764 ArrayRef<ImplicitParamDecl *> parameters() const {
3765 return {getParams(), getNumParams()};
3767 MutableArrayRef<ImplicitParamDecl *> parameters() {
3768 return {getParams(), getNumParams()};
3771 /// \brief Retrieve the parameter containing captured variables.
3772 ImplicitParamDecl *getContextParam() const {
3773 assert(ContextParam < NumParams);
3774 return getParam(ContextParam);
3776 void setContextParam(unsigned i, ImplicitParamDecl *P) {
3777 assert(i < NumParams);
3781 unsigned getContextParamPosition() const { return ContextParam; }
3783 typedef ImplicitParamDecl *const *param_iterator;
3784 typedef llvm::iterator_range<param_iterator> param_range;
3786 /// \brief Retrieve an iterator pointing to the first parameter decl.
3787 param_iterator param_begin() const { return getParams(); }
3788 /// \brief Retrieve an iterator one past the last parameter decl.
3789 param_iterator param_end() const { return getParams() + NumParams; }
3791 // Implement isa/cast/dyncast/etc.
3792 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3793 static bool classofKind(Kind K) { return K == Captured; }
3794 static DeclContext *castToDeclContext(const CapturedDecl *D) {
3795 return static_cast<DeclContext *>(const_cast<CapturedDecl *>(D));
3797 static CapturedDecl *castFromDeclContext(const DeclContext *DC) {
3798 return static_cast<CapturedDecl *>(const_cast<DeclContext *>(DC));
3801 friend class ASTDeclReader;
3802 friend class ASTDeclWriter;
3803 friend TrailingObjects;
3806 /// \brief Describes a module import declaration, which makes the contents
3807 /// of the named module visible in the current translation unit.
3809 /// An import declaration imports the named module (or submodule). For example:
3811 /// @import std.vector;
3814 /// Import declarations can also be implicitly generated from
3815 /// \#include/\#import directives.
3816 class ImportDecl final : public Decl,
3817 llvm::TrailingObjects<ImportDecl, SourceLocation> {
3818 /// \brief The imported module, along with a bit that indicates whether
3819 /// we have source-location information for each identifier in the module
3822 /// When the bit is false, we only have a single source location for the
3823 /// end of the import declaration.
3824 llvm::PointerIntPair<Module *, 1, bool> ImportedAndComplete;
3826 /// \brief The next import in the list of imports local to the translation
3827 /// unit being parsed (not loaded from an AST file).
3828 ImportDecl *NextLocalImport;
3830 friend class ASTReader;
3831 friend class ASTDeclReader;
3832 friend class ASTContext;
3833 friend TrailingObjects;
3835 ImportDecl(DeclContext *DC, SourceLocation StartLoc, Module *Imported,
3836 ArrayRef<SourceLocation> IdentifierLocs);
3838 ImportDecl(DeclContext *DC, SourceLocation StartLoc, Module *Imported,
3839 SourceLocation EndLoc);
3841 ImportDecl(EmptyShell Empty) : Decl(Import, Empty), NextLocalImport() { }
3844 /// \brief Create a new module import declaration.
3845 static ImportDecl *Create(ASTContext &C, DeclContext *DC,
3846 SourceLocation StartLoc, Module *Imported,
3847 ArrayRef<SourceLocation> IdentifierLocs);
3849 /// \brief Create a new module import declaration for an implicitly-generated
3851 static ImportDecl *CreateImplicit(ASTContext &C, DeclContext *DC,
3852 SourceLocation StartLoc, Module *Imported,
3853 SourceLocation EndLoc);
3855 /// \brief Create a new, deserialized module import declaration.
3856 static ImportDecl *CreateDeserialized(ASTContext &C, unsigned ID,
3857 unsigned NumLocations);
3859 /// \brief Retrieve the module that was imported by the import declaration.
3860 Module *getImportedModule() const { return ImportedAndComplete.getPointer(); }
3862 /// \brief Retrieves the locations of each of the identifiers that make up
3863 /// the complete module name in the import declaration.
3865 /// This will return an empty array if the locations of the individual
3866 /// identifiers aren't available.
3867 ArrayRef<SourceLocation> getIdentifierLocs() const;
3869 SourceRange getSourceRange() const override LLVM_READONLY;
3871 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3872 static bool classofKind(Kind K) { return K == Import; }
3875 /// \brief Represents a C++ Modules TS module export declaration.
3879 /// export void foo();
3881 class ExportDecl final : public Decl, public DeclContext {
3882 virtual void anchor();
3884 /// \brief The source location for the right brace (if valid).
3885 SourceLocation RBraceLoc;
3887 ExportDecl(DeclContext *DC, SourceLocation ExportLoc)
3888 : Decl(Export, DC, ExportLoc), DeclContext(Export),
3889 RBraceLoc(SourceLocation()) { }
3891 friend class ASTDeclReader;
3894 static ExportDecl *Create(ASTContext &C, DeclContext *DC,
3895 SourceLocation ExportLoc);
3896 static ExportDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3898 SourceLocation getExportLoc() const { return getLocation(); }
3899 SourceLocation getRBraceLoc() const { return RBraceLoc; }
3900 void setRBraceLoc(SourceLocation L) { RBraceLoc = L; }
3902 SourceLocation getLocEnd() const LLVM_READONLY {
3903 if (RBraceLoc.isValid())
3905 // No braces: get the end location of the (only) declaration in context
3907 return decls_empty() ? getLocation() : decls_begin()->getLocEnd();
3910 SourceRange getSourceRange() const override LLVM_READONLY {
3911 return SourceRange(getLocation(), getLocEnd());
3914 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3915 static bool classofKind(Kind K) { return K == Export; }
3916 static DeclContext *castToDeclContext(const ExportDecl *D) {
3917 return static_cast<DeclContext *>(const_cast<ExportDecl*>(D));
3919 static ExportDecl *castFromDeclContext(const DeclContext *DC) {
3920 return static_cast<ExportDecl *>(const_cast<DeclContext*>(DC));
3924 /// \brief Represents an empty-declaration.
3925 class EmptyDecl : public Decl {
3926 virtual void anchor();
3927 EmptyDecl(DeclContext *DC, SourceLocation L)
3928 : Decl(Empty, DC, L) { }
3931 static EmptyDecl *Create(ASTContext &C, DeclContext *DC,
3933 static EmptyDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3935 static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3936 static bool classofKind(Kind K) { return K == Empty; }
3939 /// Insertion operator for diagnostics. This allows sending NamedDecl's
3940 /// into a diagnostic with <<.
3941 inline const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
3942 const NamedDecl* ND) {
3943 DB.AddTaggedVal(reinterpret_cast<intptr_t>(ND),
3944 DiagnosticsEngine::ak_nameddecl);
3947 inline const PartialDiagnostic &operator<<(const PartialDiagnostic &PD,
3948 const NamedDecl* ND) {
3949 PD.AddTaggedVal(reinterpret_cast<intptr_t>(ND),
3950 DiagnosticsEngine::ak_nameddecl);
3954 template<typename decl_type>
3955 void Redeclarable<decl_type>::setPreviousDecl(decl_type *PrevDecl) {
3956 // Note: This routine is implemented here because we need both NamedDecl
3957 // and Redeclarable to be defined.
3958 assert(RedeclLink.NextIsLatest() &&
3959 "setPreviousDecl on a decl already in a redeclaration chain");
3962 // Point to previous. Make sure that this is actually the most recent
3963 // redeclaration, or we can build invalid chains. If the most recent
3964 // redeclaration is invalid, it won't be PrevDecl, but we want it anyway.
3965 First = PrevDecl->getFirstDecl();
3966 assert(First->RedeclLink.NextIsLatest() && "Expected first");
3967 decl_type *MostRecent = First->getNextRedeclaration();
3968 RedeclLink = PreviousDeclLink(cast<decl_type>(MostRecent));
3970 // If the declaration was previously visible, a redeclaration of it remains
3971 // visible even if it wouldn't be visible by itself.
3972 static_cast<decl_type*>(this)->IdentifierNamespace |=
3973 MostRecent->getIdentifierNamespace() &
3974 (Decl::IDNS_Ordinary | Decl::IDNS_Tag | Decl::IDNS_Type);
3977 First = static_cast<decl_type*>(this);
3980 // First one will point to this one as latest.
3981 First->RedeclLink.setLatest(static_cast<decl_type*>(this));
3983 assert(!isa<NamedDecl>(static_cast<decl_type*>(this)) ||
3984 cast<NamedDecl>(static_cast<decl_type*>(this))->isLinkageValid());
3987 // Inline function definitions.
3989 /// \brief Check if the given decl is complete.
3991 /// We use this function to break a cycle between the inline definitions in
3992 /// Type.h and Decl.h.
3993 inline bool IsEnumDeclComplete(EnumDecl *ED) {
3994 return ED->isComplete();
3997 /// \brief Check if the given decl is scoped.
3999 /// We use this function to break a cycle between the inline definitions in
4000 /// Type.h and Decl.h.
4001 inline bool IsEnumDeclScoped(EnumDecl *ED) {
4002 return ED->isScoped();
4005 } // end namespace clang