clang  6.0.0
Decl.h
Go to the documentation of this file.
1 //===- Decl.h - Classes for representing declarations -----------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines the Decl subclasses.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_AST_DECL_H
15 #define LLVM_CLANG_AST_DECL_H
16 
17 #include "clang/AST/APValue.h"
18 #include "clang/AST/DeclBase.h"
22 #include "clang/AST/Redeclarable.h"
23 #include "clang/AST/Type.h"
25 #include "clang/Basic/Diagnostic.h"
27 #include "clang/Basic/LLVM.h"
28 #include "clang/Basic/Linkage.h"
33 #include "clang/Basic/Specifiers.h"
34 #include "clang/Basic/Visibility.h"
35 #include "llvm/ADT/APSInt.h"
36 #include "llvm/ADT/ArrayRef.h"
37 #include "llvm/ADT/Optional.h"
38 #include "llvm/ADT/PointerIntPair.h"
39 #include "llvm/ADT/PointerUnion.h"
40 #include "llvm/ADT/StringRef.h"
41 #include "llvm/ADT/iterator_range.h"
42 #include "llvm/Support/Casting.h"
43 #include "llvm/Support/Compiler.h"
44 #include "llvm/Support/TrailingObjects.h"
45 #include <cassert>
46 #include <cstddef>
47 #include <cstdint>
48 #include <string>
49 #include <utility>
50 
51 namespace clang {
52 
53 class ASTContext;
54 struct ASTTemplateArgumentListInfo;
55 class Attr;
56 class CompoundStmt;
57 class DependentFunctionTemplateSpecializationInfo;
58 class EnumDecl;
59 class Expr;
60 class FunctionTemplateDecl;
61 class FunctionTemplateSpecializationInfo;
62 class LabelStmt;
63 class MemberSpecializationInfo;
64 class Module;
65 class NamespaceDecl;
66 class ParmVarDecl;
67 class RecordDecl;
68 class Stmt;
69 class StringLiteral;
70 class TagDecl;
71 class TemplateArgumentList;
72 class TemplateArgumentListInfo;
73 class TemplateParameterList;
74 class TypeAliasTemplateDecl;
75 class TypeLoc;
76 class UnresolvedSetImpl;
77 class VarTemplateDecl;
78 
79 /// \brief A container of type source information.
80 ///
81 /// A client can read the relevant info using TypeLoc wrappers, e.g:
82 /// @code
83 /// TypeLoc TL = TypeSourceInfo->getTypeLoc();
84 /// TL.getStartLoc().print(OS, SrcMgr);
85 /// @endcode
87  // Contains a memory block after the class, used for type source information,
88  // allocated by ASTContext.
89  friend class ASTContext;
90 
91  QualType Ty;
92 
93  TypeSourceInfo(QualType ty) : Ty(ty) {}
94 
95 public:
96  /// \brief Return the type wrapped by this type source info.
97  QualType getType() const { return Ty; }
98 
99  /// \brief Return the TypeLoc wrapper for the type source info.
100  TypeLoc getTypeLoc() const; // implemented in TypeLoc.h
101 
102  /// \brief Override the type stored in this TypeSourceInfo. Use with caution!
103  void overrideType(QualType T) { Ty = T; }
104 };
105 
106 /// TranslationUnitDecl - The top declaration context.
107 class TranslationUnitDecl : public Decl, public DeclContext {
108  ASTContext &Ctx;
109 
110  /// The (most recently entered) anonymous namespace for this
111  /// translation unit, if one has been created.
112  NamespaceDecl *AnonymousNamespace = nullptr;
113 
114  explicit TranslationUnitDecl(ASTContext &ctx);
115 
116  virtual void anchor();
117 
118 public:
119  ASTContext &getASTContext() const { return Ctx; }
120 
121  NamespaceDecl *getAnonymousNamespace() const { return AnonymousNamespace; }
122  void setAnonymousNamespace(NamespaceDecl *D) { AnonymousNamespace = D; }
123 
125 
126  // Implement isa/cast/dyncast/etc.
127  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
128  static bool classofKind(Kind K) { return K == TranslationUnit; }
130  return static_cast<DeclContext *>(const_cast<TranslationUnitDecl*>(D));
131  }
133  return static_cast<TranslationUnitDecl *>(const_cast<DeclContext*>(DC));
134  }
135 };
136 
137 /// \brief Represents a `#pragma comment` line. Always a child of
138 /// TranslationUnitDecl.
139 class PragmaCommentDecl final
140  : public Decl,
141  private llvm::TrailingObjects<PragmaCommentDecl, char> {
142  friend class ASTDeclReader;
143  friend class ASTDeclWriter;
144  friend TrailingObjects;
145 
146  PragmaMSCommentKind CommentKind;
147 
149  PragmaMSCommentKind CommentKind)
150  : Decl(PragmaComment, TU, CommentLoc), CommentKind(CommentKind) {}
151 
152  virtual void anchor();
153 
154 public:
156  SourceLocation CommentLoc,
157  PragmaMSCommentKind CommentKind,
158  StringRef Arg);
159  static PragmaCommentDecl *CreateDeserialized(ASTContext &C, unsigned ID,
160  unsigned ArgSize);
161 
162  PragmaMSCommentKind getCommentKind() const { return CommentKind; }
163 
164  StringRef getArg() const { return getTrailingObjects<char>(); }
165 
166  // Implement isa/cast/dyncast/etc.
167  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
168  static bool classofKind(Kind K) { return K == PragmaComment; }
169 };
170 
171 /// \brief Represents a `#pragma detect_mismatch` line. Always a child of
172 /// TranslationUnitDecl.
174  : public Decl,
175  private llvm::TrailingObjects<PragmaDetectMismatchDecl, char> {
176  friend class ASTDeclReader;
177  friend class ASTDeclWriter;
178  friend TrailingObjects;
179 
180  size_t ValueStart;
181 
183  size_t ValueStart)
184  : Decl(PragmaDetectMismatch, TU, Loc), ValueStart(ValueStart) {}
185 
186  virtual void anchor();
187 
188 public:
191  SourceLocation Loc, StringRef Name,
192  StringRef Value);
193  static PragmaDetectMismatchDecl *
194  CreateDeserialized(ASTContext &C, unsigned ID, unsigned NameValueSize);
195 
196  StringRef getName() const { return getTrailingObjects<char>(); }
197  StringRef getValue() const { return getTrailingObjects<char>() + ValueStart; }
198 
199  // Implement isa/cast/dyncast/etc.
200  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
201  static bool classofKind(Kind K) { return K == PragmaDetectMismatch; }
202 };
203 
204 /// \brief Declaration context for names declared as extern "C" in C++. This
205 /// is neither the semantic nor lexical context for such declarations, but is
206 /// used to check for conflicts with other extern "C" declarations. Example:
207 ///
208 /// \code
209 /// namespace N { extern "C" void f(); } // #1
210 /// void N::f() {} // #2
211 /// namespace M { extern "C" void f(); } // #3
212 /// \endcode
213 ///
214 /// The semantic context of #1 is namespace N and its lexical context is the
215 /// LinkageSpecDecl; the semantic context of #2 is namespace N and its lexical
216 /// context is the TU. However, both declarations are also visible in the
217 /// extern "C" context.
218 ///
219 /// The declaration at #3 finds it is a redeclaration of \c N::f through
220 /// lookup in the extern "C" context.
221 class ExternCContextDecl : public Decl, public DeclContext {
223  : Decl(ExternCContext, TU, SourceLocation()),
224  DeclContext(ExternCContext) {}
225 
226  virtual void anchor();
227 
228 public:
229  static ExternCContextDecl *Create(const ASTContext &C,
230  TranslationUnitDecl *TU);
231 
232  // Implement isa/cast/dyncast/etc.
233  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
234  static bool classofKind(Kind K) { return K == ExternCContext; }
236  return static_cast<DeclContext *>(const_cast<ExternCContextDecl*>(D));
237  }
239  return static_cast<ExternCContextDecl *>(const_cast<DeclContext*>(DC));
240  }
241 };
242 
243 /// NamedDecl - This represents a decl with a name. Many decls have names such
244 /// as ObjCMethodDecl, but not \@class, etc.
245 class NamedDecl : public Decl {
246  /// Name - The name of this declaration, which is typically a normal
247  /// identifier but may also be a special kind of name (C++
248  /// constructor, Objective-C selector, etc.)
249  DeclarationName Name;
250 
251  virtual void anchor();
252 
253 private:
254  NamedDecl *getUnderlyingDeclImpl() LLVM_READONLY;
255 
256 protected:
258  : Decl(DK, DC, L), Name(N) {}
259 
260 public:
261  /// getIdentifier - Get the identifier that names this declaration,
262  /// if there is one. This will return NULL if this declaration has
263  /// no name (e.g., for an unnamed class) or if the name is a special
264  /// name (C++ constructor, Objective-C selector, etc.).
266 
267  /// getName - Get the name of identifier for this declaration as a StringRef.
268  /// This requires that the declaration have a name and that it be a simple
269  /// identifier.
270  StringRef getName() const {
271  assert(Name.isIdentifier() && "Name is not a simple identifier");
272  return getIdentifier() ? getIdentifier()->getName() : "";
273  }
274 
275  /// getNameAsString - Get a human-readable name for the declaration, even if
276  /// it is one of the special kinds of names (C++ constructor, Objective-C
277  /// selector, etc). Creating this name requires expensive string
278  /// manipulation, so it should be called only when performance doesn't matter.
279  /// For simple declarations, getNameAsCString() should suffice.
280  //
281  // FIXME: This function should be renamed to indicate that it is not just an
282  // alternate form of getName(), and clients should move as appropriate.
283  //
284  // FIXME: Deprecated, move clients to getName().
285  std::string getNameAsString() const { return Name.getAsString(); }
286 
287  virtual void printName(raw_ostream &os) const;
288 
289  /// getDeclName - Get the actual, stored name of the declaration,
290  /// which may be a special name.
291  DeclarationName getDeclName() const { return Name; }
292 
293  /// \brief Set the name of this declaration.
294  void setDeclName(DeclarationName N) { Name = N; }
295 
296  /// printQualifiedName - Returns human-readable qualified name for
297  /// declaration, like A::B::i, for i being member of namespace A::B.
298  /// If declaration is not member of context which can be named (record,
299  /// namespace), it will return same result as printName().
300  /// Creating this name is expensive, so it should be called only when
301  /// performance doesn't matter.
302  void printQualifiedName(raw_ostream &OS) const;
303  void printQualifiedName(raw_ostream &OS, const PrintingPolicy &Policy) const;
304 
305  // FIXME: Remove string version.
306  std::string getQualifiedNameAsString() const;
307 
308  /// Appends a human-readable name for this declaration into the given stream.
309  ///
310  /// This is the method invoked by Sema when displaying a NamedDecl
311  /// in a diagnostic. It does not necessarily produce the same
312  /// result as printName(); for example, class template
313  /// specializations are printed with their template arguments.
314  virtual void getNameForDiagnostic(raw_ostream &OS,
315  const PrintingPolicy &Policy,
316  bool Qualified) const;
317 
318  /// \brief Determine whether this declaration, if
319  /// known to be well-formed within its context, will replace the
320  /// declaration OldD if introduced into scope. A declaration will
321  /// replace another declaration if, for example, it is a
322  /// redeclaration of the same variable or function, but not if it is
323  /// a declaration of a different kind (function vs. class) or an
324  /// overloaded function.
325  ///
326  /// \param IsKnownNewer \c true if this declaration is known to be newer
327  /// than \p OldD (for instance, if this declaration is newly-created).
328  bool declarationReplaces(NamedDecl *OldD, bool IsKnownNewer = true) const;
329 
330  /// \brief Determine whether this declaration has linkage.
331  bool hasLinkage() const;
332 
333  using Decl::isModulePrivate;
335 
336  /// \brief Determine whether this declaration is a C++ class member.
337  bool isCXXClassMember() const {
338  const DeclContext *DC = getDeclContext();
339 
340  // C++0x [class.mem]p1:
341  // The enumerators of an unscoped enumeration defined in
342  // the class are members of the class.
343  if (isa<EnumDecl>(DC))
344  DC = DC->getRedeclContext();
345 
346  return DC->isRecord();
347  }
348 
349  /// \brief Determine whether the given declaration is an instance member of
350  /// a C++ class.
351  bool isCXXInstanceMember() const;
352 
353  /// \brief Determine what kind of linkage this entity has.
354  /// This is not the linkage as defined by the standard or the codegen notion
355  /// of linkage. It is just an implementation detail that is used to compute
356  /// those.
357  Linkage getLinkageInternal() const;
358 
359  /// \brief Get the linkage from a semantic point of view. Entities in
360  /// anonymous namespaces are external (in c++98).
362  return clang::getFormalLinkage(getLinkageInternal());
363  }
364 
365  /// \brief True if this decl has external linkage.
367  return isExternalFormalLinkage(getLinkageInternal());
368  }
369 
370  bool isExternallyVisible() const {
371  return clang::isExternallyVisible(getLinkageInternal());
372  }
373 
374  /// Determine whether this declaration can be redeclared in a
375  /// different translation unit.
376  bool isExternallyDeclarable() const {
377  return isExternallyVisible() && !getOwningModuleForLinkage();
378  }
379 
380  /// \brief Determines the visibility of this entity.
382  return getLinkageAndVisibility().getVisibility();
383  }
384 
385  /// \brief Determines the linkage and visibility of this entity.
386  LinkageInfo getLinkageAndVisibility() const;
387 
388  /// Kinds of explicit visibility.
390  /// Do an LV computation for, ultimately, a type.
391  /// Visibility may be restricted by type visibility settings and
392  /// the visibility of template arguments.
394 
395  /// Do an LV computation for, ultimately, a non-type declaration.
396  /// Visibility may be restricted by value visibility settings and
397  /// the visibility of template arguments.
398  VisibilityForValue
399  };
400 
401  /// \brief If visibility was explicitly specified for this
402  /// declaration, return that visibility.
405 
406  /// \brief True if the computed linkage is valid. Used for consistency
407  /// checking. Should always return true.
408  bool isLinkageValid() const;
409 
410  /// \brief True if something has required us to compute the linkage
411  /// of this declaration.
412  ///
413  /// Language features which can retroactively change linkage (like a
414  /// typedef name for linkage purposes) may need to consider this,
415  /// but hopefully only in transitory ways during parsing.
416  bool hasLinkageBeenComputed() const {
417  return hasCachedLinkage();
418  }
419 
420  /// \brief Looks through UsingDecls and ObjCCompatibleAliasDecls for
421  /// the underlying named decl.
423  // Fast-path the common case.
424  if (this->getKind() != UsingShadow &&
425  this->getKind() != ConstructorUsingShadow &&
426  this->getKind() != ObjCCompatibleAlias &&
427  this->getKind() != NamespaceAlias)
428  return this;
429 
430  return getUnderlyingDeclImpl();
431  }
432  const NamedDecl *getUnderlyingDecl() const {
433  return const_cast<NamedDecl*>(this)->getUnderlyingDecl();
434  }
435 
437  return cast<NamedDecl>(static_cast<Decl *>(this)->getMostRecentDecl());
438  }
439  const NamedDecl *getMostRecentDecl() const {
440  return const_cast<NamedDecl*>(this)->getMostRecentDecl();
441  }
442 
443  ObjCStringFormatFamily getObjCFStringFormattingFamily() const;
444 
445  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
446  static bool classofKind(Kind K) { return K >= firstNamed && K <= lastNamed; }
447 };
448 
449 inline raw_ostream &operator<<(raw_ostream &OS, const NamedDecl &ND) {
450  ND.printName(OS);
451  return OS;
452 }
453 
454 /// LabelDecl - Represents the declaration of a label. Labels also have a
455 /// corresponding LabelStmt, which indicates the position that the label was
456 /// defined at. For normal labels, the location of the decl is the same as the
457 /// location of the statement. For GNU local labels (__label__), the decl
458 /// location is where the __label__ is.
459 class LabelDecl : public NamedDecl {
460  LabelStmt *TheStmt;
461  StringRef MSAsmName;
462  bool MSAsmNameResolved = false;
463 
464  /// LocStart - For normal labels, this is the same as the main declaration
465  /// label, i.e., the location of the identifier; for GNU local labels,
466  /// this is the location of the __label__ keyword.
467  SourceLocation LocStart;
468 
470  LabelStmt *S, SourceLocation StartL)
471  : NamedDecl(Label, DC, IdentL, II), TheStmt(S), LocStart(StartL) {}
472 
473  void anchor() override;
474 
475 public:
476  static LabelDecl *Create(ASTContext &C, DeclContext *DC,
477  SourceLocation IdentL, IdentifierInfo *II);
478  static LabelDecl *Create(ASTContext &C, DeclContext *DC,
479  SourceLocation IdentL, IdentifierInfo *II,
480  SourceLocation GnuLabelL);
481  static LabelDecl *CreateDeserialized(ASTContext &C, unsigned ID);
482 
483  LabelStmt *getStmt() const { return TheStmt; }
484  void setStmt(LabelStmt *T) { TheStmt = T; }
485 
486  bool isGnuLocal() const { return LocStart != getLocation(); }
487  void setLocStart(SourceLocation L) { LocStart = L; }
488 
489  SourceRange getSourceRange() const override LLVM_READONLY {
490  return SourceRange(LocStart, getLocation());
491  }
492 
493  bool isMSAsmLabel() const { return !MSAsmName.empty(); }
494  bool isResolvedMSAsmLabel() const { return isMSAsmLabel() && MSAsmNameResolved; }
495  void setMSAsmLabel(StringRef Name);
496  StringRef getMSAsmLabel() const { return MSAsmName; }
497  void setMSAsmLabelResolved() { MSAsmNameResolved = true; }
498 
499  // Implement isa/cast/dyncast/etc.
500  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
501  static bool classofKind(Kind K) { return K == Label; }
502 };
503 
504 /// NamespaceDecl - Represent a C++ namespace.
505 class NamespaceDecl : public NamedDecl, public DeclContext,
506  public Redeclarable<NamespaceDecl>
507 {
508  /// LocStart - The starting location of the source range, pointing
509  /// to either the namespace or the inline keyword.
510  SourceLocation LocStart;
511 
512  /// RBraceLoc - The ending location of the source range.
513  SourceLocation RBraceLoc;
514 
515  /// \brief A pointer to either the anonymous namespace that lives just inside
516  /// this namespace or to the first namespace in the chain (the latter case
517  /// only when this is not the first in the chain), along with a
518  /// boolean value indicating whether this is an inline namespace.
519  llvm::PointerIntPair<NamespaceDecl *, 1, bool> AnonOrFirstNamespaceAndInline;
520 
521  NamespaceDecl(ASTContext &C, DeclContext *DC, bool Inline,
522  SourceLocation StartLoc, SourceLocation IdLoc,
523  IdentifierInfo *Id, NamespaceDecl *PrevDecl);
524 
526 
527  NamespaceDecl *getNextRedeclarationImpl() override;
528  NamespaceDecl *getPreviousDeclImpl() override;
529  NamespaceDecl *getMostRecentDeclImpl() override;
530 
531 public:
532  friend class ASTDeclReader;
533  friend class ASTDeclWriter;
534 
535  static NamespaceDecl *Create(ASTContext &C, DeclContext *DC,
536  bool Inline, SourceLocation StartLoc,
537  SourceLocation IdLoc, IdentifierInfo *Id,
538  NamespaceDecl *PrevDecl);
539 
540  static NamespaceDecl *CreateDeserialized(ASTContext &C, unsigned ID);
541 
543  using redecl_iterator = redeclarable_base::redecl_iterator;
544 
545  using redeclarable_base::redecls_begin;
546  using redeclarable_base::redecls_end;
547  using redeclarable_base::redecls;
548  using redeclarable_base::getPreviousDecl;
549  using redeclarable_base::getMostRecentDecl;
550  using redeclarable_base::isFirstDecl;
551 
552  /// \brief Returns true if this is an anonymous namespace declaration.
553  ///
554  /// For example:
555  /// \code
556  /// namespace {
557  /// ...
558  /// };
559  /// \endcode
560  /// q.v. C++ [namespace.unnamed]
561  bool isAnonymousNamespace() const {
562  return !getIdentifier();
563  }
564 
565  /// \brief Returns true if this is an inline namespace declaration.
566  bool isInline() const {
567  return AnonOrFirstNamespaceAndInline.getInt();
568  }
569 
570  /// \brief Set whether this is an inline namespace declaration.
571  void setInline(bool Inline) {
572  AnonOrFirstNamespaceAndInline.setInt(Inline);
573  }
574 
575  /// \brief Get the original (first) namespace declaration.
576  NamespaceDecl *getOriginalNamespace();
577 
578  /// \brief Get the original (first) namespace declaration.
579  const NamespaceDecl *getOriginalNamespace() const;
580 
581  /// \brief Return true if this declaration is an original (first) declaration
582  /// of the namespace. This is false for non-original (subsequent) namespace
583  /// declarations and anonymous namespaces.
584  bool isOriginalNamespace() const;
585 
586  /// \brief Retrieve the anonymous namespace nested inside this namespace,
587  /// if any.
589  return getOriginalNamespace()->AnonOrFirstNamespaceAndInline.getPointer();
590  }
591 
593  getOriginalNamespace()->AnonOrFirstNamespaceAndInline.setPointer(D);
594  }
595 
596  /// Retrieves the canonical declaration of this namespace.
598  return getOriginalNamespace();
599  }
601  return getOriginalNamespace();
602  }
603 
604  SourceRange getSourceRange() const override LLVM_READONLY {
605  return SourceRange(LocStart, RBraceLoc);
606  }
607 
608  SourceLocation getLocStart() const LLVM_READONLY { return LocStart; }
609  SourceLocation getRBraceLoc() const { return RBraceLoc; }
610  void setLocStart(SourceLocation L) { LocStart = L; }
611  void setRBraceLoc(SourceLocation L) { RBraceLoc = L; }
612 
613  // Implement isa/cast/dyncast/etc.
614  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
615  static bool classofKind(Kind K) { return K == Namespace; }
617  return static_cast<DeclContext *>(const_cast<NamespaceDecl*>(D));
618  }
620  return static_cast<NamespaceDecl *>(const_cast<DeclContext*>(DC));
621  }
622 };
623 
624 /// ValueDecl - Represent the declaration of a variable (in which case it is
625 /// an lvalue) a function (in which case it is a function designator) or
626 /// an enum constant.
627 class ValueDecl : public NamedDecl {
628  QualType DeclType;
629 
630  void anchor() override;
631 
632 protected:
635  : NamedDecl(DK, DC, L, N), DeclType(T) {}
636 
637 public:
638  QualType getType() const { return DeclType; }
639  void setType(QualType newType) { DeclType = newType; }
640 
641  /// \brief Determine whether this symbol is weakly-imported,
642  /// or declared with the weak or weak-ref attr.
643  bool isWeak() const;
644 
645  // Implement isa/cast/dyncast/etc.
646  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
647  static bool classofKind(Kind K) { return K >= firstValue && K <= lastValue; }
648 };
649 
650 /// QualifierInfo - A struct with extended info about a syntactic
651 /// name qualifier, to be used for the case of out-of-line declarations.
654 
655  /// NumTemplParamLists - The number of "outer" template parameter lists.
656  /// The count includes all of the template parameter lists that were matched
657  /// against the template-ids occurring into the NNS and possibly (in the
658  /// case of an explicit specialization) a final "template <>".
659  unsigned NumTemplParamLists = 0;
660 
661  /// TemplParamLists - A new-allocated array of size NumTemplParamLists,
662  /// containing pointers to the "outer" template parameter lists.
663  /// It includes all of the template parameter lists that were matched
664  /// against the template-ids occurring into the NNS and possibly (in the
665  /// case of an explicit specialization) a final "template <>".
666  TemplateParameterList** TemplParamLists = nullptr;
667 
668  QualifierInfo() = default;
669  QualifierInfo(const QualifierInfo &) = delete;
670  QualifierInfo& operator=(const QualifierInfo &) = delete;
671 
672  /// setTemplateParameterListsInfo - Sets info about "outer" template
673  /// parameter lists.
674  void setTemplateParameterListsInfo(ASTContext &Context,
676 };
677 
678 /// \brief Represents a ValueDecl that came out of a declarator.
679 /// Contains type source information through TypeSourceInfo.
680 class DeclaratorDecl : public ValueDecl {
681  // A struct representing both a TInfo and a syntactic qualifier,
682  // to be used for the (uncommon) case of out-of-line declarations.
683  struct ExtInfo : public QualifierInfo {
684  TypeSourceInfo *TInfo;
685  };
686 
687  llvm::PointerUnion<TypeSourceInfo *, ExtInfo *> DeclInfo;
688 
689  /// InnerLocStart - The start of the source range for this declaration,
690  /// ignoring outer template declarations.
691  SourceLocation InnerLocStart;
692 
693  bool hasExtInfo() const { return DeclInfo.is<ExtInfo*>(); }
694  ExtInfo *getExtInfo() { return DeclInfo.get<ExtInfo*>(); }
695  const ExtInfo *getExtInfo() const { return DeclInfo.get<ExtInfo*>(); }
696 
697 protected:
700  SourceLocation StartL)
701  : ValueDecl(DK, DC, L, N, T), DeclInfo(TInfo), InnerLocStart(StartL) {}
702 
703 public:
704  friend class ASTDeclReader;
705  friend class ASTDeclWriter;
706 
708  return hasExtInfo()
709  ? getExtInfo()->TInfo
710  : DeclInfo.get<TypeSourceInfo*>();
711  }
712 
714  if (hasExtInfo())
715  getExtInfo()->TInfo = TI;
716  else
717  DeclInfo = TI;
718  }
719 
720  /// getInnerLocStart - Return SourceLocation representing start of source
721  /// range ignoring outer template declarations.
722  SourceLocation getInnerLocStart() const { return InnerLocStart; }
723  void setInnerLocStart(SourceLocation L) { InnerLocStart = L; }
724 
725  /// getOuterLocStart - Return SourceLocation representing start of source
726  /// range taking into account any outer template declarations.
727  SourceLocation getOuterLocStart() const;
728 
729  SourceRange getSourceRange() const override LLVM_READONLY;
730 
731  SourceLocation getLocStart() const LLVM_READONLY {
732  return getOuterLocStart();
733  }
734 
735  /// \brief Retrieve the nested-name-specifier that qualifies the name of this
736  /// declaration, if it was present in the source.
738  return hasExtInfo() ? getExtInfo()->QualifierLoc.getNestedNameSpecifier()
739  : nullptr;
740  }
741 
742  /// \brief Retrieve the nested-name-specifier (with source-location
743  /// information) that qualifies the name of this declaration, if it was
744  /// present in the source.
746  return hasExtInfo() ? getExtInfo()->QualifierLoc
748  }
749 
750  void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc);
751 
752  unsigned getNumTemplateParameterLists() const {
753  return hasExtInfo() ? getExtInfo()->NumTemplParamLists : 0;
754  }
755 
757  assert(index < getNumTemplateParameterLists());
758  return getExtInfo()->TemplParamLists[index];
759  }
760 
761  void setTemplateParameterListsInfo(ASTContext &Context,
763 
764  SourceLocation getTypeSpecStartLoc() const;
765 
766  // Implement isa/cast/dyncast/etc.
767  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
768  static bool classofKind(Kind K) {
769  return K >= firstDeclarator && K <= lastDeclarator;
770  }
771 };
772 
773 /// \brief Structure used to store a statement, the constant value to
774 /// which it was evaluated (if any), and whether or not the statement
775 /// is an integral constant expression (if known).
777  /// \brief Whether this statement was already evaluated.
778  bool WasEvaluated : 1;
779 
780  /// \brief Whether this statement is being evaluated.
781  bool IsEvaluating : 1;
782 
783  /// \brief Whether we already checked whether this statement was an
784  /// integral constant expression.
785  bool CheckedICE : 1;
786 
787  /// \brief Whether we are checking whether this statement is an
788  /// integral constant expression.
789  bool CheckingICE : 1;
790 
791  /// \brief Whether this statement is an integral constant expression,
792  /// or in C++11, whether the statement is a constant expression. Only
793  /// valid if CheckedICE is true.
794  bool IsICE : 1;
795 
798 
799  EvaluatedStmt() : WasEvaluated(false), IsEvaluating(false), CheckedICE(false),
800  CheckingICE(false), IsICE(false) {}
801 
802 };
803 
804 /// VarDecl - An instance of this class is created to represent a variable
805 /// declaration or definition.
806 class VarDecl : public DeclaratorDecl, public Redeclarable<VarDecl> {
807 public:
808  /// \brief Initialization styles.
810  /// C-style initialization with assignment
812 
813  /// Call-style initialization (C++98)
815 
816  /// Direct list-initialization (C++11)
818  };
819 
820  /// \brief Kinds of thread-local storage.
821  enum TLSKind {
822  /// Not a TLS variable.
824 
825  /// TLS with a known-constant initializer.
827 
828  /// TLS with a dynamic initializer.
829  TLS_Dynamic
830  };
831 
832  /// getStorageClassSpecifierString - Return the string used to
833  /// specify the storage class \p SC.
834  ///
835  /// It is illegal to call this function with SC == None.
836  static const char *getStorageClassSpecifierString(StorageClass SC);
837 
838 protected:
839  // A pointer union of Stmt * and EvaluatedStmt *. When an EvaluatedStmt, we
840  // have allocated the auxiliary struct of information there.
841  //
842  // TODO: It is a bit unfortunate to use a PointerUnion inside the VarDecl for
843  // this as *many* VarDecls are ParmVarDecls that don't have default
844  // arguments. We could save some space by moving this pointer union to be
845  // allocated in trailing space when necessary.
846  using InitType = llvm::PointerUnion<Stmt *, EvaluatedStmt *>;
847 
848  /// \brief The initializer for this variable or, for a ParmVarDecl, the
849  /// C++ default argument.
850  mutable InitType Init;
851 
852 private:
853  friend class ASTDeclReader;
854  friend class ASTNodeImporter;
855  friend class StmtIteratorBase;
856 
857  class VarDeclBitfields {
858  friend class ASTDeclReader;
859  friend class VarDecl;
860 
861  unsigned SClass : 3;
862  unsigned TSCSpec : 2;
863  unsigned InitStyle : 2;
864  };
865  enum { NumVarDeclBits = 7 };
866 
867 protected:
868  enum { NumParameterIndexBits = 8 };
869 
874  DAK_Normal
875  };
876 
878  friend class ASTDeclReader;
879  friend class ParmVarDecl;
880 
881  unsigned : NumVarDeclBits;
882 
883  /// Whether this parameter inherits a default argument from a
884  /// prior declaration.
885  unsigned HasInheritedDefaultArg : 1;
886 
887  /// Describes the kind of default argument for this parameter. By default
888  /// this is none. If this is normal, then the default argument is stored in
889  /// the \c VarDecl initializer expression unless we were unable to parse
890  /// (even an invalid) expression for the default argument.
891  unsigned DefaultArgKind : 2;
892 
893  /// Whether this parameter undergoes K&R argument promotion.
894  unsigned IsKNRPromoted : 1;
895 
896  /// Whether this parameter is an ObjC method parameter or not.
897  unsigned IsObjCMethodParam : 1;
898 
899  /// If IsObjCMethodParam, a Decl::ObjCDeclQualifier.
900  /// Otherwise, the number of function parameter scopes enclosing
901  /// the function parameter scope in which this parameter was
902  /// declared.
903  unsigned ScopeDepthOrObjCQuals : 7;
904 
905  /// The number of parameters preceding this parameter in the
906  /// function parameter scope in which it was declared.
907  unsigned ParameterIndex : NumParameterIndexBits;
908  };
909 
911  friend class ASTDeclReader;
912  friend class ImplicitParamDecl;
913  friend class VarDecl;
914 
915  unsigned : NumVarDeclBits;
916 
917  // FIXME: We need something similar to CXXRecordDecl::DefinitionData.
918  /// \brief Whether this variable is a definition which was demoted due to
919  /// module merge.
920  unsigned IsThisDeclarationADemotedDefinition : 1;
921 
922  /// \brief Whether this variable is the exception variable in a C++ catch
923  /// or an Objective-C @catch statement.
924  unsigned ExceptionVar : 1;
925 
926  /// \brief Whether this local variable could be allocated in the return
927  /// slot of its function, enabling the named return value optimization
928  /// (NRVO).
929  unsigned NRVOVariable : 1;
930 
931  /// \brief Whether this variable is the for-range-declaration in a C++0x
932  /// for-range statement.
933  unsigned CXXForRangeDecl : 1;
934 
935  /// \brief Whether this variable is an ARC pseudo-__strong
936  /// variable; see isARCPseudoStrong() for details.
937  unsigned ARCPseudoStrong : 1;
938 
939  /// \brief Whether this variable is (C++1z) inline.
940  unsigned IsInline : 1;
941 
942  /// \brief Whether this variable has (C++1z) inline explicitly specified.
943  unsigned IsInlineSpecified : 1;
944 
945  /// \brief Whether this variable is (C++0x) constexpr.
946  unsigned IsConstexpr : 1;
947 
948  /// \brief Whether this variable is the implicit variable for a lambda
949  /// init-capture.
950  unsigned IsInitCapture : 1;
951 
952  /// \brief Whether this local extern variable's previous declaration was
953  /// declared in the same block scope. This controls whether we should merge
954  /// the type of this declaration with its previous declaration.
955  unsigned PreviousDeclInSameBlockScope : 1;
956 
957  /// Defines kind of the ImplicitParamDecl: 'this', 'self', 'vtt', '_cmd' or
958  /// something else.
959  unsigned ImplicitParamKind : 3;
960  };
961 
962  union {
963  unsigned AllBits;
964  VarDeclBitfields VarDeclBits;
967  };
968 
969  VarDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
971  TypeSourceInfo *TInfo, StorageClass SC);
972 
974 
976  return getNextRedeclaration();
977  }
978 
980  return getPreviousDecl();
981  }
982 
984  return getMostRecentDecl();
985  }
986 
987 public:
989  using redecl_iterator = redeclarable_base::redecl_iterator;
990 
991  using redeclarable_base::redecls_begin;
992  using redeclarable_base::redecls_end;
993  using redeclarable_base::redecls;
994  using redeclarable_base::getPreviousDecl;
995  using redeclarable_base::getMostRecentDecl;
996  using redeclarable_base::isFirstDecl;
997 
998  static VarDecl *Create(ASTContext &C, DeclContext *DC,
999  SourceLocation StartLoc, SourceLocation IdLoc,
1001  StorageClass S);
1002 
1003  static VarDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1004 
1005  SourceRange getSourceRange() const override LLVM_READONLY;
1006 
1007  /// \brief Returns the storage class as written in the source. For the
1008  /// computed linkage of symbol, see getLinkage.
1009  StorageClass getStorageClass() const {
1010  return (StorageClass) VarDeclBits.SClass;
1011  }
1012  void setStorageClass(StorageClass SC);
1013 
1015  VarDeclBits.TSCSpec = TSC;
1016  assert(VarDeclBits.TSCSpec == TSC && "truncation");
1017  }
1019  return static_cast<ThreadStorageClassSpecifier>(VarDeclBits.TSCSpec);
1020  }
1021  TLSKind getTLSKind() const;
1022 
1023  /// hasLocalStorage - Returns true if a variable with function scope
1024  /// is a non-static local variable.
1025  bool hasLocalStorage() const {
1026  if (getStorageClass() == SC_None) {
1027  // OpenCL v1.2 s6.5.3: The __constant or constant address space name is
1028  // used to describe variables allocated in global memory and which are
1029  // accessed inside a kernel(s) as read-only variables. As such, variables
1030  // in constant address space cannot have local storage.
1031  if (getType().getAddressSpace() == LangAS::opencl_constant)
1032  return false;
1033  // Second check is for C++11 [dcl.stc]p4.
1034  return !isFileVarDecl() && getTSCSpec() == TSCS_unspecified;
1035  }
1036 
1037  // Global Named Register (GNU extension)
1038  if (getStorageClass() == SC_Register && !isLocalVarDeclOrParm())
1039  return false;
1040 
1041  // Return true for: Auto, Register.
1042  // Return false for: Extern, Static, PrivateExtern, OpenCLWorkGroupLocal.
1043 
1044  return getStorageClass() >= SC_Auto;
1045  }
1046 
1047  /// isStaticLocal - Returns true if a variable with function scope is a
1048  /// static local variable.
1049  bool isStaticLocal() const {
1050  return (getStorageClass() == SC_Static ||
1051  // C++11 [dcl.stc]p4
1052  (getStorageClass() == SC_None && getTSCSpec() == TSCS_thread_local))
1053  && !isFileVarDecl();
1054  }
1055 
1056  /// \brief Returns true if a variable has extern or __private_extern__
1057  /// storage.
1058  bool hasExternalStorage() const {
1059  return getStorageClass() == SC_Extern ||
1060  getStorageClass() == SC_PrivateExtern;
1061  }
1062 
1063  /// \brief Returns true for all variables that do not have local storage.
1064  ///
1065  /// This includes all global variables as well as static variables declared
1066  /// within a function.
1067  bool hasGlobalStorage() const { return !hasLocalStorage(); }
1068 
1069  /// \brief Get the storage duration of this variable, per C++ [basic.stc].
1071  return hasLocalStorage() ? SD_Automatic :
1072  getTSCSpec() ? SD_Thread : SD_Static;
1073  }
1074 
1075  /// \brief Compute the language linkage.
1076  LanguageLinkage getLanguageLinkage() const;
1077 
1078  /// \brief Determines whether this variable is a variable with
1079  /// external, C linkage.
1080  bool isExternC() const;
1081 
1082  /// \brief Determines whether this variable's context is, or is nested within,
1083  /// a C++ extern "C" linkage spec.
1084  bool isInExternCContext() const;
1085 
1086  /// \brief Determines whether this variable's context is, or is nested within,
1087  /// a C++ extern "C++" linkage spec.
1088  bool isInExternCXXContext() const;
1089 
1090  /// isLocalVarDecl - Returns true for local variable declarations
1091  /// other than parameters. Note that this includes static variables
1092  /// inside of functions. It also includes variables inside blocks.
1093  ///
1094  /// void foo() { int x; static int y; extern int z; }
1095  bool isLocalVarDecl() const {
1096  if (getKind() != Decl::Var && getKind() != Decl::Decomposition)
1097  return false;
1098  if (const DeclContext *DC = getLexicalDeclContext())
1099  return DC->getRedeclContext()->isFunctionOrMethod();
1100  return false;
1101  }
1102 
1103  /// \brief Similar to isLocalVarDecl but also includes parameters.
1104  bool isLocalVarDeclOrParm() const {
1105  return isLocalVarDecl() || getKind() == Decl::ParmVar;
1106  }
1107 
1108  /// isFunctionOrMethodVarDecl - Similar to isLocalVarDecl, but
1109  /// excludes variables declared in blocks.
1111  if (getKind() != Decl::Var && getKind() != Decl::Decomposition)
1112  return false;
1113  const DeclContext *DC = getLexicalDeclContext()->getRedeclContext();
1114  return DC->isFunctionOrMethod() && DC->getDeclKind() != Decl::Block;
1115  }
1116 
1117  /// \brief Determines whether this is a static data member.
1118  ///
1119  /// This will only be true in C++, and applies to, e.g., the
1120  /// variable 'x' in:
1121  /// \code
1122  /// struct S {
1123  /// static int x;
1124  /// };
1125  /// \endcode
1126  bool isStaticDataMember() const {
1127  // If it wasn't static, it would be a FieldDecl.
1128  return getKind() != Decl::ParmVar && getDeclContext()->isRecord();
1129  }
1130 
1131  VarDecl *getCanonicalDecl() override;
1132  const VarDecl *getCanonicalDecl() const {
1133  return const_cast<VarDecl*>(this)->getCanonicalDecl();
1134  }
1135 
1137  /// This declaration is only a declaration.
1139 
1140  /// This declaration is a tentative definition.
1142 
1143  /// This declaration is definitely a definition.
1144  Definition
1145  };
1146 
1147  /// \brief Check whether this declaration is a definition. If this could be
1148  /// a tentative definition (in C), don't check whether there's an overriding
1149  /// definition.
1150  DefinitionKind isThisDeclarationADefinition(ASTContext &) const;
1152  return isThisDeclarationADefinition(getASTContext());
1153  }
1154 
1155  /// \brief Check whether this variable is defined in this
1156  /// translation unit.
1159  return hasDefinition(getASTContext());
1160  }
1161 
1162  /// \brief Get the tentative definition that acts as the real definition in
1163  /// a TU. Returns null if there is a proper definition available.
1164  VarDecl *getActingDefinition();
1165  const VarDecl *getActingDefinition() const {
1166  return const_cast<VarDecl*>(this)->getActingDefinition();
1167  }
1168 
1169  /// \brief Get the real (not just tentative) definition for this declaration.
1172  return const_cast<VarDecl*>(this)->getDefinition(C);
1173  }
1175  return getDefinition(getASTContext());
1176  }
1177  const VarDecl *getDefinition() const {
1178  return const_cast<VarDecl*>(this)->getDefinition();
1179  }
1180 
1181  /// \brief Determine whether this is or was instantiated from an out-of-line
1182  /// definition of a static data member.
1183  bool isOutOfLine() const override;
1184 
1185  /// isFileVarDecl - Returns true for file scoped variable declaration.
1186  bool isFileVarDecl() const {
1187  Kind K = getKind();
1188  if (K == ParmVar || K == ImplicitParam)
1189  return false;
1190 
1191  if (getLexicalDeclContext()->getRedeclContext()->isFileContext())
1192  return true;
1193 
1194  if (isStaticDataMember())
1195  return true;
1196 
1197  return false;
1198  }
1199 
1200  /// getAnyInitializer - Get the initializer for this variable, no matter which
1201  /// declaration it is attached to.
1202  const Expr *getAnyInitializer() const {
1203  const VarDecl *D;
1204  return getAnyInitializer(D);
1205  }
1206 
1207  /// getAnyInitializer - Get the initializer for this variable, no matter which
1208  /// declaration it is attached to. Also get that declaration.
1209  const Expr *getAnyInitializer(const VarDecl *&D) const;
1210 
1211  bool hasInit() const;
1212  const Expr *getInit() const {
1213  return const_cast<VarDecl *>(this)->getInit();
1214  }
1215  Expr *getInit();
1216 
1217  /// \brief Retrieve the address of the initializer expression.
1218  Stmt **getInitAddress();
1219 
1220  void setInit(Expr *I);
1221 
1222  /// \brief Determine whether this variable's value can be used in a
1223  /// constant expression, according to the relevant language standard.
1224  /// This only checks properties of the declaration, and does not check
1225  /// whether the initializer is in fact a constant expression.
1226  bool isUsableInConstantExpressions(ASTContext &C) const;
1227 
1228  EvaluatedStmt *ensureEvaluatedStmt() const;
1229 
1230  /// \brief Attempt to evaluate the value of the initializer attached to this
1231  /// declaration, and produce notes explaining why it cannot be evaluated or is
1232  /// not a constant expression. Returns a pointer to the value if evaluation
1233  /// succeeded, 0 otherwise.
1234  APValue *evaluateValue() const;
1235  APValue *evaluateValue(SmallVectorImpl<PartialDiagnosticAt> &Notes) const;
1236 
1237  /// \brief Return the already-evaluated value of this variable's
1238  /// initializer, or NULL if the value is not yet known. Returns pointer
1239  /// to untyped APValue if the value could not be evaluated.
1240  APValue *getEvaluatedValue() const;
1241 
1242  /// \brief Determines whether it is already known whether the
1243  /// initializer is an integral constant expression or not.
1244  bool isInitKnownICE() const;
1245 
1246  /// \brief Determines whether the initializer is an integral constant
1247  /// expression, or in C++11, whether the initializer is a constant
1248  /// expression.
1249  ///
1250  /// \pre isInitKnownICE()
1251  bool isInitICE() const;
1252 
1253  /// \brief Determine whether the value of the initializer attached to this
1254  /// declaration is an integral constant expression.
1255  bool checkInitIsICE() const;
1256 
1258  VarDeclBits.InitStyle = Style;
1259  }
1260 
1261  /// \brief The style of initialization for this declaration.
1262  ///
1263  /// C-style initialization is "int x = 1;". Call-style initialization is
1264  /// a C++98 direct-initializer, e.g. "int x(1);". The Init expression will be
1265  /// the expression inside the parens or a "ClassType(a,b,c)" class constructor
1266  /// expression for class types. List-style initialization is C++11 syntax,
1267  /// e.g. "int x{1};". Clients can distinguish between different forms of
1268  /// initialization by checking this value. In particular, "int x = {1};" is
1269  /// C-style, "int x({1})" is call-style, and "int x{1};" is list-style; the
1270  /// Init expression in all three cases is an InitListExpr.
1272  return static_cast<InitializationStyle>(VarDeclBits.InitStyle);
1273  }
1274 
1275  /// \brief Whether the initializer is a direct-initializer (list or call).
1276  bool isDirectInit() const {
1277  return getInitStyle() != CInit;
1278  }
1279 
1280  /// \brief If this definition should pretend to be a declaration.
1282  return isa<ParmVarDecl>(this) ? false :
1283  NonParmVarDeclBits.IsThisDeclarationADemotedDefinition;
1284  }
1285 
1286  /// \brief This is a definition which should be demoted to a declaration.
1287  ///
1288  /// In some cases (mostly module merging) we can end up with two visible
1289  /// definitions one of which needs to be demoted to a declaration to keep
1290  /// the AST invariants.
1292  assert(isThisDeclarationADefinition() && "Not a definition!");
1293  assert(!isa<ParmVarDecl>(this) && "Cannot demote ParmVarDecls!");
1294  NonParmVarDeclBits.IsThisDeclarationADemotedDefinition = 1;
1295  }
1296 
1297  /// \brief Determine whether this variable is the exception variable in a
1298  /// C++ catch statememt or an Objective-C \@catch statement.
1299  bool isExceptionVariable() const {
1300  return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.ExceptionVar;
1301  }
1302  void setExceptionVariable(bool EV) {
1303  assert(!isa<ParmVarDecl>(this));
1304  NonParmVarDeclBits.ExceptionVar = EV;
1305  }
1306 
1307  /// \brief Determine whether this local variable can be used with the named
1308  /// return value optimization (NRVO).
1309  ///
1310  /// The named return value optimization (NRVO) works by marking certain
1311  /// non-volatile local variables of class type as NRVO objects. These
1312  /// locals can be allocated within the return slot of their containing
1313  /// function, in which case there is no need to copy the object to the
1314  /// return slot when returning from the function. Within the function body,
1315  /// each return that returns the NRVO object will have this variable as its
1316  /// NRVO candidate.
1317  bool isNRVOVariable() const {
1318  return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.NRVOVariable;
1319  }
1320  void setNRVOVariable(bool NRVO) {
1321  assert(!isa<ParmVarDecl>(this));
1322  NonParmVarDeclBits.NRVOVariable = NRVO;
1323  }
1324 
1325  /// \brief Determine whether this variable is the for-range-declaration in
1326  /// a C++0x for-range statement.
1327  bool isCXXForRangeDecl() const {
1328  return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.CXXForRangeDecl;
1329  }
1330  void setCXXForRangeDecl(bool FRD) {
1331  assert(!isa<ParmVarDecl>(this));
1332  NonParmVarDeclBits.CXXForRangeDecl = FRD;
1333  }
1334 
1335  /// \brief Determine whether this variable is an ARC pseudo-__strong
1336  /// variable. A pseudo-__strong variable has a __strong-qualified
1337  /// type but does not actually retain the object written into it.
1338  /// Generally such variables are also 'const' for safety.
1339  bool isARCPseudoStrong() const {
1340  return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.ARCPseudoStrong;
1341  }
1342  void setARCPseudoStrong(bool ps) {
1343  assert(!isa<ParmVarDecl>(this));
1344  NonParmVarDeclBits.ARCPseudoStrong = ps;
1345  }
1346 
1347  /// Whether this variable is (C++1z) inline.
1348  bool isInline() const {
1349  return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.IsInline;
1350  }
1351  bool isInlineSpecified() const {
1352  return isa<ParmVarDecl>(this) ? false
1353  : NonParmVarDeclBits.IsInlineSpecified;
1354  }
1356  assert(!isa<ParmVarDecl>(this));
1357  NonParmVarDeclBits.IsInline = true;
1358  NonParmVarDeclBits.IsInlineSpecified = true;
1359  }
1361  assert(!isa<ParmVarDecl>(this));
1362  NonParmVarDeclBits.IsInline = true;
1363  }
1364 
1365  /// Whether this variable is (C++11) constexpr.
1366  bool isConstexpr() const {
1367  return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.IsConstexpr;
1368  }
1369  void setConstexpr(bool IC) {
1370  assert(!isa<ParmVarDecl>(this));
1371  NonParmVarDeclBits.IsConstexpr = IC;
1372  }
1373 
1374  /// Whether this variable is the implicit variable for a lambda init-capture.
1375  bool isInitCapture() const {
1376  return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.IsInitCapture;
1377  }
1378  void setInitCapture(bool IC) {
1379  assert(!isa<ParmVarDecl>(this));
1380  NonParmVarDeclBits.IsInitCapture = IC;
1381  }
1382 
1383  /// Whether this local extern variable declaration's previous declaration
1384  /// was declared in the same block scope. Only correct in C++.
1386  return isa<ParmVarDecl>(this)
1387  ? false
1388  : NonParmVarDeclBits.PreviousDeclInSameBlockScope;
1389  }
1391  assert(!isa<ParmVarDecl>(this));
1392  NonParmVarDeclBits.PreviousDeclInSameBlockScope = Same;
1393  }
1394 
1395  /// \brief Retrieve the variable declaration from which this variable could
1396  /// be instantiated, if it is an instantiation (rather than a non-template).
1397  VarDecl *getTemplateInstantiationPattern() const;
1398 
1399  /// \brief If this variable is an instantiated static data member of a
1400  /// class template specialization, returns the templated static data member
1401  /// from which it was instantiated.
1402  VarDecl *getInstantiatedFromStaticDataMember() const;
1403 
1404  /// \brief If this variable is an instantiation of a variable template or a
1405  /// static data member of a class template, determine what kind of
1406  /// template specialization or instantiation this is.
1408 
1409  /// \brief If this variable is an instantiation of a variable template or a
1410  /// static data member of a class template, determine its point of
1411  /// instantiation.
1412  SourceLocation getPointOfInstantiation() const;
1413 
1414  /// \brief If this variable is an instantiation of a static data member of a
1415  /// class template specialization, retrieves the member specialization
1416  /// information.
1417  MemberSpecializationInfo *getMemberSpecializationInfo() const;
1418 
1419  /// \brief For a static data member that was instantiated from a static
1420  /// data member of a class template, set the template specialiation kind.
1421  void setTemplateSpecializationKind(TemplateSpecializationKind TSK,
1422  SourceLocation PointOfInstantiation = SourceLocation());
1423 
1424  /// \brief Specify that this variable is an instantiation of the
1425  /// static data member VD.
1426  void setInstantiationOfStaticDataMember(VarDecl *VD,
1428 
1429  /// \brief Retrieves the variable template that is described by this
1430  /// variable declaration.
1431  ///
1432  /// Every variable template is represented as a VarTemplateDecl and a
1433  /// VarDecl. The former contains template properties (such as
1434  /// the template parameter lists) while the latter contains the
1435  /// actual description of the template's
1436  /// contents. VarTemplateDecl::getTemplatedDecl() retrieves the
1437  /// VarDecl that from a VarTemplateDecl, while
1438  /// getDescribedVarTemplate() retrieves the VarTemplateDecl from
1439  /// a VarDecl.
1440  VarTemplateDecl *getDescribedVarTemplate() const;
1441 
1442  void setDescribedVarTemplate(VarTemplateDecl *Template);
1443 
1444  // Implement isa/cast/dyncast/etc.
1445  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1446  static bool classofKind(Kind K) { return K >= firstVar && K <= lastVar; }
1447 };
1448 
1449 class ImplicitParamDecl : public VarDecl {
1450  void anchor() override;
1451 
1452 public:
1453  /// Defines the kind of the implicit parameter: is this an implicit parameter
1454  /// with pointer to 'this', 'self', '_cmd', virtual table pointers, captured
1455  /// context or something else.
1456  enum ImplicitParamKind : unsigned {
1457  /// Parameter for Objective-C 'self' argument
1459 
1460  /// Parameter for Objective-C '_cmd' argument
1462 
1463  /// Parameter for C++ 'this' argument
1465 
1466  /// Parameter for C++ virtual table pointers
1468 
1469  /// Parameter for captured context
1471 
1472  /// Other implicit parameter
1474  };
1475 
1476  /// Create implicit parameter.
1479  QualType T, ImplicitParamKind ParamKind);
1481  ImplicitParamKind ParamKind);
1482 
1483  static ImplicitParamDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1484 
1487  ImplicitParamKind ParamKind)
1488  : VarDecl(ImplicitParam, C, DC, IdLoc, IdLoc, Id, Type,
1489  /*TInfo=*/nullptr, SC_None) {
1490  NonParmVarDeclBits.ImplicitParamKind = ParamKind;
1491  setImplicit();
1492  }
1493 
1495  : VarDecl(ImplicitParam, C, /*DC=*/nullptr, SourceLocation(),
1496  SourceLocation(), /*Id=*/nullptr, Type,
1497  /*TInfo=*/nullptr, SC_None) {
1498  NonParmVarDeclBits.ImplicitParamKind = ParamKind;
1499  setImplicit();
1500  }
1501 
1502  /// Returns the implicit parameter kind.
1504  return static_cast<ImplicitParamKind>(NonParmVarDeclBits.ImplicitParamKind);
1505  }
1506 
1507  // Implement isa/cast/dyncast/etc.
1508  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1509  static bool classofKind(Kind K) { return K == ImplicitParam; }
1510 };
1511 
1512 /// ParmVarDecl - Represents a parameter to a function.
1513 class ParmVarDecl : public VarDecl {
1514 public:
1515  enum { MaxFunctionScopeDepth = 255 };
1516  enum { MaxFunctionScopeIndex = 255 };
1517 
1518 protected:
1521  TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
1522  : VarDecl(DK, C, DC, StartLoc, IdLoc, Id, T, TInfo, S) {
1523  assert(ParmVarDeclBits.HasInheritedDefaultArg == false);
1524  assert(ParmVarDeclBits.DefaultArgKind == DAK_None);
1525  assert(ParmVarDeclBits.IsKNRPromoted == false);
1526  assert(ParmVarDeclBits.IsObjCMethodParam == false);
1527  setDefaultArg(DefArg);
1528  }
1529 
1530 public:
1531  static ParmVarDecl *Create(ASTContext &C, DeclContext *DC,
1532  SourceLocation StartLoc,
1534  QualType T, TypeSourceInfo *TInfo,
1535  StorageClass S, Expr *DefArg);
1536 
1537  static ParmVarDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1538 
1539  SourceRange getSourceRange() const override LLVM_READONLY;
1540 
1541  void setObjCMethodScopeInfo(unsigned parameterIndex) {
1542  ParmVarDeclBits.IsObjCMethodParam = true;
1543  setParameterIndex(parameterIndex);
1544  }
1545 
1546  void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex) {
1547  assert(!ParmVarDeclBits.IsObjCMethodParam);
1548 
1549  ParmVarDeclBits.ScopeDepthOrObjCQuals = scopeDepth;
1550  assert(ParmVarDeclBits.ScopeDepthOrObjCQuals == scopeDepth
1551  && "truncation!");
1552 
1553  setParameterIndex(parameterIndex);
1554  }
1555 
1556  bool isObjCMethodParameter() const {
1557  return ParmVarDeclBits.IsObjCMethodParam;
1558  }
1559 
1560  unsigned getFunctionScopeDepth() const {
1561  if (ParmVarDeclBits.IsObjCMethodParam) return 0;
1562  return ParmVarDeclBits.ScopeDepthOrObjCQuals;
1563  }
1564 
1565  /// Returns the index of this parameter in its prototype or method scope.
1566  unsigned getFunctionScopeIndex() const {
1567  return getParameterIndex();
1568  }
1569 
1571  if (!ParmVarDeclBits.IsObjCMethodParam) return OBJC_TQ_None;
1572  return ObjCDeclQualifier(ParmVarDeclBits.ScopeDepthOrObjCQuals);
1573  }
1575  assert(ParmVarDeclBits.IsObjCMethodParam);
1576  ParmVarDeclBits.ScopeDepthOrObjCQuals = QTVal;
1577  }
1578 
1579  /// True if the value passed to this parameter must undergo
1580  /// K&R-style default argument promotion:
1581  ///
1582  /// C99 6.5.2.2.
1583  /// If the expression that denotes the called function has a type
1584  /// that does not include a prototype, the integer promotions are
1585  /// performed on each argument, and arguments that have type float
1586  /// are promoted to double.
1587  bool isKNRPromoted() const {
1588  return ParmVarDeclBits.IsKNRPromoted;
1589  }
1590  void setKNRPromoted(bool promoted) {
1591  ParmVarDeclBits.IsKNRPromoted = promoted;
1592  }
1593 
1594  Expr *getDefaultArg();
1595  const Expr *getDefaultArg() const {
1596  return const_cast<ParmVarDecl *>(this)->getDefaultArg();
1597  }
1598 
1599  void setDefaultArg(Expr *defarg);
1600 
1601  /// \brief Retrieve the source range that covers the entire default
1602  /// argument.
1603  SourceRange getDefaultArgRange() const;
1604  void setUninstantiatedDefaultArg(Expr *arg);
1605  Expr *getUninstantiatedDefaultArg();
1607  return const_cast<ParmVarDecl *>(this)->getUninstantiatedDefaultArg();
1608  }
1609 
1610  /// hasDefaultArg - Determines whether this parameter has a default argument,
1611  /// either parsed or not.
1612  bool hasDefaultArg() const;
1613 
1614  /// hasUnparsedDefaultArg - Determines whether this parameter has a
1615  /// default argument that has not yet been parsed. This will occur
1616  /// during the processing of a C++ class whose member functions have
1617  /// default arguments, e.g.,
1618  /// @code
1619  /// class X {
1620  /// public:
1621  /// void f(int x = 17); // x has an unparsed default argument now
1622  /// }; // x has a regular default argument now
1623  /// @endcode
1624  bool hasUnparsedDefaultArg() const {
1625  return ParmVarDeclBits.DefaultArgKind == DAK_Unparsed;
1626  }
1627 
1629  return ParmVarDeclBits.DefaultArgKind == DAK_Uninstantiated;
1630  }
1631 
1632  /// setUnparsedDefaultArg - Specify that this parameter has an
1633  /// unparsed default argument. The argument will be replaced with a
1634  /// real default argument via setDefaultArg when the class
1635  /// definition enclosing the function declaration that owns this
1636  /// default argument is completed.
1638  ParmVarDeclBits.DefaultArgKind = DAK_Unparsed;
1639  }
1640 
1641  bool hasInheritedDefaultArg() const {
1642  return ParmVarDeclBits.HasInheritedDefaultArg;
1643  }
1644 
1645  void setHasInheritedDefaultArg(bool I = true) {
1646  ParmVarDeclBits.HasInheritedDefaultArg = I;
1647  }
1648 
1649  QualType getOriginalType() const;
1650 
1651  /// \brief Determine whether this parameter is actually a function
1652  /// parameter pack.
1653  bool isParameterPack() const;
1654 
1655  /// setOwningFunction - Sets the function declaration that owns this
1656  /// ParmVarDecl. Since ParmVarDecls are often created before the
1657  /// FunctionDecls that own them, this routine is required to update
1658  /// the DeclContext appropriately.
1659  void setOwningFunction(DeclContext *FD) { setDeclContext(FD); }
1660 
1661  // Implement isa/cast/dyncast/etc.
1662  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1663  static bool classofKind(Kind K) { return K == ParmVar; }
1664 
1665 private:
1666  enum { ParameterIndexSentinel = (1 << NumParameterIndexBits) - 1 };
1667 
1668  void setParameterIndex(unsigned parameterIndex) {
1669  if (parameterIndex >= ParameterIndexSentinel) {
1670  setParameterIndexLarge(parameterIndex);
1671  return;
1672  }
1673 
1674  ParmVarDeclBits.ParameterIndex = parameterIndex;
1675  assert(ParmVarDeclBits.ParameterIndex == parameterIndex && "truncation!");
1676  }
1677  unsigned getParameterIndex() const {
1678  unsigned d = ParmVarDeclBits.ParameterIndex;
1679  return d == ParameterIndexSentinel ? getParameterIndexLarge() : d;
1680  }
1681 
1682  void setParameterIndexLarge(unsigned parameterIndex);
1683  unsigned getParameterIndexLarge() const;
1684 };
1685 
1686 /// An instance of this class is created to represent a function declaration or
1687 /// definition.
1688 ///
1689 /// Since a given function can be declared several times in a program,
1690 /// there may be several FunctionDecls that correspond to that
1691 /// function. Only one of those FunctionDecls will be found when
1692 /// traversing the list of declarations in the context of the
1693 /// FunctionDecl (e.g., the translation unit); this FunctionDecl
1694 /// contains all of the information known about the function. Other,
1695 /// previous declarations of the function are available via the
1696 /// getPreviousDecl() chain.
1697 class FunctionDecl : public DeclaratorDecl, public DeclContext,
1698  public Redeclarable<FunctionDecl> {
1699 public:
1700  /// \brief The kind of templated function a FunctionDecl can be.
1706  TK_DependentFunctionTemplateSpecialization
1707  };
1708 
1709 private:
1710  /// ParamInfo - new[]'d array of pointers to VarDecls for the formal
1711  /// parameters of this function. This is null if a prototype or if there are
1712  /// no formals.
1713  ParmVarDecl **ParamInfo = nullptr;
1714 
1715  LazyDeclStmtPtr Body;
1716 
1717  // FIXME: This can be packed into the bitfields in DeclContext.
1718  // NOTE: VC++ packs bitfields poorly if the types differ.
1719  unsigned SClass : 3;
1720  unsigned IsInline : 1;
1721  unsigned IsInlineSpecified : 1;
1722 
1723 protected:
1724  // This is shared by CXXConstructorDecl, CXXConversionDecl, and
1725  // CXXDeductionGuideDecl.
1726  unsigned IsExplicitSpecified : 1;
1727 
1728 private:
1729  unsigned IsVirtualAsWritten : 1;
1730  unsigned IsPure : 1;
1731  unsigned HasInheritedPrototype : 1;
1732  unsigned HasWrittenPrototype : 1;
1733  unsigned IsDeleted : 1;
1734  unsigned IsTrivial : 1; // sunk from CXXMethodDecl
1735  unsigned IsDefaulted : 1; // sunk from CXXMethoDecl
1736  unsigned IsExplicitlyDefaulted : 1; //sunk from CXXMethodDecl
1737  unsigned HasImplicitReturnZero : 1;
1738  unsigned IsLateTemplateParsed : 1;
1739  unsigned IsConstexpr : 1;
1740  unsigned InstantiationIsPending : 1;
1741 
1742  /// \brief Indicates if the function uses __try.
1743  unsigned UsesSEHTry : 1;
1744 
1745  /// \brief Indicates if the function was a definition but its body was
1746  /// skipped.
1747  unsigned HasSkippedBody : 1;
1748 
1749  /// Indicates if the function declaration will have a body, once we're done
1750  /// parsing it.
1751  unsigned WillHaveBody : 1;
1752 
1753 protected:
1754  /// [C++17] Only used by CXXDeductionGuideDecl. Declared here to avoid
1755  /// increasing the size of CXXDeductionGuideDecl by the size of an unsigned
1756  /// int as opposed to adding a single bit to FunctionDecl.
1757  /// Indicates that the Deduction Guide is the implicitly generated 'copy
1758  /// deduction candidate' (is used during overload resolution).
1760 
1761 private:
1762 
1763  /// Store the ODRHash after first calculation.
1764  unsigned HasODRHash : 1;
1765  unsigned ODRHash;
1766 
1767  /// \brief End part of this FunctionDecl's source range.
1768  ///
1769  /// We could compute the full range in getSourceRange(). However, when we're
1770  /// dealing with a function definition deserialized from a PCH/AST file,
1771  /// we can only compute the full range once the function body has been
1772  /// de-serialized, so it's far better to have the (sometimes-redundant)
1773  /// EndRangeLoc.
1774  SourceLocation EndRangeLoc;
1775 
1776  /// \brief The template or declaration that this declaration
1777  /// describes or was instantiated from, respectively.
1778  ///
1779  /// For non-templates, this value will be NULL. For function
1780  /// declarations that describe a function template, this will be a
1781  /// pointer to a FunctionTemplateDecl. For member functions
1782  /// of class template specializations, this will be a MemberSpecializationInfo
1783  /// pointer containing information about the specialization.
1784  /// For function template specializations, this will be a
1785  /// FunctionTemplateSpecializationInfo, which contains information about
1786  /// the template being specialized and the template arguments involved in
1787  /// that specialization.
1788  llvm::PointerUnion4<FunctionTemplateDecl *,
1792  TemplateOrSpecialization;
1793 
1794  /// Provides source/type location info for the declaration name embedded in
1795  /// the DeclaratorDecl base class.
1796  DeclarationNameLoc DNLoc;
1797 
1798  /// \brief Specify that this function declaration is actually a function
1799  /// template specialization.
1800  ///
1801  /// \param C the ASTContext.
1802  ///
1803  /// \param Template the function template that this function template
1804  /// specialization specializes.
1805  ///
1806  /// \param TemplateArgs the template arguments that produced this
1807  /// function template specialization from the template.
1808  ///
1809  /// \param InsertPos If non-NULL, the position in the function template
1810  /// specialization set where the function template specialization data will
1811  /// be inserted.
1812  ///
1813  /// \param TSK the kind of template specialization this is.
1814  ///
1815  /// \param TemplateArgsAsWritten location info of template arguments.
1816  ///
1817  /// \param PointOfInstantiation point at which the function template
1818  /// specialization was first instantiated.
1819  void setFunctionTemplateSpecialization(ASTContext &C,
1820  FunctionTemplateDecl *Template,
1821  const TemplateArgumentList *TemplateArgs,
1822  void *InsertPos,
1824  const TemplateArgumentListInfo *TemplateArgsAsWritten,
1825  SourceLocation PointOfInstantiation);
1826 
1827  /// \brief Specify that this record is an instantiation of the
1828  /// member function FD.
1829  void setInstantiationOfMemberFunction(ASTContext &C, FunctionDecl *FD,
1831 
1832  void setParams(ASTContext &C, ArrayRef<ParmVarDecl *> NewParamInfo);
1833 
1834 protected:
1836  const DeclarationNameInfo &NameInfo, QualType T,
1837  TypeSourceInfo *TInfo, StorageClass S, bool isInlineSpecified,
1838  bool isConstexprSpecified)
1839  : DeclaratorDecl(DK, DC, NameInfo.getLoc(), NameInfo.getName(), T, TInfo,
1840  StartLoc),
1841  DeclContext(DK), redeclarable_base(C), SClass(S),
1842  IsInline(isInlineSpecified), IsInlineSpecified(isInlineSpecified),
1843  IsExplicitSpecified(false), IsVirtualAsWritten(false), IsPure(false),
1844  HasInheritedPrototype(false), HasWrittenPrototype(true),
1845  IsDeleted(false), IsTrivial(false), IsDefaulted(false),
1846  IsExplicitlyDefaulted(false), HasImplicitReturnZero(false),
1847  IsLateTemplateParsed(false), IsConstexpr(isConstexprSpecified),
1848  InstantiationIsPending(false), UsesSEHTry(false), HasSkippedBody(false),
1849  WillHaveBody(false), IsCopyDeductionCandidate(false), HasODRHash(false),
1850  ODRHash(0), EndRangeLoc(NameInfo.getEndLoc()),
1851  DNLoc(NameInfo.getInfo()) {}
1852 
1854 
1856  return getNextRedeclaration();
1857  }
1858 
1860  return getPreviousDecl();
1861  }
1862 
1864  return getMostRecentDecl();
1865  }
1866 
1867 public:
1868  friend class ASTDeclReader;
1869  friend class ASTDeclWriter;
1870 
1872  using redecl_iterator = redeclarable_base::redecl_iterator;
1873 
1874  using redeclarable_base::redecls_begin;
1875  using redeclarable_base::redecls_end;
1876  using redeclarable_base::redecls;
1877  using redeclarable_base::getPreviousDecl;
1878  using redeclarable_base::getMostRecentDecl;
1879  using redeclarable_base::isFirstDecl;
1880 
1882  SourceLocation StartLoc, SourceLocation NLoc,
1884  TypeSourceInfo *TInfo,
1885  StorageClass SC,
1886  bool isInlineSpecified = false,
1887  bool hasWrittenPrototype = true,
1888  bool isConstexprSpecified = false) {
1889  DeclarationNameInfo NameInfo(N, NLoc);
1890  return FunctionDecl::Create(C, DC, StartLoc, NameInfo, T, TInfo,
1891  SC,
1892  isInlineSpecified, hasWrittenPrototype,
1893  isConstexprSpecified);
1894  }
1895 
1896  static FunctionDecl *Create(ASTContext &C, DeclContext *DC,
1897  SourceLocation StartLoc,
1898  const DeclarationNameInfo &NameInfo,
1899  QualType T, TypeSourceInfo *TInfo,
1900  StorageClass SC,
1901  bool isInlineSpecified,
1902  bool hasWrittenPrototype,
1903  bool isConstexprSpecified = false);
1904 
1905  static FunctionDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1906 
1908  return DeclarationNameInfo(getDeclName(), getLocation(), DNLoc);
1909  }
1910 
1911  void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy,
1912  bool Qualified) const override;
1913 
1914  void setRangeEnd(SourceLocation E) { EndRangeLoc = E; }
1915 
1916  SourceRange getSourceRange() const override LLVM_READONLY;
1917 
1918  /// \brief Returns true if the function has a body (definition). The
1919  /// function body might be in any of the (re-)declarations of this
1920  /// function. The variant that accepts a FunctionDecl pointer will
1921  /// set that function declaration to the actual declaration
1922  /// containing the body (if there is one).
1923  bool hasBody(const FunctionDecl *&Definition) const;
1924 
1925  bool hasBody() const override {
1926  const FunctionDecl* Definition;
1927  return hasBody(Definition);
1928  }
1929 
1930  /// Returns whether the function has a trivial body that does not require any
1931  /// specific codegen.
1932  bool hasTrivialBody() const;
1933 
1934  /// Returns true if the function is defined at all, including a deleted
1935  /// definition. Except for the behavior when the function is deleted, behaves
1936  /// like hasBody.
1937  bool isDefined(const FunctionDecl *&Definition) const;
1938 
1939  virtual bool isDefined() const {
1940  const FunctionDecl* Definition;
1941  return isDefined(Definition);
1942  }
1943 
1944  /// \brief Get the definition for this declaration.
1946  const FunctionDecl *Definition;
1947  if (isDefined(Definition))
1948  return const_cast<FunctionDecl *>(Definition);
1949  return nullptr;
1950  }
1951  const FunctionDecl *getDefinition() const {
1952  return const_cast<FunctionDecl *>(this)->getDefinition();
1953  }
1954 
1955  /// Retrieve the body (definition) of the function. The function body might be
1956  /// in any of the (re-)declarations of this function. The variant that accepts
1957  /// a FunctionDecl pointer will set that function declaration to the actual
1958  /// declaration containing the body (if there is one).
1959  /// NOTE: For checking if there is a body, use hasBody() instead, to avoid
1960  /// unnecessary AST de-serialization of the body.
1961  Stmt *getBody(const FunctionDecl *&Definition) const;
1962 
1963  Stmt *getBody() const override {
1964  const FunctionDecl* Definition;
1965  return getBody(Definition);
1966  }
1967 
1968  /// Returns whether this specific declaration of the function is also a
1969  /// definition that does not contain uninstantiated body.
1970  ///
1971  /// This does not determine whether the function has been defined (e.g., in a
1972  /// previous definition); for that information, use isDefined.
1974  return IsDeleted || IsDefaulted || Body || HasSkippedBody ||
1975  IsLateTemplateParsed || WillHaveBody || hasDefiningAttr();
1976  }
1977 
1978  /// Returns whether this specific declaration of the function has a body -
1979  /// that is, if it is a non-deleted definition.
1981  return Body || IsLateTemplateParsed;
1982  }
1983 
1984  void setBody(Stmt *B);
1985  void setLazyBody(uint64_t Offset) { Body = Offset; }
1986 
1987  /// Whether this function is variadic.
1988  bool isVariadic() const;
1989 
1990  /// Whether this function is marked as virtual explicitly.
1991  bool isVirtualAsWritten() const { return IsVirtualAsWritten; }
1992  void setVirtualAsWritten(bool V) { IsVirtualAsWritten = V; }
1993 
1994  /// Whether this virtual function is pure, i.e. makes the containing class
1995  /// abstract.
1996  bool isPure() const { return IsPure; }
1997  void setPure(bool P = true);
1998 
1999  /// Whether this templated function will be late parsed.
2000  bool isLateTemplateParsed() const { return IsLateTemplateParsed; }
2001  void setLateTemplateParsed(bool ILT = true) { IsLateTemplateParsed = ILT; }
2002 
2003  /// Whether this function is "trivial" in some specialized C++ senses.
2004  /// Can only be true for default constructors, copy constructors,
2005  /// copy assignment operators, and destructors. Not meaningful until
2006  /// the class has been fully built by Sema.
2007  bool isTrivial() const { return IsTrivial; }
2008  void setTrivial(bool IT) { IsTrivial = IT; }
2009 
2010  /// Whether this function is defaulted per C++0x. Only valid for
2011  /// special member functions.
2012  bool isDefaulted() const { return IsDefaulted; }
2013  void setDefaulted(bool D = true) { IsDefaulted = D; }
2014 
2015  /// Whether this function is explicitly defaulted per C++0x. Only valid
2016  /// for special member functions.
2017  bool isExplicitlyDefaulted() const { return IsExplicitlyDefaulted; }
2018  void setExplicitlyDefaulted(bool ED = true) { IsExplicitlyDefaulted = ED; }
2019 
2020  /// Whether falling off this function implicitly returns null/zero.
2021  /// If a more specific implicit return value is required, front-ends
2022  /// should synthesize the appropriate return statements.
2023  bool hasImplicitReturnZero() const { return HasImplicitReturnZero; }
2024  void setHasImplicitReturnZero(bool IRZ) { HasImplicitReturnZero = IRZ; }
2025 
2026  /// \brief Whether this function has a prototype, either because one
2027  /// was explicitly written or because it was "inherited" by merging
2028  /// a declaration without a prototype with a declaration that has a
2029  /// prototype.
2030  bool hasPrototype() const {
2031  return HasWrittenPrototype || HasInheritedPrototype;
2032  }
2033 
2034  bool hasWrittenPrototype() const { return HasWrittenPrototype; }
2035 
2036  /// \brief Whether this function inherited its prototype from a
2037  /// previous declaration.
2038  bool hasInheritedPrototype() const { return HasInheritedPrototype; }
2039  void setHasInheritedPrototype(bool P = true) { HasInheritedPrototype = P; }
2040 
2041  /// Whether this is a (C++11) constexpr function or constexpr constructor.
2042  bool isConstexpr() const { return IsConstexpr; }
2043  void setConstexpr(bool IC) { IsConstexpr = IC; }
2044 
2045  /// \brief Whether the instantiation of this function is pending.
2046  /// This bit is set when the decision to instantiate this function is made
2047  /// and unset if and when the function body is created. That leaves out
2048  /// cases where instantiation did not happen because the template definition
2049  /// was not seen in this TU. This bit remains set in those cases, under the
2050  /// assumption that the instantiation will happen in some other TU.
2051  bool instantiationIsPending() const { return InstantiationIsPending; }
2052  void setInstantiationIsPending(bool IC) { InstantiationIsPending = IC; }
2053 
2054  /// \brief Indicates the function uses __try.
2055  bool usesSEHTry() const { return UsesSEHTry; }
2056  void setUsesSEHTry(bool UST) { UsesSEHTry = UST; }
2057 
2058  /// \brief Whether this function has been deleted.
2059  ///
2060  /// A function that is "deleted" (via the C++0x "= delete" syntax)
2061  /// acts like a normal function, except that it cannot actually be
2062  /// called or have its address taken. Deleted functions are
2063  /// typically used in C++ overload resolution to attract arguments
2064  /// whose type or lvalue/rvalue-ness would permit the use of a
2065  /// different overload that would behave incorrectly. For example,
2066  /// one might use deleted functions to ban implicit conversion from
2067  /// a floating-point number to an Integer type:
2068  ///
2069  /// @code
2070  /// struct Integer {
2071  /// Integer(long); // construct from a long
2072  /// Integer(double) = delete; // no construction from float or double
2073  /// Integer(long double) = delete; // no construction from long double
2074  /// };
2075  /// @endcode
2076  // If a function is deleted, its first declaration must be.
2077  bool isDeleted() const { return getCanonicalDecl()->IsDeleted; }
2078  bool isDeletedAsWritten() const { return IsDeleted && !IsDefaulted; }
2079  void setDeletedAsWritten(bool D = true) { IsDeleted = D; }
2080 
2081  /// \brief Determines whether this function is "main", which is the
2082  /// entry point into an executable program.
2083  bool isMain() const;
2084 
2085  /// \brief Determines whether this function is a MSVCRT user defined entry
2086  /// point.
2087  bool isMSVCRTEntryPoint() const;
2088 
2089  /// \brief Determines whether this operator new or delete is one
2090  /// of the reserved global placement operators:
2091  /// void *operator new(size_t, void *);
2092  /// void *operator new[](size_t, void *);
2093  /// void operator delete(void *, void *);
2094  /// void operator delete[](void *, void *);
2095  /// These functions have special behavior under [new.delete.placement]:
2096  /// These functions are reserved, a C++ program may not define
2097  /// functions that displace the versions in the Standard C++ library.
2098  /// The provisions of [basic.stc.dynamic] do not apply to these
2099  /// reserved placement forms of operator new and operator delete.
2100  ///
2101  /// This function must be an allocation or deallocation function.
2102  bool isReservedGlobalPlacementOperator() const;
2103 
2104  /// \brief Determines whether this function is one of the replaceable
2105  /// global allocation functions:
2106  /// void *operator new(size_t);
2107  /// void *operator new(size_t, const std::nothrow_t &) noexcept;
2108  /// void *operator new[](size_t);
2109  /// void *operator new[](size_t, const std::nothrow_t &) noexcept;
2110  /// void operator delete(void *) noexcept;
2111  /// void operator delete(void *, std::size_t) noexcept; [C++1y]
2112  /// void operator delete(void *, const std::nothrow_t &) noexcept;
2113  /// void operator delete[](void *) noexcept;
2114  /// void operator delete[](void *, std::size_t) noexcept; [C++1y]
2115  /// void operator delete[](void *, const std::nothrow_t &) noexcept;
2116  /// These functions have special behavior under C++1y [expr.new]:
2117  /// An implementation is allowed to omit a call to a replaceable global
2118  /// allocation function. [...]
2119  ///
2120  /// If this function is an aligned allocation/deallocation function, return
2121  /// true through IsAligned.
2122  bool isReplaceableGlobalAllocationFunction(bool *IsAligned = nullptr) const;
2123 
2124  /// \brief Determine whether this is a destroying operator delete.
2125  bool isDestroyingOperatorDelete() const;
2126 
2127  /// Compute the language linkage.
2128  LanguageLinkage getLanguageLinkage() const;
2129 
2130  /// \brief Determines whether this function is a function with
2131  /// external, C linkage.
2132  bool isExternC() const;
2133 
2134  /// \brief Determines whether this function's context is, or is nested within,
2135  /// a C++ extern "C" linkage spec.
2136  bool isInExternCContext() const;
2137 
2138  /// \brief Determines whether this function's context is, or is nested within,
2139  /// a C++ extern "C++" linkage spec.
2140  bool isInExternCXXContext() const;
2141 
2142  /// \brief Determines whether this is a global function.
2143  bool isGlobal() const;
2144 
2145  /// \brief Determines whether this function is known to be 'noreturn', through
2146  /// an attribute on its declaration or its type.
2147  bool isNoReturn() const;
2148 
2149  /// \brief True if the function was a definition but its body was skipped.
2150  bool hasSkippedBody() const { return HasSkippedBody; }
2151  void setHasSkippedBody(bool Skipped = true) { HasSkippedBody = Skipped; }
2152 
2153  /// True if this function will eventually have a body, once it's fully parsed.
2154  bool willHaveBody() const { return WillHaveBody; }
2155  void setWillHaveBody(bool V = true) { WillHaveBody = V; }
2156 
2157  void setPreviousDeclaration(FunctionDecl * PrevDecl);
2158 
2159  FunctionDecl *getCanonicalDecl() override;
2161  return const_cast<FunctionDecl*>(this)->getCanonicalDecl();
2162  }
2163 
2164  unsigned getBuiltinID() const;
2165 
2166  // ArrayRef interface to parameters.
2168  return {ParamInfo, getNumParams()};
2169  }
2171  return {ParamInfo, getNumParams()};
2172  }
2173 
2174  // Iterator access to formal parameters.
2177 
2178  bool param_empty() const { return parameters().empty(); }
2179  param_iterator param_begin() { return parameters().begin(); }
2180  param_iterator param_end() { return parameters().end(); }
2181  param_const_iterator param_begin() const { return parameters().begin(); }
2182  param_const_iterator param_end() const { return parameters().end(); }
2183  size_t param_size() const { return parameters().size(); }
2184 
2185  /// Return the number of parameters this function must have based on its
2186  /// FunctionType. This is the length of the ParamInfo array after it has been
2187  /// created.
2188  unsigned getNumParams() const;
2189 
2190  const ParmVarDecl *getParamDecl(unsigned i) const {
2191  assert(i < getNumParams() && "Illegal param #");
2192  return ParamInfo[i];
2193  }
2194  ParmVarDecl *getParamDecl(unsigned i) {
2195  assert(i < getNumParams() && "Illegal param #");
2196  return ParamInfo[i];
2197  }
2198  void setParams(ArrayRef<ParmVarDecl *> NewParamInfo) {
2199  setParams(getASTContext(), NewParamInfo);
2200  }
2201 
2202  /// Returns the minimum number of arguments needed to call this function. This
2203  /// may be fewer than the number of function parameters, if some of the
2204  /// parameters have default arguments (in C++).
2205  unsigned getMinRequiredArguments() const;
2206 
2208  assert(getType()->getAs<FunctionType>() && "Expected a FunctionType!");
2209  return getType()->getAs<FunctionType>()->getReturnType();
2210  }
2211 
2212  /// \brief Attempt to compute an informative source range covering the
2213  /// function return type. This may omit qualifiers and other information with
2214  /// limited representation in the AST.
2215  SourceRange getReturnTypeSourceRange() const;
2216 
2217  /// \brief Attempt to compute an informative source range covering the
2218  /// function exception specification, if any.
2219  SourceRange getExceptionSpecSourceRange() const;
2220 
2221  /// \brief Determine the type of an expression that calls this function.
2223  assert(getType()->getAs<FunctionType>() && "Expected a FunctionType!");
2224  return getType()->getAs<FunctionType>()->getCallResultType(getASTContext());
2225  }
2226 
2227  /// \brief Returns the WarnUnusedResultAttr that is either declared on this
2228  /// function, or its return type declaration.
2229  const Attr *getUnusedResultAttr() const;
2230 
2231  /// \brief Returns true if this function or its return type has the
2232  /// warn_unused_result attribute.
2233  bool hasUnusedResultAttr() const { return getUnusedResultAttr() != nullptr; }
2234 
2235  /// \brief Returns the storage class as written in the source. For the
2236  /// computed linkage of symbol, see getLinkage.
2237  StorageClass getStorageClass() const { return StorageClass(SClass); }
2238 
2239  /// \brief Determine whether the "inline" keyword was specified for this
2240  /// function.
2241  bool isInlineSpecified() const { return IsInlineSpecified; }
2242 
2243  /// Set whether the "inline" keyword was specified for this function.
2244  void setInlineSpecified(bool I) {
2245  IsInlineSpecified = I;
2246  IsInline = I;
2247  }
2248 
2249  /// Flag that this function is implicitly inline.
2251  IsInline = true;
2252  }
2253 
2254  /// \brief Determine whether this function should be inlined, because it is
2255  /// either marked "inline" or "constexpr" or is a member function of a class
2256  /// that was defined in the class body.
2257  bool isInlined() const { return IsInline; }
2258 
2259  bool isInlineDefinitionExternallyVisible() const;
2260 
2261  bool isMSExternInline() const;
2262 
2263  bool doesDeclarationForceExternallyVisibleDefinition() const;
2264 
2265  /// isOverloadedOperator - Whether this function declaration
2266  /// represents an C++ overloaded operator, e.g., "operator+".
2267  bool isOverloadedOperator() const {
2268  return getOverloadedOperator() != OO_None;
2269  }
2270 
2271  OverloadedOperatorKind getOverloadedOperator() const;
2272 
2273  const IdentifierInfo *getLiteralIdentifier() const;
2274 
2275  /// \brief If this function is an instantiation of a member function
2276  /// of a class template specialization, retrieves the function from
2277  /// which it was instantiated.
2278  ///
2279  /// This routine will return non-NULL for (non-templated) member
2280  /// functions of class templates and for instantiations of function
2281  /// templates. For example, given:
2282  ///
2283  /// \code
2284  /// template<typename T>
2285  /// struct X {
2286  /// void f(T);
2287  /// };
2288  /// \endcode
2289  ///
2290  /// The declaration for X<int>::f is a (non-templated) FunctionDecl
2291  /// whose parent is the class template specialization X<int>. For
2292  /// this declaration, getInstantiatedFromFunction() will return
2293  /// the FunctionDecl X<T>::A. When a complete definition of
2294  /// X<int>::A is required, it will be instantiated from the
2295  /// declaration returned by getInstantiatedFromMemberFunction().
2296  FunctionDecl *getInstantiatedFromMemberFunction() const;
2297 
2298  /// \brief What kind of templated function this is.
2299  TemplatedKind getTemplatedKind() const;
2300 
2301  /// \brief If this function is an instantiation of a member function of a
2302  /// class template specialization, retrieves the member specialization
2303  /// information.
2304  MemberSpecializationInfo *getMemberSpecializationInfo() const;
2305 
2306  /// \brief Specify that this record is an instantiation of the
2307  /// member function FD.
2310  setInstantiationOfMemberFunction(getASTContext(), FD, TSK);
2311  }
2312 
2313  /// \brief Retrieves the function template that is described by this
2314  /// function declaration.
2315  ///
2316  /// Every function template is represented as a FunctionTemplateDecl
2317  /// and a FunctionDecl (or something derived from FunctionDecl). The
2318  /// former contains template properties (such as the template
2319  /// parameter lists) while the latter contains the actual
2320  /// description of the template's
2321  /// contents. FunctionTemplateDecl::getTemplatedDecl() retrieves the
2322  /// FunctionDecl that describes the function template,
2323  /// getDescribedFunctionTemplate() retrieves the
2324  /// FunctionTemplateDecl from a FunctionDecl.
2325  FunctionTemplateDecl *getDescribedFunctionTemplate() const;
2326 
2327  void setDescribedFunctionTemplate(FunctionTemplateDecl *Template);
2328 
2329  /// \brief Determine whether this function is a function template
2330  /// specialization.
2332  return getPrimaryTemplate() != nullptr;
2333  }
2334 
2335  /// \brief Retrieve the class scope template pattern that this function
2336  /// template specialization is instantiated from.
2337  FunctionDecl *getClassScopeSpecializationPattern() const;
2338 
2339  /// \brief If this function is actually a function template specialization,
2340  /// retrieve information about this function template specialization.
2341  /// Otherwise, returns NULL.
2342  FunctionTemplateSpecializationInfo *getTemplateSpecializationInfo() const;
2343 
2344  /// \brief Determines whether this function is a function template
2345  /// specialization or a member of a class template specialization that can
2346  /// be implicitly instantiated.
2347  bool isImplicitlyInstantiable() const;
2348 
2349  /// \brief Determines if the given function was instantiated from a
2350  /// function template.
2351  bool isTemplateInstantiation() const;
2352 
2353  /// \brief Retrieve the function declaration from which this function could
2354  /// be instantiated, if it is an instantiation (rather than a non-template
2355  /// or a specialization, for example).
2356  FunctionDecl *getTemplateInstantiationPattern() const;
2357 
2358  /// \brief Retrieve the primary template that this function template
2359  /// specialization either specializes or was instantiated from.
2360  ///
2361  /// If this function declaration is not a function template specialization,
2362  /// returns NULL.
2363  FunctionTemplateDecl *getPrimaryTemplate() const;
2364 
2365  /// \brief Retrieve the template arguments used to produce this function
2366  /// template specialization from the primary template.
2367  ///
2368  /// If this function declaration is not a function template specialization,
2369  /// returns NULL.
2370  const TemplateArgumentList *getTemplateSpecializationArgs() const;
2371 
2372  /// \brief Retrieve the template argument list as written in the sources,
2373  /// if any.
2374  ///
2375  /// If this function declaration is not a function template specialization
2376  /// or if it had no explicit template argument list, returns NULL.
2377  /// Note that it an explicit template argument list may be written empty,
2378  /// e.g., template<> void foo<>(char* s);
2380  getTemplateSpecializationArgsAsWritten() const;
2381 
2382  /// \brief Specify that this function declaration is actually a function
2383  /// template specialization.
2384  ///
2385  /// \param Template the function template that this function template
2386  /// specialization specializes.
2387  ///
2388  /// \param TemplateArgs the template arguments that produced this
2389  /// function template specialization from the template.
2390  ///
2391  /// \param InsertPos If non-NULL, the position in the function template
2392  /// specialization set where the function template specialization data will
2393  /// be inserted.
2394  ///
2395  /// \param TSK the kind of template specialization this is.
2396  ///
2397  /// \param TemplateArgsAsWritten location info of template arguments.
2398  ///
2399  /// \param PointOfInstantiation point at which the function template
2400  /// specialization was first instantiated.
2401  void setFunctionTemplateSpecialization(FunctionTemplateDecl *Template,
2402  const TemplateArgumentList *TemplateArgs,
2403  void *InsertPos,
2405  const TemplateArgumentListInfo *TemplateArgsAsWritten = nullptr,
2406  SourceLocation PointOfInstantiation = SourceLocation()) {
2407  setFunctionTemplateSpecialization(getASTContext(), Template, TemplateArgs,
2408  InsertPos, TSK, TemplateArgsAsWritten,
2409  PointOfInstantiation);
2410  }
2411 
2412  /// \brief Specifies that this function declaration is actually a
2413  /// dependent function template specialization.
2414  void setDependentTemplateSpecialization(ASTContext &Context,
2415  const UnresolvedSetImpl &Templates,
2416  const TemplateArgumentListInfo &TemplateArgs);
2417 
2419  getDependentSpecializationInfo() const;
2420 
2421  /// \brief Determine what kind of template instantiation this function
2422  /// represents.
2424 
2425  /// \brief Determine what kind of template instantiation this function
2426  /// represents.
2427  void setTemplateSpecializationKind(TemplateSpecializationKind TSK,
2428  SourceLocation PointOfInstantiation = SourceLocation());
2429 
2430  /// \brief Retrieve the (first) point of instantiation of a function template
2431  /// specialization or a member of a class template specialization.
2432  ///
2433  /// \returns the first point of instantiation, if this function was
2434  /// instantiated from a template; otherwise, returns an invalid source
2435  /// location.
2436  SourceLocation getPointOfInstantiation() const;
2437 
2438  /// \brief Determine whether this is or was instantiated from an out-of-line
2439  /// definition of a member function.
2440  bool isOutOfLine() const override;
2441 
2442  /// \brief Identify a memory copying or setting function.
2443  /// If the given function is a memory copy or setting function, returns
2444  /// the corresponding Builtin ID. If the function is not a memory function,
2445  /// returns 0.
2446  unsigned getMemoryFunctionKind() const;
2447 
2448  /// \brief Returns ODRHash of the function. This value is calculated and
2449  /// stored on first call, then the stored value returned on the other calls.
2450  unsigned getODRHash();
2451 
2452  // Implement isa/cast/dyncast/etc.
2453  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2454  static bool classofKind(Kind K) {
2455  return K >= firstFunction && K <= lastFunction;
2456  }
2458  return static_cast<DeclContext *>(const_cast<FunctionDecl*>(D));
2459  }
2461  return static_cast<FunctionDecl *>(const_cast<DeclContext*>(DC));
2462  }
2463 };
2464 
2465 /// FieldDecl - An instance of this class is created by Sema::ActOnField to
2466 /// represent a member of a struct/union/class.
2467 class FieldDecl : public DeclaratorDecl, public Mergeable<FieldDecl> {
2468  unsigned BitField : 1;
2469  unsigned Mutable : 1;
2470  mutable unsigned CachedFieldIndex : 30;
2471 
2472  /// The kinds of value we can store in InitializerOrBitWidth.
2473  ///
2474  /// Note that this is compatible with InClassInitStyle except for
2475  /// ISK_CapturedVLAType.
2476  enum InitStorageKind {
2477  /// If the pointer is null, there's nothing special. Otherwise,
2478  /// this is a bitfield and the pointer is the Expr* storing the
2479  /// bit-width.
2480  ISK_NoInit = (unsigned) ICIS_NoInit,
2481 
2482  /// The pointer is an (optional due to delayed parsing) Expr*
2483  /// holding the copy-initializer.
2484  ISK_InClassCopyInit = (unsigned) ICIS_CopyInit,
2485 
2486  /// The pointer is an (optional due to delayed parsing) Expr*
2487  /// holding the list-initializer.
2488  ISK_InClassListInit = (unsigned) ICIS_ListInit,
2489 
2490  /// The pointer is a VariableArrayType* that's been captured;
2491  /// the enclosing context is a lambda or captured statement.
2492  ISK_CapturedVLAType,
2493  };
2494 
2495  /// If this is a bitfield with a default member initializer, this
2496  /// structure is used to represent the two expressions.
2497  struct InitAndBitWidth {
2498  Expr *Init;
2499  Expr *BitWidth;
2500  };
2501 
2502  /// \brief Storage for either the bit-width, the in-class initializer, or
2503  /// both (via InitAndBitWidth), or the captured variable length array bound.
2504  ///
2505  /// If the storage kind is ISK_InClassCopyInit or
2506  /// ISK_InClassListInit, but the initializer is null, then this
2507  /// field has an in-class initializer that has not yet been parsed
2508  /// and attached.
2509  // FIXME: Tail-allocate this to reduce the size of FieldDecl in the
2510  // overwhelmingly common case that we have none of these things.
2511  llvm::PointerIntPair<void *, 2, InitStorageKind> InitStorage;
2512 
2513 protected:
2516  QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable,
2517  InClassInitStyle InitStyle)
2518  : DeclaratorDecl(DK, DC, IdLoc, Id, T, TInfo, StartLoc),
2519  BitField(false), Mutable(Mutable), CachedFieldIndex(0),
2520  InitStorage(nullptr, (InitStorageKind) InitStyle) {
2521  if (BW)
2522  setBitWidth(BW);
2523  }
2524 
2525 public:
2526  friend class ASTDeclReader;
2527  friend class ASTDeclWriter;
2528 
2529  static FieldDecl *Create(const ASTContext &C, DeclContext *DC,
2530  SourceLocation StartLoc, SourceLocation IdLoc,
2532  TypeSourceInfo *TInfo, Expr *BW, bool Mutable,
2533  InClassInitStyle InitStyle);
2534 
2535  static FieldDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2536 
2537  /// getFieldIndex - Returns the index of this field within its record,
2538  /// as appropriate for passing to ASTRecordLayout::getFieldOffset.
2539  unsigned getFieldIndex() const;
2540 
2541  /// isMutable - Determines whether this field is mutable (C++ only).
2542  bool isMutable() const { return Mutable; }
2543 
2544  /// \brief Determines whether this field is a bitfield.
2545  bool isBitField() const { return BitField; }
2546 
2547  /// @brief Determines whether this is an unnamed bitfield.
2548  bool isUnnamedBitfield() const { return isBitField() && !getDeclName(); }
2549 
2550  /// isAnonymousStructOrUnion - Determines whether this field is a
2551  /// representative for an anonymous struct or union. Such fields are
2552  /// unnamed and are implicitly generated by the implementation to
2553  /// store the data for the anonymous union or struct.
2554  bool isAnonymousStructOrUnion() const;
2555 
2556  Expr *getBitWidth() const {
2557  if (!BitField)
2558  return nullptr;
2559  void *Ptr = InitStorage.getPointer();
2560  if (getInClassInitStyle())
2561  return static_cast<InitAndBitWidth*>(Ptr)->BitWidth;
2562  return static_cast<Expr*>(Ptr);
2563  }
2564 
2565  unsigned getBitWidthValue(const ASTContext &Ctx) const;
2566 
2567  /// setBitWidth - Set the bit-field width for this member.
2568  // Note: used by some clients (i.e., do not remove it).
2569  void setBitWidth(Expr *Width) {
2570  assert(!hasCapturedVLAType() && !BitField &&
2571  "bit width or captured type already set");
2572  assert(Width && "no bit width specified");
2573  InitStorage.setPointer(
2574  InitStorage.getInt()
2575  ? new (getASTContext())
2576  InitAndBitWidth{getInClassInitializer(), Width}
2577  : static_cast<void*>(Width));
2578  BitField = true;
2579  }
2580 
2581  /// removeBitWidth - Remove the bit-field width from this member.
2582  // Note: used by some clients (i.e., do not remove it).
2584  assert(isBitField() && "no bitfield width to remove");
2585  InitStorage.setPointer(getInClassInitializer());
2586  BitField = false;
2587  }
2588 
2589  /// Get the kind of (C++11) default member initializer that this field has.
2591  InitStorageKind storageKind = InitStorage.getInt();
2592  return (storageKind == ISK_CapturedVLAType
2593  ? ICIS_NoInit : (InClassInitStyle) storageKind);
2594  }
2595 
2596  /// Determine whether this member has a C++11 default member initializer.
2597  bool hasInClassInitializer() const {
2598  return getInClassInitStyle() != ICIS_NoInit;
2599  }
2600 
2601  /// Get the C++11 default member initializer for this member, or null if one
2602  /// has not been set. If a valid declaration has a default member initializer,
2603  /// but this returns null, then we have not parsed and attached it yet.
2605  if (!hasInClassInitializer())
2606  return nullptr;
2607  void *Ptr = InitStorage.getPointer();
2608  if (BitField)
2609  return static_cast<InitAndBitWidth*>(Ptr)->Init;
2610  return static_cast<Expr*>(Ptr);
2611  }
2612 
2613  /// setInClassInitializer - Set the C++11 in-class initializer for this
2614  /// member.
2616  assert(hasInClassInitializer() && !getInClassInitializer());
2617  if (BitField)
2618  static_cast<InitAndBitWidth*>(InitStorage.getPointer())->Init = Init;
2619  else
2620  InitStorage.setPointer(Init);
2621  }
2622 
2623  /// removeInClassInitializer - Remove the C++11 in-class initializer from this
2624  /// member.
2626  assert(hasInClassInitializer() && "no initializer to remove");
2627  InitStorage.setPointerAndInt(getBitWidth(), ISK_NoInit);
2628  }
2629 
2630  /// \brief Determine whether this member captures the variable length array
2631  /// type.
2632  bool hasCapturedVLAType() const {
2633  return InitStorage.getInt() == ISK_CapturedVLAType;
2634  }
2635 
2636  /// \brief Get the captured variable length array type.
2638  return hasCapturedVLAType() ? static_cast<const VariableArrayType *>(
2639  InitStorage.getPointer())
2640  : nullptr;
2641  }
2642 
2643  /// \brief Set the captured variable length array type for this field.
2644  void setCapturedVLAType(const VariableArrayType *VLAType);
2645 
2646  /// getParent - Returns the parent of this field declaration, which
2647  /// is the struct in which this field is defined.
2648  const RecordDecl *getParent() const {
2649  return cast<RecordDecl>(getDeclContext());
2650  }
2651 
2653  return cast<RecordDecl>(getDeclContext());
2654  }
2655 
2656  SourceRange getSourceRange() const override LLVM_READONLY;
2657 
2658  /// Retrieves the canonical declaration of this field.
2659  FieldDecl *getCanonicalDecl() override { return getFirstDecl(); }
2660  const FieldDecl *getCanonicalDecl() const { return getFirstDecl(); }
2661 
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 >= firstField && K <= lastField; }
2665 };
2666 
2667 /// EnumConstantDecl - An instance of this object exists for each enum constant
2668 /// that is defined. For example, in "enum X {a,b}", each of a/b are
2669 /// EnumConstantDecl's, X is an instance of EnumDecl, and the type of a/b is a
2670 /// TagType for the X EnumDecl.
2671 class EnumConstantDecl : public ValueDecl, public Mergeable<EnumConstantDecl> {
2672  Stmt *Init; // an integer constant expression
2673  llvm::APSInt Val; // The value.
2674 
2675 protected:
2677  IdentifierInfo *Id, QualType T, Expr *E,
2678  const llvm::APSInt &V)
2679  : ValueDecl(EnumConstant, DC, L, Id, T), Init((Stmt*)E), Val(V) {}
2680 
2681 public:
2682  friend class StmtIteratorBase;
2683 
2684  static EnumConstantDecl *Create(ASTContext &C, EnumDecl *DC,
2686  QualType T, Expr *E,
2687  const llvm::APSInt &V);
2688  static EnumConstantDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2689 
2690  const Expr *getInitExpr() const { return (const Expr*) Init; }
2691  Expr *getInitExpr() { return (Expr*) Init; }
2692  const llvm::APSInt &getInitVal() const { return Val; }
2693 
2694  void setInitExpr(Expr *E) { Init = (Stmt*) E; }
2695  void setInitVal(const llvm::APSInt &V) { Val = V; }
2696 
2697  SourceRange getSourceRange() const override LLVM_READONLY;
2698 
2699  /// Retrieves the canonical declaration of this enumerator.
2700  EnumConstantDecl *getCanonicalDecl() override { return getFirstDecl(); }
2701  const EnumConstantDecl *getCanonicalDecl() const { return getFirstDecl(); }
2702 
2703  // Implement isa/cast/dyncast/etc.
2704  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2705  static bool classofKind(Kind K) { return K == EnumConstant; }
2706 };
2707 
2708 /// IndirectFieldDecl - An instance of this class is created to represent a
2709 /// field injected from an anonymous union/struct into the parent scope.
2710 /// IndirectFieldDecl are always implicit.
2712  public Mergeable<IndirectFieldDecl> {
2713  NamedDecl **Chaining;
2714  unsigned ChainingSize;
2715 
2719 
2720  void anchor() override;
2721 
2722 public:
2723  friend class ASTDeclReader;
2724 
2728 
2729  static IndirectFieldDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2730 
2732 
2734  return llvm::makeArrayRef(Chaining, ChainingSize);
2735  }
2736  chain_iterator chain_begin() const { return chain().begin(); }
2737  chain_iterator chain_end() const { return chain().end(); }
2738 
2739  unsigned getChainingSize() const { return ChainingSize; }
2740 
2742  assert(chain().size() >= 2);
2743  return cast<FieldDecl>(chain().back());
2744  }
2745 
2746  VarDecl *getVarDecl() const {
2747  assert(chain().size() >= 2);
2748  return dyn_cast<VarDecl>(chain().front());
2749  }
2750 
2751  IndirectFieldDecl *getCanonicalDecl() override { return getFirstDecl(); }
2752  const IndirectFieldDecl *getCanonicalDecl() const { return getFirstDecl(); }
2753 
2754  // Implement isa/cast/dyncast/etc.
2755  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2756  static bool classofKind(Kind K) { return K == IndirectField; }
2757 };
2758 
2759 /// TypeDecl - Represents a declaration of a type.
2760 class TypeDecl : public NamedDecl {
2761  friend class ASTContext;
2762 
2763  /// TypeForDecl - This indicates the Type object that represents
2764  /// this TypeDecl. It is a cache maintained by
2765  /// ASTContext::getTypedefType, ASTContext::getTagDeclType, and
2766  /// ASTContext::getTemplateTypeParmType, and TemplateTypeParmDecl.
2767  mutable const Type *TypeForDecl = nullptr;
2768 
2769  /// LocStart - The start of the source range for this declaration.
2770  SourceLocation LocStart;
2771 
2772  void anchor() override;
2773 
2774 protected:
2776  SourceLocation StartL = SourceLocation())
2777  : NamedDecl(DK, DC, L, Id), LocStart(StartL) {}
2778 
2779 public:
2780  // Low-level accessor. If you just want the type defined by this node,
2781  // check out ASTContext::getTypeDeclType or one of
2782  // ASTContext::getTypedefType, ASTContext::getRecordType, etc. if you
2783  // already know the specific kind of node this is.
2784  const Type *getTypeForDecl() const { return TypeForDecl; }
2785  void setTypeForDecl(const Type *TD) { TypeForDecl = TD; }
2786 
2787  SourceLocation getLocStart() const LLVM_READONLY { return LocStart; }
2788  void setLocStart(SourceLocation L) { LocStart = L; }
2789  SourceRange getSourceRange() const override LLVM_READONLY {
2790  if (LocStart.isValid())
2791  return SourceRange(LocStart, getLocation());
2792  else
2793  return SourceRange(getLocation());
2794  }
2795 
2796  // Implement isa/cast/dyncast/etc.
2797  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2798  static bool classofKind(Kind K) { return K >= firstType && K <= lastType; }
2799 };
2800 
2801 /// Base class for declarations which introduce a typedef-name.
2802 class TypedefNameDecl : public TypeDecl, public Redeclarable<TypedefNameDecl> {
2803  using ModedTInfo = std::pair<TypeSourceInfo *, QualType>;
2804  llvm::PointerUnion<TypeSourceInfo *, ModedTInfo *> MaybeModedTInfo;
2805 
2806  // FIXME: This can be packed into the bitfields in Decl.
2807  /// If 0, we have not computed IsTransparentTag.
2808  /// Otherwise, IsTransparentTag is (CacheIsTransparentTag >> 1).
2809  mutable unsigned CacheIsTransparentTag : 2;
2810 
2811  void anchor() override;
2812 
2813 protected:
2815  SourceLocation StartLoc, SourceLocation IdLoc,
2816  IdentifierInfo *Id, TypeSourceInfo *TInfo)
2817  : TypeDecl(DK, DC, IdLoc, Id, StartLoc), redeclarable_base(C),
2818  MaybeModedTInfo(TInfo), CacheIsTransparentTag(0) {}
2819 
2821 
2823  return getNextRedeclaration();
2824  }
2825 
2827  return getPreviousDecl();
2828  }
2829 
2831  return getMostRecentDecl();
2832  }
2833 
2834 public:
2836  using redecl_iterator = redeclarable_base::redecl_iterator;
2837 
2838  using redeclarable_base::redecls_begin;
2839  using redeclarable_base::redecls_end;
2840  using redeclarable_base::redecls;
2841  using redeclarable_base::getPreviousDecl;
2842  using redeclarable_base::getMostRecentDecl;
2843  using redeclarable_base::isFirstDecl;
2844 
2845  bool isModed() const { return MaybeModedTInfo.is<ModedTInfo*>(); }
2846 
2848  return isModed()
2849  ? MaybeModedTInfo.get<ModedTInfo*>()->first
2850  : MaybeModedTInfo.get<TypeSourceInfo*>();
2851  }
2852 
2854  return isModed()
2855  ? MaybeModedTInfo.get<ModedTInfo*>()->second
2856  : MaybeModedTInfo.get<TypeSourceInfo*>()->getType();
2857  }
2858 
2860  MaybeModedTInfo = newType;
2861  }
2862 
2863  void setModedTypeSourceInfo(TypeSourceInfo *unmodedTSI, QualType modedTy) {
2864  MaybeModedTInfo = new (getASTContext()) ModedTInfo(unmodedTSI, modedTy);
2865  }
2866 
2867  /// Retrieves the canonical declaration of this typedef-name.
2868  TypedefNameDecl *getCanonicalDecl() override { return getFirstDecl(); }
2869  const TypedefNameDecl *getCanonicalDecl() const { return getFirstDecl(); }
2870 
2871  /// Retrieves the tag declaration for which this is the typedef name for
2872  /// linkage purposes, if any.
2873  ///
2874  /// \param AnyRedecl Look for the tag declaration in any redeclaration of
2875  /// this typedef declaration.
2876  TagDecl *getAnonDeclWithTypedefName(bool AnyRedecl = false) const;
2877 
2878  /// Determines if this typedef shares a name and spelling location with its
2879  /// underlying tag type, as is the case with the NS_ENUM macro.
2880  bool isTransparentTag() const {
2881  if (CacheIsTransparentTag)
2882  return CacheIsTransparentTag & 0x2;
2883  return isTransparentTagSlow();
2884  }
2885 
2886  // Implement isa/cast/dyncast/etc.
2887  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2888  static bool classofKind(Kind K) {
2889  return K >= firstTypedefName && K <= lastTypedefName;
2890  }
2891 
2892 private:
2893  bool isTransparentTagSlow() const;
2894 };
2895 
2896 /// TypedefDecl - Represents the declaration of a typedef-name via the 'typedef'
2897 /// type specifier.
2901  : TypedefNameDecl(Typedef, C, DC, StartLoc, IdLoc, Id, TInfo) {}
2902 
2903 public:
2904  static TypedefDecl *Create(ASTContext &C, DeclContext *DC,
2905  SourceLocation StartLoc, SourceLocation IdLoc,
2906  IdentifierInfo *Id, TypeSourceInfo *TInfo);
2907  static TypedefDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2908 
2909  SourceRange getSourceRange() const override LLVM_READONLY;
2910 
2911  // Implement isa/cast/dyncast/etc.
2912  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2913  static bool classofKind(Kind K) { return K == Typedef; }
2914 };
2915 
2916 /// TypeAliasDecl - Represents the declaration of a typedef-name via a C++0x
2917 /// alias-declaration.
2919  /// The template for which this is the pattern, if any.
2920  TypeAliasTemplateDecl *Template;
2921 
2924  : TypedefNameDecl(TypeAlias, C, DC, StartLoc, IdLoc, Id, TInfo),
2925  Template(nullptr) {}
2926 
2927 public:
2928  static TypeAliasDecl *Create(ASTContext &C, DeclContext *DC,
2929  SourceLocation StartLoc, SourceLocation IdLoc,
2930  IdentifierInfo *Id, TypeSourceInfo *TInfo);
2931  static TypeAliasDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2932 
2933  SourceRange getSourceRange() const override LLVM_READONLY;
2934 
2935  TypeAliasTemplateDecl *getDescribedAliasTemplate() const { return Template; }
2936  void setDescribedAliasTemplate(TypeAliasTemplateDecl *TAT) { Template = TAT; }
2937 
2938  // Implement isa/cast/dyncast/etc.
2939  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2940  static bool classofKind(Kind K) { return K == TypeAlias; }
2941 };
2942 
2943 /// TagDecl - Represents the declaration of a struct/union/class/enum.
2944 class TagDecl
2945  : public TypeDecl, public DeclContext, public Redeclarable<TagDecl> {
2946 public:
2947  // This is really ugly.
2949 
2950 private:
2951  // FIXME: This can be packed into the bitfields in Decl.
2952  /// TagDeclKind - The TagKind enum.
2953  unsigned TagDeclKind : 3;
2954 
2955  /// IsCompleteDefinition - True if this is a definition ("struct foo
2956  /// {};"), false if it is a declaration ("struct foo;"). It is not
2957  /// a definition until the definition has been fully processed.
2958  unsigned IsCompleteDefinition : 1;
2959 
2960 protected:
2961  /// IsBeingDefined - True if this is currently being defined.
2962  unsigned IsBeingDefined : 1;
2963 
2964 private:
2965  /// IsEmbeddedInDeclarator - True if this tag declaration is
2966  /// "embedded" (i.e., defined or declared for the very first time)
2967  /// in the syntax of a declarator.
2968  unsigned IsEmbeddedInDeclarator : 1;
2969 
2970  /// \brief True if this tag is free standing, e.g. "struct foo;".
2971  unsigned IsFreeStanding : 1;
2972 
2973 protected:
2974  // These are used by (and only defined for) EnumDecl.
2975  unsigned NumPositiveBits : 8;
2976  unsigned NumNegativeBits : 8;
2977 
2978  /// IsScoped - True if this tag declaration is a scoped enumeration. Only
2979  /// possible in C++11 mode.
2980  unsigned IsScoped : 1;
2981 
2982  /// IsScopedUsingClassTag - If this tag declaration is a scoped enum,
2983  /// then this is true if the scoped enum was declared using the class
2984  /// tag, false if it was declared with the struct tag. No meaning is
2985  /// associated if this tag declaration is not a scoped enum.
2987 
2988  /// IsFixed - True if this is an enumeration with fixed underlying type. Only
2989  /// possible in C++11, Microsoft extensions, or Objective C mode.
2990  unsigned IsFixed : 1;
2991 
2992  /// \brief Indicates whether it is possible for declarations of this kind
2993  /// to have an out-of-date definition.
2994  ///
2995  /// This option is only enabled when modules are enabled.
2996  unsigned MayHaveOutOfDateDef : 1;
2997 
2998  /// Has the full definition of this type been required by a use somewhere in
2999  /// the TU.
3001 
3002 private:
3003  SourceRange BraceRange;
3004 
3005  // A struct representing syntactic qualifier info,
3006  // to be used for the (uncommon) case of out-of-line declarations.
3007  using ExtInfo = QualifierInfo;
3008 
3009  /// \brief If the (out-of-line) tag declaration name
3010  /// is qualified, it points to the qualifier info (nns and range);
3011  /// otherwise, if the tag declaration is anonymous and it is part of
3012  /// a typedef or alias, it points to the TypedefNameDecl (used for mangling);
3013  /// otherwise, if the tag declaration is anonymous and it is used as a
3014  /// declaration specifier for variables, it points to the first VarDecl (used
3015  /// for mangling);
3016  /// otherwise, it is a null (TypedefNameDecl) pointer.
3017  llvm::PointerUnion<TypedefNameDecl *, ExtInfo *> TypedefNameDeclOrQualifier;
3018 
3019  bool hasExtInfo() const { return TypedefNameDeclOrQualifier.is<ExtInfo *>(); }
3020  ExtInfo *getExtInfo() { return TypedefNameDeclOrQualifier.get<ExtInfo *>(); }
3021  const ExtInfo *getExtInfo() const {
3022  return TypedefNameDeclOrQualifier.get<ExtInfo *>();
3023  }
3024 
3025 protected:
3026  TagDecl(Kind DK, TagKind TK, const ASTContext &C, DeclContext *DC,
3027  SourceLocation L, IdentifierInfo *Id, TagDecl *PrevDecl,
3028  SourceLocation StartL)
3029  : TypeDecl(DK, DC, L, Id, StartL), DeclContext(DK), redeclarable_base(C),
3030  TagDeclKind(TK), IsCompleteDefinition(false), IsBeingDefined(false),
3031  IsEmbeddedInDeclarator(false), IsFreeStanding(false),
3032  IsCompleteDefinitionRequired(false),
3033  TypedefNameDeclOrQualifier((TypedefNameDecl *)nullptr) {
3034  assert((DK != Enum || TK == TTK_Enum) &&
3035  "EnumDecl not matched with TTK_Enum");
3036  setPreviousDecl(PrevDecl);
3037  }
3038 
3040 
3042  return getNextRedeclaration();
3043  }
3044 
3046  return getPreviousDecl();
3047  }
3048 
3050  return getMostRecentDecl();
3051  }
3052 
3053  /// @brief Completes the definition of this tag declaration.
3054  ///
3055  /// This is a helper function for derived classes.
3056  void completeDefinition();
3057 
3058 public:
3059  friend class ASTDeclReader;
3060  friend class ASTDeclWriter;
3061 
3063  using redecl_iterator = redeclarable_base::redecl_iterator;
3064 
3065  using redeclarable_base::redecls_begin;
3066  using redeclarable_base::redecls_end;
3067  using redeclarable_base::redecls;
3068  using redeclarable_base::getPreviousDecl;
3069  using redeclarable_base::getMostRecentDecl;
3070  using redeclarable_base::isFirstDecl;
3071 
3072  SourceRange getBraceRange() const { return BraceRange; }
3073  void setBraceRange(SourceRange R) { BraceRange = R; }
3074 
3075  /// getInnerLocStart - Return SourceLocation representing start of source
3076  /// range ignoring outer template declarations.
3077  SourceLocation getInnerLocStart() const { return getLocStart(); }
3078 
3079  /// getOuterLocStart - Return SourceLocation representing start of source
3080  /// range taking into account any outer template declarations.
3081  SourceLocation getOuterLocStart() const;
3082  SourceRange getSourceRange() const override LLVM_READONLY;
3083 
3084  TagDecl *getCanonicalDecl() override;
3085  const TagDecl *getCanonicalDecl() const {
3086  return const_cast<TagDecl*>(this)->getCanonicalDecl();
3087  }
3088 
3089  /// isThisDeclarationADefinition() - Return true if this declaration
3090  /// is a completion definition of the type. Provided for consistency.
3092  return isCompleteDefinition();
3093  }
3094 
3095  /// isCompleteDefinition - Return true if this decl has its body
3096  /// fully specified.
3097  bool isCompleteDefinition() const {
3098  return IsCompleteDefinition;
3099  }
3100 
3101  /// \brief Return true if this complete decl is
3102  /// required to be complete for some existing use.
3104  return IsCompleteDefinitionRequired;
3105  }
3106 
3107  /// isBeingDefined - Return true if this decl is currently being defined.
3108  bool isBeingDefined() const {
3109  return IsBeingDefined;
3110  }
3111 
3112  bool isEmbeddedInDeclarator() const {
3113  return IsEmbeddedInDeclarator;
3114  }
3115  void setEmbeddedInDeclarator(bool isInDeclarator) {
3116  IsEmbeddedInDeclarator = isInDeclarator;
3117  }
3118 
3119  bool isFreeStanding() const { return IsFreeStanding; }
3120  void setFreeStanding(bool isFreeStanding = true) {
3121  IsFreeStanding = isFreeStanding;
3122  }
3123 
3124  /// \brief Whether this declaration declares a type that is
3125  /// dependent, i.e., a type that somehow depends on template
3126  /// parameters.
3127  bool isDependentType() const { return isDependentContext(); }
3128 
3129  /// @brief Starts the definition of this tag declaration.
3130  ///
3131  /// This method should be invoked at the beginning of the definition
3132  /// of this tag declaration. It will set the tag type into a state
3133  /// where it is in the process of being defined.
3134  void startDefinition();
3135 
3136  /// getDefinition - Returns the TagDecl that actually defines this
3137  /// struct/union/class/enum. When determining whether or not a
3138  /// struct/union/class/enum has a definition, one should use this
3139  /// method as opposed to 'isDefinition'. 'isDefinition' indicates
3140  /// whether or not a specific TagDecl is defining declaration, not
3141  /// whether or not the struct/union/class/enum type is defined.
3142  /// This method returns NULL if there is no TagDecl that defines
3143  /// the struct/union/class/enum.
3144  TagDecl *getDefinition() const;
3145 
3146  void setCompleteDefinition(bool V) { IsCompleteDefinition = V; }
3147 
3148  void setCompleteDefinitionRequired(bool V = true) {
3149  IsCompleteDefinitionRequired = V;
3150  }
3151 
3152  StringRef getKindName() const {
3153  return TypeWithKeyword::getTagTypeKindName(getTagKind());
3154  }
3155 
3157  return TagKind(TagDeclKind);
3158  }
3159 
3160  void setTagKind(TagKind TK) { TagDeclKind = TK; }
3161 
3162  bool isStruct() const { return getTagKind() == TTK_Struct; }
3163  bool isInterface() const { return getTagKind() == TTK_Interface; }
3164  bool isClass() const { return getTagKind() == TTK_Class; }
3165  bool isUnion() const { return getTagKind() == TTK_Union; }
3166  bool isEnum() const { return getTagKind() == TTK_Enum; }
3167 
3168  /// Is this tag type named, either directly or via being defined in
3169  /// a typedef of this type?
3170  ///
3171  /// C++11 [basic.link]p8:
3172  /// A type is said to have linkage if and only if:
3173  /// - it is a class or enumeration type that is named (or has a
3174  /// name for linkage purposes) and the name has linkage; ...
3175  /// C++11 [dcl.typedef]p9:
3176  /// If the typedef declaration defines an unnamed class (or enum),
3177  /// the first typedef-name declared by the declaration to be that
3178  /// class type (or enum type) is used to denote the class type (or
3179  /// enum type) for linkage purposes only.
3180  ///
3181  /// C does not have an analogous rule, but the same concept is
3182  /// nonetheless useful in some places.
3183  bool hasNameForLinkage() const {
3184  return (getDeclName() || getTypedefNameForAnonDecl());
3185  }
3186 
3188  return hasExtInfo() ? nullptr
3189  : TypedefNameDeclOrQualifier.get<TypedefNameDecl *>();
3190  }
3191 
3192  void setTypedefNameForAnonDecl(TypedefNameDecl *TDD);
3193 
3194  /// \brief Retrieve the nested-name-specifier that qualifies the name of this
3195  /// declaration, if it was present in the source.
3197  return hasExtInfo() ? getExtInfo()->QualifierLoc.getNestedNameSpecifier()
3198  : nullptr;
3199  }
3200 
3201  /// \brief Retrieve the nested-name-specifier (with source-location
3202  /// information) that qualifies the name of this declaration, if it was
3203  /// present in the source.
3205  return hasExtInfo() ? getExtInfo()->QualifierLoc
3207  }
3208 
3209  void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc);
3210 
3211  unsigned getNumTemplateParameterLists() const {
3212  return hasExtInfo() ? getExtInfo()->NumTemplParamLists : 0;
3213  }
3214 
3216  assert(i < getNumTemplateParameterLists());
3217  return getExtInfo()->TemplParamLists[i];
3218  }
3219 
3220  void setTemplateParameterListsInfo(ASTContext &Context,
3222 
3223  // Implement isa/cast/dyncast/etc.
3224  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3225  static bool classofKind(Kind K) { return K >= firstTag && K <= lastTag; }
3226 
3228  return static_cast<DeclContext *>(const_cast<TagDecl*>(D));
3229  }
3230 
3232  return static_cast<TagDecl *>(const_cast<DeclContext*>(DC));
3233  }
3234 };
3235 
3236 /// EnumDecl - Represents an enum. In C++11, enums can be forward-declared
3237 /// with a fixed underlying type, and in C we allow them to be forward-declared
3238 /// with no underlying type as an extension.
3239 class EnumDecl : public TagDecl {
3240  /// IntegerType - This represent the integer type that the enum corresponds
3241  /// to for code generation purposes. Note that the enumerator constants may
3242  /// have a different type than this does.
3243  ///
3244  /// If the underlying integer type was explicitly stated in the source
3245  /// code, this is a TypeSourceInfo* for that type. Otherwise this type
3246  /// was automatically deduced somehow, and this is a Type*.
3247  ///
3248  /// Normally if IsFixed(), this would contain a TypeSourceInfo*, but in
3249  /// some cases it won't.
3250  ///
3251  /// The underlying type of an enumeration never has any qualifiers, so
3252  /// we can get away with just storing a raw Type*, and thus save an
3253  /// extra pointer when TypeSourceInfo is needed.
3254  llvm::PointerUnion<const Type *, TypeSourceInfo *> IntegerType;
3255 
3256  /// PromotionType - The integer type that values of this type should
3257  /// promote to. In C, enumerators are generally of an integer type
3258  /// directly, but gcc-style large enumerators (and all enumerators
3259  /// in C++) are of the enum type instead.
3260  QualType PromotionType;
3261 
3262  /// \brief If this enumeration is an instantiation of a member enumeration
3263  /// of a class template specialization, this is the member specialization
3264  /// information.
3265  MemberSpecializationInfo *SpecializationInfo = nullptr;
3266 
3267  EnumDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
3268  SourceLocation IdLoc, IdentifierInfo *Id, EnumDecl *PrevDecl,
3269  bool Scoped, bool ScopedUsingClassTag, bool Fixed)
3270  : TagDecl(Enum, TTK_Enum, C, DC, IdLoc, Id, PrevDecl, StartLoc) {
3271  assert(Scoped || !ScopedUsingClassTag);
3272  IntegerType = (const Type *)nullptr;
3273  NumNegativeBits = 0;
3274  NumPositiveBits = 0;
3275  IsScoped = Scoped;
3276  IsScopedUsingClassTag = ScopedUsingClassTag;
3277  IsFixed = Fixed;
3278  }
3279 
3280  void anchor() override;
3281 
3282  void setInstantiationOfMemberEnum(ASTContext &C, EnumDecl *ED,
3284 public:
3285  friend class ASTDeclReader;
3286 
3288  return cast<EnumDecl>(TagDecl::getCanonicalDecl());
3289  }
3290  const EnumDecl *getCanonicalDecl() const {
3291  return const_cast<EnumDecl*>(this)->getCanonicalDecl();
3292  }
3293 
3295  return cast_or_null<EnumDecl>(
3296  static_cast<TagDecl *>(this)->getPreviousDecl());
3297  }
3298  const EnumDecl *getPreviousDecl() const {
3299  return const_cast<EnumDecl*>(this)->getPreviousDecl();
3300  }
3301 
3303  return cast<EnumDecl>(static_cast<TagDecl *>(this)->getMostRecentDecl());
3304  }
3305  const EnumDecl *getMostRecentDecl() const {
3306  return const_cast<EnumDecl*>(this)->getMostRecentDecl();
3307  }
3308 
3310  return cast_or_null<EnumDecl>(TagDecl::getDefinition());
3311  }
3312 
3313  static EnumDecl *Create(ASTContext &C, DeclContext *DC,
3314  SourceLocation StartLoc, SourceLocation IdLoc,
3315  IdentifierInfo *Id, EnumDecl *PrevDecl,
3316  bool IsScoped, bool IsScopedUsingClassTag,
3317  bool IsFixed);
3318  static EnumDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3319 
3320  /// completeDefinition - When created, the EnumDecl corresponds to a
3321  /// forward-declared enum. This method is used to mark the
3322  /// declaration as being defined; it's enumerators have already been
3323  /// added (via DeclContext::addDecl). NewType is the new underlying
3324  /// type of the enumeration type.
3325  void completeDefinition(QualType NewType,
3326  QualType PromotionType,
3327  unsigned NumPositiveBits,
3328  unsigned NumNegativeBits);
3329 
3330  // enumerator_iterator - Iterates through the enumerators of this
3331  // enumeration.
3333  using enumerator_range =
3334  llvm::iterator_range<specific_decl_iterator<EnumConstantDecl>>;
3335 
3337  return enumerator_range(enumerator_begin(), enumerator_end());
3338  }
3339 
3341  const EnumDecl *E = getDefinition();
3342  if (!E)
3343  E = this;
3344  return enumerator_iterator(E->decls_begin());
3345  }
3346 
3348  const EnumDecl *E = getDefinition();
3349  if (!E)
3350  E = this;
3351  return enumerator_iterator(E->decls_end());
3352  }
3353 
3354  /// getPromotionType - Return the integer type that enumerators
3355  /// should promote to.
3356  QualType getPromotionType() const { return PromotionType; }
3357 
3358  /// \brief Set the promotion type.
3359  void setPromotionType(QualType T) { PromotionType = T; }
3360 
3361  /// getIntegerType - Return the integer type this enum decl corresponds to.
3362  /// This returns a null QualType for an enum forward definition with no fixed
3363  /// underlying type.
3365  if (!IntegerType)
3366  return QualType();
3367  if (const Type *T = IntegerType.dyn_cast<const Type*>())
3368  return QualType(T, 0);
3369  return IntegerType.get<TypeSourceInfo*>()->getType().getUnqualifiedType();
3370  }
3371 
3372  /// \brief Set the underlying integer type.
3373  void setIntegerType(QualType T) { IntegerType = T.getTypePtrOrNull(); }
3374 
3375  /// \brief Set the underlying integer type source info.
3376  void setIntegerTypeSourceInfo(TypeSourceInfo *TInfo) { IntegerType = TInfo; }
3377 
3378  /// \brief Return the type source info for the underlying integer type,
3379  /// if no type source info exists, return 0.
3381  return IntegerType.dyn_cast<TypeSourceInfo*>();
3382  }
3383 
3384  /// \brief Retrieve the source range that covers the underlying type if
3385  /// specified.
3386  SourceRange getIntegerTypeRange() const LLVM_READONLY;
3387 
3388  /// \brief Returns the width in bits required to store all the
3389  /// non-negative enumerators of this enum.
3390  unsigned getNumPositiveBits() const {
3391  return NumPositiveBits;
3392  }
3393  void setNumPositiveBits(unsigned Num) {
3394  NumPositiveBits = Num;
3395  assert(NumPositiveBits == Num && "can't store this bitcount");
3396  }
3397 
3398  /// \brief Returns the width in bits required to store all the
3399  /// negative enumerators of this enum. These widths include
3400  /// the rightmost leading 1; that is:
3401  ///
3402  /// MOST NEGATIVE ENUMERATOR PATTERN NUM NEGATIVE BITS
3403  /// ------------------------ ------- -----------------
3404  /// -1 1111111 1
3405  /// -10 1110110 5
3406  /// -101 1001011 8
3407  unsigned getNumNegativeBits() const {
3408  return NumNegativeBits;
3409  }
3410  void setNumNegativeBits(unsigned Num) {
3411  NumNegativeBits = Num;
3412  }
3413 
3414  /// \brief Returns true if this is a C++11 scoped enumeration.
3415  bool isScoped() const {
3416  return IsScoped;
3417  }
3418 
3419  /// \brief Returns true if this is a C++11 scoped enumeration.
3420  bool isScopedUsingClassTag() const {
3421  return IsScopedUsingClassTag;
3422  }
3423 
3424  /// \brief Returns true if this is an Objective-C, C++11, or
3425  /// Microsoft-style enumeration with a fixed underlying type.
3426  bool isFixed() const {
3427  return IsFixed;
3428  }
3429 
3430  /// \brief Returns true if this can be considered a complete type.
3431  bool isComplete() const {
3432  return isCompleteDefinition() || isFixed();
3433  }
3434 
3435  /// Returns true if this enum is either annotated with
3436  /// enum_extensibility(closed) or isn't annotated with enum_extensibility.
3437  bool isClosed() const;
3438 
3439  /// Returns true if this enum is annotated with flag_enum and isn't annotated
3440  /// with enum_extensibility(open).
3441  bool isClosedFlag() const;
3442 
3443  /// Returns true if this enum is annotated with neither flag_enum nor
3444  /// enum_extensibility(open).
3445  bool isClosedNonFlag() const;
3446 
3447  /// \brief Retrieve the enum definition from which this enumeration could
3448  /// be instantiated, if it is an instantiation (rather than a non-template).
3449  EnumDecl *getTemplateInstantiationPattern() const;
3450 
3451  /// \brief Returns the enumeration (declared within the template)
3452  /// from which this enumeration type was instantiated, or NULL if
3453  /// this enumeration was not instantiated from any template.
3454  EnumDecl *getInstantiatedFromMemberEnum() const;
3455 
3456  /// \brief If this enumeration is a member of a specialization of a
3457  /// templated class, determine what kind of template specialization
3458  /// or instantiation this is.
3460 
3461  /// \brief For an enumeration member that was instantiated from a member
3462  /// enumeration of a templated class, set the template specialiation kind.
3463  void setTemplateSpecializationKind(TemplateSpecializationKind TSK,
3464  SourceLocation PointOfInstantiation = SourceLocation());
3465 
3466  /// \brief If this enumeration is an instantiation of a member enumeration of
3467  /// a class template specialization, retrieves the member specialization
3468  /// information.
3469  MemberSpecializationInfo *getMemberSpecializationInfo() const {
3470  return SpecializationInfo;
3471  }
3472 
3473  /// \brief Specify that this enumeration is an instantiation of the
3474  /// member enumeration ED.
3477  setInstantiationOfMemberEnum(getASTContext(), ED, TSK);
3478  }
3479 
3480  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3481  static bool classofKind(Kind K) { return K == Enum; }
3482 };
3483 
3484 /// RecordDecl - Represents a struct/union/class. For example:
3485 /// struct X; // Forward declaration, no "body".
3486 /// union Y { int A, B; }; // Has body with members A and B (FieldDecls).
3487 /// This decl will be marked invalid if *any* members are invalid.
3488 class RecordDecl : public TagDecl {
3489  friend class DeclContext;
3490 
3491  // FIXME: This can be packed into the bitfields in Decl.
3492  /// HasFlexibleArrayMember - This is true if this struct ends with a flexible
3493  /// array member (e.g. int X[]) or if this union contains a struct that does.
3494  /// If so, this cannot be contained in arrays or other structs as a member.
3495  bool HasFlexibleArrayMember : 1;
3496 
3497  /// AnonymousStructOrUnion - Whether this is the type of an anonymous struct
3498  /// or union.
3499  bool AnonymousStructOrUnion : 1;
3500 
3501  /// HasObjectMember - This is true if this struct has at least one member
3502  /// containing an Objective-C object pointer type.
3503  bool HasObjectMember : 1;
3504 
3505  /// HasVolatileMember - This is true if struct has at least one member of
3506  /// 'volatile' type.
3507  bool HasVolatileMember : 1;
3508 
3509  /// \brief Whether the field declarations of this record have been loaded
3510  /// from external storage. To avoid unnecessary deserialization of
3511  /// methods/nested types we allow deserialization of just the fields
3512  /// when needed.
3513  mutable bool LoadedFieldsFromExternalStorage : 1;
3514 
3515 protected:
3516  RecordDecl(Kind DK, TagKind TK, const ASTContext &C, DeclContext *DC,
3517  SourceLocation StartLoc, SourceLocation IdLoc,
3518  IdentifierInfo *Id, RecordDecl *PrevDecl);
3519 
3520 public:
3521  static RecordDecl *Create(const ASTContext &C, TagKind TK, DeclContext *DC,
3522  SourceLocation StartLoc, SourceLocation IdLoc,
3523  IdentifierInfo *Id, RecordDecl* PrevDecl = nullptr);
3524  static RecordDecl *CreateDeserialized(const ASTContext &C, unsigned ID);
3525 
3527  return cast_or_null<RecordDecl>(
3528  static_cast<TagDecl *>(this)->getPreviousDecl());
3529  }
3530  const RecordDecl *getPreviousDecl() const {
3531  return const_cast<RecordDecl*>(this)->getPreviousDecl();
3532  }
3533 
3535  return cast<RecordDecl>(static_cast<TagDecl *>(this)->getMostRecentDecl());
3536  }
3538  return const_cast<RecordDecl*>(this)->getMostRecentDecl();
3539  }
3540 
3541  bool hasFlexibleArrayMember() const { return HasFlexibleArrayMember; }
3542  void setHasFlexibleArrayMember(bool V) { HasFlexibleArrayMember = V; }
3543 
3544  /// isAnonymousStructOrUnion - Whether this is an anonymous struct
3545  /// or union. To be an anonymous struct or union, it must have been
3546  /// declared without a name and there must be no objects of this
3547  /// type declared, e.g.,
3548  /// @code
3549  /// union { int i; float f; };
3550  /// @endcode
3551  /// is an anonymous union but neither of the following are:
3552  /// @code
3553  /// union X { int i; float f; };
3554  /// union { int i; float f; } obj;
3555  /// @endcode
3556  bool isAnonymousStructOrUnion() const { return AnonymousStructOrUnion; }
3557  void setAnonymousStructOrUnion(bool Anon) {
3558  AnonymousStructOrUnion = Anon;
3559  }
3560 
3561  bool hasObjectMember() const { return HasObjectMember; }
3562  void setHasObjectMember (bool val) { HasObjectMember = val; }
3563 
3564  bool hasVolatileMember() const { return HasVolatileMember; }
3565  void setHasVolatileMember (bool val) { HasVolatileMember = val; }
3566 
3568  return LoadedFieldsFromExternalStorage;
3569  }
3571  LoadedFieldsFromExternalStorage = val;
3572  }
3573 
3574  /// \brief Determines whether this declaration represents the
3575  /// injected class name.
3576  ///
3577  /// The injected class name in C++ is the name of the class that
3578  /// appears inside the class itself. For example:
3579  ///
3580  /// \code
3581  /// struct C {
3582  /// // C is implicitly declared here as a synonym for the class name.
3583  /// };
3584  ///
3585  /// C::C c; // same as "C c;"
3586  /// \endcode
3587  bool isInjectedClassName() const;
3588 
3589  /// \brief Determine whether this record is a class describing a lambda
3590  /// function object.
3591  bool isLambda() const;
3592 
3593  /// \brief Determine whether this record is a record for captured variables in
3594  /// CapturedStmt construct.
3595  bool isCapturedRecord() const;
3596 
3597  /// \brief Mark the record as a record for captured variables in CapturedStmt
3598  /// construct.
3599  void setCapturedRecord();
3600 
3601  /// getDefinition - Returns the RecordDecl that actually defines
3602  /// this struct/union/class. When determining whether or not a
3603  /// struct/union/class is completely defined, one should use this
3604  /// method as opposed to 'isCompleteDefinition'.
3605  /// 'isCompleteDefinition' indicates whether or not a specific
3606  /// RecordDecl is a completed definition, not whether or not the
3607  /// record type is defined. This method returns NULL if there is
3608  /// no RecordDecl that defines the struct/union/tag.
3610  return cast_or_null<RecordDecl>(TagDecl::getDefinition());
3611  }
3612 
3613  // Iterator access to field members. The field iterator only visits
3614  // the non-static data members of this class, ignoring any static
3615  // data members, functions, constructors, destructors, etc.
3617  using field_range = llvm::iterator_range<specific_decl_iterator<FieldDecl>>;
3618 
3619  field_range fields() const { return field_range(field_begin(), field_end()); }
3620  field_iterator field_begin() const;
3621 
3623  return field_iterator(decl_iterator());
3624  }
3625 
3626  // field_empty - Whether there are any fields (non-static data
3627  // members) in this record.
3628  bool field_empty() const {
3629  return field_begin() == field_end();
3630  }
3631 
3632  /// completeDefinition - Notes that the definition of this type is
3633  /// now complete.
3634  virtual void completeDefinition();
3635 
3636  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3637  static bool classofKind(Kind K) {
3638  return K >= firstRecord && K <= lastRecord;
3639  }
3640 
3641  /// \brief Get whether or not this is an ms_struct which can
3642  /// be turned on with an attribute, pragma, or -mms-bitfields
3643  /// commandline option.
3644  bool isMsStruct(const ASTContext &C) const;
3645 
3646  /// \brief Whether we are allowed to insert extra padding between fields.
3647  /// These padding are added to help AddressSanitizer detect
3648  /// intra-object-overflow bugs.
3649  bool mayInsertExtraPadding(bool EmitRemark = false) const;
3650 
3651  /// Finds the first data member which has a name.
3652  /// nullptr is returned if no named data member exists.
3653  const FieldDecl *findFirstNamedDataMember() const;
3654 
3655 private:
3656  /// \brief Deserialize just the fields.
3657  void LoadFieldsFromExternalStorage() const;
3658 };
3659 
3660 class FileScopeAsmDecl : public Decl {
3661  StringLiteral *AsmString;
3662  SourceLocation RParenLoc;
3663 
3664  FileScopeAsmDecl(DeclContext *DC, StringLiteral *asmstring,
3665  SourceLocation StartL, SourceLocation EndL)
3666  : Decl(FileScopeAsm, DC, StartL), AsmString(asmstring), RParenLoc(EndL) {}
3667 
3668  virtual void anchor();
3669 
3670 public:
3672  StringLiteral *Str, SourceLocation AsmLoc,
3673  SourceLocation RParenLoc);
3674 
3675  static FileScopeAsmDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3676 
3677  SourceLocation getAsmLoc() const { return getLocation(); }
3678  SourceLocation getRParenLoc() const { return RParenLoc; }
3679  void setRParenLoc(SourceLocation L) { RParenLoc = L; }
3680  SourceRange getSourceRange() const override LLVM_READONLY {
3681  return SourceRange(getAsmLoc(), getRParenLoc());
3682  }
3683 
3684  const StringLiteral *getAsmString() const { return AsmString; }
3685  StringLiteral *getAsmString() { return AsmString; }
3686  void setAsmString(StringLiteral *Asm) { AsmString = Asm; }
3687 
3688  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3689  static bool classofKind(Kind K) { return K == FileScopeAsm; }
3690 };
3691 
3692 /// BlockDecl - This represents a block literal declaration, which is like an
3693 /// unnamed FunctionDecl. For example:
3694 /// ^{ statement-body } or ^(int arg1, float arg2){ statement-body }
3695 class BlockDecl : public Decl, public DeclContext {
3696 public:
3697  /// A class which contains all the information about a particular
3698  /// captured value.
3699  class Capture {
3700  enum {
3701  flag_isByRef = 0x1,
3702  flag_isNested = 0x2
3703  };
3704 
3705  /// The variable being captured.
3706  llvm::PointerIntPair<VarDecl*, 2> VariableAndFlags;
3707 
3708  /// The copy expression, expressed in terms of a DeclRef (or
3709  /// BlockDeclRef) to the captured variable. Only required if the
3710  /// variable has a C++ class type.
3711  Expr *CopyExpr;
3712 
3713  public:
3714  Capture(VarDecl *variable, bool byRef, bool nested, Expr *copy)
3715  : VariableAndFlags(variable,
3716  (byRef ? flag_isByRef : 0) | (nested ? flag_isNested : 0)),
3717  CopyExpr(copy) {}
3718 
3719  /// The variable being captured.
3720  VarDecl *getVariable() const { return VariableAndFlags.getPointer(); }
3721 
3722  /// Whether this is a "by ref" capture, i.e. a capture of a __block
3723  /// variable.
3724  bool isByRef() const { return VariableAndFlags.getInt() & flag_isByRef; }
3725 
3726  /// Whether this is a nested capture, i.e. the variable captured
3727  /// is not from outside the immediately enclosing function/block.
3728  bool isNested() const { return VariableAndFlags.getInt() & flag_isNested; }
3729 
3730  bool hasCopyExpr() const { return CopyExpr != nullptr; }
3731  Expr *getCopyExpr() const { return CopyExpr; }
3732  void setCopyExpr(Expr *e) { CopyExpr = e; }
3733  };
3734 
3735 private:
3736  // FIXME: This can be packed into the bitfields in Decl.
3737  bool IsVariadic : 1;
3738  bool CapturesCXXThis : 1;
3739  bool BlockMissingReturnType : 1;
3740  bool IsConversionFromLambda : 1;
3741 
3742  /// ParamInfo - new[]'d array of pointers to ParmVarDecls for the formal
3743  /// parameters of this function. This is null if a prototype or if there are
3744  /// no formals.
3745  ParmVarDecl **ParamInfo = nullptr;
3746  unsigned NumParams = 0;
3747 
3748  Stmt *Body = nullptr;
3749  TypeSourceInfo *SignatureAsWritten = nullptr;
3750 
3751  const Capture *Captures = nullptr;
3752  unsigned NumCaptures = 0;
3753 
3754  unsigned ManglingNumber = 0;
3755  Decl *ManglingContextDecl = nullptr;
3756 
3757 protected:
3759  : Decl(Block, DC, CaretLoc), DeclContext(Block), IsVariadic(false),
3760  CapturesCXXThis(false), BlockMissingReturnType(true),
3761  IsConversionFromLambda(false) {}
3762 
3763 public:
3764  static BlockDecl *Create(ASTContext &C, DeclContext *DC, SourceLocation L);
3765  static BlockDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3766 
3767  SourceLocation getCaretLocation() const { return getLocation(); }
3768 
3769  bool isVariadic() const { return IsVariadic; }
3770  void setIsVariadic(bool value) { IsVariadic = value; }
3771 
3772  CompoundStmt *getCompoundBody() const { return (CompoundStmt*) Body; }
3773  Stmt *getBody() const override { return (Stmt*) Body; }
3774  void setBody(CompoundStmt *B) { Body = (Stmt*) B; }
3775 
3776  void setSignatureAsWritten(TypeSourceInfo *Sig) { SignatureAsWritten = Sig; }
3777  TypeSourceInfo *getSignatureAsWritten() const { return SignatureAsWritten; }
3778 
3779  // ArrayRef access to formal parameters.
3781  return {ParamInfo, getNumParams()};
3782  }
3784  return {ParamInfo, getNumParams()};
3785  }
3786 
3787  // Iterator access to formal parameters.
3790 
3791  bool param_empty() const { return parameters().empty(); }
3792  param_iterator param_begin() { return parameters().begin(); }
3793  param_iterator param_end() { return parameters().end(); }
3794  param_const_iterator param_begin() const { return parameters().begin(); }
3795  param_const_iterator param_end() const { return parameters().end(); }
3796  size_t param_size() const { return parameters().size(); }
3797 
3798  unsigned getNumParams() const { return NumParams; }
3799 
3800  const ParmVarDecl *getParamDecl(unsigned i) const {
3801  assert(i < getNumParams() && "Illegal param #");
3802  return ParamInfo[i];
3803  }
3804  ParmVarDecl *getParamDecl(unsigned i) {
3805  assert(i < getNumParams() && "Illegal param #");
3806  return ParamInfo[i];
3807  }
3808 
3809  void setParams(ArrayRef<ParmVarDecl *> NewParamInfo);
3810 
3811  /// hasCaptures - True if this block (or its nested blocks) captures
3812  /// anything of local storage from its enclosing scopes.
3813  bool hasCaptures() const { return NumCaptures != 0 || CapturesCXXThis; }
3814 
3815  /// getNumCaptures - Returns the number of captured variables.
3816  /// Does not include an entry for 'this'.
3817  unsigned getNumCaptures() const { return NumCaptures; }
3818 
3820 
3821  ArrayRef<Capture> captures() const { return {Captures, NumCaptures}; }
3822 
3823  capture_const_iterator capture_begin() const { return captures().begin(); }
3824  capture_const_iterator capture_end() const { return captures().end(); }
3825 
3826  bool capturesCXXThis() const { return CapturesCXXThis; }
3827  bool blockMissingReturnType() const { return BlockMissingReturnType; }
3828  void setBlockMissingReturnType(bool val) { BlockMissingReturnType = val; }
3829 
3830  bool isConversionFromLambda() const { return IsConversionFromLambda; }
3831  void setIsConversionFromLambda(bool val) { IsConversionFromLambda = val; }
3832 
3833  bool capturesVariable(const VarDecl *var) const;
3834 
3835  void setCaptures(ASTContext &Context, ArrayRef<Capture> Captures,
3836  bool CapturesCXXThis);
3837 
3838  unsigned getBlockManglingNumber() const {
3839  return ManglingNumber;
3840  }
3841 
3843  return ManglingContextDecl;
3844  }
3845 
3846  void setBlockMangling(unsigned Number, Decl *Ctx) {
3847  ManglingNumber = Number;
3848  ManglingContextDecl = Ctx;
3849  }
3850 
3851  SourceRange getSourceRange() const override LLVM_READONLY;
3852 
3853  // Implement isa/cast/dyncast/etc.
3854  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3855  static bool classofKind(Kind K) { return K == Block; }
3857  return static_cast<DeclContext *>(const_cast<BlockDecl*>(D));
3858  }
3860  return static_cast<BlockDecl *>(const_cast<DeclContext*>(DC));
3861  }
3862 };
3863 
3864 /// \brief This represents the body of a CapturedStmt, and serves as its
3865 /// DeclContext.
3866 class CapturedDecl final
3867  : public Decl,
3868  public DeclContext,
3869  private llvm::TrailingObjects<CapturedDecl, ImplicitParamDecl *> {
3870 protected:
3871  size_t numTrailingObjects(OverloadToken<ImplicitParamDecl>) {
3872  return NumParams;
3873  }
3874 
3875 private:
3876  /// \brief The number of parameters to the outlined function.
3877  unsigned NumParams;
3878 
3879  /// \brief The position of context parameter in list of parameters.
3880  unsigned ContextParam;
3881 
3882  /// \brief The body of the outlined function.
3883  llvm::PointerIntPair<Stmt *, 1, bool> BodyAndNothrow;
3884 
3885  explicit CapturedDecl(DeclContext *DC, unsigned NumParams);
3886 
3887  ImplicitParamDecl *const *getParams() const {
3888  return getTrailingObjects<ImplicitParamDecl *>();
3889  }
3890 
3891  ImplicitParamDecl **getParams() {
3892  return getTrailingObjects<ImplicitParamDecl *>();
3893  }
3894 
3895 public:
3896  friend class ASTDeclReader;
3897  friend class ASTDeclWriter;
3899 
3900  static CapturedDecl *Create(ASTContext &C, DeclContext *DC,
3901  unsigned NumParams);
3902  static CapturedDecl *CreateDeserialized(ASTContext &C, unsigned ID,
3903  unsigned NumParams);
3904 
3905  Stmt *getBody() const override;
3906  void setBody(Stmt *B);
3907 
3908  bool isNothrow() const;
3909  void setNothrow(bool Nothrow = true);
3910 
3911  unsigned getNumParams() const { return NumParams; }
3912 
3913  ImplicitParamDecl *getParam(unsigned i) const {
3914  assert(i < NumParams);
3915  return getParams()[i];
3916  }
3917  void setParam(unsigned i, ImplicitParamDecl *P) {
3918  assert(i < NumParams);
3919  getParams()[i] = P;
3920  }
3921 
3922  // ArrayRef interface to parameters.
3924  return {getParams(), getNumParams()};
3925  }
3927  return {getParams(), getNumParams()};
3928  }
3929 
3930  /// \brief Retrieve the parameter containing captured variables.
3932  assert(ContextParam < NumParams);
3933  return getParam(ContextParam);
3934  }
3935  void setContextParam(unsigned i, ImplicitParamDecl *P) {
3936  assert(i < NumParams);
3937  ContextParam = i;
3938  setParam(i, P);
3939  }
3940  unsigned getContextParamPosition() const { return ContextParam; }
3941 
3943  using param_range = llvm::iterator_range<param_iterator>;
3944 
3945  /// \brief Retrieve an iterator pointing to the first parameter decl.
3946  param_iterator param_begin() const { return getParams(); }
3947  /// \brief Retrieve an iterator one past the last parameter decl.
3948  param_iterator param_end() const { return getParams() + NumParams; }
3949 
3950  // Implement isa/cast/dyncast/etc.
3951  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3952  static bool classofKind(Kind K) { return K == Captured; }
3954  return static_cast<DeclContext *>(const_cast<CapturedDecl *>(D));
3955  }
3957  return static_cast<CapturedDecl *>(const_cast<DeclContext *>(DC));
3958  }
3959 };
3960 
3961 /// \brief Describes a module import declaration, which makes the contents
3962 /// of the named module visible in the current translation unit.
3963 ///
3964 /// An import declaration imports the named module (or submodule). For example:
3965 /// \code
3966 /// @import std.vector;
3967 /// \endcode
3968 ///
3969 /// Import declarations can also be implicitly generated from
3970 /// \#include/\#import directives.
3971 class ImportDecl final : public Decl,
3972  llvm::TrailingObjects<ImportDecl, SourceLocation> {
3973  friend class ASTContext;
3974  friend class ASTDeclReader;
3975  friend class ASTReader;
3976  friend TrailingObjects;
3977 
3978  /// \brief The imported module, along with a bit that indicates whether
3979  /// we have source-location information for each identifier in the module
3980  /// name.
3981  ///
3982  /// When the bit is false, we only have a single source location for the
3983  /// end of the import declaration.
3984  llvm::PointerIntPair<Module *, 1, bool> ImportedAndComplete;
3985 
3986  /// \brief The next import in the list of imports local to the translation
3987  /// unit being parsed (not loaded from an AST file).
3988  ImportDecl *NextLocalImport = nullptr;
3989 
3990  ImportDecl(DeclContext *DC, SourceLocation StartLoc, Module *Imported,
3991  ArrayRef<SourceLocation> IdentifierLocs);
3992 
3993  ImportDecl(DeclContext *DC, SourceLocation StartLoc, Module *Imported,
3994  SourceLocation EndLoc);
3995 
3996  ImportDecl(EmptyShell Empty) : Decl(Import, Empty) {}
3997 
3998 public:
3999  /// \brief Create a new module import declaration.
4000  static ImportDecl *Create(ASTContext &C, DeclContext *DC,
4001  SourceLocation StartLoc, Module *Imported,
4002  ArrayRef<SourceLocation> IdentifierLocs);
4003 
4004  /// \brief Create a new module import declaration for an implicitly-generated
4005  /// import.
4006  static ImportDecl *CreateImplicit(ASTContext &C, DeclContext *DC,
4007  SourceLocation StartLoc, Module *Imported,
4008  SourceLocation EndLoc);
4009 
4010  /// \brief Create a new, deserialized module import declaration.
4011  static ImportDecl *CreateDeserialized(ASTContext &C, unsigned ID,
4012  unsigned NumLocations);
4013 
4014  /// \brief Retrieve the module that was imported by the import declaration.
4015  Module *getImportedModule() const { return ImportedAndComplete.getPointer(); }
4016 
4017  /// \brief Retrieves the locations of each of the identifiers that make up
4018  /// the complete module name in the import declaration.
4019  ///
4020  /// This will return an empty array if the locations of the individual
4021  /// identifiers aren't available.
4022  ArrayRef<SourceLocation> getIdentifierLocs() const;
4023 
4024  SourceRange getSourceRange() const override LLVM_READONLY;
4025 
4026  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
4027  static bool classofKind(Kind K) { return K == Import; }
4028 };
4029 
4030 /// \brief Represents a C++ Modules TS module export declaration.
4031 ///
4032 /// For example:
4033 /// \code
4034 /// export void foo();
4035 /// \endcode
4036 class ExportDecl final : public Decl, public DeclContext {
4037  virtual void anchor();
4038 
4039 private:
4040  friend class ASTDeclReader;
4041 
4042  /// \brief The source location for the right brace (if valid).
4043  SourceLocation RBraceLoc;
4044 
4045  ExportDecl(DeclContext *DC, SourceLocation ExportLoc)
4046  : Decl(Export, DC, ExportLoc), DeclContext(Export),
4047  RBraceLoc(SourceLocation()) {}
4048 
4049 public:
4050  static ExportDecl *Create(ASTContext &C, DeclContext *DC,
4051  SourceLocation ExportLoc);
4052  static ExportDecl *CreateDeserialized(ASTContext &C, unsigned ID);
4053 
4054  SourceLocation getExportLoc() const { return getLocation(); }
4055  SourceLocation getRBraceLoc() const { return RBraceLoc; }
4056  void setRBraceLoc(SourceLocation L) { RBraceLoc = L; }
4057 
4058  SourceLocation getLocEnd() const LLVM_READONLY {
4059  if (RBraceLoc.isValid())
4060  return RBraceLoc;
4061  // No braces: get the end location of the (only) declaration in context
4062  // (if present).
4063  return decls_empty() ? getLocation() : decls_begin()->getLocEnd();
4064  }
4065 
4066  SourceRange getSourceRange() const override LLVM_READONLY {
4067  return SourceRange(getLocation(), getLocEnd());
4068  }
4069 
4070  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
4071  static bool classofKind(Kind K) { return K == Export; }
4073  return static_cast<DeclContext *>(const_cast<ExportDecl*>(D));
4074  }
4076  return static_cast<ExportDecl *>(const_cast<DeclContext*>(DC));
4077  }
4078 };
4079 
4080 /// \brief Represents an empty-declaration.
4081 class EmptyDecl : public Decl {
4082  EmptyDecl(DeclContext *DC, SourceLocation L) : Decl(Empty, DC, L) {}
4083 
4084  virtual void anchor();
4085 
4086 public:
4087  static EmptyDecl *Create(ASTContext &C, DeclContext *DC,
4088  SourceLocation L);
4089  static EmptyDecl *CreateDeserialized(ASTContext &C, unsigned ID);
4090 
4091  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
4092  static bool classofKind(Kind K) { return K == Empty; }
4093 };
4094 
4095 /// Insertion operator for diagnostics. This allows sending NamedDecl's
4096 /// into a diagnostic with <<.
4098  const NamedDecl* ND) {
4099  DB.AddTaggedVal(reinterpret_cast<intptr_t>(ND),
4101  return DB;
4102 }
4104  const NamedDecl* ND) {
4105  PD.AddTaggedVal(reinterpret_cast<intptr_t>(ND),
4107  return PD;
4108 }
4109 
4110 template<typename decl_type>
4111 void Redeclarable<decl_type>::setPreviousDecl(decl_type *PrevDecl) {
4112  // Note: This routine is implemented here because we need both NamedDecl
4113  // and Redeclarable to be defined.
4114  assert(RedeclLink.NextIsLatest() &&
4115  "setPreviousDecl on a decl already in a redeclaration chain");
4116 
4117  if (PrevDecl) {
4118  // Point to previous. Make sure that this is actually the most recent
4119  // redeclaration, or we can build invalid chains. If the most recent
4120  // redeclaration is invalid, it won't be PrevDecl, but we want it anyway.
4121  First = PrevDecl->getFirstDecl();
4122  assert(First->RedeclLink.NextIsLatest() && "Expected first");
4123  decl_type *MostRecent = First->getNextRedeclaration();
4124  RedeclLink = PreviousDeclLink(cast<decl_type>(MostRecent));
4125 
4126  // If the declaration was previously visible, a redeclaration of it remains
4127  // visible even if it wouldn't be visible by itself.
4128  static_cast<decl_type*>(this)->IdentifierNamespace |=
4129  MostRecent->getIdentifierNamespace() &
4131  } else {
4132  // Make this first.
4133  First = static_cast<decl_type*>(this);
4134  }
4135 
4136  // First one will point to this one as latest.
4137  First->RedeclLink.setLatest(static_cast<decl_type*>(this));
4138 
4139  assert(!isa<NamedDecl>(static_cast<decl_type*>(this)) ||
4140  cast<NamedDecl>(static_cast<decl_type*>(this))->isLinkageValid());
4141 }
4142 
4143 // Inline function definitions.
4144 
4145 /// \brief Check if the given decl is complete.
4146 ///
4147 /// We use this function to break a cycle between the inline definitions in
4148 /// Type.h and Decl.h.
4149 inline bool IsEnumDeclComplete(EnumDecl *ED) {
4150  return ED->isComplete();
4151 }
4152 
4153 /// \brief Check if the given decl is scoped.
4154 ///
4155 /// We use this function to break a cycle between the inline definitions in
4156 /// Type.h and Decl.h.
4157 inline bool IsEnumDeclScoped(EnumDecl *ED) {
4158  return ED->isScoped();
4159 }
4160 
4161 } // namespace clang
4162 
4163 #endif // LLVM_CLANG_AST_DECL_H
static bool classof(const Decl *D)
Definition: Decl.h:3224
static bool classofKind(Kind K)
Definition: Decl.h:4092
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.h:3680
void setHasSkippedBody(bool Skipped=true)
Definition: Decl.h:2151
FunctionDecl * getDefinition()
Get the definition for this declaration.
Definition: Decl.h:1945
void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex)
Definition: Decl.h:1546
void setOwningFunction(DeclContext *FD)
setOwningFunction - Sets the function declaration that owns this ParmVarDecl.
Definition: Decl.h:1659
bool hasCapturedVLAType() const
Determine whether this member captures the variable length array type.
Definition: Decl.h:2632
redeclarable_base::redecl_range redecl_range
Definition: Decl.h:3062
bool hasCopyExpr() const
Definition: Decl.h:3730
enumerator_iterator enumerator_end() const
Definition: Decl.h:3347
unsigned NumNegativeBits
Definition: Decl.h:2976
bool isStruct() const
Definition: Decl.h:3162
static unsigned getFieldIndex(Decl *F)
ObjCStringFormatFamily
static const Decl * getCanonicalDecl(const Decl *D)
An instance of this class is created to represent a function declaration or definition.
Definition: Decl.h:1697
bool isThisDeclarationADemotedDefinition() const
If this definition should pretend to be a declaration.
Definition: Decl.h:1281
Other implicit parameter.
Definition: Decl.h:1473
static bool classof(const Decl *D)
Definition: Decl.h:646
Expr * getCopyExpr() const
Definition: Decl.h:3731
static DeclContext * castToDeclContext(const ExternCContextDecl *D)
Definition: Decl.h:235
void setAnonymousStructOrUnion(bool Anon)
Definition: Decl.h:3557
A class which contains all the information about a particular captured value.
Definition: Decl.h:3699
A (possibly-)qualified type.
Definition: Type.h:653
TagDecl * getDefinition() const
getDefinition - Returns the TagDecl that actually defines this struct/union/class/enum.
Definition: Decl.cpp:3748
Static storage duration.
Definition: Specifiers.h:277
static bool classofKind(Kind K)
Definition: Decl.h:234
bool isOverloadedOperator() const
isOverloadedOperator - Whether this function declaration represents an C++ overloaded operator...
Definition: Decl.h:2267
bool hasCaptures() const
hasCaptures - True if this block (or its nested blocks) captures anything of local storage from its e...
Definition: Decl.h:3813
static bool classofKind(Kind K)
Definition: Decl.h:446
param_iterator param_begin() const
Retrieve an iterator pointing to the first parameter decl.
Definition: Decl.h:3946
Expr * getInitExpr()
Definition: Decl.h:2691
bool isObjCMethodParameter() const
Definition: Decl.h:1556
capture_const_iterator capture_begin() const
Definition: Decl.h:3823
SourceRange getBraceRange() const
Definition: Decl.h:3072
bool willHaveBody() const
True if this function will eventually have a body, once it&#39;s fully parsed.
Definition: Decl.h:2154
const NamedDecl * getUnderlyingDecl() const
Definition: Decl.h:432
InClassInitStyle getInClassInitStyle() const
Get the kind of (C++11) default member initializer that this field has.
Definition: Decl.h:2590
VarDecl * getVarDecl() const
Definition: Decl.h:2746
redeclarable_base::redecl_iterator redecl_iterator
Definition: Decl.h:543
static TranslationUnitDecl * castFromDeclContext(const DeclContext *DC)
Definition: Decl.h:132
bool IsEnumDeclScoped(EnumDecl *ED)
Check if the given decl is scoped.
Definition: Decl.h:4157
static bool classofKind(Kind K)
Definition: Decl.h:3689
Stmt - This represents one statement.
Definition: Stmt.h:66
Expr * getBitWidth() const
Definition: Decl.h:2556
void setPreviousDecl(decl_type *PrevDecl)
Set the previous declaration.
Definition: Decl.h:4111
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3056
TagDecl(Kind DK, TagKind TK, const ASTContext &C, DeclContext *DC, SourceLocation L, IdentifierInfo *Id, TagDecl *PrevDecl, SourceLocation StartL)
Definition: Decl.h:3026
bool IsICE
Whether this statement is an integral constant expression, or in C++11, whether the statement is a co...
Definition: Decl.h:794
EnumConstantDecl - An instance of this object exists for each enum constant that is defined...
Definition: Decl.h:2671
void setEmbeddedInDeclarator(bool isInDeclarator)
Definition: Decl.h:3115
TypedefDecl - Represents the declaration of a typedef-name via the &#39;typedef&#39; type specifier...
Definition: Decl.h:2898
C Language Family Type Representation.
bool param_empty() const
Definition: Decl.h:3791
const EnumDecl * getCanonicalDecl() const
Definition: Decl.h:3290
void setParam(unsigned i, ImplicitParamDecl *P)
Definition: Decl.h:3917
bool IsEvaluating
Whether this statement is being evaluated.
Definition: Decl.h:781
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
Definition: Decl.h:2042
const RecordDecl * getMostRecentDecl() const
Definition: Decl.h:3537
bool hasVolatileMember() const
Definition: Decl.h:3564
param_const_iterator param_end() const
Definition: Decl.h:3795
redeclarable_base::redecl_range redecl_range
Definition: Decl.h:1871
static TemplateSpecializationKind getTemplateSpecializationKind(Decl *D)
Determine what kind of template specialization the given declaration is.
const Type * getTypeForDecl() const
Definition: Decl.h:2784
DeclaratorDecl(Kind DK, DeclContext *DC, SourceLocation L, DeclarationName N, QualType T, TypeSourceInfo *TInfo, SourceLocation StartL)
Definition: Decl.h:698
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:86
unsigned getNumCaptures() const
getNumCaptures - Returns the number of captured variables.
Definition: Decl.h:3817
void setRangeEnd(SourceLocation E)
Definition: Decl.h:1914
redeclarable_base::redecl_iterator redecl_iterator
Definition: Decl.h:1872
bool hasUnusedResultAttr() const
Returns true if this function or its return type has the warn_unused_result attribute.
Definition: Decl.h:2233
void AddTaggedVal(intptr_t V, DiagnosticsEngine::ArgumentKind Kind) const
EnumDecl * getPreviousDecl()
Definition: Decl.h:3294
ThreadStorageClassSpecifier getTSCSpec() const
Definition: Decl.h:1018
param_iterator param_end()
Definition: Decl.h:3793
StringRef P
NamedDecl(Kind DK, DeclContext *DC, SourceLocation L, DeclarationName N)
Definition: Decl.h:257
Parameter for C++ &#39;this&#39; argument.
Definition: Decl.h:1464
bool hasWrittenPrototype() const
Definition: Decl.h:2034
ImplicitParamKind
Defines the kind of the implicit parameter: is this an implicit parameter with pointer to &#39;this&#39;...
Definition: Decl.h:1456
const DiagnosticBuilder & operator<<(const DiagnosticBuilder &DB, const Attr *At)
Definition: Attr.h:195
unsigned getBlockManglingNumber() const
Definition: Decl.h:3838
const RecordDecl * getParent() const
getParent - Returns the parent of this field declaration, which is the struct in which this field is ...
Definition: Decl.h:2648
bool isCXXForRangeDecl() const
Determine whether this variable is the for-range-declaration in a C++0x for-range statement...
Definition: Decl.h:1327
The base class of the type hierarchy.
Definition: Type.h:1351
Represents an empty-declaration.
Definition: Decl.h:4081
void setCopyExpr(Expr *e)
Definition: Decl.h:3732
friend TrailingObjects
Definition: Decl.h:3898
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies the name of this declaration, if it was present in ...
Definition: Decl.h:3196
bool usesSEHTry() const
Indicates the function uses __try.
Definition: Decl.h:2055
Declaration of a variable template.
NamespaceDecl - Represent a C++ namespace.
Definition: Decl.h:505
A container of type source information.
Definition: Decl.h:86
QualType getCallResultType() const
Determine the type of an expression that calls this function.
Definition: Decl.h:2222
StorageDuration
The storage duration for an object (per C++ [basic.stc]).
Definition: Specifiers.h:273
StringLiteral * getAsmString()
Definition: Decl.h:3685
ArrayRef< Capture >::const_iterator capture_const_iterator
Definition: Decl.h:3819
bool CheckingICE
Whether we are checking whether this statement is an integral constant expression.
Definition: Decl.h:789
const Expr * getAnyInitializer() const
getAnyInitializer - Get the initializer for this variable, no matter which declaration it is attached...
Definition: Decl.h:1202
void setInitStyle(InitializationStyle Style)
Definition: Decl.h:1257
ArrayRef< ParmVarDecl * >::const_iterator param_const_iterator
Definition: Decl.h:2176
MutableArrayRef< ParmVarDecl * >::iterator param_iterator
Definition: Decl.h:3788
bool isVirtualAsWritten() const
Whether this function is marked as virtual explicitly.
Definition: Decl.h:1991
bool hasInClassInitializer() const
Determine whether this member has a C++11 default member initializer.
Definition: Decl.h:2597
size_t param_size() const
Definition: Decl.h:2183
bool isCompleteDefinition() const
isCompleteDefinition - Return true if this decl has its body fully specified.
Definition: Decl.h:3097
capture_const_iterator capture_end() const
Definition: Decl.h:3824
Represents a #pragma comment line.
Definition: Decl.h:139
static CapturedDecl * castFromDeclContext(const DeclContext *DC)
Definition: Decl.h:3956
VarDecl * getMostRecentDeclImpl() override
Implementation of getMostRecentDecl(), to be overridden by any subclass that has a redeclaration chai...
Definition: Decl.h:983
enumerator_range enumerators() const
Definition: Decl.h:3336
bool isInterface() const
Definition: Decl.h:3163
ExplicitVisibilityKind
Kinds of explicit visibility.
Definition: Decl.h:389
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:806
bool WasEvaluated
Whether this statement was already evaluated.
Definition: Decl.h:778
QualType getReturnType() const
Definition: Decl.h:2207
RecordDecl * getPreviousDecl()
Definition: Decl.h:3526
bool isFixed() const
Returns true if this is an Objective-C, C++11, or Microsoft-style enumeration with a fixed underlying...
Definition: Decl.h:3426
static bool classofKind(Kind K)
Definition: Decl.h:2913
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6305
redeclarable_base::redecl_range redecl_range
Definition: Decl.h:542
The "union" keyword.
Definition: Type.h:4694
bool hasInheritedDefaultArg() const
Definition: Decl.h:1641
size_t numTrailingObjects(OverloadToken< ImplicitParamDecl >)
Definition: Decl.h:3871
Declaration context for names declared as extern "C" in C++.
Definition: Decl.h:221
The "__interface" keyword.
Definition: Type.h:4691
Parameter for Objective-C &#39;_cmd&#39; argument.
Definition: Decl.h:1461
const FunctionDecl * getCanonicalDecl() const
Definition: Decl.h:2160
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:422
bool field_empty() const
Definition: Decl.h:3628
NamespaceDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this namespace.
Definition: Decl.h:597
Represents an explicit template argument list in C++, e.g., the "<int>" in "sort<int>".
Definition: TemplateBase.h:595
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:68
unsigned getContextParamPosition() const
Definition: Decl.h:3940
static StringRef getTagTypeKindName(TagTypeKind Kind)
Definition: Type.h:4768
static bool classof(const Decl *D)
Definition: Decl.h:2755
Not a TLS variable.
Definition: Decl.h:823
Describes how types, statements, expressions, and declarations should be printed. ...
Definition: PrettyPrinter.h:38
static DeclContext * castToDeclContext(const ExportDecl *D)
Definition: Decl.h:4072
unsigned IsExplicitSpecified
Definition: Decl.h:1726
static const NamedDecl * getDefinition(const Decl *D)
Definition: SemaDecl.cpp:2512
ParmVarDecl - Represents a parameter to a function.
Definition: Decl.h:1513
ArrayRef< ParmVarDecl * >::const_iterator param_const_iterator
Definition: Decl.h:3789
MutableArrayRef< ParmVarDecl * >::iterator param_iterator
Definition: Decl.h:2175
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have...
Definition: Linkage.h:25
Provides information about a dependent function-template specialization declaration.
Definition: DeclTemplate.h:671
MutableArrayRef< ParmVarDecl * > parameters()
Definition: Decl.h:3783
bool isARCPseudoStrong() const
Determine whether this variable is an ARC pseudo-__strong variable.
Definition: Decl.h:1339
bool isClass() const
Definition: Decl.h:3164
IdentifierInfo * getIdentifier() const
getIdentifier - Get the identifier that names this declaration, if there is one.
Definition: Decl.h:265
Types, declared with &#39;struct foo&#39;, typedefs, etc.
Definition: DeclBase.h:130
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:56
LabelStmt - Represents a label, which has a substatement.
Definition: Stmt.h:842
RecordDecl - Represents a struct/union/class.
Definition: Decl.h:3488
void AddTaggedVal(intptr_t V, DiagnosticsEngine::ArgumentKind Kind) const
Definition: Diagnostic.h:1069
DeclarationName getDeclName() const
getDeclName - Get the actual, stored name of the declaration, which may be a special name...
Definition: Decl.h:291
Provides common interface for the Decls that can be redeclared.
Definition: Redeclarable.h:87
TypeSourceInfo * getIntegerTypeSourceInfo() const
Return the type source info for the underlying integer type, if no type source info exists...
Definition: Decl.h:3380
FunctionDecl * getPreviousDeclImpl() override
Implementation of getPreviousDecl(), to be overridden by any subclass that has a redeclaration chain...
Definition: Decl.h:1859
static bool classofKind(Kind K)
Definition: Decl.h:1446
Linkage getFormalLinkage() const
Get the linkage from a semantic point of view.
Definition: Decl.h:361
bool isComplete() const
Returns true if this can be considered a complete type.
Definition: Decl.h:3431
One of these records is kept for each identifier that is lexed.
void setIntegerType(QualType T)
Set the underlying integer type.
Definition: Decl.h:3373
bool hasBody() const override
Returns true if this Decl represents a declaration for a body of code, such as a function or method d...
Definition: Decl.h:1925
static bool classofKind(Kind K)
Definition: Decl.h:3637
FieldDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this field.
Definition: Decl.h:2659
static bool classof(const Decl *D)
Definition: Decl.h:2797
Copy initialization.
Definition: Specifiers.h:228
void setCompleteDefinition(bool V)
Definition: Decl.h:3146
RecordDecl * getParent()
Definition: Decl.h:2652
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:149
A C++ nested-name-specifier augmented with source location information.
bool isInline() const
Returns true if this is an inline namespace declaration.
Definition: Decl.h:566
bool CheckedICE
Whether we already checked whether this statement was an integral constant expression.
Definition: Decl.h:785
static bool classof(const Decl *D)
Definition: Decl.h:500
RecordDecl * getDefinition() const
getDefinition - Returns the RecordDecl that actually defines this struct/union/class.
Definition: Decl.h:3609
field_range fields() const
Definition: Decl.h:3619
bool hasSkippedBody() const
True if the function was a definition but its body was skipped.
Definition: Decl.h:2150
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2467
void setBlockMissingReturnType(bool val)
Definition: Decl.h:3828
ImplicitParamDecl * getContextParam() const
Retrieve the parameter containing captured variables.
Definition: Decl.h:3931
Parameter for C++ virtual table pointers.
Definition: Decl.h:1467
const llvm::APSInt & getInitVal() const
Definition: Decl.h:2692
void setLocStart(SourceLocation L)
Definition: Decl.h:487
const FunctionDecl * getDefinition() const
Definition: Decl.h:1951
unsigned getFunctionScopeIndex() const
Returns the index of this parameter in its prototype or method scope.
Definition: Decl.h:1566
static DeclContext * castToDeclContext(const FunctionDecl *D)
Definition: Decl.h:2457
StringRef getValue() const
Definition: Decl.h:197
ImplicitParamDecl(ASTContext &C, QualType Type, ImplicitParamKind ParamKind)
Definition: Decl.h:1494
FieldDecl * getAnonField() const
Definition: Decl.h:2741
void overrideType(QualType T)
Override the type stored in this TypeSourceInfo. Use with caution!
Definition: Decl.h:103
Linkage getFormalLinkage(Linkage L)
Definition: Linkage.h:91
static bool classofKind(Kind K)
Definition: Decl.h:3481
bool isExternallyDeclarable() const
Determine whether this declaration can be redeclared in a different translation unit.
Definition: Decl.h:376
Stmt * getBody() const override
getBody - If this Decl represents a declaration for a body of code, such as a function or method defi...
Definition: Decl.h:3773
void setNumPositiveBits(unsigned Num)
Definition: Decl.h:3393
void setParams(ArrayRef< ParmVarDecl *> NewParamInfo)
Definition: Decl.h:2198
bool hasLoadedFieldsFromExternalStorage() const
Definition: Decl.h:3567
bool isGnuLocal() const
Definition: Decl.h:486
bool isPreviousDeclInSameBlockScope() const
Whether this local extern variable declaration&#39;s previous declaration was declared in the same block ...
Definition: Decl.h:1385
TypedefNameDecl * getNextRedeclarationImpl() override
Returns the next redeclaration or itself if this is the only decl.
Definition: Decl.h:2822
TypeSourceInfo * getSignatureAsWritten() const
Definition: Decl.h:3777
Describes a module or submodule.
Definition: Module.h:65
static bool classofKind(Kind K)
Definition: Decl.h:768
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:2167
virtual bool isDefined() const
Definition: Decl.h:1939
SourceLocation getAsmLoc() const
Definition: Decl.h:3677
Provides information about a function template specialization, which is a FunctionDecl that has been ...
Definition: DeclTemplate.h:507
TypedefNameDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this typedef-name.
Definition: Decl.h:2868
unsigned getNumParams() const
Definition: Decl.h:3798
static NamespaceDecl * castFromDeclContext(const DeclContext *DC)
Definition: Decl.h:619
InitializationStyle
Initialization styles.
Definition: Decl.h:809
static bool classof(const Decl *D)
Definition: Decl.h:2704
bool isBitField() const
Determines whether this field is a bitfield.
Definition: Decl.h:2545
TypeDecl(Kind DK, DeclContext *DC, SourceLocation L, IdentifierInfo *Id, SourceLocation StartL=SourceLocation())
Definition: Decl.h:2775
TagKind getTagKind() const
Definition: Decl.h:3156
redeclarable_base::redecl_iterator redecl_iterator
Definition: Decl.h:989
A convenient class for passing around template argument information.
Definition: TemplateBase.h:546
bool isKNRPromoted() const
True if the value passed to this parameter must undergo K&R-style default argument promotion: ...
Definition: Decl.h:1587
uint32_t Offset
Definition: CacheTokens.cpp:43
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
const FieldDecl * getCanonicalDecl() const
Definition: Decl.h:2660
Parameter for captured context.
Definition: Decl.h:1470
bool hasPrototype() const
Whether this function has a prototype, either because one was explicitly written or because it was "i...
Definition: Decl.h:2030
ArrayRef< NamedDecl * > chain() const
Definition: Decl.h:2733
ASTContext & getASTContext() const
Definition: Decl.h:119
Visibility
Describes the different kinds of visibility that a declaration may have.
Definition: Visibility.h:32
param_iterator param_end() const
Retrieve an iterator one past the last parameter decl.
Definition: Decl.h:3948
static bool classof(const Decl *D)
Definition: Decl.h:3854
DefinitionKind hasDefinition() const
Definition: Decl.h:1158
bool isByRef() const
Whether this is a "by ref" capture, i.e.
Definition: Decl.h:3724
TypeDecl - Represents a declaration of a type.
Definition: Decl.h:2760
void setHasObjectMember(bool val)
Definition: Decl.h:3562
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier (with source-location information) that qualifies the name of this...
Definition: Decl.h:745
unsigned getNumPositiveBits() const
Returns the width in bits required to store all the non-negative enumerators of this enum...
Definition: Decl.h:3390
A set of unresolved declarations.
Definition: UnresolvedSet.h:61
void setHasImplicitReturnZero(bool IRZ)
Definition: Decl.h:2024
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this enumeration is an instantiation of a member enumeration of a class template specialization...
Definition: Decl.h:3469
void setExceptionVariable(bool EV)
Definition: Decl.h:1302
Defines the Diagnostic-related interfaces.
bool isConstexpr() const
Whether this variable is (C++11) constexpr.
Definition: Decl.h:1366
static bool classof(const Decl *D)
Definition: Decl.h:127
FunctionDecl * getMostRecentDeclImpl() override
Implementation of getMostRecentDecl(), to be overridden by any subclass that has a redeclaration chai...
Definition: Decl.h:1863
bool hasUnparsedDefaultArg() const
hasUnparsedDefaultArg - Determines whether this parameter has a default argument that has not yet bee...
Definition: Decl.h:1624
void setTrivial(bool IT)
Definition: Decl.h:2008
static BlockDecl * castFromDeclContext(const DeclContext *DC)
Definition: Decl.h:3859
TagDecl * getPreviousDeclImpl() override
Implementation of getPreviousDecl(), to be overridden by any subclass that has a redeclaration chain...
Definition: Decl.h:3045
static bool classof(const Decl *D)
Definition: Decl.h:3951
Defines the Linkage enumeration and various utility functions.
const Expr * getInitExpr() const
Definition: Decl.h:2690
bool hasNameForLinkage() const
Is this tag type named, either directly or via being defined in a typedef of this type...
Definition: Decl.h:3183
TypedefNameDecl * getPreviousDeclImpl() override
Implementation of getPreviousDecl(), to be overridden by any subclass that has a redeclaration chain...
Definition: Decl.h:2826
bool isCompleteDefinitionRequired() const
Return true if this complete decl is required to be complete for some existing use.
Definition: Decl.h:3103
void setNumNegativeBits(unsigned Num)
Definition: Decl.h:3410
static bool classofKind(Kind K)
Definition: Decl.h:1509
redeclarable_base::redecl_range redecl_range
Definition: Decl.h:988
static bool classofKind(Kind K)
Definition: Decl.h:168
This represents the body of a CapturedStmt, and serves as its DeclContext.
Definition: Decl.h:3866
void setInitVal(const llvm::APSInt &V)
Definition: Decl.h:2695
Ordinary names.
Definition: DeclBase.h:144
void setInitExpr(Expr *E)
Definition: Decl.h:2694
void setStmt(LabelStmt *T)
Definition: Decl.h:484
void setLocStart(SourceLocation L)
Definition: Decl.h:2788
static FunctionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation NLoc, DeclarationName N, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool isInlineSpecified=false, bool hasWrittenPrototype=true, bool isConstexprSpecified=false)
Definition: Decl.h:1881
SourceLocation getLocEnd() const LLVM_READONLY
Definition: Decl.h:4058
VarDecl * getPreviousDeclImpl() override
Implementation of getPreviousDecl(), to be overridden by any subclass that has a redeclaration chain...
Definition: Decl.h:979
bool isAnonymousStructOrUnion() const
isAnonymousStructOrUnion - Whether this is an anonymous struct or union.
Definition: Decl.h:3556
param_iterator param_begin()
Definition: Decl.h:2179
void setHasInheritedPrototype(bool P=true)
Definition: Decl.h:2039
Defines the clang::Visibility enumeration and various utility functions.
Module * getImportedModule() const
Retrieve the module that was imported by the import declaration.
Definition: Decl.h:4015
param_const_iterator param_end() const
Definition: Decl.h:2182
static bool classof(const Decl *D)
Definition: Decl.h:3480
StorageDuration getStorageDuration() const
Get the storage duration of this variable, per C++ [basic.stc].
Definition: Decl.h:1070
static bool classof(const Decl *D)
Definition: Decl.h:2912
StringRef getArg() const
Definition: Decl.h:164
void removeInClassInitializer()
removeInClassInitializer - Remove the C++11 in-class initializer from this member.
Definition: Decl.h:2625
void setInline(bool Inline)
Set whether this is an inline namespace declaration.
Definition: Decl.h:571
Provides definitions for the various language-specific address spaces.
void setLazyBody(uint64_t Offset)
Definition: Decl.h:1985
bool isExternalFormalLinkage(Linkage L)
Definition: Linkage.h:104
RecordDecl * getMostRecentDecl()
Definition: Decl.h:3534
A placeholder type used to construct an empty shell of a decl-derived type that will be filled in lat...
Definition: DeclBase.h:102
TypeAliasDecl - Represents the declaration of a typedef-name via a C++0x alias-declaration.
Definition: Decl.h:2918
A little helper class used to produce diagnostics.
Definition: Diagnostic.h:955
CompoundStmt - This represents a group of statements like { stmt stmt }.
Definition: Stmt.h:595
void setHasLoadedFieldsFromExternalStorage(bool val)
Definition: Decl.h:3570
static bool classof(const Decl *D)
Definition: Decl.h:1445
bool isFileVarDecl() const
isFileVarDecl - Returns true for file scoped variable declaration.
Definition: Decl.h:1186
static bool classofKind(Kind K)
Definition: Decl.h:615
SourceLocation getLocStart() const LLVM_READONLY
Definition: Decl.h:2787
static bool classof(const Decl *D)
Definition: Decl.h:4026
Represents a ValueDecl that came out of a declarator.
Definition: Decl.h:680
QualType getPromotionType() const
getPromotionType - Return the integer type that enumerators should promote to.
Definition: Decl.h:3356
bool isInlineSpecified() const
Definition: Decl.h:1351
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:2847
static bool classof(const Decl *D)
Definition: Decl.h:3688
void setInClassInitializer(Expr *Init)
setInClassInitializer - Set the C++11 in-class initializer for this member.
Definition: Decl.h:2615
FieldDecl(Kind DK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable, InClassInitStyle InitStyle)
Definition: Decl.h:2514
bool isTransparentTag() const
Determines if this typedef shares a name and spelling location with its underlying tag type...
Definition: Decl.h:2880
static bool classof(const Decl *D)
Definition: Decl.h:2663
TypedefNameDecl * getMostRecentDeclImpl() override
Implementation of getMostRecentDecl(), to be overridden by any subclass that has a redeclaration chai...
Definition: Decl.h:2830
bool isInlineSpecified() const
Determine whether the "inline" keyword was specified for this function.
Definition: Decl.h:2241
BlockDecl - This represents a block literal declaration, which is like an unnamed FunctionDecl...
Definition: Decl.h:3695
unsigned getFunctionScopeDepth() const
Definition: Decl.h:1560
bool isDependentType() const
Whether this declaration declares a type that is dependent, i.e., a type that somehow depends on temp...
Definition: Decl.h:3127
ValueDecl - Represent the declaration of a variable (in which case it is an lvalue) a function (in wh...
Definition: Decl.h:627
Expr - This represents one expression.
Definition: Expr.h:106
StringRef getKindName() const
Definition: Decl.h:3152
TypedefNameDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, TypeSourceInfo *TInfo)
Definition: Decl.h:2814
unsigned getChainingSize() const
Definition: Decl.h:2739
void setBitWidth(Expr *Width)
setBitWidth - Set the bit-field width for this member.
Definition: Decl.h:2569
static bool classofKind(Kind K)
Definition: Decl.h:2756
bool isDefaulted() const
Whether this function is defaulted per C++0x.
Definition: Decl.h:2012
std::string Label
static bool classof(const Decl *D)
Definition: Decl.h:4070
bool isScopedUsingClassTag() const
Returns true if this is a C++11 scoped enumeration.
Definition: Decl.h:3420
int Id
Definition: ASTDiff.cpp:191
bool hasLocalStorage() const
hasLocalStorage - Returns true if a variable with function scope is a non-static local variable...
Definition: Decl.h:1025
const FunctionProtoType * T
NamespaceDecl * getAnonymousNamespace() const
Definition: Decl.h:121
void setRBraceLoc(SourceLocation L)
Definition: Decl.h:611
unsigned getNumParams() const
Definition: Decl.h:3911
bool isThisDeclarationADefinition() const
Returns whether this specific declaration of the function is also a definition that does not contain ...
Definition: Decl.h:1973
std::string getAsString() const
getNameAsString - Retrieve the human-readable string for this name.
bool isAnonymousNamespace() const
Returns true if this is an anonymous namespace declaration.
Definition: Decl.h:561
bool isExceptionVariable() const
Determine whether this variable is the exception variable in a C++ catch statememt or an Objective-C ...
Definition: Decl.h:1299
void setContextParam(unsigned i, ImplicitParamDecl *P)
Definition: Decl.h:3935
Defines an enumeration for C++ overloaded operators.
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies the name of this declaration, if it was present in ...
Definition: Decl.h:737
field_iterator field_end() const
Definition: Decl.h:3622
ArrayRef< ImplicitParamDecl * > parameters() const
Definition: Decl.h:3923
TemplateParameterList * getTemplateParameterList(unsigned index) const
Definition: Decl.h:756
static bool classofKind(Kind K)
Definition: Decl.h:2888
llvm::PointerUnion< Stmt *, EvaluatedStmt * > InitType
Definition: Decl.h:846
This declaration is a tentative definition.
Definition: Decl.h:1141
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:2237
static bool classof(const Decl *D)
Definition: Decl.h:767
void setCompleteDefinitionRequired(bool V=true)
Definition: Decl.h:3148
EnumDecl * getDefinition() const
Definition: Decl.h:3309
EnumDecl * getMostRecentDecl()
Definition: Decl.h:3302
void setLateTemplateParsed(bool ILT=true)
Definition: Decl.h:2001
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:3800
void setLocStart(SourceLocation L)
Definition: Decl.h:610
static DeclContext * castToDeclContext(const CapturedDecl *D)
Definition: Decl.h:3953
bool isFunctionTemplateSpecialization() const
Determine whether this function is a function template specialization.
Definition: Decl.h:2331
IdentifierInfo * getAsIdentifierInfo() const
getAsIdentifierInfo - Retrieve the IdentifierInfo * stored in this declaration name, or NULL if this declaration name isn&#39;t a simple identifier.
MutableArrayRef< ParmVarDecl * > parameters()
Definition: Decl.h:2170
void setModulePrivate()
Specify that this declaration was marked as being private to the module in which it was defined...
Definition: DeclBase.h:618
const VarDecl * getDefinition() const
Definition: Decl.h:1177
void setConstexpr(bool IC)
Definition: Decl.h:1369
unsigned IsCopyDeductionCandidate
[C++17] Only used by CXXDeductionGuideDecl.
Definition: Decl.h:1759
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
bool isFunctionOrMethod() const
Definition: DeclBase.h:1384
StorageClass
Storage classes.
Definition: Specifiers.h:203
static Optional< Visibility > getExplicitVisibility(const NamedDecl *D, LVComputationKind kind)
Definition: Decl.cpp:152
llvm::iterator_range< specific_decl_iterator< FieldDecl > > field_range
Definition: Decl.h:3617
enumerator_iterator enumerator_begin() const
Definition: Decl.h:3340
PragmaMSCommentKind
Definition: PragmaKinds.h:15
bool isIdentifier() const
Predicate functions for querying what type of name this is.
InClassInitStyle
In-class initialization styles for non-static data members.
Definition: Specifiers.h:226
Declaration of an alias template.
const EnumConstantDecl * getCanonicalDecl() const
Definition: Decl.h:2701
bool isExternallyVisible(Linkage L)
Definition: Linkage.h:87
unsigned IsScopedUsingClassTag
IsScopedUsingClassTag - If this tag declaration is a scoped enum, then this is true if the scoped enu...
Definition: Decl.h:2986
void setModedTypeSourceInfo(TypeSourceInfo *unmodedTSI, QualType modedTy)
Definition: Decl.h:2863
static bool hasDefinition(const ObjCObjectPointerType *ObjPtr)
const IndirectFieldDecl * getCanonicalDecl() const
Definition: Decl.h:2752
SourceLocation getCaretLocation() const
Definition: Decl.h:3767
const EnumDecl * getMostRecentDecl() const
Definition: Decl.h:3305
static bool classof(const Decl *D)
Definition: Decl.h:1662
TagDecl * getMostRecentDeclImpl() override
Implementation of getMostRecentDecl(), to be overridden by any subclass that has a redeclaration chai...
Definition: Decl.h:3049
StringRef getName() const
Definition: Decl.h:196
static DeclContext * castToDeclContext(const NamespaceDecl *D)
Definition: Decl.h:616
This template specialization was implicitly instantiated from a template.
Definition: Specifiers.h:149
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
Definition: Decl.h:2007
DefinitionKind isThisDeclarationADefinition() const
Definition: Decl.h:1151
InitializationStyle getInitStyle() const
The style of initialization for this declaration.
Definition: Decl.h:1271
bool IsEnumDeclComplete(EnumDecl *ED)
Check if the given decl is complete.
Definition: Decl.h:4149
void setBlockMangling(unsigned Number, Decl *Ctx)
Definition: Decl.h:3846
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
Definition: Specifiers.h:167
static StringRef getIdentifier(const Token &Tok)
static bool classofKind(Kind K)
Definition: Decl.h:3952
static bool classof(const Decl *D)
Definition: Decl.h:2887
bool isDirectInit() const
Whether the initializer is a direct-initializer (list or call).
Definition: Decl.h:1276
bool isEnum() const
Definition: Decl.h:3166
param_iterator param_begin()
Definition: Decl.h:3792
void setIsVariadic(bool value)
Definition: Decl.h:3770
bool hasInheritedPrototype() const
Whether this function inherited its prototype from a previous declaration.
Definition: Decl.h:2038
Thread storage duration.
Definition: Specifiers.h:276
BlockDecl(DeclContext *DC, SourceLocation CaretLoc)
Definition: Decl.h:3758
virtual void printName(raw_ostream &os) const
Definition: Decl.cpp:1468
void setTypeForDecl(const Type *TD)
Definition: Decl.h:2785
static bool classof(const Decl *D)
Definition: Decl.h:614
Represents a C++ Modules TS module export declaration.
Definition: Decl.h:4036
chain_iterator chain_end() const
Definition: Decl.h:2737
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.h:604
QualifierInfo - A struct with extended info about a syntactic name qualifier, to be used for the case...
Definition: Decl.h:652
Decl::Kind getDeclKind() const
Definition: DeclBase.h:1328
static bool classofKind(Kind K)
Definition: Decl.h:2940
static bool classofKind(Kind K)
Definition: Decl.h:3225
static bool classof(const Decl *D)
Definition: Decl.h:3636
#define false
Definition: stdbool.h:33
The "struct" keyword.
Definition: Type.h:4688
static ExternCContextDecl * castFromDeclContext(const DeclContext *DC)
Definition: Decl.h:238
const VarDecl * getActingDefinition() const
Definition: Decl.h:1165
ArrayRef< NamedDecl * >::const_iterator chain_iterator
Definition: Decl.h:2731
void setIsConversionFromLambda(bool val)
Definition: Decl.h:3831
void setKNRPromoted(bool promoted)
Definition: Decl.h:1590
unsigned NumPositiveBits
Definition: Decl.h:2975
Encodes a location in the source.
static DeclContext * castToDeclContext(const TranslationUnitDecl *D)
Definition: Decl.h:129
bool isPure() const
Whether this virtual function is pure, i.e.
Definition: Decl.h:1996
ImplicitParamDecl *const * param_iterator
Definition: Decl.h:3942
decl_iterator decls_begin() const
Definition: DeclBase.cpp:1335
static bool classof(const Decl *D)
Definition: Decl.h:233
static bool classofKind(Kind K)
Definition: Decl.h:4027
void setBraceRange(SourceRange R)
Definition: Decl.h:3073
ParmVarDecl * getParamDecl(unsigned i)
Definition: Decl.h:2194
void setAnonymousNamespace(NamespaceDecl *D)
Definition: Decl.h:592
static bool classofKind(Kind K)
Definition: Decl.h:2705
SourceLocation getLocStart() const LLVM_READONLY
Definition: Decl.h:608
std::string getNameAsString() const
getNameAsString - Get a human-readable name for the declaration, even if it is one of the special kin...
Definition: Decl.h:285
bool isUnnamedBitfield() const
Determines whether this is an unnamed bitfield.
Definition: Decl.h:2548
redeclarable_base::redecl_iterator redecl_iterator
Definition: Decl.h:2836
const VariableArrayType * getCapturedVLAType() const
Get the captured variable length array type.
Definition: Decl.h:2637
void setFreeStanding(bool isFreeStanding=true)
Definition: Decl.h:3120
TagDecl - Represents the declaration of a struct/union/class/enum.
Definition: Decl.h:2944
LanguageLinkage
Describes the different kinds of language linkage (C++ [dcl.link]) that an entity may have...
Definition: Linkage.h:66
TypeAliasTemplateDecl * getDescribedAliasTemplate() const
Definition: Decl.h:2935
LabelDecl - Represents the declaration of a label.
Definition: Decl.h:459
TagDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.cpp:3714
Expr * getInClassInitializer() const
Get the C++11 default member initializer for this member, or null if one has not been set...
Definition: Decl.h:2604
SourceLocation getRParenLoc() const
Definition: Decl.h:3678
const NamespaceDecl * getCanonicalDecl() const
Definition: Decl.h:600
void setDefaulted(bool D=true)
Definition: Decl.h:2013
void setHasFlexibleArrayMember(bool V)
Definition: Decl.h:3542
EnumDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.h:3287
bool hasGlobalStorage() const
Returns true for all variables that do not have local storage.
Definition: Decl.h:1067
Represents a C++ nested name specifier, such as "\::std::vector<int>::".
C-style initialization with assignment.
Definition: Decl.h:811
void setInstantiationOfMemberEnum(EnumDecl *ED, TemplateSpecializationKind TSK)
Specify that this enumeration is an instantiation of the member enumeration ED.
Definition: Decl.h:3475
bool isConversionFromLambda() const
Definition: Decl.h:3830
static bool classof(const Decl *D)
Definition: Decl.h:445
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:2190
void demoteThisDefinitionToDeclaration()
This is a definition which should be demoted to a declaration.
Definition: Decl.h:1291
IndirectFieldDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: Decl.h:2751
bool isScoped() const
Returns true if this is a C++11 scoped enumeration.
Definition: Decl.h:3415
void setDeclName(DeclarationName N)
Set the name of this declaration.
Definition: Decl.h:294
Capture(VarDecl *variable, bool byRef, bool nested, Expr *copy)
Definition: Decl.h:3714
FunctionDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, StorageClass S, bool isInlineSpecified, bool isConstexprSpecified)
Definition: Decl.h:1835
llvm::iterator_range< specific_decl_iterator< EnumConstantDecl > > enumerator_range
Definition: Decl.h:3334
ParmVarDecl * getParamDecl(unsigned i)
Definition: Decl.h:3804
void setTagKind(TagKind TK)
Definition: Decl.h:3160
This declaration is only a declaration.
Definition: Decl.h:1138
Direct list-initialization.
Definition: Specifiers.h:229
void removeBitWidth()
removeBitWidth - Remove the bit-field width from this member.
Definition: Decl.h:2583
bool isMSAsmLabel() const
Definition: Decl.h:493
static ExportDecl * castFromDeclContext(const DeclContext *DC)
Definition: Decl.h:4075
bool isModed() const
Definition: Decl.h:2845
Decl * getBlockManglingContextDecl() const
Definition: Decl.h:3842
bool hasLinkageBeenComputed() const
True if something has required us to compute the linkage of this declaration.
Definition: Decl.h:416
bool hasUninstantiatedDefaultArg() const
Definition: Decl.h:1628
VarDecl * getVariable() const
The variable being captured.
Definition: Decl.h:3720
bool isExplicitlyDefaulted() const
Whether this function is explicitly defaulted per C++0x.
Definition: Decl.h:2017
DeclarationNameInfo getNameInfo() const
Definition: Decl.h:1907
Stmt * getBody() const override
getBody - If this Decl represents a declaration for a body of code, such as a function or method defi...
Definition: Decl.h:1963
const Expr * getDefaultArg() const
Definition: Decl.h:1595
bool hasImplicitReturnZero() const
Whether falling off this function implicitly returns null/zero.
Definition: Decl.h:2023
static DeclContext * castToDeclContext(const BlockDecl *D)
Definition: Decl.h:3856
void setExplicitlyDefaulted(bool ED=true)
Definition: Decl.h:2018
void setHasInheritedDefaultArg(bool I=true)
Definition: Decl.h:1645
bool hasFlexibleArrayMember() const
Definition: Decl.h:3541
static bool classofKind(Kind K)
Definition: Decl.h:647
Describes a module import declaration, which makes the contents of the named module visible in the cu...
Definition: Decl.h:3971
const TypedefNameDecl * getCanonicalDecl() const
Definition: Decl.h:2869
void setVirtualAsWritten(bool V)
Definition: Decl.h:1992
C++11 thread_local.
Definition: Specifiers.h:196
Defines various enumerations that describe declaration and type specifiers.
DeclarationNameLoc - Additional source/type location info for a declaration name. ...
ObjCDeclQualifier getObjCDeclQualifier() const
Definition: Decl.h:1570
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier (with source-location information) that qualifies the name of this...
Definition: Decl.h:3204
const NamedDecl * getMostRecentDecl() const
Definition: Decl.h:439
decl_iterator - Iterates through the declarations stored within this context.
Definition: DeclBase.h:1537
Base class for declarations which introduce a typedef-name.
Definition: Decl.h:2802
void setAnonymousNamespace(NamespaceDecl *D)
Definition: Decl.h:122
LabelStmt * getStmt() const
Definition: Decl.h:483
TagTypeKind
The kind of a tag type.
Definition: Type.h:4686
static bool classofKind(Kind K)
Definition: Decl.h:2454
Dataflow Directional Tag Classes.
void setDescribedAliasTemplate(TypeAliasTemplateDecl *TAT)
Definition: Decl.h:2936
void setBody(CompoundStmt *B)
Definition: Decl.h:3774
bool isValid() const
Return true if this is a valid SourceLocation object.
void setImplicitlyInline()
Flag that this function is implicitly inline.
Definition: Decl.h:2250
MutableArrayRef< ImplicitParamDecl * > parameters()
Definition: Decl.h:3926
const EnumDecl * getPreviousDecl() const
Definition: Decl.h:3298
void setHasVolatileMember(bool val)
Definition: Decl.h:3565
EnumConstantDecl * getCanonicalDecl() override
Retrieves the canonical declaration of this enumerator.
Definition: Decl.h:2700
bool isLateTemplateParsed() const
Whether this templated function will be late parsed.
Definition: Decl.h:2000
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1256
param_const_iterator param_begin() const
Definition: Decl.h:3794
CompoundStmt * getCompoundBody() const
Definition: Decl.h:3772
ArrayRef< Capture > captures() const
Definition: Decl.h:3821
bool isNested() const
Whether this is a nested capture, i.e.
Definition: Decl.h:3728
FunctionDecl * getNextRedeclarationImpl() override
Returns the next redeclaration or itself if this is the only decl.
Definition: Decl.h:1855
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Definition: OperatorKinds.h:22
bool isVariadic() const
Definition: Decl.h:3769
const VarDecl * getCanonicalDecl() const
Definition: Decl.h:1132
VarDecl * getNextRedeclarationImpl() override
Returns the next redeclaration or itself if this is the only decl.
Definition: Decl.h:975
StringRef getMSAsmLabel() const
Definition: Decl.h:496
SourceRange getSourceRange(const SourceRange &Range)
Returns the SourceRange of a SourceRange.
Definition: FixIt.h:34
bool isRecord() const
Definition: DeclBase.h:1409
Parameter for Objective-C &#39;self&#39; argument.
Definition: Decl.h:1458
InitType Init
The initializer for this variable or, for a ParmVarDecl, the C++ default argument.
Definition: Decl.h:850
ParmVarDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
Definition: Decl.h:1519
Reads an AST files chain containing the contents of a translation unit.
Definition: ASTReader.h:358
TagDecl * getNextRedeclarationImpl() override
Returns the next redeclaration or itself if this is the only decl.
Definition: Decl.h:3041
void setARCPseudoStrong(bool ps)
Definition: Decl.h:1342
IndirectFieldDecl - An instance of this class is created to represent a field injected from an anonym...
Definition: Decl.h:2711
static bool classof(const Decl *D)
Definition: Decl.h:167
QualType getUnderlyingType() const
Definition: Decl.h:2853
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.h:4066
const Expr * getInit() const
Definition: Decl.h:1212
unsigned IsScoped
IsScoped - True if this tag declaration is a scoped enumeration.
Definition: Decl.h:2980
bool isEmbeddedInDeclarator() const
Definition: Decl.h:3112
unsigned getNumTemplateParameterLists() const
Definition: Decl.h:3211
TLSKind
Kinds of thread-local storage.
Definition: Decl.h:821
void setWillHaveBody(bool V=true)
Definition: Decl.h:2155
DeclarationName - The name of a declaration.
void setInstantiationIsPending(bool IC)
Definition: Decl.h:2052
bool isCXXClassMember() const
Determine whether this declaration is a C++ class member.
Definition: Decl.h:337
void setInstantiationOfMemberFunction(FunctionDecl *FD, TemplateSpecializationKind TSK)
Specify that this record is an instantiation of the member function FD.
Definition: Decl.h:2308
Kind getKind() const
Definition: DeclBase.h:419
ParmVarDeclBitfields ParmVarDeclBits
Definition: Decl.h:965
bool instantiationIsPending() const
Whether the instantiation of this function is pending.
Definition: Decl.h:2051
SourceLocation getLocStart() const LLVM_READONLY
Definition: Decl.h:731
unsigned getNumTemplateParameterLists() const
Definition: Decl.h:752
EnumDecl - Represents an enum.
Definition: Decl.h:3239
llvm::iterator_range< redecl_iterator > redecl_range
Definition: Redeclarable.h:295
void setInlineSpecified()
Definition: Decl.h:1355
static bool classof(const Decl *D)
Definition: Decl.h:2453
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
Definition: Specifiers.h:143
bool isInitCapture() const
Whether this variable is the implicit variable for a lambda init-capture.
Definition: Decl.h:1375
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
Tags, declared with &#39;struct foo;&#39; and referenced with &#39;struct foo&#39;.
Definition: DeclBase.h:125
void setPreviousDeclInSameBlockScope(bool Same)
Definition: Decl.h:1390
const RecordDecl * getPreviousDecl() const
Definition: Decl.h:3530
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext, providing only those that are of type SpecificDecl (or a class derived from it).
Definition: DeclBase.h:1600
param_iterator param_end()
Definition: Decl.h:2180
void setInitCapture(bool IC)
Definition: Decl.h:1378
void setImplicitlyInline()
Definition: Decl.h:1360
Do an LV computation for, ultimately, a type.
Definition: Decl.h:393
unsigned MayHaveOutOfDateDef
Indicates whether it is possible for declarations of this kind to have an out-of-date definition...
Definition: Decl.h:2996
Not an overloaded operator.
Definition: OperatorKinds.h:23
ImplicitParamDecl(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id, QualType Type, ImplicitParamKind ParamKind)
Definition: Decl.h:1485
static FunctionDecl * castFromDeclContext(const DeclContext *DC)
Definition: Decl.h:2460
Provides common interface for the Decls that cannot be redeclared, but can be merged if the same decl...
Definition: Redeclarable.h:317
static const TypeInfo & getInfo(unsigned id)
Definition: Types.cpp:34
void setUnparsedDefaultArg()
setUnparsedDefaultArg - Specify that this parameter has an unparsed default argument.
Definition: Decl.h:1637
NonParmVarDeclBitfields NonParmVarDeclBits
Definition: Decl.h:966
chain_iterator chain_begin() const
Definition: Decl.h:2736
friend TrailingObjects
Definition: OpenMPClause.h:88
llvm::iterator_range< param_iterator > param_range
Definition: Decl.h:3943
void setTypeSourceInfo(TypeSourceInfo *TI)
Definition: Decl.h:713
bool isStaticLocal() const
isStaticLocal - Returns true if a variable with function scope is a static local variable.
Definition: Decl.h:1049
size_t param_size() const
Definition: Decl.h:3796
const Expr * getUninstantiatedDefaultArg() const
Definition: Decl.h:1606
TypeSourceInfo * getTypeSourceInfo() const
Definition: Decl.h:707
void setUsesSEHTry(bool UST)
Definition: Decl.h:2056
static bool classof(const Decl *D)
Definition: Decl.h:2939
DeclContext * getRedeclContext()
getRedeclContext - Retrieve the context in which an entity conflicts with other entities of the same ...
Definition: DeclBase.cpp:1663
ImplicitParamDecl * getParam(unsigned i) const
Definition: Decl.h:3913
void setCXXForRangeDecl(bool FRD)
Definition: Decl.h:1330
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.h:489
static bool classofKind(Kind K)
Definition: Decl.h:2664
redeclarable_base::redecl_iterator redecl_iterator
Definition: Decl.h:3063
Implements a partial diagnostic that can be emitted anwyhere in a DiagnosticBuilder stream...
The "class" keyword.
Definition: Type.h:4697
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat]...
Definition: APValue.h:38
unsigned IsBeingDefined
IsBeingDefined - True if this is currently being defined.
Definition: Decl.h:2962
const Type * getTypePtrOrNull() const
Definition: Type.h:5722
static bool classofKind(Kind K)
Definition: Decl.h:3855
void setInnerLocStart(SourceLocation L)
Definition: Decl.h:723
void setObjCMethodScopeInfo(unsigned parameterIndex)
Definition: Decl.h:1541
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
Definition: Decl.h:2257
bool capturesCXXThis() const
Definition: Decl.h:3826
void setSignatureAsWritten(TypeSourceInfo *Sig)
Definition: Decl.h:3776
void setPromotionType(QualType T)
Set the promotion type.
Definition: Decl.h:3359
unsigned IsFixed
IsFixed - True if this is an enumeration with fixed underlying type.
Definition: Decl.h:2990
void setAsmString(StringLiteral *Asm)
Definition: Decl.h:3686
void setRParenLoc(SourceLocation L)
Definition: Decl.h:3679
A template argument list.
Definition: DeclTemplate.h:210
TypeLoc getTypeLoc() const
Return the TypeLoc wrapper for the type source info.
Definition: TypeLoc.h:239
void setRBraceLoc(SourceLocation L)
Definition: Decl.h:4056
const VarDecl * getDefinition(ASTContext &C) const
Definition: Decl.h:1171
NestedNameSpecifierLoc QualifierLoc
Definition: Decl.h:653
bool isResolvedMSAsmLabel() const
Definition: Decl.h:494
static bool classofKind(Kind K)
Definition: Decl.h:1663
Call-style initialization (C++98)
Definition: Decl.h:814
static DeclContext * castToDeclContext(const TagDecl *D)
Definition: Decl.h:3227
static bool classofKind(Kind K)
Definition: Decl.h:4071
ValueDecl(Kind DK, DeclContext *DC, SourceLocation L, DeclarationName N, QualType T)
Definition: Decl.h:633
ThreadStorageClassSpecifier
Thread storage-class-specifier.
Definition: Specifiers.h:190
Defines the clang::SourceLocation class and associated facilities.
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition: Type.h:5798
TypedefNameDecl * getTypedefNameForAnonDecl() const
Definition: Decl.h:3187
bool isMutable() const
isMutable - Determines whether this field is mutable (C++ only).
Definition: Decl.h:2542
bool isThisDeclarationADefinition() const
isThisDeclarationADefinition() - Return true if this declaration is a completion definition of the ty...
Definition: Decl.h:3091
SourceLocation getRBraceLoc() const
Definition: Decl.h:4055
void setTSCSpec(ThreadStorageClassSpecifier TSC)
Definition: Decl.h:1014
bool isNRVOVariable() const
Determine whether this local variable can be used with the named return value optimization (NRVO)...
Definition: Decl.h:1317
ObjCDeclQualifier
ObjCDeclQualifier - &#39;Qualifiers&#39; written next to the return and parameter types in method declaration...
Definition: DeclBase.h:195
static bool classofKind(Kind K)
Definition: Decl.h:2798
void setConstexpr(bool IC)
Definition: Decl.h:2043
unsigned getNumNegativeBits() const
Returns the width in bits required to store all the negative enumerators of this enum.
Definition: Decl.h:3407
Provides information a specialization of a member of a class template, which may be a member function...
Definition: DeclTemplate.h:607
VarDecl * getDefinition()
Definition: Decl.h:1174
The "enum" keyword.
Definition: Type.h:4700
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: Decl.h:2789
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:61
bool hasExternalStorage() const
Returns true if a variable has extern or private_extern storage.
Definition: Decl.h:1058
static bool classof(const Decl *D)
Definition: Decl.h:200
static bool classofKind(Kind K)
Definition: Decl.h:128
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1509
TLS with a known-constant initializer.
Definition: Decl.h:826
QualType getIntegerType() const
getIntegerType - Return the integer type this enum decl corresponds to.
Definition: Decl.h:3364
bool doesThisDeclarationHaveABody() const
Returns whether this specific declaration of the function has a body - that is, if it is a non-delete...
Definition: Decl.h:1980
StringRef getName() const
getName - Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:270
Kind
Lists the kind of concrete classes of Decl.
Definition: DeclBase.h:89
bool blockMissingReturnType() const
Definition: Decl.h:3827
static TagDecl * castFromDeclContext(const DeclContext *DC)
Definition: Decl.h:3231
static Decl::Kind getKind(const Decl *D)
Definition: DeclBase.cpp:930
VarDeclBitfields VarDeclBits
Definition: Decl.h:964
TranslationUnitDecl - The top declaration context.
Definition: Decl.h:107
bool isFunctionOrMethodVarDecl() const
isFunctionOrMethodVarDecl - Similar to isLocalVarDecl, but excludes variables declared in blocks...
Definition: Decl.h:1110
static bool classofKind(Kind K)
Definition: Decl.h:201
static bool classof(const Decl *D)
Definition: Decl.h:4091
const TagDecl * getCanonicalDecl() const
Definition: Decl.h:3085
bool isUnion() const
Definition: Decl.h:3165
ArrayRef< ParmVarDecl * > parameters() const
Definition: Decl.h:3780
NamedDecl * getMostRecentDecl()
Definition: Decl.h:436
Visibility getVisibility() const
Determines the visibility of this entity.
Definition: Decl.h:381
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:2077
bool hasObjectMember() const
Definition: Decl.h:3561
EnumConstantDecl(DeclContext *DC, SourceLocation L, IdentifierInfo *Id, QualType T, Expr *E, const llvm::APSInt &V)
Definition: Decl.h:2676
void setObjCDeclQualifier(ObjCDeclQualifier QTVal)
Definition: Decl.h:1574
void setMSAsmLabelResolved()
Definition: Decl.h:497
bool isStaticDataMember() const
Determines whether this is a static data member.
Definition: Decl.h:1126
SourceLocation getInnerLocStart() const
getInnerLocStart - Return SourceLocation representing start of source range ignoring outer template d...
Definition: Decl.h:3077
NamespaceDecl * getAnonymousNamespace() const
Retrieve the anonymous namespace nested inside this namespace, if any.
Definition: Decl.h:588
bool isLocalVarDecl() const
isLocalVarDecl - Returns true for local variable declarations other than parameters.
Definition: Decl.h:1095
QualType getType() const
Definition: Decl.h:638
#define true
Definition: stdbool.h:32
unsigned AllBits
Definition: Decl.h:963
unsigned IsCompleteDefinitionRequired
Has the full definition of this type been required by a use somewhere in the TU.
Definition: Decl.h:3000
void setFunctionTemplateSpecialization(FunctionTemplateDecl *Template, const TemplateArgumentList *TemplateArgs, void *InsertPos, TemplateSpecializationKind TSK=TSK_ImplicitInstantiation, const TemplateArgumentListInfo *TemplateArgsAsWritten=nullptr, SourceLocation PointOfInstantiation=SourceLocation())
Specify that this function declaration is actually a function template specialization.
Definition: Decl.h:2401
A trivial tuple used to represent a source range.
bool isModulePrivate() const
Whether this declaration was marked as being private to the module in which it was defined...
Definition: DeclBase.h:600
void setIntegerTypeSourceInfo(TypeSourceInfo *TInfo)
Set the underlying integer type source info.
Definition: Decl.h:3376
NamedDecl - This represents a decl with a name.
Definition: Decl.h:245
void setTypeSourceInfo(TypeSourceInfo *newType)
Definition: Decl.h:2859
Represents a C array with a specified size that is not an integer-constant-expression.
Definition: Type.h:2717
Automatic storage duration (most local variables).
Definition: Specifiers.h:275
bool isInline() const
Whether this variable is (C++1z) inline.
Definition: Decl.h:1348
ImplicitParamKind getParameterKind() const
Returns the implicit parameter kind.
Definition: Decl.h:1503
APValue Evaluated
Definition: Decl.h:797
Represents a #pragma detect_mismatch line.
Definition: Decl.h:173
static bool classofKind(Kind K)
Definition: Decl.h:501
SourceLocation getExportLoc() const
Definition: Decl.h:4054
void setNRVOVariable(bool NRVO)
Definition: Decl.h:1320
static bool classof(const Decl *D)
Definition: Decl.h:1508
void setType(QualType newType)
Definition: Decl.h:639
bool isFreeStanding() const
Definition: Decl.h:3119
SourceLocation getInnerLocStart() const
getInnerLocStart - Return SourceLocation representing start of source range ignoring outer template d...
Definition: Decl.h:722
void setDeletedAsWritten(bool D=true)
Definition: Decl.h:2079
No in-class initializer.
Definition: Specifiers.h:227
void setInlineSpecified(bool I)
Set whether the "inline" keyword was specified for this function.
Definition: Decl.h:2244
TemplateParameterList * getTemplateParameterList(unsigned i) const
Definition: Decl.h:3215
Declaration of a template function.
Definition: DeclTemplate.h:967
bool isLocalVarDeclOrParm() const
Similar to isLocalVarDecl but also includes parameters.
Definition: Decl.h:1104
Attr - This represents one attribute.
Definition: Attr.h:43
bool isDeletedAsWritten() const
Definition: Decl.h:2078
const StringLiteral * getAsmString() const
Definition: Decl.h:3684
bool isExternallyVisible() const
Definition: Decl.h:370
QualType getType() const
Return the type wrapped by this type source info.
Definition: Decl.h:97
bool isBeingDefined() const
isBeingDefined - Return true if this decl is currently being defined.
Definition: Decl.h:3108
SourceLocation getRBraceLoc() const
Definition: Decl.h:609
PragmaMSCommentKind getCommentKind() const
Definition: Decl.h:162
decl_iterator decls_end() const
Definition: DeclBase.h:1582
param_const_iterator param_begin() const
Definition: Decl.h:2181
bool param_empty() const
Definition: Decl.h:2178
static OMPLinearClause * Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc, SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef< Expr *> VL, ArrayRef< Expr *> PL, ArrayRef< Expr *> IL, Expr *Step, Expr *CalcStep, Stmt *PreInit, Expr *PostUpdate)
Creates clause with a list of variables VL and a linear step Step.
bool hasExternalFormalLinkage() const
True if this decl has external linkage.
Definition: Decl.h:366
redeclarable_base::redecl_range redecl_range
Definition: Decl.h:2835
const FormatStyle & Style
static bool isExternC(const NamedDecl *ND)
Definition: Mangle.cpp:60
Structure used to store a statement, the constant value to which it was evaluated (if any)...
Definition: Decl.h:776
TemplatedKind
The kind of templated function a FunctionDecl can be.
Definition: Decl.h:1701