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