clang  17.0.0git
Decl.h
Go to the documentation of this file.
1 //===- Decl.h - Classes for representing declarations -----------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file defines the Decl subclasses.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #ifndef LLVM_CLANG_AST_DECL_H
14 #define LLVM_CLANG_AST_DECL_H
15 
16 #include "clang/AST/APValue.h"
19 #include "clang/AST/DeclBase.h"
23 #include "clang/AST/Redeclarable.h"
24 #include "clang/AST/Type.h"
26 #include "clang/Basic/Diagnostic.h"
28 #include "clang/Basic/LLVM.h"
29 #include "clang/Basic/Linkage.h"
34 #include "clang/Basic/Specifiers.h"
35 #include "clang/Basic/Visibility.h"
36 #include "llvm/ADT/APSInt.h"
37 #include "llvm/ADT/ArrayRef.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 <optional>
49 #include <string>
50 #include <utility>
51 
52 namespace clang {
53 
54 class ASTContext;
55 struct ASTTemplateArgumentListInfo;
56 class CompoundStmt;
57 class DependentFunctionTemplateSpecializationInfo;
58 class EnumDecl;
59 class Expr;
60 class FunctionTemplateDecl;
61 class FunctionTemplateSpecializationInfo;
62 class FunctionTypeLoc;
63 class LabelStmt;
64 class MemberSpecializationInfo;
65 class Module;
66 class NamespaceDecl;
67 class ParmVarDecl;
68 class RecordDecl;
69 class Stmt;
70 class StringLiteral;
71 class TagDecl;
72 class TemplateArgumentList;
73 class TemplateArgumentListInfo;
74 class TemplateParameterList;
75 class TypeAliasTemplateDecl;
76 class UnresolvedSetImpl;
77 class VarTemplateDecl;
78 
79 /// The top declaration context.
80 class TranslationUnitDecl : public Decl,
81  public DeclContext,
82  public Redeclarable<TranslationUnitDecl> {
84 
85  TranslationUnitDecl *getNextRedeclarationImpl() override {
86  return getNextRedeclaration();
87  }
88 
89  TranslationUnitDecl *getPreviousDeclImpl() override {
90  return getPreviousDecl();
91  }
92 
93  TranslationUnitDecl *getMostRecentDeclImpl() override {
94  return getMostRecentDecl();
95  }
96 
97  ASTContext &Ctx;
98 
99  /// The (most recently entered) anonymous namespace for this
100  /// translation unit, if one has been created.
101  NamespaceDecl *AnonymousNamespace = nullptr;
102 
103  explicit TranslationUnitDecl(ASTContext &ctx);
104 
105  virtual void anchor();
106 
107 public:
109  using redecl_iterator = redeclarable_base::redecl_iterator;
110 
117 
118  ASTContext &getASTContext() const { return Ctx; }
119 
120  NamespaceDecl *getAnonymousNamespace() const { return AnonymousNamespace; }
121  void setAnonymousNamespace(NamespaceDecl *D) { AnonymousNamespace = D; }
122 
124 
125  // Implement isa/cast/dyncast/etc.
126  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
127  static bool classofKind(Kind K) { return K == TranslationUnit; }
129  return static_cast<DeclContext *>(const_cast<TranslationUnitDecl*>(D));
130  }
132  return static_cast<TranslationUnitDecl *>(const_cast<DeclContext*>(DC));
133  }
134 };
135 
136 /// Represents a `#pragma comment` line. Always a child of
137 /// TranslationUnitDecl.
138 class PragmaCommentDecl final
139  : public Decl,
140  private llvm::TrailingObjects<PragmaCommentDecl, char> {
141  friend class ASTDeclReader;
142  friend class ASTDeclWriter;
143  friend TrailingObjects;
144 
145  PragmaMSCommentKind CommentKind;
146 
148  PragmaMSCommentKind CommentKind)
149  : Decl(PragmaComment, TU, CommentLoc), CommentKind(CommentKind) {}
150 
151  virtual void anchor();
152 
153 public:
155  SourceLocation CommentLoc,
156  PragmaMSCommentKind CommentKind,
157  StringRef Arg);
159  unsigned ArgSize);
160 
161  PragmaMSCommentKind getCommentKind() const { return CommentKind; }
162 
163  StringRef getArg() const { return getTrailingObjects<char>(); }
164 
165  // Implement isa/cast/dyncast/etc.
166  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
167  static bool classofKind(Kind K) { return K == PragmaComment; }
168 };
169 
170 /// Represents a `#pragma detect_mismatch` line. Always a child of
171 /// TranslationUnitDecl.
173  : public Decl,
174  private llvm::TrailingObjects<PragmaDetectMismatchDecl, char> {
175  friend class ASTDeclReader;
176  friend class ASTDeclWriter;
177  friend TrailingObjects;
178 
179  size_t ValueStart;
180 
182  size_t ValueStart)
183  : Decl(PragmaDetectMismatch, TU, Loc), ValueStart(ValueStart) {}
184 
185  virtual void anchor();
186 
187 public:
190  SourceLocation Loc, StringRef Name,
191  StringRef Value);
192  static PragmaDetectMismatchDecl *
193  CreateDeserialized(ASTContext &C, unsigned ID, unsigned NameValueSize);
194 
195  StringRef getName() const { return getTrailingObjects<char>(); }
196  StringRef getValue() const { return getTrailingObjects<char>() + ValueStart; }
197 
198  // Implement isa/cast/dyncast/etc.
199  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
200  static bool classofKind(Kind K) { return K == PragmaDetectMismatch; }
201 };
202 
203 /// Declaration context for names declared as extern "C" in C++. This
204 /// is neither the semantic nor lexical context for such declarations, but is
205 /// used to check for conflicts with other extern "C" declarations. Example:
206 ///
207 /// \code
208 /// namespace N { extern "C" void f(); } // #1
209 /// void N::f() {} // #2
210 /// namespace M { extern "C" void f(); } // #3
211 /// \endcode
212 ///
213 /// The semantic context of #1 is namespace N and its lexical context is the
214 /// LinkageSpecDecl; the semantic context of #2 is namespace N and its lexical
215 /// context is the TU. However, both declarations are also visible in the
216 /// extern "C" context.
217 ///
218 /// The declaration at #3 finds it is a redeclaration of \c N::f through
219 /// lookup in the extern "C" context.
220 class ExternCContextDecl : public Decl, public DeclContext {
222  : Decl(ExternCContext, TU, SourceLocation()),
223  DeclContext(ExternCContext) {}
224 
225  virtual void anchor();
226 
227 public:
228  static ExternCContextDecl *Create(const ASTContext &C,
229  TranslationUnitDecl *TU);
230 
231  // Implement isa/cast/dyncast/etc.
232  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
233  static bool classofKind(Kind K) { return K == ExternCContext; }
235  return static_cast<DeclContext *>(const_cast<ExternCContextDecl*>(D));
236  }
238  return static_cast<ExternCContextDecl *>(const_cast<DeclContext*>(DC));
239  }
240 };
241 
242 /// This represents a decl that may have a name. Many decls have names such
243 /// as ObjCMethodDecl, but not \@class, etc.
244 ///
245 /// Note that not every NamedDecl is actually named (e.g., a struct might
246 /// be anonymous), and not every name is an identifier.
247 class NamedDecl : public Decl {
248  /// The name of this declaration, which is typically a normal
249  /// identifier but may also be a special kind of name (C++
250  /// constructor, Objective-C selector, etc.)
251  DeclarationName Name;
252 
253  virtual void anchor();
254 
255 private:
256  NamedDecl *getUnderlyingDeclImpl() LLVM_READONLY;
257 
258 protected:
260  : Decl(DK, DC, L), Name(N) {}
261 
262 public:
263  /// Get the identifier that names this declaration, if there is one.
264  ///
265  /// This will return NULL if this declaration has no name (e.g., for
266  /// an unnamed class) or if the name is a special name (C++ constructor,
267  /// Objective-C selector, etc.).
268  IdentifierInfo *getIdentifier() const { return Name.getAsIdentifierInfo(); }
269 
270  /// Get the name of identifier for this declaration as a StringRef.
271  ///
272  /// This requires that the declaration have a name and that it be a simple
273  /// identifier.
274  StringRef getName() const {
275  assert(Name.isIdentifier() && "Name is not a simple identifier");
276  return getIdentifier() ? getIdentifier()->getName() : "";
277  }
278 
279  /// Get a human-readable name for the declaration, even if it is one of the
280  /// special kinds of names (C++ constructor, Objective-C selector, etc).
281  ///
282  /// Creating this name requires expensive string manipulation, so it should
283  /// be called only when performance doesn't matter. For simple declarations,
284  /// getNameAsCString() should suffice.
285  //
286  // FIXME: This function should be renamed to indicate that it is not just an
287  // alternate form of getName(), and clients should move as appropriate.
288  //
289  // FIXME: Deprecated, move clients to getName().
290  std::string getNameAsString() const { return Name.getAsString(); }
291 
292  /// Pretty-print the unqualified name of this declaration. Can be overloaded
293  /// by derived classes to provide a more user-friendly name when appropriate.
294  virtual void printName(raw_ostream &OS, const PrintingPolicy &Policy) const;
295  /// Calls printName() with the ASTContext printing policy from the decl.
296  void printName(raw_ostream &OS) const;
297 
298  /// Get the actual, stored name of the declaration, which may be a special
299  /// name.
300  ///
301  /// Note that generally in diagnostics, the non-null \p NamedDecl* itself
302  /// should be sent into the diagnostic instead of using the result of
303  /// \p getDeclName().
304  ///
305  /// A \p DeclarationName in a diagnostic will just be streamed to the output,
306  /// which will directly result in a call to \p DeclarationName::print.
307  ///
308  /// A \p NamedDecl* in a diagnostic will also ultimately result in a call to
309  /// \p DeclarationName::print, but with two customisation points along the
310  /// way (\p getNameForDiagnostic and \p printName). These are used to print
311  /// the template arguments if any, and to provide a user-friendly name for
312  /// some entities (such as unnamed variables and anonymous records).
313  DeclarationName getDeclName() const { return Name; }
314 
315  /// Set the name of this declaration.
316  void setDeclName(DeclarationName N) { Name = N; }
317 
318  /// Returns a human-readable qualified name for this declaration, like
319  /// A::B::i, for i being member of namespace A::B.
320  ///
321  /// If the declaration is not a member of context which can be named (record,
322  /// namespace), it will return the same result as printName().
323  ///
324  /// Creating this name is expensive, so it should be called only when
325  /// performance doesn't matter.
326  void printQualifiedName(raw_ostream &OS) const;
327  void printQualifiedName(raw_ostream &OS, const PrintingPolicy &Policy) const;
328 
329  /// Print only the nested name specifier part of a fully-qualified name,
330  /// including the '::' at the end. E.g.
331  /// when `printQualifiedName(D)` prints "A::B::i",
332  /// this function prints "A::B::".
333  void printNestedNameSpecifier(raw_ostream &OS) const;
334  void printNestedNameSpecifier(raw_ostream &OS,
335  const PrintingPolicy &Policy) const;
336 
337  // FIXME: Remove string version.
339 
340  /// Appends a human-readable name for this declaration into the given stream.
341  ///
342  /// This is the method invoked by Sema when displaying a NamedDecl
343  /// in a diagnostic. It does not necessarily produce the same
344  /// result as printName(); for example, class template
345  /// specializations are printed with their template arguments.
346  virtual void getNameForDiagnostic(raw_ostream &OS,
347  const PrintingPolicy &Policy,
348  bool Qualified) const;
349 
350  /// Determine whether this declaration, if known to be well-formed within
351  /// its context, will replace the declaration OldD if introduced into scope.
352  ///
353  /// A declaration will replace another declaration if, for example, it is
354  /// a redeclaration of the same variable or function, but not if it is a
355  /// declaration of a different kind (function vs. class) or an overloaded
356  /// function.
357  ///
358  /// \param IsKnownNewer \c true if this declaration is known to be newer
359  /// than \p OldD (for instance, if this declaration is newly-created).
360  bool declarationReplaces(NamedDecl *OldD, bool IsKnownNewer = true) const;
361 
362  /// Determine whether this declaration has linkage.
363  bool hasLinkage() const;
364 
365  using Decl::isModulePrivate;
367 
368  /// Determine whether this declaration is a C++ class member.
369  bool isCXXClassMember() const {
370  const DeclContext *DC = getDeclContext();
371 
372  // C++0x [class.mem]p1:
373  // The enumerators of an unscoped enumeration defined in
374  // the class are members of the class.
375  if (isa<EnumDecl>(DC))
376  DC = DC->getRedeclContext();
377 
378  return DC->isRecord();
379  }
380 
381  /// Determine whether the given declaration is an instance member of
382  /// a C++ class.
383  bool isCXXInstanceMember() const;
384 
385  /// Determine if the declaration obeys the reserved identifier rules of the
386  /// given language.
387  ReservedIdentifierStatus isReserved(const LangOptions &LangOpts) const;
388 
389  /// Determine what kind of linkage this entity has.
390  ///
391  /// This is not the linkage as defined by the standard or the codegen notion
392  /// of linkage. It is just an implementation detail that is used to compute
393  /// those.
394  Linkage getLinkageInternal() const;
395 
396  /// Get the linkage from a semantic point of view. Entities in
397  /// anonymous namespaces are external (in c++98).
400  }
401 
402  /// True if this decl has external linkage.
405  }
406 
407  bool isExternallyVisible() const {
409  }
410 
411  /// Determine whether this declaration can be redeclared in a
412  /// different translation unit.
413  bool isExternallyDeclarable() const {
415  }
416 
417  /// Determines the visibility of this entity.
420  }
421 
422  /// Determines the linkage and visibility of this entity.
424 
425  /// Kinds of explicit visibility.
427  /// Do an LV computation for, ultimately, a type.
428  /// Visibility may be restricted by type visibility settings and
429  /// the visibility of template arguments.
431 
432  /// Do an LV computation for, ultimately, a non-type declaration.
433  /// Visibility may be restricted by value visibility settings and
434  /// the visibility of template arguments.
436  };
437 
438  /// If visibility was explicitly specified for this
439  /// declaration, return that visibility.
440  std::optional<Visibility>
442 
443  /// True if the computed linkage is valid. Used for consistency
444  /// checking. Should always return true.
445  bool isLinkageValid() const;
446 
447  /// True if something has required us to compute the linkage
448  /// of this declaration.
449  ///
450  /// Language features which can retroactively change linkage (like a
451  /// typedef name for linkage purposes) may need to consider this,
452  /// but hopefully only in transitory ways during parsing.
453  bool hasLinkageBeenComputed() const {
454  return hasCachedLinkage();
455  }
456 
457  /// Looks through UsingDecls and ObjCCompatibleAliasDecls for
458  /// the underlying named decl.
460  // Fast-path the common case.
461  if (this->getKind() != UsingShadow &&
462  this->getKind() != ConstructorUsingShadow &&
463  this->getKind() != ObjCCompatibleAlias &&
464  this->getKind() != NamespaceAlias)
465  return this;
466 
467  return getUnderlyingDeclImpl();
468  }
469  const NamedDecl *getUnderlyingDecl() const {
470  return const_cast<NamedDecl*>(this)->getUnderlyingDecl();
471  }
472 
474  return cast<NamedDecl>(static_cast<Decl *>(this)->getMostRecentDecl());
475  }
476  const NamedDecl *getMostRecentDecl() const {
477  return const_cast<NamedDecl*>(this)->getMostRecentDecl();
478  }
479 
481 
482  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
483  static bool classofKind(Kind K) { return K >= firstNamed && K <= lastNamed; }
484 };
485 
486 inline raw_ostream &operator<<(raw_ostream &OS, const NamedDecl &ND) {
487  ND.printName(OS);
488  return OS;
489 }
490 
491 /// Represents the declaration of a label. Labels also have a
492 /// corresponding LabelStmt, which indicates the position that the label was
493 /// defined at. For normal labels, the location of the decl is the same as the
494 /// location of the statement. For GNU local labels (__label__), the decl
495 /// location is where the __label__ is.
496 class LabelDecl : public NamedDecl {
497  LabelStmt *TheStmt;
498  StringRef MSAsmName;
499  bool MSAsmNameResolved = false;
500 
501  /// For normal labels, this is the same as the main declaration
502  /// label, i.e., the location of the identifier; for GNU local labels,
503  /// this is the location of the __label__ keyword.
504  SourceLocation LocStart;
505 
507  LabelStmt *S, SourceLocation StartL)
508  : NamedDecl(Label, DC, IdentL, II), TheStmt(S), LocStart(StartL) {}
509 
510  void anchor() override;
511 
512 public:
513  static LabelDecl *Create(ASTContext &C, DeclContext *DC,
514  SourceLocation IdentL, IdentifierInfo *II);
515  static LabelDecl *Create(ASTContext &C, DeclContext *DC,
516  SourceLocation IdentL, IdentifierInfo *II,
517  SourceLocation GnuLabelL);
518  static LabelDecl *CreateDeserialized(ASTContext &C, unsigned ID);
519 
520  LabelStmt *getStmt() const { return TheStmt; }
521  void setStmt(LabelStmt *T) { TheStmt = T; }
522 
523  bool isGnuLocal() const { return LocStart != getLocation(); }
524  void setLocStart(SourceLocation L) { LocStart = L; }
525 
526  SourceRange getSourceRange() const override LLVM_READONLY {
527  return SourceRange(LocStart, getLocation());
528  }
529 
530  bool isMSAsmLabel() const { return !MSAsmName.empty(); }
531  bool isResolvedMSAsmLabel() const { return isMSAsmLabel() && MSAsmNameResolved; }
532  void setMSAsmLabel(StringRef Name);
533  StringRef getMSAsmLabel() const { return MSAsmName; }
534  void setMSAsmLabelResolved() { MSAsmNameResolved = true; }
535 
536  // Implement isa/cast/dyncast/etc.
537  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
538  static bool classofKind(Kind K) { return K == Label; }
539 };
540 
541 /// Represent a C++ namespace.
542 class NamespaceDecl : public NamedDecl, public DeclContext,
543  public Redeclarable<NamespaceDecl>
544 {
545 
546  enum Flags : unsigned { F_Inline = 1 << 0, F_Nested = 1 << 1 };
547 
548  /// The starting location of the source range, pointing
549  /// to either the namespace or the inline keyword.
550  SourceLocation LocStart;
551 
552  /// The ending location of the source range.
553  SourceLocation RBraceLoc;
554 
555  /// A pointer to either the anonymous namespace that lives just inside
556  /// this namespace or to the first namespace in the chain (the latter case
557  /// only when this is not the first in the chain), along with a
558  /// boolean value indicating whether this is an inline namespace.
559  llvm::PointerIntPair<NamespaceDecl *, 2, unsigned>
560  AnonOrFirstNamespaceAndFlags;
561 
562  NamespaceDecl(ASTContext &C, DeclContext *DC, bool Inline,
563  SourceLocation StartLoc, SourceLocation IdLoc,
564  IdentifierInfo *Id, NamespaceDecl *PrevDecl, bool Nested);
565 
567 
568  NamespaceDecl *getNextRedeclarationImpl() override;
569  NamespaceDecl *getPreviousDeclImpl() override;
570  NamespaceDecl *getMostRecentDeclImpl() override;
571 
572 public:
573  friend class ASTDeclReader;
574  friend class ASTDeclWriter;
575 
576  static NamespaceDecl *Create(ASTContext &C, DeclContext *DC, bool Inline,
577  SourceLocation StartLoc, SourceLocation IdLoc,
578  IdentifierInfo *Id, NamespaceDecl *PrevDecl,
579  bool Nested);
580 
581  static NamespaceDecl *CreateDeserialized(ASTContext &C, unsigned ID);
582 
584  using redecl_iterator = redeclarable_base::redecl_iterator;
585 
592 
593  /// Returns true if this is an anonymous namespace declaration.
594  ///
595  /// For example:
596  /// \code
597  /// namespace {
598  /// ...
599  /// };
600  /// \endcode
601  /// q.v. C++ [namespace.unnamed]
602  bool isAnonymousNamespace() const {
603  return !getIdentifier();
604  }
605 
606  /// Returns true if this is an inline namespace declaration.
607  bool isInline() const {
608  return AnonOrFirstNamespaceAndFlags.getInt() & F_Inline;
609  }
610 
611  /// Set whether this is an inline namespace declaration.
612  void setInline(bool Inline) {
613  unsigned F = AnonOrFirstNamespaceAndFlags.getInt();
614  if (Inline)
615  AnonOrFirstNamespaceAndFlags.setInt(F | F_Inline);
616  else
617  AnonOrFirstNamespaceAndFlags.setInt(F & ~F_Inline);
618  }
619 
620  /// Returns true if this is a nested namespace declaration.
621  /// \code
622  /// namespace outer::nested { }
623  /// \endcode
624  bool isNested() const {
625  return AnonOrFirstNamespaceAndFlags.getInt() & F_Nested;
626  }
627 
628  /// Set whether this is a nested namespace declaration.
629  void setNested(bool Nested) {
630  unsigned F = AnonOrFirstNamespaceAndFlags.getInt();
631  if (Nested)
632  AnonOrFirstNamespaceAndFlags.setInt(F | F_Nested);
633  else
634  AnonOrFirstNamespaceAndFlags.setInt(F & ~F_Nested);
635  }
636 
637  /// Returns true if the inline qualifier for \c Name is redundant.
639  if (!isInline())
640  return false;
641  auto X = lookup(Name);
642  // We should not perform a lookup within a transparent context, so find a
643  // non-transparent parent context.
644  auto Y = getParent()->getNonTransparentContext()->lookup(Name);
645  return std::distance(X.begin(), X.end()) ==
646  std::distance(Y.begin(), Y.end());
647  }
648 
649  /// Get the original (first) namespace declaration.
651 
652  /// Get the original (first) namespace declaration.
653  const NamespaceDecl *getOriginalNamespace() const;
654 
655  /// Return true if this declaration is an original (first) declaration
656  /// of the namespace. This is false for non-original (subsequent) namespace
657  /// declarations and anonymous namespaces.
658  bool isOriginalNamespace() const;
659 
660  /// Retrieve the anonymous namespace nested inside this namespace,
661  /// if any.
663  return getOriginalNamespace()->AnonOrFirstNamespaceAndFlags.getPointer();
664  }
665 
667  getOriginalNamespace()->AnonOrFirstNamespaceAndFlags.setPointer(D);
668  }
669 
670  /// Retrieves the canonical declaration of this namespace.
672  return getOriginalNamespace();
673  }
675  return getOriginalNamespace();
676  }
677 
678  SourceRange getSourceRange() const override LLVM_READONLY {
679  return SourceRange(LocStart, RBraceLoc);
680  }
681 
682  SourceLocation getBeginLoc() const LLVM_READONLY { return LocStart; }
683  SourceLocation getRBraceLoc() const { return RBraceLoc; }
684  void setLocStart(SourceLocation L) { LocStart = L; }
685  void setRBraceLoc(SourceLocation L) { RBraceLoc = L; }
686 
687  // Implement isa/cast/dyncast/etc.
688  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
689  static bool classofKind(Kind K) { return K == Namespace; }
691  return static_cast<DeclContext *>(const_cast<NamespaceDecl*>(D));
692  }
694  return static_cast<NamespaceDecl *>(const_cast<DeclContext*>(DC));
695  }
696 };
697 
698 class VarDecl;
699 
700 /// Represent the declaration of a variable (in which case it is
701 /// an lvalue) a function (in which case it is a function designator) or
702 /// an enum constant.
703 class ValueDecl : public NamedDecl {
704  QualType DeclType;
705 
706  void anchor() override;
707 
708 protected:
711  : NamedDecl(DK, DC, L, N), DeclType(T) {}
712 
713 public:
714  QualType getType() const { return DeclType; }
715  void setType(QualType newType) { DeclType = newType; }
716 
717  /// Determine whether this symbol is weakly-imported,
718  /// or declared with the weak or weak-ref attr.
719  bool isWeak() const;
720 
721  /// Whether this variable is the implicit variable for a lambda init-capture.
722  /// Only VarDecl can be init captures, but both VarDecl and BindingDecl
723  /// can be captured.
724  bool isInitCapture() const;
725 
726  // If this is a VarDecl, or a BindindDecl with an
727  // associated decomposed VarDecl, return that VarDecl.
730  return const_cast<ValueDecl *>(this)->getPotentiallyDecomposedVarDecl();
731  }
732 
733  // Implement isa/cast/dyncast/etc.
734  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
735  static bool classofKind(Kind K) { return K >= firstValue && K <= lastValue; }
736 };
737 
738 /// A struct with extended info about a syntactic
739 /// name qualifier, to be used for the case of out-of-line declarations.
742 
743  /// The number of "outer" template parameter lists.
744  /// The count includes all of the template parameter lists that were matched
745  /// against the template-ids occurring into the NNS and possibly (in the
746  /// case of an explicit specialization) a final "template <>".
747  unsigned NumTemplParamLists = 0;
748 
749  /// A new-allocated array of size NumTemplParamLists,
750  /// containing pointers to the "outer" template parameter lists.
751  /// It includes all of the template parameter lists that were matched
752  /// against the template-ids occurring into the NNS and possibly (in the
753  /// case of an explicit specialization) a final "template <>".
755 
756  QualifierInfo() = default;
757  QualifierInfo(const QualifierInfo &) = delete;
758  QualifierInfo& operator=(const QualifierInfo &) = delete;
759 
760  /// Sets info about "outer" template parameter lists.
763 };
764 
765 /// Represents a ValueDecl that came out of a declarator.
766 /// Contains type source information through TypeSourceInfo.
767 class DeclaratorDecl : public ValueDecl {
768  // A struct representing a TInfo, a trailing requires-clause and a syntactic
769  // qualifier, to be used for the (uncommon) case of out-of-line declarations
770  // and constrained function decls.
771  struct ExtInfo : public QualifierInfo {
772  TypeSourceInfo *TInfo;
773  Expr *TrailingRequiresClause = nullptr;
774  };
775 
776  llvm::PointerUnion<TypeSourceInfo *, ExtInfo *> DeclInfo;
777 
778  /// The start of the source range for this declaration,
779  /// ignoring outer template declarations.
780  SourceLocation InnerLocStart;
781 
782  bool hasExtInfo() const { return DeclInfo.is<ExtInfo*>(); }
783  ExtInfo *getExtInfo() { return DeclInfo.get<ExtInfo*>(); }
784  const ExtInfo *getExtInfo() const { return DeclInfo.get<ExtInfo*>(); }
785 
786 protected:
789  SourceLocation StartL)
790  : ValueDecl(DK, DC, L, N, T), DeclInfo(TInfo), InnerLocStart(StartL) {}
791 
792 public:
793  friend class ASTDeclReader;
794  friend class ASTDeclWriter;
795 
797  return hasExtInfo()
798  ? getExtInfo()->TInfo
799  : DeclInfo.get<TypeSourceInfo*>();
800  }
801 
803  if (hasExtInfo())
804  getExtInfo()->TInfo = TI;
805  else
806  DeclInfo = TI;
807  }
808 
809  /// Return start of source range ignoring outer template declarations.
810  SourceLocation getInnerLocStart() const { return InnerLocStart; }
811  void setInnerLocStart(SourceLocation L) { InnerLocStart = L; }
812 
813  /// Return start of source range taking into account any outer template
814  /// declarations.
816 
817  SourceRange getSourceRange() const override LLVM_READONLY;
818 
819  SourceLocation getBeginLoc() const LLVM_READONLY {
820  return getOuterLocStart();
821  }
822 
823  /// Retrieve the nested-name-specifier that qualifies the name of this
824  /// declaration, if it was present in the source.
826  return hasExtInfo() ? getExtInfo()->QualifierLoc.getNestedNameSpecifier()
827  : nullptr;
828  }
829 
830  /// Retrieve the nested-name-specifier (with source-location
831  /// information) that qualifies the name of this declaration, if it was
832  /// present in the source.
834  return hasExtInfo() ? getExtInfo()->QualifierLoc
836  }
837 
838  void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc);
839 
840  /// \brief Get the constraint-expression introduced by the trailing
841  /// requires-clause in the function/member declaration, or null if no
842  /// requires-clause was provided.
844  return hasExtInfo() ? getExtInfo()->TrailingRequiresClause
845  : nullptr;
846  }
847 
849  return hasExtInfo() ? getExtInfo()->TrailingRequiresClause
850  : nullptr;
851  }
852 
853  void setTrailingRequiresClause(Expr *TrailingRequiresClause);
854 
855  unsigned getNumTemplateParameterLists() const {
856  return hasExtInfo() ? getExtInfo()->NumTemplParamLists : 0;
857  }
858 
860  assert(index < getNumTemplateParameterLists());
861  return getExtInfo()->TemplParamLists[index];
862  }
863 
866 
869 
870  // Implement isa/cast/dyncast/etc.
871  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
872  static bool classofKind(Kind K) {
873  return K >= firstDeclarator && K <= lastDeclarator;
874  }
875 };
876 
877 /// Structure used to store a statement, the constant value to
878 /// which it was evaluated (if any), and whether or not the statement
879 /// is an integral constant expression (if known).
881  /// Whether this statement was already evaluated.
882  bool WasEvaluated : 1;
883 
884  /// Whether this statement is being evaluated.
885  bool IsEvaluating : 1;
886 
887  /// Whether this variable is known to have constant initialization. This is
888  /// currently only computed in C++, for static / thread storage duration
889  /// variables that might have constant initialization and for variables that
890  /// are usable in constant expressions.
892 
893  /// Whether this variable is known to have constant destruction. That is,
894  /// whether running the destructor on the initial value is a side-effect
895  /// (and doesn't inspect any state that might have changed during program
896  /// execution). This is currently only computed if the destructor is
897  /// non-trivial.
899 
900  /// In C++98, whether the initializer is an ICE. This affects whether the
901  /// variable is usable in constant expressions.
902  bool HasICEInit : 1;
904 
907 
912 };
913 
914 /// Represents a variable declaration or definition.
915 class VarDecl : public DeclaratorDecl, public Redeclarable<VarDecl> {
916 public:
917  /// Initialization styles.
919  /// C-style initialization with assignment
921 
922  /// Call-style initialization (C++98)
924 
925  /// Direct list-initialization (C++11)
927 
928  /// Parenthesized list-initialization (C++20)
930  };
931 
932  /// Kinds of thread-local storage.
933  enum TLSKind {
934  /// Not a TLS variable.
936 
937  /// TLS with a known-constant initializer.
939 
940  /// TLS with a dynamic initializer.
942  };
943 
944  /// Return the string used to specify the storage class \p SC.
945  ///
946  /// It is illegal to call this function with SC == None.
947  static const char *getStorageClassSpecifierString(StorageClass SC);
948 
949 protected:
950  // A pointer union of Stmt * and EvaluatedStmt *. When an EvaluatedStmt, we
951  // have allocated the auxiliary struct of information there.
952  //
953  // TODO: It is a bit unfortunate to use a PointerUnion inside the VarDecl for
954  // this as *many* VarDecls are ParmVarDecls that don't have default
955  // arguments. We could save some space by moving this pointer union to be
956  // allocated in trailing space when necessary.
957  using InitType = llvm::PointerUnion<Stmt *, EvaluatedStmt *>;
958 
959  /// The initializer for this variable or, for a ParmVarDecl, the
960  /// C++ default argument.
961  mutable InitType Init;
962 
963 private:
964  friend class ASTDeclReader;
965  friend class ASTNodeImporter;
966  friend class StmtIteratorBase;
967 
968  class VarDeclBitfields {
969  friend class ASTDeclReader;
970  friend class VarDecl;
971 
972  unsigned SClass : 3;
973  unsigned TSCSpec : 2;
974  unsigned InitStyle : 2;
975 
976  /// Whether this variable is an ARC pseudo-__strong variable; see
977  /// isARCPseudoStrong() for details.
978  unsigned ARCPseudoStrong : 1;
979  };
980  enum { NumVarDeclBits = 8 };
981 
982 protected:
983  enum { NumParameterIndexBits = 8 };
984 
990  };
991 
993 
995  friend class ASTDeclReader;
996  friend class ParmVarDecl;
997 
998  unsigned : NumVarDeclBits;
999 
1000  /// Whether this parameter inherits a default argument from a
1001  /// prior declaration.
1002  unsigned HasInheritedDefaultArg : 1;
1003 
1004  /// Describes the kind of default argument for this parameter. By default
1005  /// this is none. If this is normal, then the default argument is stored in
1006  /// the \c VarDecl initializer expression unless we were unable to parse
1007  /// (even an invalid) expression for the default argument.
1008  unsigned DefaultArgKind : 2;
1009 
1010  /// Whether this parameter undergoes K&R argument promotion.
1011  unsigned IsKNRPromoted : 1;
1012 
1013  /// Whether this parameter is an ObjC method parameter or not.
1014  unsigned IsObjCMethodParam : 1;
1015 
1016  /// If IsObjCMethodParam, a Decl::ObjCDeclQualifier.
1017  /// Otherwise, the number of function parameter scopes enclosing
1018  /// the function parameter scope in which this parameter was
1019  /// declared.
1020  unsigned ScopeDepthOrObjCQuals : NumScopeDepthOrObjCQualsBits;
1021 
1022  /// The number of parameters preceding this parameter in the
1023  /// function parameter scope in which it was declared.
1024  unsigned ParameterIndex : NumParameterIndexBits;
1025  };
1026 
1028  friend class ASTDeclReader;
1029  friend class ImplicitParamDecl;
1030  friend class VarDecl;
1031 
1032  unsigned : NumVarDeclBits;
1033 
1034  // FIXME: We need something similar to CXXRecordDecl::DefinitionData.
1035  /// Whether this variable is a definition which was demoted due to
1036  /// module merge.
1037  unsigned IsThisDeclarationADemotedDefinition : 1;
1038 
1039  /// Whether this variable is the exception variable in a C++ catch
1040  /// or an Objective-C @catch statement.
1041  unsigned ExceptionVar : 1;
1042 
1043  /// Whether this local variable could be allocated in the return
1044  /// slot of its function, enabling the named return value optimization
1045  /// (NRVO).
1046  unsigned NRVOVariable : 1;
1047 
1048  /// Whether this variable is the for-range-declaration in a C++0x
1049  /// for-range statement.
1050  unsigned CXXForRangeDecl : 1;
1051 
1052  /// Whether this variable is the for-in loop declaration in Objective-C.
1053  unsigned ObjCForDecl : 1;
1054 
1055  /// Whether this variable is (C++1z) inline.
1056  unsigned IsInline : 1;
1057 
1058  /// Whether this variable has (C++1z) inline explicitly specified.
1059  unsigned IsInlineSpecified : 1;
1060 
1061  /// Whether this variable is (C++0x) constexpr.
1062  unsigned IsConstexpr : 1;
1063 
1064  /// Whether this variable is the implicit variable for a lambda
1065  /// init-capture.
1066  unsigned IsInitCapture : 1;
1067 
1068  /// Whether this local extern variable's previous declaration was
1069  /// declared in the same block scope. This controls whether we should merge
1070  /// the type of this declaration with its previous declaration.
1071  unsigned PreviousDeclInSameBlockScope : 1;
1072 
1073  /// Defines kind of the ImplicitParamDecl: 'this', 'self', 'vtt', '_cmd' or
1074  /// something else.
1075  unsigned ImplicitParamKind : 3;
1076 
1077  unsigned EscapingByref : 1;
1078  };
1079 
1080  union {
1081  unsigned AllBits;
1082  VarDeclBitfields VarDeclBits;
1085  };
1086 
1087  VarDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
1088  SourceLocation IdLoc, const IdentifierInfo *Id, QualType T,
1089  TypeSourceInfo *TInfo, StorageClass SC);
1090 
1092 
1094  return getNextRedeclaration();
1095  }
1096 
1098  return getPreviousDecl();
1099  }
1100 
1102  return getMostRecentDecl();
1103  }
1104 
1105 public:
1107  using redecl_iterator = redeclarable_base::redecl_iterator;
1108 
1115 
1116  static VarDecl *Create(ASTContext &C, DeclContext *DC,
1117  SourceLocation StartLoc, SourceLocation IdLoc,
1118  const IdentifierInfo *Id, QualType T,
1119  TypeSourceInfo *TInfo, StorageClass S);
1120 
1121  static VarDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1122 
1123  SourceRange getSourceRange() const override LLVM_READONLY;
1124 
1125  /// Returns the storage class as written in the source. For the
1126  /// computed linkage of symbol, see getLinkage.
1128  return (StorageClass) VarDeclBits.SClass;
1129  }
1130  void setStorageClass(StorageClass SC);
1131 
1133  VarDeclBits.TSCSpec = TSC;
1134  assert(VarDeclBits.TSCSpec == TSC && "truncation");
1135  }
1137  return static_cast<ThreadStorageClassSpecifier>(VarDeclBits.TSCSpec);
1138  }
1139  TLSKind getTLSKind() const;
1140 
1141  /// Returns true if a variable with function scope is a non-static local
1142  /// variable.
1143  bool hasLocalStorage() const {
1144  if (getStorageClass() == SC_None) {
1145  // OpenCL v1.2 s6.5.3: The __constant or constant address space name is
1146  // used to describe variables allocated in global memory and which are
1147  // accessed inside a kernel(s) as read-only variables. As such, variables
1148  // in constant address space cannot have local storage.
1149  if (getType().getAddressSpace() == LangAS::opencl_constant)
1150  return false;
1151  // Second check is for C++11 [dcl.stc]p4.
1152  return !isFileVarDecl() && getTSCSpec() == TSCS_unspecified;
1153  }
1154 
1155  // Global Named Register (GNU extension)
1157  return false;
1158 
1159  // Return true for: Auto, Register.
1160  // Return false for: Extern, Static, PrivateExtern, OpenCLWorkGroupLocal.
1161 
1162  return getStorageClass() >= SC_Auto;
1163  }
1164 
1165  /// Returns true if a variable with function scope is a static local
1166  /// variable.
1167  bool isStaticLocal() const {
1168  return (getStorageClass() == SC_Static ||
1169  // C++11 [dcl.stc]p4
1171  && !isFileVarDecl();
1172  }
1173 
1174  /// Returns true if a variable has extern or __private_extern__
1175  /// storage.
1176  bool hasExternalStorage() const {
1177  return getStorageClass() == SC_Extern ||
1179  }
1180 
1181  /// Returns true for all variables that do not have local storage.
1182  ///
1183  /// This includes all global variables as well as static variables declared
1184  /// within a function.
1185  bool hasGlobalStorage() const { return !hasLocalStorage(); }
1186 
1187  /// Get the storage duration of this variable, per C++ [basic.stc].
1189  return hasLocalStorage() ? SD_Automatic :
1191  }
1192 
1193  /// Compute the language linkage.
1195 
1196  /// Determines whether this variable is a variable with external, C linkage.
1197  bool isExternC() const;
1198 
1199  /// Determines whether this variable's context is, or is nested within,
1200  /// a C++ extern "C" linkage spec.
1201  bool isInExternCContext() const;
1202 
1203  /// Determines whether this variable's context is, or is nested within,
1204  /// a C++ extern "C++" linkage spec.
1205  bool isInExternCXXContext() const;
1206 
1207  /// Returns true for local variable declarations other than parameters.
1208  /// Note that this includes static variables inside of functions. It also
1209  /// includes variables inside blocks.
1210  ///
1211  /// void foo() { int x; static int y; extern int z; }
1212  bool isLocalVarDecl() const {
1213  if (getKind() != Decl::Var && getKind() != Decl::Decomposition)
1214  return false;
1215  if (const DeclContext *DC = getLexicalDeclContext())
1216  return DC->getRedeclContext()->isFunctionOrMethod();
1217  return false;
1218  }
1219 
1220  /// Similar to isLocalVarDecl but also includes parameters.
1221  bool isLocalVarDeclOrParm() const {
1222  return isLocalVarDecl() || getKind() == Decl::ParmVar;
1223  }
1224 
1225  /// Similar to isLocalVarDecl, but excludes variables declared in blocks.
1227  if (getKind() != Decl::Var && getKind() != Decl::Decomposition)
1228  return false;
1230  return DC->isFunctionOrMethod() && DC->getDeclKind() != Decl::Block;
1231  }
1232 
1233  /// Determines whether this is a static data member.
1234  ///
1235  /// This will only be true in C++, and applies to, e.g., the
1236  /// variable 'x' in:
1237  /// \code
1238  /// struct S {
1239  /// static int x;
1240  /// };
1241  /// \endcode
1242  bool isStaticDataMember() const {
1243  // If it wasn't static, it would be a FieldDecl.
1244  return getKind() != Decl::ParmVar && getDeclContext()->isRecord();
1245  }
1246 
1247  VarDecl *getCanonicalDecl() override;
1248  const VarDecl *getCanonicalDecl() const {
1249  return const_cast<VarDecl*>(this)->getCanonicalDecl();
1250  }
1251 
1253  /// This declaration is only a declaration.
1255 
1256  /// This declaration is a tentative definition.
1258 
1259  /// This declaration is definitely a definition.
1261  };
1262 
1263  /// Check whether this declaration is a definition. If this could be
1264  /// a tentative definition (in C), don't check whether there's an overriding
1265  /// definition.
1269  }
1270 
1271  /// Check whether this variable is defined in this translation unit.
1274  return hasDefinition(getASTContext());
1275  }
1276 
1277  /// Get the tentative definition that acts as the real definition in a TU.
1278  /// Returns null if there is a proper definition available.
1280  const VarDecl *getActingDefinition() const {
1281  return const_cast<VarDecl*>(this)->getActingDefinition();
1282  }
1283 
1284  /// Get the real (not just tentative) definition for this declaration.
1286  const VarDecl *getDefinition(ASTContext &C) const {
1287  return const_cast<VarDecl*>(this)->getDefinition(C);
1288  }
1290  return getDefinition(getASTContext());
1291  }
1292  const VarDecl *getDefinition() const {
1293  return const_cast<VarDecl*>(this)->getDefinition();
1294  }
1295 
1296  /// Determine whether this is or was instantiated from an out-of-line
1297  /// definition of a static data member.
1298  bool isOutOfLine() const override;
1299 
1300  /// Returns true for file scoped variable declaration.
1301  bool isFileVarDecl() const {
1302  Kind K = getKind();
1303  if (K == ParmVar || K == ImplicitParam)
1304  return false;
1305 
1306  if (getLexicalDeclContext()->getRedeclContext()->isFileContext())
1307  return true;
1308 
1309  if (isStaticDataMember())
1310  return true;
1311 
1312  return false;
1313  }
1314 
1315  /// Get the initializer for this variable, no matter which
1316  /// declaration it is attached to.
1317  const Expr *getAnyInitializer() const {
1318  const VarDecl *D;
1319  return getAnyInitializer(D);
1320  }
1321 
1322  /// Get the initializer for this variable, no matter which
1323  /// declaration it is attached to. Also get that declaration.
1324  const Expr *getAnyInitializer(const VarDecl *&D) const;
1325 
1326  bool hasInit() const;
1327  const Expr *getInit() const {
1328  return const_cast<VarDecl *>(this)->getInit();
1329  }
1330  Expr *getInit();
1331 
1332  /// Retrieve the address of the initializer expression.
1333  Stmt **getInitAddress();
1334 
1335  void setInit(Expr *I);
1336 
1337  /// Get the initializing declaration of this variable, if any. This is
1338  /// usually the definition, except that for a static data member it can be
1339  /// the in-class declaration.
1342  return const_cast<VarDecl *>(this)->getInitializingDeclaration();
1343  }
1344 
1345  /// Determine whether this variable's value might be usable in a
1346  /// constant expression, according to the relevant language standard.
1347  /// This only checks properties of the declaration, and does not check
1348  /// whether the initializer is in fact a constant expression.
1349  ///
1350  /// This corresponds to C++20 [expr.const]p3's notion of a
1351  /// "potentially-constant" variable.
1352  bool mightBeUsableInConstantExpressions(const ASTContext &C) const;
1353 
1354  /// Determine whether this variable's value can be used in a
1355  /// constant expression, according to the relevant language standard,
1356  /// including checking whether it was initialized by a constant expression.
1357  bool isUsableInConstantExpressions(const ASTContext &C) const;
1358 
1361 
1362  /// Attempt to evaluate the value of the initializer attached to this
1363  /// declaration, and produce notes explaining why it cannot be evaluated.
1364  /// Returns a pointer to the value if evaluation succeeded, 0 otherwise.
1365  APValue *evaluateValue() const;
1366 
1367 private:
1368  APValue *evaluateValueImpl(SmallVectorImpl<PartialDiagnosticAt> &Notes,
1369  bool IsConstantInitialization) const;
1370 
1371 public:
1372  /// Return the already-evaluated value of this variable's
1373  /// initializer, or NULL if the value is not yet known. Returns pointer
1374  /// to untyped APValue if the value could not be evaluated.
1375  APValue *getEvaluatedValue() const;
1376 
1377  /// Evaluate the destruction of this variable to determine if it constitutes
1378  /// constant destruction.
1379  ///
1380  /// \pre hasConstantInitialization()
1381  /// \return \c true if this variable has constant destruction, \c false if
1382  /// not.
1384 
1385  /// Determine whether this variable has constant initialization.
1386  ///
1387  /// This is only set in two cases: when the language semantics require
1388  /// constant initialization (globals in C and some globals in C++), and when
1389  /// the variable is usable in constant expressions (constexpr, const int, and
1390  /// reference variables in C++).
1391  bool hasConstantInitialization() const;
1392 
1393  /// Determine whether the initializer of this variable is an integer constant
1394  /// expression. For use in C++98, where this affects whether the variable is
1395  /// usable in constant expressions.
1396  bool hasICEInitializer(const ASTContext &Context) const;
1397 
1398  /// Evaluate the initializer of this variable to determine whether it's a
1399  /// constant initializer. Should only be called once, after completing the
1400  /// definition of the variable.
1403 
1405  VarDeclBits.InitStyle = Style;
1406  }
1407 
1408  /// The style of initialization for this declaration.
1409  ///
1410  /// C-style initialization is "int x = 1;". Call-style initialization is
1411  /// a C++98 direct-initializer, e.g. "int x(1);". The Init expression will be
1412  /// the expression inside the parens or a "ClassType(a,b,c)" class constructor
1413  /// expression for class types. List-style initialization is C++11 syntax,
1414  /// e.g. "int x{1};". Clients can distinguish between different forms of
1415  /// initialization by checking this value. In particular, "int x = {1};" is
1416  /// C-style, "int x({1})" is call-style, and "int x{1};" is list-style; the
1417  /// Init expression in all three cases is an InitListExpr.
1419  return static_cast<InitializationStyle>(VarDeclBits.InitStyle);
1420  }
1421 
1422  /// Whether the initializer is a direct-initializer (list or call).
1423  bool isDirectInit() const {
1424  return getInitStyle() != CInit;
1425  }
1426 
1427  /// If this definition should pretend to be a declaration.
1429  return isa<ParmVarDecl>(this) ? false :
1430  NonParmVarDeclBits.IsThisDeclarationADemotedDefinition;
1431  }
1432 
1433  /// This is a definition which should be demoted to a declaration.
1434  ///
1435  /// In some cases (mostly module merging) we can end up with two visible
1436  /// definitions one of which needs to be demoted to a declaration to keep
1437  /// the AST invariants.
1439  assert(isThisDeclarationADefinition() && "Not a definition!");
1440  assert(!isa<ParmVarDecl>(this) && "Cannot demote ParmVarDecls!");
1441  NonParmVarDeclBits.IsThisDeclarationADemotedDefinition = 1;
1442  }
1443 
1444  /// Determine whether this variable is the exception variable in a
1445  /// C++ catch statememt or an Objective-C \@catch statement.
1446  bool isExceptionVariable() const {
1447  return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.ExceptionVar;
1448  }
1449  void setExceptionVariable(bool EV) {
1450  assert(!isa<ParmVarDecl>(this));
1451  NonParmVarDeclBits.ExceptionVar = EV;
1452  }
1453 
1454  /// Determine whether this local variable can be used with the named
1455  /// return value optimization (NRVO).
1456  ///
1457  /// The named return value optimization (NRVO) works by marking certain
1458  /// non-volatile local variables of class type as NRVO objects. These
1459  /// locals can be allocated within the return slot of their containing
1460  /// function, in which case there is no need to copy the object to the
1461  /// return slot when returning from the function. Within the function body,
1462  /// each return that returns the NRVO object will have this variable as its
1463  /// NRVO candidate.
1464  bool isNRVOVariable() const {
1465  return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.NRVOVariable;
1466  }
1467  void setNRVOVariable(bool NRVO) {
1468  assert(!isa<ParmVarDecl>(this));
1469  NonParmVarDeclBits.NRVOVariable = NRVO;
1470  }
1471 
1472  /// Determine whether this variable is the for-range-declaration in
1473  /// a C++0x for-range statement.
1474  bool isCXXForRangeDecl() const {
1475  return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.CXXForRangeDecl;
1476  }
1477  void setCXXForRangeDecl(bool FRD) {
1478  assert(!isa<ParmVarDecl>(this));
1479  NonParmVarDeclBits.CXXForRangeDecl = FRD;
1480  }
1481 
1482  /// Determine whether this variable is a for-loop declaration for a
1483  /// for-in statement in Objective-C.
1484  bool isObjCForDecl() const {
1485  return NonParmVarDeclBits.ObjCForDecl;
1486  }
1487 
1488  void setObjCForDecl(bool FRD) {
1489  NonParmVarDeclBits.ObjCForDecl = FRD;
1490  }
1491 
1492  /// Determine whether this variable is an ARC pseudo-__strong variable. A
1493  /// pseudo-__strong variable has a __strong-qualified type but does not
1494  /// actually retain the object written into it. Generally such variables are
1495  /// also 'const' for safety. There are 3 cases where this will be set, 1) if
1496  /// the variable is annotated with the objc_externally_retained attribute, 2)
1497  /// if its 'self' in a non-init method, or 3) if its the variable in an for-in
1498  /// loop.
1499  bool isARCPseudoStrong() const { return VarDeclBits.ARCPseudoStrong; }
1500  void setARCPseudoStrong(bool PS) { VarDeclBits.ARCPseudoStrong = PS; }
1501 
1502  /// Whether this variable is (C++1z) inline.
1503  bool isInline() const {
1504  return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.IsInline;
1505  }
1506  bool isInlineSpecified() const {
1507  return isa<ParmVarDecl>(this) ? false
1508  : NonParmVarDeclBits.IsInlineSpecified;
1509  }
1511  assert(!isa<ParmVarDecl>(this));
1512  NonParmVarDeclBits.IsInline = true;
1513  NonParmVarDeclBits.IsInlineSpecified = true;
1514  }
1516  assert(!isa<ParmVarDecl>(this));
1517  NonParmVarDeclBits.IsInline = true;
1518  }
1519 
1520  /// Whether this variable is (C++11) constexpr.
1521  bool isConstexpr() const {
1522  return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.IsConstexpr;
1523  }
1524  void setConstexpr(bool IC) {
1525  assert(!isa<ParmVarDecl>(this));
1526  NonParmVarDeclBits.IsConstexpr = IC;
1527  }
1528 
1529  /// Whether this variable is the implicit variable for a lambda init-capture.
1530  bool isInitCapture() const {
1531  return isa<ParmVarDecl>(this) ? false : NonParmVarDeclBits.IsInitCapture;
1532  }
1533  void setInitCapture(bool IC) {
1534  assert(!isa<ParmVarDecl>(this));
1535  NonParmVarDeclBits.IsInitCapture = IC;
1536  }
1537 
1538  /// Determine whether this variable is actually a function parameter pack or
1539  /// init-capture pack.
1540  bool isParameterPack() const;
1541 
1542  /// Whether this local extern variable declaration's previous declaration
1543  /// was declared in the same block scope. Only correct in C++.
1545  return isa<ParmVarDecl>(this)
1546  ? false
1547  : NonParmVarDeclBits.PreviousDeclInSameBlockScope;
1548  }
1550  assert(!isa<ParmVarDecl>(this));
1551  NonParmVarDeclBits.PreviousDeclInSameBlockScope = Same;
1552  }
1553 
1554  /// Indicates the capture is a __block variable that is captured by a block
1555  /// that can potentially escape (a block for which BlockDecl::doesNotEscape
1556  /// returns false).
1557  bool isEscapingByref() const;
1558 
1559  /// Indicates the capture is a __block variable that is never captured by an
1560  /// escaping block.
1561  bool isNonEscapingByref() const;
1562 
1564  NonParmVarDeclBits.EscapingByref = true;
1565  }
1566 
1567  /// Determines if this variable's alignment is dependent.
1568  bool hasDependentAlignment() const;
1569 
1570  /// Retrieve the variable declaration from which this variable could
1571  /// be instantiated, if it is an instantiation (rather than a non-template).
1573 
1574  /// If this variable is an instantiated static data member of a
1575  /// class template specialization, returns the templated static data member
1576  /// from which it was instantiated.
1578 
1579  /// If this variable is an instantiation of a variable template or a
1580  /// static data member of a class template, determine what kind of
1581  /// template specialization or instantiation this is.
1583 
1584  /// Get the template specialization kind of this variable for the purposes of
1585  /// template instantiation. This differs from getTemplateSpecializationKind()
1586  /// for an instantiation of a class-scope explicit specialization.
1589 
1590  /// If this variable is an instantiation of a variable template or a
1591  /// static data member of a class template, determine its point of
1592  /// instantiation.
1594 
1595  /// If this variable is an instantiation of a static data member of a
1596  /// class template specialization, retrieves the member specialization
1597  /// information.
1599 
1600  /// For a static data member that was instantiated from a static
1601  /// data member of a class template, set the template specialiation kind.
1603  SourceLocation PointOfInstantiation = SourceLocation());
1604 
1605  /// Specify that this variable is an instantiation of the
1606  /// static data member VD.
1609 
1610  /// Retrieves the variable template that is described by this
1611  /// variable declaration.
1612  ///
1613  /// Every variable template is represented as a VarTemplateDecl and a
1614  /// VarDecl. The former contains template properties (such as
1615  /// the template parameter lists) while the latter contains the
1616  /// actual description of the template's
1617  /// contents. VarTemplateDecl::getTemplatedDecl() retrieves the
1618  /// VarDecl that from a VarTemplateDecl, while
1619  /// getDescribedVarTemplate() retrieves the VarTemplateDecl from
1620  /// a VarDecl.
1622 
1623  void setDescribedVarTemplate(VarTemplateDecl *Template);
1624 
1625  // Is this variable known to have a definition somewhere in the complete
1626  // program? This may be true even if the declaration has internal linkage and
1627  // has no definition within this source file.
1628  bool isKnownToBeDefined() const;
1629 
1630  /// Is destruction of this variable entirely suppressed? If so, the variable
1631  /// need not have a usable destructor at all.
1632  bool isNoDestroy(const ASTContext &) const;
1633 
1634  /// Would the destruction of this variable have any effect, and if so, what
1635  /// kind?
1637 
1638  /// Whether this variable has a flexible array member initialized with one
1639  /// or more elements. This can only be called for declarations where
1640  /// hasInit() is true.
1641  ///
1642  /// (The standard doesn't allow initializing flexible array members; this is
1643  /// a gcc/msvc extension.)
1644  bool hasFlexibleArrayInit(const ASTContext &Ctx) const;
1645 
1646  /// If hasFlexibleArrayInit is true, compute the number of additional bytes
1647  /// necessary to store those elements. Otherwise, returns zero.
1648  ///
1649  /// This can only be called for declarations where hasInit() is true.
1651 
1652  // Implement isa/cast/dyncast/etc.
1653  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1654  static bool classofKind(Kind K) { return K >= firstVar && K <= lastVar; }
1655 };
1656 
1657 class ImplicitParamDecl : public VarDecl {
1658  void anchor() override;
1659 
1660 public:
1661  /// Defines the kind of the implicit parameter: is this an implicit parameter
1662  /// with pointer to 'this', 'self', '_cmd', virtual table pointers, captured
1663  /// context or something else.
1664  enum ImplicitParamKind : unsigned {
1665  /// Parameter for Objective-C 'self' argument
1667 
1668  /// Parameter for Objective-C '_cmd' argument
1670 
1671  /// Parameter for C++ 'this' argument
1673 
1674  /// Parameter for C++ virtual table pointers
1676 
1677  /// Parameter for captured context
1679 
1680  /// Parameter for Thread private variable
1682 
1683  /// Other implicit parameter
1685  };
1686 
1687  /// Create implicit parameter.
1690  QualType T, ImplicitParamKind ParamKind);
1692  ImplicitParamKind ParamKind);
1693 
1694  static ImplicitParamDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1695 
1698  ImplicitParamKind ParamKind)
1699  : VarDecl(ImplicitParam, C, DC, IdLoc, IdLoc, Id, Type,
1700  /*TInfo=*/nullptr, SC_None) {
1701  NonParmVarDeclBits.ImplicitParamKind = ParamKind;
1702  setImplicit();
1703  }
1704 
1706  : VarDecl(ImplicitParam, C, /*DC=*/nullptr, SourceLocation(),
1707  SourceLocation(), /*Id=*/nullptr, Type,
1708  /*TInfo=*/nullptr, SC_None) {
1709  NonParmVarDeclBits.ImplicitParamKind = ParamKind;
1710  setImplicit();
1711  }
1712 
1713  /// Returns the implicit parameter kind.
1715  return static_cast<ImplicitParamKind>(NonParmVarDeclBits.ImplicitParamKind);
1716  }
1717 
1718  // Implement isa/cast/dyncast/etc.
1719  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1720  static bool classofKind(Kind K) { return K == ImplicitParam; }
1721 };
1722 
1723 /// Represents a parameter to a function.
1724 class ParmVarDecl : public VarDecl {
1725 public:
1726  enum { MaxFunctionScopeDepth = 255 };
1727  enum { MaxFunctionScopeIndex = 255 };
1728 
1729 protected:
1732  TypeSourceInfo *TInfo, StorageClass S, Expr *DefArg)
1733  : VarDecl(DK, C, DC, StartLoc, IdLoc, Id, T, TInfo, S) {
1734  assert(ParmVarDeclBits.HasInheritedDefaultArg == false);
1735  assert(ParmVarDeclBits.DefaultArgKind == DAK_None);
1736  assert(ParmVarDeclBits.IsKNRPromoted == false);
1737  assert(ParmVarDeclBits.IsObjCMethodParam == false);
1738  setDefaultArg(DefArg);
1739  }
1740 
1741 public:
1742  static ParmVarDecl *Create(ASTContext &C, DeclContext *DC,
1743  SourceLocation StartLoc,
1745  QualType T, TypeSourceInfo *TInfo,
1746  StorageClass S, Expr *DefArg);
1747 
1748  static ParmVarDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1749 
1750  SourceRange getSourceRange() const override LLVM_READONLY;
1751 
1752  void setObjCMethodScopeInfo(unsigned parameterIndex) {
1753  ParmVarDeclBits.IsObjCMethodParam = true;
1754  setParameterIndex(parameterIndex);
1755  }
1756 
1757  void setScopeInfo(unsigned scopeDepth, unsigned parameterIndex) {
1758  assert(!ParmVarDeclBits.IsObjCMethodParam);
1759 
1760  ParmVarDeclBits.ScopeDepthOrObjCQuals = scopeDepth;
1761  assert(ParmVarDeclBits.ScopeDepthOrObjCQuals == scopeDepth
1762  && "truncation!");
1763 
1764  setParameterIndex(parameterIndex);
1765  }
1766 
1767  bool isObjCMethodParameter() const {
1768  return ParmVarDeclBits.IsObjCMethodParam;
1769  }
1770 
1771  /// Determines whether this parameter is destroyed in the callee function.
1772  bool isDestroyedInCallee() const;
1773 
1774  unsigned getFunctionScopeDepth() const {
1775  if (ParmVarDeclBits.IsObjCMethodParam) return 0;
1776  return ParmVarDeclBits.ScopeDepthOrObjCQuals;
1777  }
1778 
1779  static constexpr unsigned getMaxFunctionScopeDepth() {
1780  return (1u << NumScopeDepthOrObjCQualsBits) - 1;
1781  }
1782 
1783  /// Returns the index of this parameter in its prototype or method scope.
1784  unsigned getFunctionScopeIndex() const {
1785  return getParameterIndex();
1786  }
1787 
1789  if (!ParmVarDeclBits.IsObjCMethodParam) return OBJC_TQ_None;
1790  return ObjCDeclQualifier(ParmVarDeclBits.ScopeDepthOrObjCQuals);
1791  }
1793  assert(ParmVarDeclBits.IsObjCMethodParam);
1794  ParmVarDeclBits.ScopeDepthOrObjCQuals = QTVal;
1795  }
1796 
1797  /// True if the value passed to this parameter must undergo
1798  /// K&R-style default argument promotion:
1799  ///
1800  /// C99 6.5.2.2.
1801  /// If the expression that denotes the called function has a type
1802  /// that does not include a prototype, the integer promotions are
1803  /// performed on each argument, and arguments that have type float
1804  /// are promoted to double.
1805  bool isKNRPromoted() const {
1806  return ParmVarDeclBits.IsKNRPromoted;
1807  }
1808  void setKNRPromoted(bool promoted) {
1809  ParmVarDeclBits.IsKNRPromoted = promoted;
1810  }
1811 
1812  Expr *getDefaultArg();
1813  const Expr *getDefaultArg() const {
1814  return const_cast<ParmVarDecl *>(this)->getDefaultArg();
1815  }
1816 
1817  void setDefaultArg(Expr *defarg);
1818 
1819  /// Retrieve the source range that covers the entire default
1820  /// argument.
1825  return const_cast<ParmVarDecl *>(this)->getUninstantiatedDefaultArg();
1826  }
1827 
1828  /// Determines whether this parameter has a default argument,
1829  /// either parsed or not.
1830  bool hasDefaultArg() const;
1831 
1832  /// Determines whether this parameter has a default argument that has not
1833  /// yet been parsed. This will occur during the processing of a C++ class
1834  /// whose member functions have default arguments, e.g.,
1835  /// @code
1836  /// class X {
1837  /// public:
1838  /// void f(int x = 17); // x has an unparsed default argument now
1839  /// }; // x has a regular default argument now
1840  /// @endcode
1841  bool hasUnparsedDefaultArg() const {
1842  return ParmVarDeclBits.DefaultArgKind == DAK_Unparsed;
1843  }
1844 
1846  return ParmVarDeclBits.DefaultArgKind == DAK_Uninstantiated;
1847  }
1848 
1849  /// Specify that this parameter has an unparsed default argument.
1850  /// The argument will be replaced with a real default argument via
1851  /// setDefaultArg when the class definition enclosing the function
1852  /// declaration that owns this default argument is completed.
1854  ParmVarDeclBits.DefaultArgKind = DAK_Unparsed;
1855  }
1856 
1857  bool hasInheritedDefaultArg() const {
1858  return ParmVarDeclBits.HasInheritedDefaultArg;
1859  }
1860 
1861  void setHasInheritedDefaultArg(bool I = true) {
1862  ParmVarDeclBits.HasInheritedDefaultArg = I;
1863  }
1864 
1865  QualType getOriginalType() const;
1866 
1867  /// Sets the function declaration that owns this
1868  /// ParmVarDecl. Since ParmVarDecls are often created before the
1869  /// FunctionDecls that own them, this routine is required to update
1870  /// the DeclContext appropriately.
1872 
1873  // Implement isa/cast/dyncast/etc.
1874  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1875  static bool classofKind(Kind K) { return K == ParmVar; }
1876 
1877 private:
1878  enum { ParameterIndexSentinel = (1 << NumParameterIndexBits) - 1 };
1879 
1880  void setParameterIndex(unsigned parameterIndex) {
1881  if (parameterIndex >= ParameterIndexSentinel) {
1882  setParameterIndexLarge(parameterIndex);
1883  return;
1884  }
1885 
1886  ParmVarDeclBits.ParameterIndex = parameterIndex;
1887  assert(ParmVarDeclBits.ParameterIndex == parameterIndex && "truncation!");
1888  }
1889  unsigned getParameterIndex() const {
1890  unsigned d = ParmVarDeclBits.ParameterIndex;
1891  return d == ParameterIndexSentinel ? getParameterIndexLarge() : d;
1892  }
1893 
1894  void setParameterIndexLarge(unsigned parameterIndex);
1895  unsigned getParameterIndexLarge() const;
1896 };
1897 
1898 enum class MultiVersionKind {
1899  None,
1900  Target,
1901  CPUSpecific,
1902  CPUDispatch,
1903  TargetClones,
1905 };
1906 
1907 /// Represents a function declaration or definition.
1908 ///
1909 /// Since a given function can be declared several times in a program,
1910 /// there may be several FunctionDecls that correspond to that
1911 /// function. Only one of those FunctionDecls will be found when
1912 /// traversing the list of declarations in the context of the
1913 /// FunctionDecl (e.g., the translation unit); this FunctionDecl
1914 /// contains all of the information known about the function. Other,
1915 /// previous declarations of the function are available via the
1916 /// getPreviousDecl() chain.
1918  public DeclContext,
1919  public Redeclarable<FunctionDecl> {
1920  // This class stores some data in DeclContext::FunctionDeclBits
1921  // to save some space. Use the provided accessors to access it.
1922 public:
1923  /// The kind of templated function a FunctionDecl can be.
1925  // Not templated.
1927  // The pattern in a function template declaration.
1929  // A non-template function that is an instantiation or explicit
1930  // specialization of a member of a templated class.
1932  // An instantiation or explicit specialization of a function template.
1933  // Note: this might have been instantiated from a templated class if it
1934  // is a class-scope explicit specialization.
1936  // A function template specialization that hasn't yet been resolved to a
1937  // particular specialized function template.
1939  // A non-template function which is in a dependent scope.
1941 
1942  };
1943 
1944  /// Stashed information about a defaulted function definition whose body has
1945  /// not yet been lazily generated.
1947  : llvm::TrailingObjects<DefaultedFunctionInfo, DeclAccessPair> {
1948  friend TrailingObjects;
1949  unsigned NumLookups;
1950 
1951  public:
1952  static DefaultedFunctionInfo *Create(ASTContext &Context,
1953  ArrayRef<DeclAccessPair> Lookups);
1954  /// Get the unqualified lookup results that should be used in this
1955  /// defaulted function definition.
1957  return {getTrailingObjects<DeclAccessPair>(), NumLookups};
1958  }
1959  };
1960 
1961 private:
1962  /// A new[]'d array of pointers to VarDecls for the formal
1963  /// parameters of this function. This is null if a prototype or if there are
1964  /// no formals.
1965  ParmVarDecl **ParamInfo = nullptr;
1966 
1967  /// The active member of this union is determined by
1968  /// FunctionDeclBits.HasDefaultedFunctionInfo.
1969  union {
1970  /// The body of the function.
1972  /// Information about a future defaulted function definition.
1974  };
1975 
1976  unsigned ODRHash;
1977 
1978  /// End part of this FunctionDecl's source range.
1979  ///
1980  /// We could compute the full range in getSourceRange(). However, when we're
1981  /// dealing with a function definition deserialized from a PCH/AST file,
1982  /// we can only compute the full range once the function body has been
1983  /// de-serialized, so it's far better to have the (sometimes-redundant)
1984  /// EndRangeLoc.
1985  SourceLocation EndRangeLoc;
1986 
1987  SourceLocation DefaultKWLoc;
1988 
1989  /// The template or declaration that this declaration
1990  /// describes or was instantiated from, respectively.
1991  ///
1992  /// For non-templates this value will be NULL, unless this declaration was
1993  /// declared directly inside of a function template, in which case it will
1994  /// have a pointer to a FunctionDecl, stored in the NamedDecl. For function
1995  /// declarations that describe a function template, this will be a pointer to
1996  /// a FunctionTemplateDecl, stored in the NamedDecl. For member functions of
1997  /// class template specializations, this will be a MemberSpecializationInfo
1998  /// pointer containing information about the specialization.
1999  /// For function template specializations, this will be a
2000  /// FunctionTemplateSpecializationInfo, which contains information about
2001  /// the template being specialized and the template arguments involved in
2002  /// that specialization.
2003  llvm::PointerUnion<NamedDecl *, MemberSpecializationInfo *,
2006  TemplateOrSpecialization;
2007 
2008  /// Provides source/type location info for the declaration name embedded in
2009  /// the DeclaratorDecl base class.
2010  DeclarationNameLoc DNLoc;
2011 
2012  /// Specify that this function declaration is actually a function
2013  /// template specialization.
2014  ///
2015  /// \param C the ASTContext.
2016  ///
2017  /// \param Template the function template that this function template
2018  /// specialization specializes.
2019  ///
2020  /// \param TemplateArgs the template arguments that produced this
2021  /// function template specialization from the template.
2022  ///
2023  /// \param InsertPos If non-NULL, the position in the function template
2024  /// specialization set where the function template specialization data will
2025  /// be inserted.
2026  ///
2027  /// \param TSK the kind of template specialization this is.
2028  ///
2029  /// \param TemplateArgsAsWritten location info of template arguments.
2030  ///
2031  /// \param PointOfInstantiation point at which the function template
2032  /// specialization was first instantiated.
2033  void setFunctionTemplateSpecialization(ASTContext &C,
2034  FunctionTemplateDecl *Template,
2035  const TemplateArgumentList *TemplateArgs,
2036  void *InsertPos,
2038  const TemplateArgumentListInfo *TemplateArgsAsWritten,
2039  SourceLocation PointOfInstantiation);
2040 
2041  /// Specify that this record is an instantiation of the
2042  /// member function FD.
2043  void setInstantiationOfMemberFunction(ASTContext &C, FunctionDecl *FD,
2045 
2046  void setParams(ASTContext &C, ArrayRef<ParmVarDecl *> NewParamInfo);
2047 
2048  // This is unfortunately needed because ASTDeclWriter::VisitFunctionDecl
2049  // need to access this bit but we want to avoid making ASTDeclWriter
2050  // a friend of FunctionDeclBitfields just for this.
2051  bool isDeletedBit() const { return FunctionDeclBits.IsDeleted; }
2052 
2053  /// Whether an ODRHash has been stored.
2054  bool hasODRHash() const { return FunctionDeclBits.HasODRHash; }
2055 
2056  /// State that an ODRHash has been stored.
2057  void setHasODRHash(bool B = true) { FunctionDeclBits.HasODRHash = B; }
2058 
2059 protected:
2060  FunctionDecl(Kind DK, ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
2061  const DeclarationNameInfo &NameInfo, QualType T,
2062  TypeSourceInfo *TInfo, StorageClass S, bool UsesFPIntrin,
2063  bool isInlineSpecified, ConstexprSpecKind ConstexprKind,
2064  Expr *TrailingRequiresClause = nullptr);
2065 
2067 
2069  return getNextRedeclaration();
2070  }
2071 
2073  return getPreviousDecl();
2074  }
2075 
2077  return getMostRecentDecl();
2078  }
2079 
2080 public:
2081  friend class ASTDeclReader;
2082  friend class ASTDeclWriter;
2083 
2085  using redecl_iterator = redeclarable_base::redecl_iterator;
2086 
2093 
2094  static FunctionDecl *
2097  TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin = false,
2098  bool isInlineSpecified = false, bool hasWrittenPrototype = true,
2100  Expr *TrailingRequiresClause = nullptr) {
2101  DeclarationNameInfo NameInfo(N, NLoc);
2102  return FunctionDecl::Create(C, DC, StartLoc, NameInfo, T, TInfo, SC,
2104  hasWrittenPrototype, ConstexprKind,
2105  TrailingRequiresClause);
2106  }
2107 
2108  static FunctionDecl *
2109  Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
2110  const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
2112  bool hasWrittenPrototype, ConstexprSpecKind ConstexprKind,
2113  Expr *TrailingRequiresClause);
2114 
2115  static FunctionDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2116 
2118  return DeclarationNameInfo(getDeclName(), getLocation(), DNLoc);
2119  }
2120 
2121  void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy,
2122  bool Qualified) const override;
2123 
2124  void setRangeEnd(SourceLocation E) { EndRangeLoc = E; }
2125 
2126  /// Returns the location of the ellipsis of a variadic function.
2128  const auto *FPT = getType()->getAs<FunctionProtoType>();
2129  if (FPT && FPT->isVariadic())
2130  return FPT->getEllipsisLoc();
2131  return SourceLocation();
2132  }
2133 
2134  SourceRange getSourceRange() const override LLVM_READONLY;
2135 
2136  // Function definitions.
2137  //
2138  // A function declaration may be:
2139  // - a non defining declaration,
2140  // - a definition. A function may be defined because:
2141  // - it has a body, or will have it in the case of late parsing.
2142  // - it has an uninstantiated body. The body does not exist because the
2143  // function is not used yet, but the declaration is considered a
2144  // definition and does not allow other definition of this function.
2145  // - it does not have a user specified body, but it does not allow
2146  // redefinition, because it is deleted/defaulted or is defined through
2147  // some other mechanism (alias, ifunc).
2148 
2149  /// Returns true if the function has a body.
2150  ///
2151  /// The function body might be in any of the (re-)declarations of this
2152  /// function. The variant that accepts a FunctionDecl pointer will set that
2153  /// function declaration to the actual declaration containing the body (if
2154  /// there is one).
2155  bool hasBody(const FunctionDecl *&Definition) const;
2156 
2157  bool hasBody() const override {
2158  const FunctionDecl* Definition;
2159  return hasBody(Definition);
2160  }
2161 
2162  /// Returns whether the function has a trivial body that does not require any
2163  /// specific codegen.
2164  bool hasTrivialBody() const;
2165 
2166  /// Returns true if the function has a definition that does not need to be
2167  /// instantiated.
2168  ///
2169  /// The variant that accepts a FunctionDecl pointer will set that function
2170  /// declaration to the declaration that is a definition (if there is one).
2171  ///
2172  /// \param CheckForPendingFriendDefinition If \c true, also check for friend
2173  /// declarations that were instantiataed from function definitions.
2174  /// Such a declaration behaves as if it is a definition for the
2175  /// purpose of redefinition checking, but isn't actually a "real"
2176  /// definition until its body is instantiated.
2177  bool isDefined(const FunctionDecl *&Definition,
2178  bool CheckForPendingFriendDefinition = false) const;
2179 
2180  bool isDefined() const {
2181  const FunctionDecl* Definition;
2182  return isDefined(Definition);
2183  }
2184 
2185  /// Get the definition for this declaration.
2187  const FunctionDecl *Definition;
2188  if (isDefined(Definition))
2189  return const_cast<FunctionDecl *>(Definition);
2190  return nullptr;
2191  }
2192  const FunctionDecl *getDefinition() const {
2193  return const_cast<FunctionDecl *>(this)->getDefinition();
2194  }
2195 
2196  /// Retrieve the body (definition) of the function. The function body might be
2197  /// in any of the (re-)declarations of this function. The variant that accepts
2198  /// a FunctionDecl pointer will set that function declaration to the actual
2199  /// declaration containing the body (if there is one).
2200  /// NOTE: For checking if there is a body, use hasBody() instead, to avoid
2201  /// unnecessary AST de-serialization of the body.
2202  Stmt *getBody(const FunctionDecl *&Definition) const;
2203 
2204  Stmt *getBody() const override {
2205  const FunctionDecl* Definition;
2206  return getBody(Definition);
2207  }
2208 
2209  /// Returns whether this specific declaration of the function is also a
2210  /// definition that does not contain uninstantiated body.
2211  ///
2212  /// This does not determine whether the function has been defined (e.g., in a
2213  /// previous definition); for that information, use isDefined.
2214  ///
2215  /// Note: the function declaration does not become a definition until the
2216  /// parser reaches the definition, if called before, this function will return
2217  /// `false`.
2219  return isDeletedAsWritten() || isDefaulted() ||
2222  }
2223 
2224  /// Determine whether this specific declaration of the function is a friend
2225  /// declaration that was instantiated from a function definition. Such
2226  /// declarations behave like definitions in some contexts.
2228 
2229  /// Returns whether this specific declaration of the function has a body.
2231  return (!FunctionDeclBits.HasDefaultedFunctionInfo && Body) ||
2233  }
2234 
2235  void setBody(Stmt *B);
2237  FunctionDeclBits.HasDefaultedFunctionInfo = false;
2239  }
2240 
2241  void setDefaultedFunctionInfo(DefaultedFunctionInfo *Info);
2242  DefaultedFunctionInfo *getDefaultedFunctionInfo() const;
2243 
2244  /// Whether this function is variadic.
2245  bool isVariadic() const;
2246 
2247  /// Whether this function is marked as virtual explicitly.
2248  bool isVirtualAsWritten() const {
2249  return FunctionDeclBits.IsVirtualAsWritten;
2250  }
2251 
2252  /// State that this function is marked as virtual explicitly.
2253  void setVirtualAsWritten(bool V) { FunctionDeclBits.IsVirtualAsWritten = V; }
2254 
2255  /// Whether this virtual function is pure, i.e. makes the containing class
2256  /// abstract.
2257  bool isPure() const { return FunctionDeclBits.IsPure; }
2258  void setPure(bool P = true);
2259 
2260  /// Whether this templated function will be late parsed.
2261  bool isLateTemplateParsed() const {
2262  return FunctionDeclBits.IsLateTemplateParsed;
2263  }
2264 
2265  /// State that this templated function will be late parsed.
2266  void setLateTemplateParsed(bool ILT = true) {
2267  FunctionDeclBits.IsLateTemplateParsed = ILT;
2268  }
2269 
2270  /// Whether this function is "trivial" in some specialized C++ senses.
2271  /// Can only be true for default constructors, copy constructors,
2272  /// copy assignment operators, and destructors. Not meaningful until
2273  /// the class has been fully built by Sema.
2274  bool isTrivial() const { return FunctionDeclBits.IsTrivial; }
2275  void setTrivial(bool IT) { FunctionDeclBits.IsTrivial = IT; }
2276 
2277  bool isTrivialForCall() const { return FunctionDeclBits.IsTrivialForCall; }
2278  void setTrivialForCall(bool IT) { FunctionDeclBits.IsTrivialForCall = IT; }
2279 
2280  /// Whether this function is defaulted. Valid for e.g.
2281  /// special member functions, defaulted comparisions (not methods!).
2282  bool isDefaulted() const { return FunctionDeclBits.IsDefaulted; }
2283  void setDefaulted(bool D = true) { FunctionDeclBits.IsDefaulted = D; }
2284 
2285  /// Whether this function is explicitly defaulted.
2286  bool isExplicitlyDefaulted() const {
2287  return FunctionDeclBits.IsExplicitlyDefaulted;
2288  }
2289 
2290  /// State that this function is explicitly defaulted.
2291  void setExplicitlyDefaulted(bool ED = true) {
2292  FunctionDeclBits.IsExplicitlyDefaulted = ED;
2293  }
2294 
2296  return isExplicitlyDefaulted() ? DefaultKWLoc : SourceLocation();
2297  }
2298 
2300  assert((NewLoc.isInvalid() || isExplicitlyDefaulted()) &&
2301  "Can't set default loc is function isn't explicitly defaulted");
2302  DefaultKWLoc = NewLoc;
2303  }
2304 
2305  /// True if this method is user-declared and was not
2306  /// deleted or defaulted on its first declaration.
2307  bool isUserProvided() const {
2308  auto *DeclAsWritten = this;
2310  DeclAsWritten = Pattern;
2311  return !(DeclAsWritten->isDeleted() ||
2312  DeclAsWritten->getCanonicalDecl()->isDefaulted());
2313  }
2314 
2316  return FunctionDeclBits.IsIneligibleOrNotSelected;
2317  }
2319  FunctionDeclBits.IsIneligibleOrNotSelected = II;
2320  }
2321 
2322  /// Whether falling off this function implicitly returns null/zero.
2323  /// If a more specific implicit return value is required, front-ends
2324  /// should synthesize the appropriate return statements.
2325  bool hasImplicitReturnZero() const {
2326  return FunctionDeclBits.HasImplicitReturnZero;
2327  }
2328 
2329  /// State that falling off this function implicitly returns null/zero.
2330  /// If a more specific implicit return value is required, front-ends
2331  /// should synthesize the appropriate return statements.
2332  void setHasImplicitReturnZero(bool IRZ) {
2333  FunctionDeclBits.HasImplicitReturnZero = IRZ;
2334  }
2335 
2336  /// Whether this function has a prototype, either because one
2337  /// was explicitly written or because it was "inherited" by merging
2338  /// a declaration without a prototype with a declaration that has a
2339  /// prototype.
2340  bool hasPrototype() const {
2342  }
2343 
2344  /// Whether this function has a written prototype.
2345  bool hasWrittenPrototype() const {
2346  return FunctionDeclBits.HasWrittenPrototype;
2347  }
2348 
2349  /// State that this function has a written prototype.
2350  void setHasWrittenPrototype(bool P = true) {
2351  FunctionDeclBits.HasWrittenPrototype = P;
2352  }
2353 
2354  /// Whether this function inherited its prototype from a
2355  /// previous declaration.
2356  bool hasInheritedPrototype() const {
2357  return FunctionDeclBits.HasInheritedPrototype;
2358  }
2359 
2360  /// State that this function inherited its prototype from a
2361  /// previous declaration.
2362  void setHasInheritedPrototype(bool P = true) {
2363  FunctionDeclBits.HasInheritedPrototype = P;
2364  }
2365 
2366  /// Whether this is a (C++11) constexpr function or constexpr constructor.
2367  bool isConstexpr() const {
2369  }
2371  FunctionDeclBits.ConstexprKind = static_cast<uint64_t>(CSK);
2372  }
2374  return static_cast<ConstexprSpecKind>(FunctionDeclBits.ConstexprKind);
2375  }
2376  bool isConstexprSpecified() const {
2378  }
2379  bool isConsteval() const {
2381  }
2382 
2383  /// Whether the instantiation of this function is pending.
2384  /// This bit is set when the decision to instantiate this function is made
2385  /// and unset if and when the function body is created. That leaves out
2386  /// cases where instantiation did not happen because the template definition
2387  /// was not seen in this TU. This bit remains set in those cases, under the
2388  /// assumption that the instantiation will happen in some other TU.
2389  bool instantiationIsPending() const {
2390  return FunctionDeclBits.InstantiationIsPending;
2391  }
2392 
2393  /// State that the instantiation of this function is pending.
2394  /// (see instantiationIsPending)
2396  FunctionDeclBits.InstantiationIsPending = IC;
2397  }
2398 
2399  /// Indicates the function uses __try.
2400  bool usesSEHTry() const { return FunctionDeclBits.UsesSEHTry; }
2401  void setUsesSEHTry(bool UST) { FunctionDeclBits.UsesSEHTry = UST; }
2402 
2403  /// Whether this function has been deleted.
2404  ///
2405  /// A function that is "deleted" (via the C++0x "= delete" syntax)
2406  /// acts like a normal function, except that it cannot actually be
2407  /// called or have its address taken. Deleted functions are
2408  /// typically used in C++ overload resolution to attract arguments
2409  /// whose type or lvalue/rvalue-ness would permit the use of a
2410  /// different overload that would behave incorrectly. For example,
2411  /// one might use deleted functions to ban implicit conversion from
2412  /// a floating-point number to an Integer type:
2413  ///
2414  /// @code
2415  /// struct Integer {
2416  /// Integer(long); // construct from a long
2417  /// Integer(double) = delete; // no construction from float or double
2418  /// Integer(long double) = delete; // no construction from long double
2419  /// };
2420  /// @endcode
2421  // If a function is deleted, its first declaration must be.
2422  bool isDeleted() const {
2423  return getCanonicalDecl()->FunctionDeclBits.IsDeleted;
2424  }
2425 
2426  bool isDeletedAsWritten() const {
2427  return FunctionDeclBits.IsDeleted && !isDefaulted();
2428  }
2429 
2430  void setDeletedAsWritten(bool D = true) { FunctionDeclBits.IsDeleted = D; }
2431 
2432  /// Determines whether this function is "main", which is the
2433  /// entry point into an executable program.
2434  bool isMain() const;
2435 
2436  /// Determines whether this function is a MSVCRT user defined entry
2437  /// point.
2438  bool isMSVCRTEntryPoint() const;
2439 
2440  /// Determines whether this operator new or delete is one
2441  /// of the reserved global placement operators:
2442  /// void *operator new(size_t, void *);
2443  /// void *operator new[](size_t, void *);
2444  /// void operator delete(void *, void *);
2445  /// void operator delete[](void *, void *);
2446  /// These functions have special behavior under [new.delete.placement]:
2447  /// These functions are reserved, a C++ program may not define
2448  /// functions that displace the versions in the Standard C++ library.
2449  /// The provisions of [basic.stc.dynamic] do not apply to these
2450  /// reserved placement forms of operator new and operator delete.
2451  ///
2452  /// This function must be an allocation or deallocation function.
2453  bool isReservedGlobalPlacementOperator() const;
2454 
2455  /// Determines whether this function is one of the replaceable
2456  /// global allocation functions:
2457  /// void *operator new(size_t);
2458  /// void *operator new(size_t, const std::nothrow_t &) noexcept;
2459  /// void *operator new[](size_t);
2460  /// void *operator new[](size_t, const std::nothrow_t &) noexcept;
2461  /// void operator delete(void *) noexcept;
2462  /// void operator delete(void *, std::size_t) noexcept; [C++1y]
2463  /// void operator delete(void *, const std::nothrow_t &) noexcept;
2464  /// void operator delete[](void *) noexcept;
2465  /// void operator delete[](void *, std::size_t) noexcept; [C++1y]
2466  /// void operator delete[](void *, const std::nothrow_t &) noexcept;
2467  /// These functions have special behavior under C++1y [expr.new]:
2468  /// An implementation is allowed to omit a call to a replaceable global
2469  /// allocation function. [...]
2470  ///
2471  /// If this function is an aligned allocation/deallocation function, return
2472  /// the parameter number of the requested alignment through AlignmentParam.
2473  ///
2474  /// If this function is an allocation/deallocation function that takes
2475  /// the `std::nothrow_t` tag, return true through IsNothrow,
2477  std::optional<unsigned> *AlignmentParam = nullptr,
2478  bool *IsNothrow = nullptr) const;
2479 
2480  /// Determine if this function provides an inline implementation of a builtin.
2481  bool isInlineBuiltinDeclaration() const;
2482 
2483  /// Determine whether this is a destroying operator delete.
2484  bool isDestroyingOperatorDelete() const;
2485 
2486  /// Compute the language linkage.
2488 
2489  /// Determines whether this function is a function with
2490  /// external, C linkage.
2491  bool isExternC() const;
2492 
2493  /// Determines whether this function's context is, or is nested within,
2494  /// a C++ extern "C" linkage spec.
2495  bool isInExternCContext() const;
2496 
2497  /// Determines whether this function's context is, or is nested within,
2498  /// a C++ extern "C++" linkage spec.
2499  bool isInExternCXXContext() const;
2500 
2501  /// Determines whether this is a global function.
2502  bool isGlobal() const;
2503 
2504  /// Determines whether this function is known to be 'noreturn', through
2505  /// an attribute on its declaration or its type.
2506  bool isNoReturn() const;
2507 
2508  /// True if the function was a definition but its body was skipped.
2509  bool hasSkippedBody() const { return FunctionDeclBits.HasSkippedBody; }
2510  void setHasSkippedBody(bool Skipped = true) {
2511  FunctionDeclBits.HasSkippedBody = Skipped;
2512  }
2513 
2514  /// True if this function will eventually have a body, once it's fully parsed.
2515  bool willHaveBody() const { return FunctionDeclBits.WillHaveBody; }
2516  void setWillHaveBody(bool V = true) { FunctionDeclBits.WillHaveBody = V; }
2517 
2518  /// True if this function is considered a multiversioned function.
2519  bool isMultiVersion() const {
2520  return getCanonicalDecl()->FunctionDeclBits.IsMultiVersion;
2521  }
2522 
2523  /// Sets the multiversion state for this declaration and all of its
2524  /// redeclarations.
2525  void setIsMultiVersion(bool V = true) {
2526  getCanonicalDecl()->FunctionDeclBits.IsMultiVersion = V;
2527  }
2528 
2529  // Sets that this is a constrained friend where the constraint refers to an
2530  // enclosing template.
2533  ->FunctionDeclBits.FriendConstraintRefersToEnclosingTemplate = V;
2534  }
2535  // Indicates this function is a constrained friend, where the constraint
2536  // refers to an enclosing template for hte purposes of [temp.friend]p9.
2538  return getCanonicalDecl()
2539  ->FunctionDeclBits.FriendConstraintRefersToEnclosingTemplate;
2540  }
2541 
2542  /// Gets the kind of multiversioning attribute this declaration has. Note that
2543  /// this can return a value even if the function is not multiversion, such as
2544  /// the case of 'target'.
2546 
2547 
2548  /// True if this function is a multiversioned dispatch function as a part of
2549  /// the cpu_specific/cpu_dispatch functionality.
2550  bool isCPUDispatchMultiVersion() const;
2551  /// True if this function is a multiversioned processor specific function as a
2552  /// part of the cpu_specific/cpu_dispatch functionality.
2553  bool isCPUSpecificMultiVersion() const;
2554 
2555  /// True if this function is a multiversioned dispatch function as a part of
2556  /// the target functionality.
2557  bool isTargetMultiVersion() const;
2558 
2559  /// True if this function is a multiversioned dispatch function as a part of
2560  /// the target-clones functionality.
2561  bool isTargetClonesMultiVersion() const;
2562 
2563  /// \brief Get the associated-constraints of this function declaration.
2564  /// Currently, this will either be a vector of size 1 containing the
2565  /// trailing-requires-clause or an empty vector.
2566  ///
2567  /// Use this instead of getTrailingRequiresClause for concepts APIs that
2568  /// accept an ArrayRef of constraint expressions.
2570  if (auto *TRC = getTrailingRequiresClause())
2571  AC.push_back(TRC);
2572  }
2573 
2574  void setPreviousDeclaration(FunctionDecl * PrevDecl);
2575 
2576  FunctionDecl *getCanonicalDecl() override;
2578  return const_cast<FunctionDecl*>(this)->getCanonicalDecl();
2579  }
2580 
2581  unsigned getBuiltinID(bool ConsiderWrapperFunctions = false) const;
2582 
2583  // ArrayRef interface to parameters.
2585  return {ParamInfo, getNumParams()};
2586  }
2588  return {ParamInfo, getNumParams()};
2589  }
2590 
2591  // Iterator access to formal parameters.
2594 
2595  bool param_empty() const { return parameters().empty(); }
2596  param_iterator param_begin() { return parameters().begin(); }
2597  param_iterator param_end() { return parameters().end(); }
2598  param_const_iterator param_begin() const { return parameters().begin(); }
2599  param_const_iterator param_end() const { return parameters().end(); }
2600  size_t param_size() const { return parameters().size(); }
2601 
2602  /// Return the number of parameters this function must have based on its
2603  /// FunctionType. This is the length of the ParamInfo array after it has been
2604  /// created.
2605  unsigned getNumParams() const;
2606 
2607  const ParmVarDecl *getParamDecl(unsigned i) const {
2608  assert(i < getNumParams() && "Illegal param #");
2609  return ParamInfo[i];
2610  }
2611  ParmVarDecl *getParamDecl(unsigned i) {
2612  assert(i < getNumParams() && "Illegal param #");
2613  return ParamInfo[i];
2614  }
2615  void setParams(ArrayRef<ParmVarDecl *> NewParamInfo) {
2616  setParams(getASTContext(), NewParamInfo);
2617  }
2618 
2619  /// Returns the minimum number of arguments needed to call this function. This
2620  /// may be fewer than the number of function parameters, if some of the
2621  /// parameters have default arguments (in C++).
2622  unsigned getMinRequiredArguments() const;
2623 
2624  /// Determine whether this function has a single parameter, or multiple
2625  /// parameters where all but the first have default arguments.
2626  ///
2627  /// This notion is used in the definition of copy/move constructors and
2628  /// initializer list constructors. Note that, unlike getMinRequiredArguments,
2629  /// parameter packs are not treated specially here.
2630  bool hasOneParamOrDefaultArgs() const;
2631 
2632  /// Find the source location information for how the type of this function
2633  /// was written. May be absent (for example if the function was declared via
2634  /// a typedef) and may contain a different type from that of the function
2635  /// (for example if the function type was adjusted by an attribute).
2637 
2639  return getType()->castAs<FunctionType>()->getReturnType();
2640  }
2641 
2642  /// Attempt to compute an informative source range covering the
2643  /// function return type. This may omit qualifiers and other information with
2644  /// limited representation in the AST.
2646 
2647  /// Attempt to compute an informative source range covering the
2648  /// function parameters, including the ellipsis of a variadic function.
2649  /// The source range excludes the parentheses, and is invalid if there are
2650  /// no parameters and no ellipsis.
2652 
2653  /// Get the declared return type, which may differ from the actual return
2654  /// type if the return type is deduced.
2656  auto *TSI = getTypeSourceInfo();
2657  QualType T = TSI ? TSI->getType() : getType();
2658  return T->castAs<FunctionType>()->getReturnType();
2659  }
2660 
2661  /// Gets the ExceptionSpecificationType as declared.
2663  auto *TSI = getTypeSourceInfo();
2664  QualType T = TSI ? TSI->getType() : getType();
2665  const auto *FPT = T->getAs<FunctionProtoType>();
2666  return FPT ? FPT->getExceptionSpecType() : EST_None;
2667  }
2668 
2669  /// Attempt to compute an informative source range covering the
2670  /// function exception specification, if any.
2672 
2673  /// Determine the type of an expression that calls this function.
2676  getASTContext());
2677  }
2678 
2679  /// Returns the storage class as written in the source. For the
2680  /// computed linkage of symbol, see getLinkage.
2682  return static_cast<StorageClass>(FunctionDeclBits.SClass);
2683  }
2684 
2685  /// Sets the storage class as written in the source.
2687  FunctionDeclBits.SClass = SClass;
2688  }
2689 
2690  /// Determine whether the "inline" keyword was specified for this
2691  /// function.
2692  bool isInlineSpecified() const { return FunctionDeclBits.IsInlineSpecified; }
2693 
2694  /// Set whether the "inline" keyword was specified for this function.
2695  void setInlineSpecified(bool I) {
2696  FunctionDeclBits.IsInlineSpecified = I;
2697  FunctionDeclBits.IsInline = I;
2698  }
2699 
2700  /// Determine whether the function was declared in source context
2701  /// that requires constrained FP intrinsics
2702  bool UsesFPIntrin() const { return FunctionDeclBits.UsesFPIntrin; }
2703 
2704  /// Set whether the function was declared in source context
2705  /// that requires constrained FP intrinsics
2706  void setUsesFPIntrin(bool I) { FunctionDeclBits.UsesFPIntrin = I; }
2707 
2708  /// Flag that this function is implicitly inline.
2709  void setImplicitlyInline(bool I = true) { FunctionDeclBits.IsInline = I; }
2710 
2711  /// Determine whether this function should be inlined, because it is
2712  /// either marked "inline" or "constexpr" or is a member function of a class
2713  /// that was defined in the class body.
2714  bool isInlined() const { return FunctionDeclBits.IsInline; }
2715 
2717 
2718  bool isMSExternInline() const;
2719 
2721 
2722  bool isStatic() const { return getStorageClass() == SC_Static; }
2723 
2724  /// Whether this function declaration represents an C++ overloaded
2725  /// operator, e.g., "operator+".
2726  bool isOverloadedOperator() const {
2727  return getOverloadedOperator() != OO_None;
2728  }
2729 
2731 
2732  const IdentifierInfo *getLiteralIdentifier() const;
2733 
2734  /// If this function is an instantiation of a member function
2735  /// of a class template specialization, retrieves the function from
2736  /// which it was instantiated.
2737  ///
2738  /// This routine will return non-NULL for (non-templated) member
2739  /// functions of class templates and for instantiations of function
2740  /// templates. For example, given:
2741  ///
2742  /// \code
2743  /// template<typename T>
2744  /// struct X {
2745  /// void f(T);
2746  /// };
2747  /// \endcode
2748  ///
2749  /// The declaration for X<int>::f is a (non-templated) FunctionDecl
2750  /// whose parent is the class template specialization X<int>. For
2751  /// this declaration, getInstantiatedFromFunction() will return
2752  /// the FunctionDecl X<T>::A. When a complete definition of
2753  /// X<int>::A is required, it will be instantiated from the
2754  /// declaration returned by getInstantiatedFromMemberFunction().
2756 
2757  /// What kind of templated function this is.
2759 
2760  /// If this function is an instantiation of a member function of a
2761  /// class template specialization, retrieves the member specialization
2762  /// information.
2764 
2765  /// Specify that this record is an instantiation of the
2766  /// member function FD.
2769  setInstantiationOfMemberFunction(getASTContext(), FD, TSK);
2770  }
2771 
2772  /// Specify that this function declaration was instantiated from a
2773  /// FunctionDecl FD. This is only used if this is a function declaration
2774  /// declared locally inside of a function template.
2776 
2778 
2779  /// Retrieves the function template that is described by this
2780  /// function declaration.
2781  ///
2782  /// Every function template is represented as a FunctionTemplateDecl
2783  /// and a FunctionDecl (or something derived from FunctionDecl). The
2784  /// former contains template properties (such as the template
2785  /// parameter lists) while the latter contains the actual
2786  /// description of the template's
2787  /// contents. FunctionTemplateDecl::getTemplatedDecl() retrieves the
2788  /// FunctionDecl that describes the function template,
2789  /// getDescribedFunctionTemplate() retrieves the
2790  /// FunctionTemplateDecl from a FunctionDecl.
2792 
2794 
2795  /// Determine whether this function is a function template
2796  /// specialization.
2798  return getPrimaryTemplate() != nullptr;
2799  }
2800 
2801  /// If this function is actually a function template specialization,
2802  /// retrieve information about this function template specialization.
2803  /// Otherwise, returns NULL.
2805 
2806  /// Determines whether this function is a function template
2807  /// specialization or a member of a class template specialization that can
2808  /// be implicitly instantiated.
2809  bool isImplicitlyInstantiable() const;
2810 
2811  /// Determines if the given function was instantiated from a
2812  /// function template.
2813  bool isTemplateInstantiation() const;
2814 
2815  /// Retrieve the function declaration from which this function could
2816  /// be instantiated, if it is an instantiation (rather than a non-template
2817  /// or a specialization, for example).
2818  ///
2819  /// If \p ForDefinition is \c false, explicit specializations will be treated
2820  /// as if they were implicit instantiations. This will then find the pattern
2821  /// corresponding to non-definition portions of the declaration, such as
2822  /// default arguments and the exception specification.
2823  FunctionDecl *
2825 
2826  /// Retrieve the primary template that this function template
2827  /// specialization either specializes or was instantiated from.
2828  ///
2829  /// If this function declaration is not a function template specialization,
2830  /// returns NULL.
2832 
2833  /// Retrieve the template arguments used to produce this function
2834  /// template specialization from the primary template.
2835  ///
2836  /// If this function declaration is not a function template specialization,
2837  /// returns NULL.
2839 
2840  /// Retrieve the template argument list as written in the sources,
2841  /// if any.
2842  ///
2843  /// If this function declaration is not a function template specialization
2844  /// or if it had no explicit template argument list, returns NULL.
2845  /// Note that it an explicit template argument list may be written empty,
2846  /// e.g., template<> void foo<>(char* s);
2849 
2850  /// Specify that this function declaration is actually a function
2851  /// template specialization.
2852  ///
2853  /// \param Template the function template that this function template
2854  /// specialization specializes.
2855  ///
2856  /// \param TemplateArgs the template arguments that produced this
2857  /// function template specialization from the template.
2858  ///
2859  /// \param InsertPos If non-NULL, the position in the function template
2860  /// specialization set where the function template specialization data will
2861  /// be inserted.
2862  ///
2863  /// \param TSK the kind of template specialization this is.
2864  ///
2865  /// \param TemplateArgsAsWritten location info of template arguments.
2866  ///
2867  /// \param PointOfInstantiation point at which the function template
2868  /// specialization was first instantiated.
2870  const TemplateArgumentList *TemplateArgs,
2871  void *InsertPos,
2873  const TemplateArgumentListInfo *TemplateArgsAsWritten = nullptr,
2874  SourceLocation PointOfInstantiation = SourceLocation()) {
2875  setFunctionTemplateSpecialization(getASTContext(), Template, TemplateArgs,
2876  InsertPos, TSK, TemplateArgsAsWritten,
2877  PointOfInstantiation);
2878  }
2879 
2880  /// Specifies that this function declaration is actually a
2881  /// dependent function template specialization.
2883  const UnresolvedSetImpl &Templates,
2884  const TemplateArgumentListInfo &TemplateArgs);
2885 
2888 
2889  /// Determine what kind of template instantiation this function
2890  /// represents.
2892 
2893  /// Determine the kind of template specialization this function represents
2894  /// for the purpose of template instantiation.
2897 
2898  /// Determine what kind of template instantiation this function
2899  /// represents.
2901  SourceLocation PointOfInstantiation = SourceLocation());
2902 
2903  /// Retrieve the (first) point of instantiation of a function template
2904  /// specialization or a member of a class template specialization.
2905  ///
2906  /// \returns the first point of instantiation, if this function was
2907  /// instantiated from a template; otherwise, returns an invalid source
2908  /// location.
2910 
2911  /// Determine whether this is or was instantiated from an out-of-line
2912  /// definition of a member function.
2913  bool isOutOfLine() const override;
2914 
2915  /// Identify a memory copying or setting function.
2916  /// If the given function is a memory copy or setting function, returns
2917  /// the corresponding Builtin ID. If the function is not a memory function,
2918  /// returns 0.
2919  unsigned getMemoryFunctionKind() const;
2920 
2921  /// Returns ODRHash of the function. This value is calculated and
2922  /// stored on first call, then the stored value returned on the other calls.
2923  unsigned getODRHash();
2924 
2925  /// Returns cached ODRHash of the function. This must have been previously
2926  /// computed and stored.
2927  unsigned getODRHash() const;
2928 
2929  // Implement isa/cast/dyncast/etc.
2930  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2931  static bool classofKind(Kind K) {
2932  return K >= firstFunction && K <= lastFunction;
2933  }
2935  return static_cast<DeclContext *>(const_cast<FunctionDecl*>(D));
2936  }
2938  return static_cast<FunctionDecl *>(const_cast<DeclContext*>(DC));
2939  }
2940 };
2941 
2942 /// Represents a member of a struct/union/class.
2943 class FieldDecl : public DeclaratorDecl, public Mergeable<FieldDecl> {
2944  unsigned BitField : 1;
2945  unsigned Mutable : 1;
2946  mutable unsigned CachedFieldIndex : 30;
2947 
2948  /// The kinds of value we can store in InitializerOrBitWidth.
2949  ///
2950  /// Note that this is compatible with InClassInitStyle except for
2951  /// ISK_CapturedVLAType.
2952  enum InitStorageKind {
2953  /// If the pointer is null, there's nothing special. Otherwise,
2954  /// this is a bitfield and the pointer is the Expr* storing the
2955  /// bit-width.
2956  ISK_NoInit = (unsigned) ICIS_NoInit,
2957 
2958  /// The pointer is an (optional due to delayed parsing) Expr*
2959  /// holding the copy-initializer.
2960  ISK_InClassCopyInit = (unsigned) ICIS_CopyInit,
2961 
2962  /// The pointer is an (optional due to delayed parsing) Expr*
2963  /// holding the list-initializer.
2964  ISK_InClassListInit = (unsigned) ICIS_ListInit,
2965 
2966  /// The pointer is a VariableArrayType* that's been captured;
2967  /// the enclosing context is a lambda or captured statement.
2968  ISK_CapturedVLAType,
2969  };
2970 
2971  /// If this is a bitfield with a default member initializer, this
2972  /// structure is used to represent the two expressions.
2973  struct InitAndBitWidth {
2974  Expr *Init;
2975  Expr *BitWidth;
2976  };
2977 
2978  /// Storage for either the bit-width, the in-class initializer, or
2979  /// both (via InitAndBitWidth), or the captured variable length array bound.
2980  ///
2981  /// If the storage kind is ISK_InClassCopyInit or
2982  /// ISK_InClassListInit, but the initializer is null, then this
2983  /// field has an in-class initializer that has not yet been parsed
2984  /// and attached.
2985  // FIXME: Tail-allocate this to reduce the size of FieldDecl in the
2986  // overwhelmingly common case that we have none of these things.
2987  llvm::PointerIntPair<void *, 2, InitStorageKind> InitStorage;
2988 
2989 protected:
2992  QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable,
2993  InClassInitStyle InitStyle)
2994  : DeclaratorDecl(DK, DC, IdLoc, Id, T, TInfo, StartLoc),
2995  BitField(false), Mutable(Mutable), CachedFieldIndex(0),
2996  InitStorage(nullptr, (InitStorageKind) InitStyle) {
2997  if (BW)
2998  setBitWidth(BW);
2999  }
3000 
3001 public:
3002  friend class ASTDeclReader;
3003  friend class ASTDeclWriter;
3004 
3005  static FieldDecl *Create(const ASTContext &C, DeclContext *DC,
3006  SourceLocation StartLoc, SourceLocation IdLoc,
3008  TypeSourceInfo *TInfo, Expr *BW, bool Mutable,
3009  InClassInitStyle InitStyle);
3010 
3011  static FieldDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3012 
3013  /// Returns the index of this field within its record,
3014  /// as appropriate for passing to ASTRecordLayout::getFieldOffset.
3015  unsigned getFieldIndex() const;
3016 
3017  /// Determines whether this field is mutable (C++ only).
3018  bool isMutable() const { return Mutable; }
3019 
3020  /// Determines whether this field is a bitfield.
3021  bool isBitField() const { return BitField; }
3022 
3023  /// Determines whether this is an unnamed bitfield.
3024  bool isUnnamedBitfield() const { return isBitField() && !getDeclName(); }
3025 
3026  /// Determines whether this field is a
3027  /// representative for an anonymous struct or union. Such fields are
3028  /// unnamed and are implicitly generated by the implementation to
3029  /// store the data for the anonymous union or struct.
3030  bool isAnonymousStructOrUnion() const;
3031 
3032  Expr *getBitWidth() const {
3033  if (!BitField)
3034  return nullptr;
3035  void *Ptr = InitStorage.getPointer();
3036  if (getInClassInitStyle())
3037  return static_cast<InitAndBitWidth*>(Ptr)->BitWidth;
3038  return static_cast<Expr*>(Ptr);
3039  }
3040 
3041  unsigned getBitWidthValue(const ASTContext &Ctx) const;
3042 
3043  /// Set the bit-field width for this member.
3044  // Note: used by some clients (i.e., do not remove it).
3045  void setBitWidth(Expr *Width) {
3046  assert(!hasCapturedVLAType() && !BitField &&
3047  "bit width or captured type already set");
3048  assert(Width && "no bit width specified");
3049  InitStorage.setPointer(
3050  InitStorage.getInt()
3051  ? new (getASTContext())
3052  InitAndBitWidth{getInClassInitializer(), Width}
3053  : static_cast<void*>(Width));
3054  BitField = true;
3055  }
3056 
3057  /// Remove the bit-field width from this member.
3058  // Note: used by some clients (i.e., do not remove it).
3060  assert(isBitField() && "no bitfield width to remove");
3061  InitStorage.setPointer(getInClassInitializer());
3062  BitField = false;
3063  }
3064 
3065  /// Is this a zero-length bit-field? Such bit-fields aren't really bit-fields
3066  /// at all and instead act as a separator between contiguous runs of other
3067  /// bit-fields.
3068  bool isZeroLengthBitField(const ASTContext &Ctx) const;
3069 
3070  /// Determine if this field is a subobject of zero size, that is, either a
3071  /// zero-length bit-field or a field of empty class type with the
3072  /// [[no_unique_address]] attribute.
3073  bool isZeroSize(const ASTContext &Ctx) const;
3074 
3075  /// Get the kind of (C++11) default member initializer that this field has.
3077  InitStorageKind storageKind = InitStorage.getInt();
3078  return (storageKind == ISK_CapturedVLAType
3079  ? ICIS_NoInit : (InClassInitStyle) storageKind);
3080  }
3081 
3082  /// Determine whether this member has a C++11 default member initializer.
3083  bool hasInClassInitializer() const {
3084  return getInClassInitStyle() != ICIS_NoInit;
3085  }
3086 
3087  /// Get the C++11 default member initializer for this member, or null if one
3088  /// has not been set. If a valid declaration has a default member initializer,
3089  /// but this returns null, then we have not parsed and attached it yet.
3091  if (!hasInClassInitializer())
3092  return nullptr;
3093  void *Ptr = InitStorage.getPointer();
3094  if (BitField)
3095  return static_cast<InitAndBitWidth*>(Ptr)->Init;
3096  return static_cast<Expr*>(Ptr);
3097  }
3098 
3099  /// Set the C++11 in-class initializer for this member.
3102  if (BitField)
3103  static_cast<InitAndBitWidth*>(InitStorage.getPointer())->Init = Init;
3104  else
3105  InitStorage.setPointer(Init);
3106  }
3107 
3108  /// Remove the C++11 in-class initializer from this member.
3110  assert(hasInClassInitializer() && "no initializer to remove");
3111  InitStorage.setPointerAndInt(getBitWidth(), ISK_NoInit);
3112  }
3113 
3114  /// Determine whether this member captures the variable length array
3115  /// type.
3116  bool hasCapturedVLAType() const {
3117  return InitStorage.getInt() == ISK_CapturedVLAType;
3118  }
3119 
3120  /// Get the captured variable length array type.
3122  return hasCapturedVLAType() ? static_cast<const VariableArrayType *>(
3123  InitStorage.getPointer())
3124  : nullptr;
3125  }
3126 
3127  /// Set the captured variable length array type for this field.
3128  void setCapturedVLAType(const VariableArrayType *VLAType);
3129 
3130  /// Returns the parent of this field declaration, which
3131  /// is the struct in which this field is defined.
3132  ///
3133  /// Returns null if this is not a normal class/struct field declaration, e.g.
3134  /// ObjCAtDefsFieldDecl, ObjCIvarDecl.
3135  const RecordDecl *getParent() const {
3136  return dyn_cast<RecordDecl>(getDeclContext());
3137  }
3138 
3140  return dyn_cast<RecordDecl>(getDeclContext());
3141  }
3142 
3143  SourceRange getSourceRange() const override LLVM_READONLY;
3144 
3145  /// Retrieves the canonical declaration of this field.
3146  FieldDecl *getCanonicalDecl() override { return getFirstDecl(); }
3147  const FieldDecl *getCanonicalDecl() const { return getFirstDecl(); }
3148 
3149  // Implement isa/cast/dyncast/etc.
3150  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3151  static bool classofKind(Kind K) { return K >= firstField && K <= lastField; }
3152 };
3153 
3154 /// An instance of this object exists for each enum constant
3155 /// that is defined. For example, in "enum X {a,b}", each of a/b are
3156 /// EnumConstantDecl's, X is an instance of EnumDecl, and the type of a/b is a
3157 /// TagType for the X EnumDecl.
3158 class EnumConstantDecl : public ValueDecl, public Mergeable<EnumConstantDecl> {
3159  Stmt *Init; // an integer constant expression
3160  llvm::APSInt Val; // The value.
3161 
3162 protected:
3164  IdentifierInfo *Id, QualType T, Expr *E,
3165  const llvm::APSInt &V)
3166  : ValueDecl(EnumConstant, DC, L, Id, T), Init((Stmt*)E), Val(V) {}
3167 
3168 public:
3169  friend class StmtIteratorBase;
3170 
3173  QualType T, Expr *E,
3174  const llvm::APSInt &V);
3175  static EnumConstantDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3176 
3177  const Expr *getInitExpr() const { return (const Expr*) Init; }
3178  Expr *getInitExpr() { return (Expr*) Init; }
3179  const llvm::APSInt &getInitVal() const { return Val; }
3180 
3181  void setInitExpr(Expr *E) { Init = (Stmt*) E; }
3182  void setInitVal(const llvm::APSInt &V) { Val = V; }
3183 
3184  SourceRange getSourceRange() const override LLVM_READONLY;
3185 
3186  /// Retrieves the canonical declaration of this enumerator.
3188  const EnumConstantDecl *getCanonicalDecl() const { return getFirstDecl(); }
3189 
3190  // Implement isa/cast/dyncast/etc.
3191  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3192  static bool classofKind(Kind K) { return K == EnumConstant; }
3193 };
3194 
3195 /// Represents a field injected from an anonymous union/struct into the parent
3196 /// scope. These are always implicit.
3198  public Mergeable<IndirectFieldDecl> {
3199  NamedDecl **Chaining;
3200  unsigned ChainingSize;
3201 
3205 
3206  void anchor() override;
3207 
3208 public:
3209  friend class ASTDeclReader;
3210 
3214 
3215  static IndirectFieldDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3216 
3218 
3220  return llvm::ArrayRef(Chaining, ChainingSize);
3221  }
3222  chain_iterator chain_begin() const { return chain().begin(); }
3223  chain_iterator chain_end() const { return chain().end(); }
3224 
3225  unsigned getChainingSize() const { return ChainingSize; }
3226 
3228  assert(chain().size() >= 2);
3229  return cast<FieldDecl>(chain().back());
3230  }
3231 
3232  VarDecl *getVarDecl() const {
3233  assert(chain().size() >= 2);
3234  return dyn_cast<VarDecl>(chain().front());
3235  }
3236 
3238  const IndirectFieldDecl *getCanonicalDecl() const { return getFirstDecl(); }
3239 
3240  // Implement isa/cast/dyncast/etc.
3241  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3242  static bool classofKind(Kind K) { return K == IndirectField; }
3243 };
3244 
3245 /// Represents a declaration of a type.
3246 class TypeDecl : public NamedDecl {
3247  friend class ASTContext;
3248 
3249  /// This indicates the Type object that represents
3250  /// this TypeDecl. It is a cache maintained by
3251  /// ASTContext::getTypedefType, ASTContext::getTagDeclType, and
3252  /// ASTContext::getTemplateTypeParmType, and TemplateTypeParmDecl.
3253  mutable const Type *TypeForDecl = nullptr;
3254 
3255  /// The start of the source range for this declaration.
3256  SourceLocation LocStart;
3257 
3258  void anchor() override;
3259 
3260 protected:
3262  SourceLocation StartL = SourceLocation())
3263  : NamedDecl(DK, DC, L, Id), LocStart(StartL) {}
3264 
3265 public:
3266  // Low-level accessor. If you just want the type defined by this node,
3267  // check out ASTContext::getTypeDeclType or one of
3268  // ASTContext::getTypedefType, ASTContext::getRecordType, etc. if you
3269  // already know the specific kind of node this is.
3270  const Type *getTypeForDecl() const { return TypeForDecl; }
3271  void setTypeForDecl(const Type *TD) { TypeForDecl = TD; }
3272 
3273  SourceLocation getBeginLoc() const LLVM_READONLY { return LocStart; }
3274  void setLocStart(SourceLocation L) { LocStart = L; }
3275  SourceRange getSourceRange() const override LLVM_READONLY {
3276  if (LocStart.isValid())
3277  return SourceRange(LocStart, getLocation());
3278  else
3279  return SourceRange(getLocation());
3280  }
3281 
3282  // Implement isa/cast/dyncast/etc.
3283  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3284  static bool classofKind(Kind K) { return K >= firstType && K <= lastType; }
3285 };
3286 
3287 /// Base class for declarations which introduce a typedef-name.
3288 class TypedefNameDecl : public TypeDecl, public Redeclarable<TypedefNameDecl> {
3289  struct alignas(8) ModedTInfo {
3290  TypeSourceInfo *first;
3291  QualType second;
3292  };
3293 
3294  /// If int part is 0, we have not computed IsTransparentTag.
3295  /// Otherwise, IsTransparentTag is (getInt() >> 1).
3296  mutable llvm::PointerIntPair<
3297  llvm::PointerUnion<TypeSourceInfo *, ModedTInfo *>, 2>
3298  MaybeModedTInfo;
3299 
3300  void anchor() override;
3301 
3302 protected:
3304  SourceLocation StartLoc, SourceLocation IdLoc,
3305  IdentifierInfo *Id, TypeSourceInfo *TInfo)
3306  : TypeDecl(DK, DC, IdLoc, Id, StartLoc), redeclarable_base(C),
3307  MaybeModedTInfo(TInfo, 0) {}
3308 
3310 
3312  return getNextRedeclaration();
3313  }
3314 
3316  return getPreviousDecl();
3317  }
3318 
3320  return getMostRecentDecl();
3321  }
3322 
3323 public:
3325  using redecl_iterator = redeclarable_base::redecl_iterator;
3326 
3333 
3334  bool isModed() const {
3335  return MaybeModedTInfo.getPointer().is<ModedTInfo *>();
3336  }
3337 
3339  return isModed() ? MaybeModedTInfo.getPointer().get<ModedTInfo *>()->first
3340  : MaybeModedTInfo.getPointer().get<TypeSourceInfo *>();
3341  }
3342 
3344  return isModed() ? MaybeModedTInfo.getPointer().get<ModedTInfo *>()->second
3345  : MaybeModedTInfo.getPointer()
3346  .get<TypeSourceInfo *>()
3347  ->getType();
3348  }
3349 
3351  MaybeModedTInfo.setPointer(newType);
3352  }
3353 
3354  void setModedTypeSourceInfo(TypeSourceInfo *unmodedTSI, QualType modedTy) {
3355  MaybeModedTInfo.setPointer(new (getASTContext(), 8)
3356  ModedTInfo({unmodedTSI, modedTy}));
3357  }
3358 
3359  /// Retrieves the canonical declaration of this typedef-name.
3361  const TypedefNameDecl *getCanonicalDecl() const { return getFirstDecl(); }
3362 
3363  /// Retrieves the tag declaration for which this is the typedef name for
3364  /// linkage purposes, if any.
3365  ///
3366  /// \param AnyRedecl Look for the tag declaration in any redeclaration of
3367  /// this typedef declaration.
3368  TagDecl *getAnonDeclWithTypedefName(bool AnyRedecl = false) const;
3369 
3370  /// Determines if this typedef shares a name and spelling location with its
3371  /// underlying tag type, as is the case with the NS_ENUM macro.
3372  bool isTransparentTag() const {
3373  if (MaybeModedTInfo.getInt())
3374  return MaybeModedTInfo.getInt() & 0x2;
3375  return isTransparentTagSlow();
3376  }
3377 
3378  // Implement isa/cast/dyncast/etc.
3379  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3380  static bool classofKind(Kind K) {
3381  return K >= firstTypedefName && K <= lastTypedefName;
3382  }
3383 
3384 private:
3385  bool isTransparentTagSlow() const;
3386 };
3387 
3388 /// Represents the declaration of a typedef-name via the 'typedef'
3389 /// type specifier.
3393  : TypedefNameDecl(Typedef, C, DC, StartLoc, IdLoc, Id, TInfo) {}
3394 
3395 public:
3396  static TypedefDecl *Create(ASTContext &C, DeclContext *DC,
3397  SourceLocation StartLoc, SourceLocation IdLoc,
3398  IdentifierInfo *Id, TypeSourceInfo *TInfo);
3399  static TypedefDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3400 
3401  SourceRange getSourceRange() const override LLVM_READONLY;
3402 
3403  // Implement isa/cast/dyncast/etc.
3404  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3405  static bool classofKind(Kind K) { return K == Typedef; }
3406 };
3407 
3408 /// Represents the declaration of a typedef-name via a C++11
3409 /// alias-declaration.
3411  /// The template for which this is the pattern, if any.
3412  TypeAliasTemplateDecl *Template;
3413 
3416  : TypedefNameDecl(TypeAlias, C, DC, StartLoc, IdLoc, Id, TInfo),
3417  Template(nullptr) {}
3418 
3419 public:
3420  static TypeAliasDecl *Create(ASTContext &C, DeclContext *DC,
3421  SourceLocation StartLoc, SourceLocation IdLoc,
3422  IdentifierInfo *Id, TypeSourceInfo *TInfo);
3423  static TypeAliasDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3424 
3425  SourceRange getSourceRange() const override LLVM_READONLY;
3426 
3427  TypeAliasTemplateDecl *getDescribedAliasTemplate() const { return Template; }
3428  void setDescribedAliasTemplate(TypeAliasTemplateDecl *TAT) { Template = TAT; }
3429 
3430  // Implement isa/cast/dyncast/etc.
3431  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3432  static bool classofKind(Kind K) { return K == TypeAlias; }
3433 };
3434 
3435 /// Represents the declaration of a struct/union/class/enum.
3436 class TagDecl : public TypeDecl,
3437  public DeclContext,
3438  public Redeclarable<TagDecl> {
3439  // This class stores some data in DeclContext::TagDeclBits
3440  // to save some space. Use the provided accessors to access it.
3441 public:
3442  // This is really ugly.
3444 
3445 private:
3446  SourceRange BraceRange;
3447 
3448  // A struct representing syntactic qualifier info,
3449  // to be used for the (uncommon) case of out-of-line declarations.
3450  using ExtInfo = QualifierInfo;
3451 
3452  /// If the (out-of-line) tag declaration name
3453  /// is qualified, it points to the qualifier info (nns and range);
3454  /// otherwise, if the tag declaration is anonymous and it is part of
3455  /// a typedef or alias, it points to the TypedefNameDecl (used for mangling);
3456  /// otherwise, if the tag declaration is anonymous and it is used as a
3457  /// declaration specifier for variables, it points to the first VarDecl (used
3458  /// for mangling);
3459  /// otherwise, it is a null (TypedefNameDecl) pointer.
3460  llvm::PointerUnion<TypedefNameDecl *, ExtInfo *> TypedefNameDeclOrQualifier;
3461 
3462  bool hasExtInfo() const { return TypedefNameDeclOrQualifier.is<ExtInfo *>(); }
3463  ExtInfo *getExtInfo() { return TypedefNameDeclOrQualifier.get<ExtInfo *>(); }
3464  const ExtInfo *getExtInfo() const {
3465  return TypedefNameDeclOrQualifier.get<ExtInfo *>();
3466  }
3467 
3468 protected:
3469  TagDecl(Kind DK, TagKind TK, const ASTContext &C, DeclContext *DC,
3470  SourceLocation L, IdentifierInfo *Id, TagDecl *PrevDecl,
3471  SourceLocation StartL);
3472 
3474 
3476  return getNextRedeclaration();
3477  }
3478 
3480  return getPreviousDecl();
3481  }
3482 
3484  return getMostRecentDecl();
3485  }
3486 
3487  /// Completes the definition of this tag declaration.
3488  ///
3489  /// This is a helper function for derived classes.
3490  void completeDefinition();
3491 
3492  /// True if this decl is currently being defined.
3493  void setBeingDefined(bool V = true) { TagDeclBits.IsBeingDefined = V; }
3494 
3495  /// Indicates whether it is possible for declarations of this kind
3496  /// to have an out-of-date definition.
3497  ///
3498  /// This option is only enabled when modules are enabled.
3499  void setMayHaveOutOfDateDef(bool V = true) {
3500  TagDeclBits.MayHaveOutOfDateDef = V;
3501  }
3502 
3503 public:
3504  friend class ASTDeclReader;
3505  friend class ASTDeclWriter;
3506 
3508  using redecl_iterator = redeclarable_base::redecl_iterator;
3509 
3516 
3517  SourceRange getBraceRange() const { return BraceRange; }
3518  void setBraceRange(SourceRange R) { BraceRange = R; }
3519 
3520  /// Return SourceLocation representing start of source
3521  /// range ignoring outer template declarations.
3523 
3524  /// Return SourceLocation representing start of source
3525  /// range taking into account any outer template declarations.
3527  SourceRange getSourceRange() const override LLVM_READONLY;
3528 
3529  TagDecl *getCanonicalDecl() override;
3530  const TagDecl *getCanonicalDecl() const {
3531  return const_cast<TagDecl*>(this)->getCanonicalDecl();
3532  }
3533 
3534  /// Return true if this declaration is a completion definition of the type.
3535  /// Provided for consistency.
3537  return isCompleteDefinition();
3538  }
3539 
3540  /// Return true if this decl has its body fully specified.
3541  bool isCompleteDefinition() const { return TagDeclBits.IsCompleteDefinition; }
3542 
3543  /// True if this decl has its body fully specified.
3544  void setCompleteDefinition(bool V = true) {
3545  TagDeclBits.IsCompleteDefinition = V;
3546  }
3547 
3548  /// Return true if this complete decl is
3549  /// required to be complete for some existing use.
3551  return TagDeclBits.IsCompleteDefinitionRequired;
3552  }
3553 
3554  /// True if this complete decl is
3555  /// required to be complete for some existing use.
3556  void setCompleteDefinitionRequired(bool V = true) {
3557  TagDeclBits.IsCompleteDefinitionRequired = V;
3558  }
3559 
3560  /// Return true if this decl is currently being defined.
3561  bool isBeingDefined() const { return TagDeclBits.IsBeingDefined; }
3562 
3563  /// True if this tag declaration is "embedded" (i.e., defined or declared
3564  /// for the very first time) in the syntax of a declarator.
3565  bool isEmbeddedInDeclarator() const {
3566  return TagDeclBits.IsEmbeddedInDeclarator;
3567  }
3568 
3569  /// True if this tag declaration is "embedded" (i.e., defined or declared
3570  /// for the very first time) in the syntax of a declarator.
3571  void setEmbeddedInDeclarator(bool isInDeclarator) {
3572  TagDeclBits.IsEmbeddedInDeclarator = isInDeclarator;
3573  }
3574 
3575  /// True if this tag is free standing, e.g. "struct foo;".
3576  bool isFreeStanding() const { return TagDeclBits.IsFreeStanding; }
3577 
3578  /// True if this tag is free standing, e.g. "struct foo;".
3579  void setFreeStanding(bool isFreeStanding = true) {
3580  TagDeclBits.IsFreeStanding = isFreeStanding;
3581  }
3582 
3583  /// Indicates whether it is possible for declarations of this kind
3584  /// to have an out-of-date definition.
3585  ///
3586  /// This option is only enabled when modules are enabled.
3587  bool mayHaveOutOfDateDef() const { return TagDeclBits.MayHaveOutOfDateDef; }
3588 
3589  /// Whether this declaration declares a type that is
3590  /// dependent, i.e., a type that somehow depends on template
3591  /// parameters.
3592  bool isDependentType() const { return isDependentContext(); }
3593 
3594  /// Whether this declaration was a definition in some module but was forced
3595  /// to be a declaration.
3596  ///
3597  /// Useful for clients checking if a module has a definition of a specific
3598  /// symbol and not interested in the final AST with deduplicated definitions.
3600  return TagDeclBits.IsThisDeclarationADemotedDefinition;
3601  }
3602 
3603  /// Mark a definition as a declaration and maintain information it _was_
3604  /// a definition.
3606  assert(isCompleteDefinition() &&
3607  "Should demote definitions only, not forward declarations");
3608  setCompleteDefinition(false);
3609  TagDeclBits.IsThisDeclarationADemotedDefinition = true;
3610  }
3611 
3612  /// Starts the definition of this tag declaration.
3613  ///
3614  /// This method should be invoked at the beginning of the definition
3615  /// of this tag declaration. It will set the tag type into a state
3616  /// where it is in the process of being defined.
3617  void startDefinition();
3618 
3619  /// Returns the TagDecl that actually defines this
3620  /// struct/union/class/enum. When determining whether or not a
3621  /// struct/union/class/enum has a definition, one should use this
3622  /// method as opposed to 'isDefinition'. 'isDefinition' indicates
3623  /// whether or not a specific TagDecl is defining declaration, not
3624  /// whether or not the struct/union/class/enum type is defined.
3625  /// This method returns NULL if there is no TagDecl that defines
3626  /// the struct/union/class/enum.
3627  TagDecl *getDefinition() const;
3628 
3629  StringRef getKindName() const {
3631  }
3632 
3634  return static_cast<TagKind>(TagDeclBits.TagDeclKind);
3635  }
3636 
3637  void setTagKind(TagKind TK) { TagDeclBits.TagDeclKind = TK; }
3638 
3639  bool isStruct() const { return getTagKind() == TTK_Struct; }
3640  bool isInterface() const { return getTagKind() == TTK_Interface; }
3641  bool isClass() const { return getTagKind() == TTK_Class; }
3642  bool isUnion() const { return getTagKind() == TTK_Union; }
3643  bool isEnum() const { return getTagKind() == TTK_Enum; }
3644 
3645  /// Is this tag type named, either directly or via being defined in
3646  /// a typedef of this type?
3647  ///
3648  /// C++11 [basic.link]p8:
3649  /// A type is said to have linkage if and only if:
3650  /// - it is a class or enumeration type that is named (or has a
3651  /// name for linkage purposes) and the name has linkage; ...
3652  /// C++11 [dcl.typedef]p9:
3653  /// If the typedef declaration defines an unnamed class (or enum),
3654  /// the first typedef-name declared by the declaration to be that
3655  /// class type (or enum type) is used to denote the class type (or
3656  /// enum type) for linkage purposes only.
3657  ///
3658  /// C does not have an analogous rule, but the same concept is
3659  /// nonetheless useful in some places.
3660  bool hasNameForLinkage() const {
3661  return (getDeclName() || getTypedefNameForAnonDecl());
3662  }
3663 
3665  return hasExtInfo() ? nullptr
3666  : TypedefNameDeclOrQualifier.get<TypedefNameDecl *>();
3667  }
3668 
3670 
3671  /// Retrieve the nested-name-specifier that qualifies the name of this
3672  /// declaration, if it was present in the source.
3674  return hasExtInfo() ? getExtInfo()->QualifierLoc.getNestedNameSpecifier()
3675  : nullptr;
3676  }
3677 
3678  /// Retrieve the nested-name-specifier (with source-location
3679  /// information) that qualifies the name of this declaration, if it was
3680  /// present in the source.
3682  return hasExtInfo() ? getExtInfo()->QualifierLoc
3684  }
3685 
3686  void setQualifierInfo(NestedNameSpecifierLoc QualifierLoc);
3687 
3688  unsigned getNumTemplateParameterLists() const {
3689  return hasExtInfo() ? getExtInfo()->NumTemplParamLists : 0;
3690  }
3691 
3693  assert(i < getNumTemplateParameterLists());
3694  return getExtInfo()->TemplParamLists[i];
3695  }
3696 
3697  void printName(raw_ostream &OS, const PrintingPolicy &Policy) const override;
3698 
3701 
3702  // Implement isa/cast/dyncast/etc.
3703  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3704  static bool classofKind(Kind K) { return K >= firstTag && K <= lastTag; }
3705 
3707  return static_cast<DeclContext *>(const_cast<TagDecl*>(D));
3708  }
3709 
3711  return static_cast<TagDecl *>(const_cast<DeclContext*>(DC));
3712  }
3713 };
3714 
3715 /// Represents an enum. In C++11, enums can be forward-declared
3716 /// with a fixed underlying type, and in C we allow them to be forward-declared
3717 /// with no underlying type as an extension.
3718 class EnumDecl : public TagDecl {
3719  // This class stores some data in DeclContext::EnumDeclBits
3720  // to save some space. Use the provided accessors to access it.
3721 
3722  /// This represent the integer type that the enum corresponds
3723  /// to for code generation purposes. Note that the enumerator constants may
3724  /// have a different type than this does.
3725  ///
3726  /// If the underlying integer type was explicitly stated in the source
3727  /// code, this is a TypeSourceInfo* for that type. Otherwise this type
3728  /// was automatically deduced somehow, and this is a Type*.
3729  ///
3730  /// Normally if IsFixed(), this would contain a TypeSourceInfo*, but in
3731  /// some cases it won't.
3732  ///
3733  /// The underlying type of an enumeration never has any qualifiers, so
3734  /// we can get away with just storing a raw Type*, and thus save an
3735  /// extra pointer when TypeSourceInfo is needed.
3736  llvm::PointerUnion<const Type *, TypeSourceInfo *> IntegerType;
3737 
3738  /// The integer type that values of this type should
3739  /// promote to. In C, enumerators are generally of an integer type
3740  /// directly, but gcc-style large enumerators (and all enumerators
3741  /// in C++) are of the enum type instead.
3742  QualType PromotionType;
3743 
3744  /// If this enumeration is an instantiation of a member enumeration
3745  /// of a class template specialization, this is the member specialization
3746  /// information.
3747  MemberSpecializationInfo *SpecializationInfo = nullptr;
3748 
3749  /// Store the ODRHash after first calculation.
3750  /// The corresponding flag HasODRHash is in EnumDeclBits
3751  /// and can be accessed with the provided accessors.
3752  unsigned ODRHash;
3753 
3754  EnumDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
3755  SourceLocation IdLoc, IdentifierInfo *Id, EnumDecl *PrevDecl,
3756  bool Scoped, bool ScopedUsingClassTag, bool Fixed);
3757 
3758  void anchor() override;
3759 
3760  void setInstantiationOfMemberEnum(ASTContext &C, EnumDecl *ED,
3762 
3763  /// Sets the width in bits required to store all the
3764  /// non-negative enumerators of this enum.
3765  void setNumPositiveBits(unsigned Num) {
3766  EnumDeclBits.NumPositiveBits = Num;
3767  assert(EnumDeclBits.NumPositiveBits == Num && "can't store this bitcount");
3768  }
3769 
3770  /// Returns the width in bits required to store all the
3771  /// negative enumerators of this enum. (see getNumNegativeBits)
3772  void setNumNegativeBits(unsigned Num) { EnumDeclBits.NumNegativeBits = Num; }
3773 
3774 public:
3775  /// True if this tag declaration is a scoped enumeration. Only
3776  /// possible in C++11 mode.
3777  void setScoped(bool Scoped = true) { EnumDeclBits.IsScoped = Scoped; }
3778 
3779  /// If this tag declaration is a scoped enum,
3780  /// then this is true if the scoped enum was declared using the class
3781  /// tag, false if it was declared with the struct tag. No meaning is
3782  /// associated if this tag declaration is not a scoped enum.
3783  void setScopedUsingClassTag(bool ScopedUCT = true) {
3784  EnumDeclBits.IsScopedUsingClassTag = ScopedUCT;
3785  }
3786 
3787  /// True if this is an Objective-C, C++11, or
3788  /// Microsoft-style enumeration with a fixed underlying type.
3789  void setFixed(bool Fixed = true) { EnumDeclBits.IsFixed = Fixed; }
3790 
3791 private:
3792  /// True if a valid hash is stored in ODRHash.
3793  bool hasODRHash() const { return EnumDeclBits.HasODRHash; }
3794  void setHasODRHash(bool Hash = true) { EnumDeclBits.HasODRHash = Hash; }
3795 
3796 public:
3797  friend class ASTDeclReader;
3798 
3800  return cast<EnumDecl>(TagDecl::getCanonicalDecl());
3801  }
3802  const EnumDecl *getCanonicalDecl() const {
3803  return const_cast<EnumDecl*>(this)->getCanonicalDecl();
3804  }
3805 
3807  return cast_or_null<EnumDecl>(
3808  static_cast<TagDecl *>(this)->getPreviousDecl());
3809  }
3810  const EnumDecl *getPreviousDecl() const {
3811  return const_cast<EnumDecl*>(this)->getPreviousDecl();
3812  }
3813 
3815  return cast<EnumDecl>(static_cast<TagDecl *>(this)->getMostRecentDecl());
3816  }
3817  const EnumDecl *getMostRecentDecl() const {
3818  return const_cast<EnumDecl*>(this)->getMostRecentDecl();
3819  }
3820 
3822  return cast_or_null<EnumDecl>(TagDecl::getDefinition());
3823  }
3824 
3825  static EnumDecl *Create(ASTContext &C, DeclContext *DC,
3826  SourceLocation StartLoc, SourceLocation IdLoc,
3827  IdentifierInfo *Id, EnumDecl *PrevDecl,
3828  bool IsScoped, bool IsScopedUsingClassTag,
3829  bool IsFixed);
3830  static EnumDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3831 
3832  /// Overrides to provide correct range when there's an enum-base specifier
3833  /// with forward declarations.
3834  SourceRange getSourceRange() const override LLVM_READONLY;
3835 
3836  /// When created, the EnumDecl corresponds to a
3837  /// forward-declared enum. This method is used to mark the
3838  /// declaration as being defined; its enumerators have already been
3839  /// added (via DeclContext::addDecl). NewType is the new underlying
3840  /// type of the enumeration type.
3841  void completeDefinition(QualType NewType,
3842  QualType PromotionType,
3843  unsigned NumPositiveBits,
3844  unsigned NumNegativeBits);
3845 
3846  // Iterates through the enumerators of this enumeration.
3848  using enumerator_range =
3850 
3853  }
3854 
3856  const EnumDecl *E = getDefinition();
3857  if (!E)
3858  E = this;
3859  return enumerator_iterator(E->decls_begin());
3860  }
3861 
3863  const EnumDecl *E = getDefinition();
3864  if (!E)
3865  E = this;
3866  return enumerator_iterator(E->decls_end());
3867  }
3868 
3869  /// Return the integer type that enumerators should promote to.
3870  QualType getPromotionType() const { return PromotionType; }
3871 
3872  /// Set the promotion type.
3873  void setPromotionType(QualType T) { PromotionType = T; }
3874 
3875  /// Return the integer type this enum decl corresponds to.
3876  /// This returns a null QualType for an enum forward definition with no fixed
3877  /// underlying type.
3879  if (!IntegerType)
3880  return QualType();
3881  if (const Type *T = IntegerType.dyn_cast<const Type*>())
3882  return QualType(T, 0);
3883  return IntegerType.get<TypeSourceInfo*>()->getType().getUnqualifiedType();
3884  }
3885 
3886  /// Set the underlying integer type.
3887  void setIntegerType(QualType T) { IntegerType = T.getTypePtrOrNull(); }
3888 
3889  /// Set the underlying integer type source info.
3890  void setIntegerTypeSourceInfo(TypeSourceInfo *TInfo) { IntegerType = TInfo; }
3891 
3892  /// Return the type source info for the underlying integer type,
3893  /// if no type source info exists, return 0.
3895  return IntegerType.dyn_cast<TypeSourceInfo*>();
3896  }
3897 
3898  /// Retrieve the source range that covers the underlying type if
3899  /// specified.
3900  SourceRange getIntegerTypeRange() const LLVM_READONLY;
3901 
3902  /// Returns the width in bits required to store all the
3903  /// non-negative enumerators of this enum.
3904  unsigned getNumPositiveBits() const { return EnumDeclBits.NumPositiveBits; }
3905 
3906  /// Returns the width in bits required to store all the
3907  /// negative enumerators of this enum. These widths include
3908  /// the rightmost leading 1; that is:
3909  ///
3910  /// MOST NEGATIVE ENUMERATOR PATTERN NUM NEGATIVE BITS
3911  /// ------------------------ ------- -----------------
3912  /// -1 1111111 1
3913  /// -10 1110110 5
3914  /// -101 1001011 8
3915  unsigned getNumNegativeBits() const { return EnumDeclBits.NumNegativeBits; }
3916 
3917  /// Calculates the [Min,Max) values the enum can store based on the
3918  /// NumPositiveBits and NumNegativeBits. This matters for enums that do not
3919  /// have a fixed underlying type.
3920  void getValueRange(llvm::APInt &Max, llvm::APInt &Min) const;
3921 
3922  /// Returns true if this is a C++11 scoped enumeration.
3923  bool isScoped() const { return EnumDeclBits.IsScoped; }
3924 
3925  /// Returns true if this is a C++11 scoped enumeration.
3926  bool isScopedUsingClassTag() const {
3927  return EnumDeclBits.IsScopedUsingClassTag;
3928  }
3929 
3930  /// Returns true if this is an Objective-C, C++11, or
3931  /// Microsoft-style enumeration with a fixed underlying type.
3932  bool isFixed() const { return EnumDeclBits.IsFixed; }
3933 
3934  unsigned getODRHash();
3935 
3936  /// Returns true if this can be considered a complete type.
3937  bool isComplete() const {
3938  // IntegerType is set for fixed type enums and non-fixed but implicitly
3939  // int-sized Microsoft enums.
3940  return isCompleteDefinition() || IntegerType;
3941  }
3942 
3943  /// Returns true if this enum is either annotated with
3944  /// enum_extensibility(closed) or isn't annotated with enum_extensibility.
3945  bool isClosed() const;
3946 
3947  /// Returns true if this enum is annotated with flag_enum and isn't annotated
3948  /// with enum_extensibility(open).
3949  bool isClosedFlag() const;
3950 
3951  /// Returns true if this enum is annotated with neither flag_enum nor
3952  /// enum_extensibility(open).
3953  bool isClosedNonFlag() const;
3954 
3955  /// Retrieve the enum definition from which this enumeration could
3956  /// be instantiated, if it is an instantiation (rather than a non-template).
3958 
3959  /// Returns the enumeration (declared within the template)
3960  /// from which this enumeration type was instantiated, or NULL if
3961  /// this enumeration was not instantiated from any template.
3963 
3964  /// If this enumeration is a member of a specialization of a
3965  /// templated class, determine what kind of template specialization
3966  /// or instantiation this is.
3968 
3969  /// For an enumeration member that was instantiated from a member
3970  /// enumeration of a templated class, set the template specialiation kind.
3972  SourceLocation PointOfInstantiation = SourceLocation());
3973 
3974  /// If this enumeration is an instantiation of a member enumeration of
3975  /// a class template specialization, retrieves the member specialization
3976  /// information.
3978  return SpecializationInfo;
3979  }
3980 
3981  /// Specify that this enumeration is an instantiation of the
3982  /// member enumeration ED.
3985  setInstantiationOfMemberEnum(getASTContext(), ED, TSK);
3986  }
3987 
3988  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3989  static bool classofKind(Kind K) { return K == Enum; }
3990 };
3991 
3992 /// Represents a struct/union/class. For example:
3993 /// struct X; // Forward declaration, no "body".
3994 /// union Y { int A, B; }; // Has body with members A and B (FieldDecls).
3995 /// This decl will be marked invalid if *any* members are invalid.
3996 class RecordDecl : public TagDecl {
3997  // This class stores some data in DeclContext::RecordDeclBits
3998  // to save some space. Use the provided accessors to access it.
3999 public:
4000  friend class DeclContext;
4001  friend class ASTDeclReader;
4002  /// Enum that represents the different ways arguments are passed to and
4003  /// returned from function calls. This takes into account the target-specific
4004  /// and version-specific rules along with the rules determined by the
4005  /// language.
4006  enum ArgPassingKind : unsigned {
4007  /// The argument of this type can be passed directly in registers.
4009 
4010  /// The argument of this type cannot be passed directly in registers.
4011  /// Records containing this type as a subobject are not forced to be passed
4012  /// indirectly. This value is used only in C++. This value is required by
4013  /// C++ because, in uncommon situations, it is possible for a class to have
4014  /// only trivial copy/move constructors even when one of its subobjects has
4015  /// a non-trivial copy/move constructor (if e.g. the corresponding copy/move
4016  /// constructor in the derived class is deleted).
4018 
4019  /// The argument of this type cannot be passed directly in registers.
4020  /// Records containing this type as a subobject are forced to be passed
4021  /// indirectly.
4023  };
4024 
4025 protected:
4026  RecordDecl(Kind DK, TagKind TK, const ASTContext &C, DeclContext *DC,
4027  SourceLocation StartLoc, SourceLocation IdLoc,
4028  IdentifierInfo *Id, RecordDecl *PrevDecl);
4029 
4030 public:
4031  static RecordDecl *Create(const ASTContext &C, TagKind TK, DeclContext *DC,
4032  SourceLocation StartLoc, SourceLocation IdLoc,
4033  IdentifierInfo *Id, RecordDecl* PrevDecl = nullptr);
4034  static RecordDecl *CreateDeserialized(const ASTContext &C, unsigned ID);
4035 
4037  return cast_or_null<RecordDecl>(
4038  static_cast<TagDecl *>(this)->getPreviousDecl());
4039  }
4040  const RecordDecl *getPreviousDecl() const {
4041  return const_cast<RecordDecl*>(this)->getPreviousDecl();
4042  }
4043 
4045  return cast<RecordDecl>(static_cast<TagDecl *>(this)->getMostRecentDecl());
4046  }
4048  return const_cast<RecordDecl*>(this)->getMostRecentDecl();
4049  }
4050 
4051  bool hasFlexibleArrayMember() const {
4052  return RecordDeclBits.HasFlexibleArrayMember;
4053  }
4054 
4056  RecordDeclBits.HasFlexibleArrayMember = V;
4057  }
4058 
4059  /// Whether this is an anonymous struct or union. To be an anonymous
4060  /// struct or union, it must have been declared without a name and
4061  /// there must be no objects of this type declared, e.g.,
4062  /// @code
4063  /// union { int i; float f; };
4064  /// @endcode
4065  /// is an anonymous union but neither of the following are:
4066  /// @code
4067  /// union X { int i; float f; };
4068  /// union { int i; float f; } obj;
4069  /// @endcode
4071  return RecordDeclBits.AnonymousStructOrUnion;
4072  }
4073 
4074  void setAnonymousStructOrUnion(bool Anon) {
4075  RecordDeclBits.AnonymousStructOrUnion = Anon;
4076  }
4077 
4078  bool hasObjectMember() const { return RecordDeclBits.HasObjectMember; }
4079  void setHasObjectMember(bool val) { RecordDeclBits.HasObjectMember = val; }
4080 
4081  bool hasVolatileMember() const { return RecordDeclBits.HasVolatileMember; }
4082 
4083  void setHasVolatileMember(bool val) {
4084  RecordDeclBits.HasVolatileMember = val;
4085  }
4086 
4088  return RecordDeclBits.LoadedFieldsFromExternalStorage;
4089  }
4090 
4092  RecordDeclBits.LoadedFieldsFromExternalStorage = val;
4093  }
4094 
4095  /// Functions to query basic properties of non-trivial C structs.
4097  return RecordDeclBits.NonTrivialToPrimitiveDefaultInitialize;
4098  }
4099 
4101  RecordDeclBits.NonTrivialToPrimitiveDefaultInitialize = V;
4102  }
4103 
4105  return RecordDeclBits.NonTrivialToPrimitiveCopy;
4106  }
4107 
4109  RecordDeclBits.NonTrivialToPrimitiveCopy = V;
4110  }
4111 
4113  return RecordDeclBits.NonTrivialToPrimitiveDestroy;
4114  }
4115 
4117  RecordDeclBits.NonTrivialToPrimitiveDestroy = V;
4118  }
4119 
4121  return RecordDeclBits.HasNonTrivialToPrimitiveDefaultInitializeCUnion;
4122  }
4123 
4125  RecordDeclBits.HasNonTrivialToPrimitiveDefaultInitializeCUnion = V;
4126  }
4127 
4129  return RecordDeclBits.HasNonTrivialToPrimitiveDestructCUnion;
4130  }
4131 
4133  RecordDeclBits.HasNonTrivialToPrimitiveDestructCUnion = V;
4134  }
4135 
4137  return RecordDeclBits.HasNonTrivialToPrimitiveCopyCUnion;
4138  }
4139 
4141  RecordDeclBits.HasNonTrivialToPrimitiveCopyCUnion = V;
4142  }
4143 
4144  /// Determine whether this class can be passed in registers. In C++ mode,
4145  /// it must have at least one trivial, non-deleted copy or move constructor.
4146  /// FIXME: This should be set as part of completeDefinition.
4147  bool canPassInRegisters() const {
4149  }
4150 
4152  return static_cast<ArgPassingKind>(RecordDeclBits.ArgPassingRestrictions);
4153  }
4154 
4156  RecordDeclBits.ArgPassingRestrictions = Kind;
4157  }
4158 
4160  return RecordDeclBits.ParamDestroyedInCallee;
4161  }
4162 
4164  RecordDeclBits.ParamDestroyedInCallee = V;
4165  }
4166 
4167  bool isRandomized() const { return RecordDeclBits.IsRandomized; }
4168 
4169  void setIsRandomized(bool V) { RecordDeclBits.IsRandomized = V; }
4170 
4171  void reorderDecls(const SmallVectorImpl<Decl *> &Decls);
4172 
4173  /// Determines whether this declaration represents the
4174  /// injected class name.
4175  ///
4176  /// The injected class name in C++ is the name of the class that
4177  /// appears inside the class itself. For example:
4178  ///
4179  /// \code
4180  /// struct C {
4181  /// // C is implicitly declared here as a synonym for the class name.
4182  /// };
4183  ///
4184  /// C::C c; // same as "C c;"
4185  /// \endcode
4186  bool isInjectedClassName() const;
4187 
4188  /// Determine whether this record is a class describing a lambda
4189  /// function object.
4190  bool isLambda() const;
4191 
4192  /// Determine whether this record is a record for captured variables in
4193  /// CapturedStmt construct.
4194  bool isCapturedRecord() const;
4195 
4196  /// Mark the record as a record for captured variables in CapturedStmt
4197  /// construct.
4198  void setCapturedRecord();
4199 
4200  /// Returns the RecordDecl that actually defines
4201  /// this struct/union/class. When determining whether or not a
4202  /// struct/union/class is completely defined, one should use this
4203  /// method as opposed to 'isCompleteDefinition'.
4204  /// 'isCompleteDefinition' indicates whether or not a specific
4205  /// RecordDecl is a completed definition, not whether or not the
4206  /// record type is defined. This method returns NULL if there is
4207  /// no RecordDecl that defines the struct/union/tag.
4209  return cast_or_null<RecordDecl>(TagDecl::getDefinition());
4210  }
4211 
4212  /// Returns whether this record is a union, or contains (at any nesting level)
4213  /// a union member. This is used by CMSE to warn about possible information
4214  /// leaks.
4215  bool isOrContainsUnion() const;
4216 
4217  // Iterator access to field members. The field iterator only visits
4218  // the non-static data members of this class, ignoring any static
4219  // data members, functions, constructors, destructors, etc.
4221  using field_range = llvm::iterator_range<specific_decl_iterator<FieldDecl>>;
4222 
4224  field_iterator field_begin() const;
4225 
4227  return field_iterator(decl_iterator());
4228  }
4229 
4230  // Whether there are any fields (non-static data members) in this record.
4231  bool field_empty() const {
4232  return field_begin() == field_end();
4233  }
4234 
4235  /// Note that the definition of this type is now complete.
4236  virtual void completeDefinition();
4237 
4238  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
4239  static bool classofKind(Kind K) {
4240  return K >= firstRecord && K <= lastRecord;
4241  }
4242 
4243  /// Get whether or not this is an ms_struct which can
4244  /// be turned on with an attribute, pragma, or -mms-bitfields
4245  /// commandline option.
4246  bool isMsStruct(const ASTContext &C) const;
4247 
4248  /// Whether we are allowed to insert extra padding between fields.
4249  /// These padding are added to help AddressSanitizer detect
4250  /// intra-object-overflow bugs.
4251  bool mayInsertExtraPadding(bool EmitRemark = false) const;
4252 
4253  /// Finds the first data member which has a name.
4254  /// nullptr is returned if no named data member exists.
4255  const FieldDecl *findFirstNamedDataMember() const;
4256 
4257  /// Get precomputed ODRHash or add a new one.
4258  unsigned getODRHash();
4259 
4260 private:
4261  /// Deserialize just the fields.
4262  void LoadFieldsFromExternalStorage() const;
4263 
4264  /// True if a valid hash is stored in ODRHash.
4265  bool hasODRHash() const { return RecordDeclBits.ODRHash; }
4266  void setODRHash(unsigned Hash) { RecordDeclBits.ODRHash = Hash; }
4267 };
4268 
4269 class FileScopeAsmDecl : public Decl {
4270  StringLiteral *AsmString;
4271  SourceLocation RParenLoc;
4272 
4273  FileScopeAsmDecl(DeclContext *DC, StringLiteral *asmstring,
4274  SourceLocation StartL, SourceLocation EndL)
4275  : Decl(FileScopeAsm, DC, StartL), AsmString(asmstring), RParenLoc(EndL) {}
4276 
4277  virtual void anchor();
4278 
4279 public:
4281  StringLiteral *Str, SourceLocation AsmLoc,
4282  SourceLocation RParenLoc);
4283 
4284  static FileScopeAsmDecl *CreateDeserialized(ASTContext &C, unsigned ID);
4285 
4286  SourceLocation getAsmLoc() const { return getLocation(); }
4287  SourceLocation getRParenLoc() const { return RParenLoc; }
4288  void setRParenLoc(SourceLocation L) { RParenLoc = L; }
4289  SourceRange getSourceRange() const override LLVM_READONLY {
4290  return SourceRange(getAsmLoc(), getRParenLoc());
4291  }
4292 
4293  const StringLiteral *getAsmString() const { return AsmString; }
4294  StringLiteral *getAsmString() { return AsmString; }
4295  void setAsmString(StringLiteral *Asm) { AsmString = Asm; }
4296 
4297  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
4298  static bool classofKind(Kind K) { return K == FileScopeAsm; }
4299 };
4300 
4301 /// A declaration that models statements at global scope. This declaration
4302 /// supports incremental and interactive C/C++.
4303 ///
4304 /// \note This is used in libInterpreter, clang -cc1 -fincremental-extensions
4305 /// and in tools such as clang-repl.
4306 class TopLevelStmtDecl : public Decl {
4307  friend class ASTDeclReader;
4308  friend class ASTDeclWriter;
4309 
4310  Stmt *Statement = nullptr;
4311 
4313  : Decl(TopLevelStmt, DC, L), Statement(S) {}
4314 
4315  virtual void anchor();
4316 
4317 public:
4318  static TopLevelStmtDecl *Create(ASTContext &C, Stmt *Statement);
4319  static TopLevelStmtDecl *CreateDeserialized(ASTContext &C, unsigned ID);
4320 
4321  SourceRange getSourceRange() const override LLVM_READONLY;
4322  Stmt *getStmt() { return Statement; }
4323  const Stmt *getStmt() const { return Statement; }
4324 
4325  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
4326  static bool classofKind(Kind K) { return K == TopLevelStmt; }
4327 };
4328 
4329 /// Represents a block literal declaration, which is like an
4330 /// unnamed FunctionDecl. For example:
4331 /// ^{ statement-body } or ^(int arg1, float arg2){ statement-body }
4332 class BlockDecl : public Decl, public DeclContext {
4333  // This class stores some data in DeclContext::BlockDeclBits
4334  // to save some space. Use the provided accessors to access it.
4335 public:
4336  /// A class which contains all the information about a particular
4337  /// captured value.
4338  class Capture {
4339  enum {
4340  flag_isByRef = 0x1,
4341  flag_isNested = 0x2
4342  };
4343 
4344  /// The variable being captured.
4345  llvm::PointerIntPair<VarDecl*, 2> VariableAndFlags;
4346 
4347  /// The copy expression, expressed in terms of a DeclRef (or
4348  /// BlockDeclRef) to the captured variable. Only required if the
4349  /// variable has a C++ class type.
4350  Expr *CopyExpr;
4351 
4352  public:
4353  Capture(VarDecl *variable, bool byRef, bool nested, Expr *copy)
4354  : VariableAndFlags(variable,
4355  (byRef ? flag_isByRef : 0) | (nested ? flag_isNested : 0)),
4356  CopyExpr(copy) {}
4357 
4358  /// The variable being captured.
4359  VarDecl *getVariable() const { return VariableAndFlags.getPointer(); }
4360 
4361  /// Whether this is a "by ref" capture, i.e. a capture of a __block
4362  /// variable.
4363  bool isByRef() const { return VariableAndFlags.getInt() & flag_isByRef; }
4364 
4365  bool isEscapingByref() const {
4366  return getVariable()->isEscapingByref();
4367  }
4368 
4369  bool isNonEscapingByref() const {
4370  return getVariable()->isNonEscapingByref();
4371  }
4372 
4373  /// Whether this is a nested capture, i.e. the variable captured
4374  /// is not from outside the immediately enclosing function/block.
4375  bool isNested() const { return VariableAndFlags.getInt() & flag_isNested; }
4376 
4377  bool hasCopyExpr() const { return CopyExpr != nullptr; }
4378  Expr *getCopyExpr() const { return CopyExpr; }
4379  void setCopyExpr(Expr *e) { CopyExpr = e; }
4380  };
4381 
4382 private:
4383  /// A new[]'d array of pointers to ParmVarDecls for the formal
4384  /// parameters of this function. This is null if a prototype or if there are
4385  /// no formals.
4386  ParmVarDecl **ParamInfo = nullptr;
4387  unsigned NumParams = 0;
4388 
4389  Stmt *Body = nullptr;
4390  TypeSourceInfo *SignatureAsWritten = nullptr;
4391 
4392  const Capture *Captures = nullptr;
4393  unsigned NumCaptures = 0;
4394 
4395  unsigned ManglingNumber = 0;
4396  Decl *ManglingContextDecl = nullptr;
4397 
4398 protected:
4399  BlockDecl(DeclContext *DC, SourceLocation CaretLoc);
4400 
4401 public:
4403  static BlockDecl *CreateDeserialized(ASTContext &C, unsigned ID);
4404 
4406 
4407  bool isVariadic() const { return BlockDeclBits.IsVariadic; }
4408  void setIsVariadic(bool value) { BlockDeclBits.IsVariadic = value; }
4409 
4410  CompoundStmt *getCompoundBody() const { return (CompoundStmt*) Body; }
4411  Stmt *getBody() const override { return (Stmt*) Body; }
4412  void setBody(CompoundStmt *B) { Body = (Stmt*) B; }
4413 
4414  void setSignatureAsWritten(TypeSourceInfo *Sig) { SignatureAsWritten = Sig; }
4415  TypeSourceInfo *getSignatureAsWritten() const { return SignatureAsWritten; }
4416 
4417  // ArrayRef access to formal parameters.
4419  return {ParamInfo, getNumParams()};
4420  }
4422  return {ParamInfo, getNumParams()};
4423  }
4424 
4425  // Iterator access to formal parameters.
4428 
4429  bool param_empty() const { return parameters().empty(); }
4430  param_iterator param_begin() { return parameters().begin(); }
4431  param_iterator param_end() { return parameters().end(); }
4432  param_const_iterator param_begin() const { return parameters().begin(); }
4433  param_const_iterator param_end() const { return parameters().end(); }
4434  size_t param_size() const { return parameters().size(); }
4435 
4436  unsigned getNumParams() const { return NumParams; }
4437 
4438  const ParmVarDecl *getParamDecl(unsigned i) const {
4439  assert(i < getNumParams() && "Illegal param #");
4440  return ParamInfo[i];
4441  }
4442  ParmVarDecl *getParamDecl(unsigned i) {
4443  assert(i < getNumParams() && "Illegal param #");
4444  return ParamInfo[i];
4445  }
4446 
4447  void setParams(ArrayRef<ParmVarDecl *> NewParamInfo);
4448 
4449  /// True if this block (or its nested blocks) captures
4450  /// anything of local storage from its enclosing scopes.
4451  bool hasCaptures() const { return NumCaptures || capturesCXXThis(); }
4452 
4453  /// Returns the number of captured variables.
4454  /// Does not include an entry for 'this'.
4455  unsigned getNumCaptures() const { return NumCaptures; }
4456 
4458 
4459  ArrayRef<Capture> captures() const { return {Captures, NumCaptures}; }
4460 
4461  capture_const_iterator capture_begin() const { return captures().begin(); }
4462  capture_const_iterator capture_end() const { return captures().end(); }
4463 
4464  bool capturesCXXThis() const { return BlockDeclBits.CapturesCXXThis; }
4465  void setCapturesCXXThis(bool B = true) { BlockDeclBits.CapturesCXXThis = B; }
4466 
4467  bool blockMissingReturnType() const {
4468  return BlockDeclBits.BlockMissingReturnType;
4469  }
4470 
4471  void setBlockMissingReturnType(bool val = true) {
4472  BlockDeclBits.BlockMissingReturnType = val;
4473  }
4474 
4475  bool isConversionFromLambda() const {
4476  return BlockDeclBits.IsConversionFromLambda;
4477  }
4478 
4479  void setIsConversionFromLambda(bool val = true) {
4480  BlockDeclBits.IsConversionFromLambda = val;
4481  }
4482 
4483  bool doesNotEscape() const { return BlockDeclBits.DoesNotEscape; }
4484  void setDoesNotEscape(bool B = true) { BlockDeclBits.DoesNotEscape = B; }
4485 
4486  bool canAvoidCopyToHeap() const {
4487  return BlockDeclBits.CanAvoidCopyToHeap;
4488  }
4489  void setCanAvoidCopyToHeap(bool B = true) {
4490  BlockDeclBits.CanAvoidCopyToHeap = B;
4491  }
4492 
4493  bool capturesVariable(const VarDecl *var) const;
4494 
4495  void setCaptures(ASTContext &Context, ArrayRef<Capture> Captures,
4496  bool CapturesCXXThis);
4497 
4498  unsigned getBlockManglingNumber() const { return ManglingNumber; }
4499 
4500  Decl *getBlockManglingContextDecl() const { return ManglingContextDecl; }
4501 
4502  void setBlockMangling(unsigned Number, Decl *Ctx) {
4503  ManglingNumber = Number;
4504  ManglingContextDecl = Ctx;
4505  }
4506 
4507  SourceRange getSourceRange() const override LLVM_READONLY;
4508 
4509  // Implement isa/cast/dyncast/etc.
4510  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
4511  static bool classofKind(Kind K) { return K == Block; }
4513  return static_cast<DeclContext *>(const_cast<BlockDecl*>(D));
4514  }
4516  return static_cast<BlockDecl *>(const_cast<DeclContext*>(DC));
4517  }
4518 };
4519 
4520 /// Represents the body of a CapturedStmt, and serves as its DeclContext.
4521 class CapturedDecl final
4522  : public Decl,
4523  public DeclContext,
4524  private llvm::TrailingObjects<CapturedDecl, ImplicitParamDecl *> {
4525 protected:
4526  size_t numTrailingObjects(OverloadToken<ImplicitParamDecl>) {
4527  return NumParams;
4528  }
4529 
4530 private:
4531  /// The number of parameters to the outlined function.
4532  unsigned NumParams;
4533 
4534  /// The position of context parameter in list of parameters.
4535  unsigned ContextParam;
4536 
4537  /// The body of the outlined function.
4538  llvm::PointerIntPair<Stmt *, 1, bool> BodyAndNothrow;
4539 
4540  explicit CapturedDecl(DeclContext *DC, unsigned NumParams);
4541 
4542  ImplicitParamDecl *const *getParams() const {
4543  return getTrailingObjects<ImplicitParamDecl *>();
4544  }
4545 
4546  ImplicitParamDecl **getParams() {
4547  return getTrailingObjects<ImplicitParamDecl *>();
4548  }
4549 
4550 public:
4551  friend class ASTDeclReader;
4552  friend class ASTDeclWriter;
4554 
4555  static CapturedDecl *Create(ASTContext &C, DeclContext *DC,
4556  unsigned NumParams);
4557  static CapturedDecl *CreateDeserialized(ASTContext &C, unsigned ID,
4558  unsigned NumParams);
4559 
4560  Stmt *getBody() const override;
4561  void setBody(Stmt *B);
4562 
4563  bool isNothrow() const;
4564  void setNothrow(bool Nothrow = true);
4565 
4566  unsigned getNumParams() const { return NumParams; }
4567 
4568  ImplicitParamDecl *getParam(unsigned i) const {
4569  assert(i < NumParams);
4570  return getParams()[i];
4571  }
4572  void setParam(unsigned i, ImplicitParamDecl *P) {
4573  assert(i < NumParams);
4574  getParams()[i] = P;
4575  }
4576 
4577  // ArrayRef interface to parameters.
4579  return {getParams(), getNumParams()};
4580  }
4582  return {getParams(), getNumParams()};
4583  }
4584 
4585  /// Retrieve the parameter containing captured variables.
4587  assert(ContextParam < NumParams);
4588  return getParam(ContextParam);
4589  }
4590  void setContextParam(unsigned i, ImplicitParamDecl *P) {
4591  assert(i < NumParams);
4592  ContextParam = i;
4593  setParam(i, P);
4594  }
4595  unsigned getContextParamPosition() const { return ContextParam; }
4596 
4598  using param_range = llvm::iterator_range<param_iterator>;
4599 
4600  /// Retrieve an iterator pointing to the first parameter decl.
4601  param_iterator param_begin() const { return getParams(); }
4602  /// Retrieve an iterator one past the last parameter decl.
4603  param_iterator param_end() const { return getParams() + NumParams; }
4604 
4605  // Implement isa/cast/dyncast/etc.
4606  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
4607  static bool classofKind(Kind K) { return K == Captured; }
4609  return static_cast<DeclContext *>(const_cast<CapturedDecl *>(D));
4610  }
4612  return static_cast<CapturedDecl *>(const_cast<DeclContext *>(DC));
4613  }
4614 };
4615 
4616 /// Describes a module import declaration, which makes the contents
4617 /// of the named module visible in the current translation unit.
4618 ///
4619 /// An import declaration imports the named module (or submodule). For example:
4620 /// \code
4621 /// @import std.vector;
4622 /// \endcode
4623 ///
4624 /// A C++20 module import declaration imports the named module or partition.
4625 /// Periods are permitted in C++20 module names, but have no semantic meaning.
4626 /// For example:
4627 /// \code
4628 /// import NamedModule;
4629 /// import :SomePartition; // Must be a partition of the current module.
4630 /// import Names.Like.this; // Allowed.
4631 /// import :and.Also.Partition.names;
4632 /// \endcode
4633 ///
4634 /// Import declarations can also be implicitly generated from
4635 /// \#include/\#import directives.
4636 class ImportDecl final : public Decl,
4637  llvm::TrailingObjects<ImportDecl, SourceLocation> {
4638  friend class ASTContext;
4639  friend class ASTDeclReader;
4640  friend class ASTReader;
4641  friend TrailingObjects;
4642 
4643  /// The imported module.
4644  Module *ImportedModule = nullptr;
4645 
4646  /// The next import in the list of imports local to the translation
4647  /// unit being parsed (not loaded from an AST file).
4648  ///
4649  /// Includes a bit that indicates whether we have source-location information
4650  /// for each identifier in the module name.
4651  ///
4652  /// When the bit is false, we only have a single source location for the
4653  /// end of the import declaration.
4654  llvm::PointerIntPair<ImportDecl *, 1, bool> NextLocalImportAndComplete;
4655 
4656  ImportDecl(DeclContext *DC, SourceLocation StartLoc, Module *Imported,
4657  ArrayRef<SourceLocation> IdentifierLocs);
4658 
4659  ImportDecl(DeclContext *DC, SourceLocation StartLoc, Module *Imported,
4660  SourceLocation EndLoc);
4661 
4662  ImportDecl(EmptyShell Empty) : Decl(Import, Empty) {}
4663 
4664  bool isImportComplete() const { return NextLocalImportAndComplete.getInt(); }
4665 
4666  void setImportComplete(bool C) { NextLocalImportAndComplete.setInt(C); }
4667 
4668  /// The next import in the list of imports local to the translation
4669  /// unit being parsed (not loaded from an AST file).
4670  ImportDecl *getNextLocalImport() const {
4671  return NextLocalImportAndComplete.getPointer();
4672  }
4673 
4674  void setNextLocalImport(ImportDecl *Import) {
4675  NextLocalImportAndComplete.setPointer(Import);
4676  }
4677 
4678 public:
4679  /// Create a new module import declaration.
4680  static ImportDecl *Create(ASTContext &C, DeclContext *DC,
4681  SourceLocation StartLoc, Module *Imported,
4682  ArrayRef<SourceLocation> IdentifierLocs);
4683 
4684  /// Create a new module import declaration for an implicitly-generated
4685  /// import.
4686  static ImportDecl *CreateImplicit(ASTContext &C, DeclContext *DC,
4687  SourceLocation StartLoc, Module *Imported,
4688  SourceLocation EndLoc);
4689 
4690  /// Create a new, deserialized module import declaration.
4691  static ImportDecl *CreateDeserialized(ASTContext &C, unsigned ID,
4692  unsigned NumLocations);
4693 
4694  /// Retrieve the module that was imported by the import declaration.
4695  Module *getImportedModule() const { return ImportedModule; }
4696 
4697  /// Retrieves the locations of each of the identifiers that make up
4698  /// the complete module name in the import declaration.
4699  ///
4700  /// This will return an empty array if the locations of the individual
4701  /// identifiers aren't available.
4703 
4704  SourceRange getSourceRange() const override LLVM_READONLY;
4705 
4706  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
4707  static bool classofKind(Kind K) { return K == Import; }
4708 };
4709 
4710 /// Represents a C++ Modules TS module export declaration.
4711 ///
4712 /// For example:
4713 /// \code
4714 /// export void foo();
4715 /// \endcode
4716 class ExportDecl final : public Decl, public DeclContext {
4717  virtual void anchor();
4718 
4719 private:
4720  friend class ASTDeclReader;
4721 
4722  /// The source location for the right brace (if valid).
4723  SourceLocation RBraceLoc;
4724 
4725  ExportDecl(DeclContext *DC, SourceLocation ExportLoc)
4726  : Decl(Export, DC, ExportLoc), DeclContext(Export),
4727  RBraceLoc(SourceLocation()) {}
4728 
4729 public:
4730  static ExportDecl *Create(ASTContext &C, DeclContext *DC,
4731  SourceLocation ExportLoc);
4732  static ExportDecl *CreateDeserialized(ASTContext &C, unsigned ID);
4733 
4735  SourceLocation getRBraceLoc() const { return RBraceLoc; }
4736  void setRBraceLoc(SourceLocation L) { RBraceLoc = L; }
4737 
4738  bool hasBraces() const { return RBraceLoc.isValid(); }
4739 
4740  SourceLocation getEndLoc() const LLVM_READONLY {
4741  if (hasBraces())
4742  return RBraceLoc;
4743  // No braces: get the end location of the (only) declaration in context
4744  // (if present).
4745  return decls_empty() ? getLocation() : decls_begin()->getEndLoc();
4746  }
4747 
4748  SourceRange getSourceRange() const override LLVM_READONLY {
4749  return SourceRange(getLocation(), getEndLoc());
4750  }
4751 
4752  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
4753  static bool classofKind(Kind K) { return K == Export; }
4755  return static_cast<DeclContext *>(const_cast<ExportDecl*>(D));
4756  }
4758  return static_cast<ExportDecl *>(const_cast<DeclContext*>(DC));
4759  }
4760 };
4761 
4762 /// Represents an empty-declaration.
4763 class EmptyDecl : public Decl {
4764  EmptyDecl(DeclContext *DC, SourceLocation L) : Decl(Empty, DC, L) {}
4765 
4766  virtual void anchor();
4767 
4768 public:
4769  static EmptyDecl *Create(ASTContext &C, DeclContext *DC,
4770  SourceLocation L);
4771  static EmptyDecl *CreateDeserialized(ASTContext &C, unsigned ID);
4772 
4773  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
4774  static bool classofKind(Kind K) { return K == Empty; }
4775 };
4776 
4777 /// HLSLBufferDecl - Represent a cbuffer or tbuffer declaration.
4778 class HLSLBufferDecl final : public NamedDecl, public DeclContext {
4779  /// LBraceLoc - The ending location of the source range.
4780  SourceLocation LBraceLoc;
4781  /// RBraceLoc - The ending location of the source range.
4782  SourceLocation RBraceLoc;
4783  /// KwLoc - The location of the cbuffer or tbuffer keyword.
4784  SourceLocation KwLoc;
4785  /// IsCBuffer - Whether the buffer is a cbuffer (and not a tbuffer).
4786  bool IsCBuffer;
4787 
4788  HLSLBufferDecl(DeclContext *DC, bool CBuffer, SourceLocation KwLoc,
4790  SourceLocation LBrace);
4791 
4792 public:
4793  static HLSLBufferDecl *Create(ASTC