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