[AST] Remove DeclCXX.h dep on ASTContext.h
[lldb.git] / clang / include / clang / AST / DeclCXX.h
1 //===- DeclCXX.h - Classes for representing C++ 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 /// \file
10 /// Defines the C++ Decl subclasses, other than those for templates
11 /// (found in DeclTemplate.h) and friends (in DeclFriend.h).
12 //
13 //===----------------------------------------------------------------------===//
14
15 #ifndef LLVM_CLANG_AST_DECLCXX_H
16 #define LLVM_CLANG_AST_DECLCXX_H
17
18 #include "clang/AST/ASTUnresolvedSet.h"
19 #include "clang/AST/Decl.h"
20 #include "clang/AST/DeclBase.h"
21 #include "clang/AST/DeclarationName.h"
22 #include "clang/AST/Expr.h"
23 #include "clang/AST/ExternalASTSource.h"
24 #include "clang/AST/LambdaCapture.h"
25 #include "clang/AST/NestedNameSpecifier.h"
26 #include "clang/AST/Redeclarable.h"
27 #include "clang/AST/Stmt.h"
28 #include "clang/AST/Type.h"
29 #include "clang/AST/TypeLoc.h"
30 #include "clang/AST/UnresolvedSet.h"
31 #include "clang/Basic/LLVM.h"
32 #include "clang/Basic/Lambda.h"
33 #include "clang/Basic/LangOptions.h"
34 #include "clang/Basic/OperatorKinds.h"
35 #include "clang/Basic/SourceLocation.h"
36 #include "clang/Basic/Specifiers.h"
37 #include "llvm/ADT/ArrayRef.h"
38 #include "llvm/ADT/DenseMap.h"
39 #include "llvm/ADT/PointerIntPair.h"
40 #include "llvm/ADT/PointerUnion.h"
41 #include "llvm/ADT/STLExtras.h"
42 #include "llvm/ADT/TinyPtrVector.h"
43 #include "llvm/ADT/iterator_range.h"
44 #include "llvm/Support/Casting.h"
45 #include "llvm/Support/Compiler.h"
46 #include "llvm/Support/PointerLikeTypeTraits.h"
47 #include "llvm/Support/TrailingObjects.h"
48 #include <cassert>
49 #include <cstddef>
50 #include <iterator>
51 #include <memory>
52 #include <vector>
53
54 namespace clang {
55
56 class ASTContext;
57 class ClassTemplateDecl;
58 class ConstructorUsingShadowDecl;
59 class CXXBasePath;
60 class CXXBasePaths;
61 class CXXConstructorDecl;
62 class CXXDestructorDecl;
63 class CXXFinalOverriderMap;
64 class CXXIndirectPrimaryBaseSet;
65 class CXXMethodDecl;
66 class DecompositionDecl;
67 class DiagnosticBuilder;
68 class FriendDecl;
69 class FunctionTemplateDecl;
70 class IdentifierInfo;
71 class MemberSpecializationInfo;
72 class TemplateDecl;
73 class TemplateParameterList;
74 class UsingDecl;
75
76 /// Represents an access specifier followed by colon ':'.
77 ///
78 /// An objects of this class represents sugar for the syntactic occurrence
79 /// of an access specifier followed by a colon in the list of member
80 /// specifiers of a C++ class definition.
81 ///
82 /// Note that they do not represent other uses of access specifiers,
83 /// such as those occurring in a list of base specifiers.
84 /// Also note that this class has nothing to do with so-called
85 /// "access declarations" (C++98 11.3 [class.access.dcl]).
86 class AccessSpecDecl : public Decl {
87   /// The location of the ':'.
88   SourceLocation ColonLoc;
89
90   AccessSpecDecl(AccessSpecifier AS, DeclContext *DC,
91                  SourceLocation ASLoc, SourceLocation ColonLoc)
92     : Decl(AccessSpec, DC, ASLoc), ColonLoc(ColonLoc) {
93     setAccess(AS);
94   }
95
96   AccessSpecDecl(EmptyShell Empty) : Decl(AccessSpec, Empty) {}
97
98   virtual void anchor();
99
100 public:
101   /// The location of the access specifier.
102   SourceLocation getAccessSpecifierLoc() const { return getLocation(); }
103
104   /// Sets the location of the access specifier.
105   void setAccessSpecifierLoc(SourceLocation ASLoc) { setLocation(ASLoc); }
106
107   /// The location of the colon following the access specifier.
108   SourceLocation getColonLoc() const { return ColonLoc; }
109
110   /// Sets the location of the colon.
111   void setColonLoc(SourceLocation CLoc) { ColonLoc = CLoc; }
112
113   SourceRange getSourceRange() const override LLVM_READONLY {
114     return SourceRange(getAccessSpecifierLoc(), getColonLoc());
115   }
116
117   static AccessSpecDecl *Create(ASTContext &C, AccessSpecifier AS,
118                                 DeclContext *DC, SourceLocation ASLoc,
119                                 SourceLocation ColonLoc) {
120     return new (C, DC) AccessSpecDecl(AS, DC, ASLoc, ColonLoc);
121   }
122
123   static AccessSpecDecl *CreateDeserialized(ASTContext &C, unsigned ID);
124
125   // Implement isa/cast/dyncast/etc.
126   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
127   static bool classofKind(Kind K) { return K == AccessSpec; }
128 };
129
130 /// Represents a base class of a C++ class.
131 ///
132 /// Each CXXBaseSpecifier represents a single, direct base class (or
133 /// struct) of a C++ class (or struct). It specifies the type of that
134 /// base class, whether it is a virtual or non-virtual base, and what
135 /// level of access (public, protected, private) is used for the
136 /// derivation. For example:
137 ///
138 /// \code
139 ///   class A { };
140 ///   class B { };
141 ///   class C : public virtual A, protected B { };
142 /// \endcode
143 ///
144 /// In this code, C will have two CXXBaseSpecifiers, one for "public
145 /// virtual A" and the other for "protected B".
146 class CXXBaseSpecifier {
147   /// The source code range that covers the full base
148   /// specifier, including the "virtual" (if present) and access
149   /// specifier (if present).
150   SourceRange Range;
151
152   /// The source location of the ellipsis, if this is a pack
153   /// expansion.
154   SourceLocation EllipsisLoc;
155
156   /// Whether this is a virtual base class or not.
157   unsigned Virtual : 1;
158
159   /// Whether this is the base of a class (true) or of a struct (false).
160   ///
161   /// This determines the mapping from the access specifier as written in the
162   /// source code to the access specifier used for semantic analysis.
163   unsigned BaseOfClass : 1;
164
165   /// Access specifier as written in the source code (may be AS_none).
166   ///
167   /// The actual type of data stored here is an AccessSpecifier, but we use
168   /// "unsigned" here to work around a VC++ bug.
169   unsigned Access : 2;
170
171   /// Whether the class contains a using declaration
172   /// to inherit the named class's constructors.
173   unsigned InheritConstructors : 1;
174
175   /// The type of the base class.
176   ///
177   /// This will be a class or struct (or a typedef of such). The source code
178   /// range does not include the \c virtual or the access specifier.
179   TypeSourceInfo *BaseTypeInfo;
180
181 public:
182   CXXBaseSpecifier() = default;
183   CXXBaseSpecifier(SourceRange R, bool V, bool BC, AccessSpecifier A,
184                    TypeSourceInfo *TInfo, SourceLocation EllipsisLoc)
185     : Range(R), EllipsisLoc(EllipsisLoc), Virtual(V), BaseOfClass(BC),
186       Access(A), InheritConstructors(false), BaseTypeInfo(TInfo) {}
187
188   /// Retrieves the source range that contains the entire base specifier.
189   SourceRange getSourceRange() const LLVM_READONLY { return Range; }
190   SourceLocation getBeginLoc() const LLVM_READONLY { return Range.getBegin(); }
191   SourceLocation getEndLoc() const LLVM_READONLY { return Range.getEnd(); }
192
193   /// Get the location at which the base class type was written.
194   SourceLocation getBaseTypeLoc() const LLVM_READONLY {
195     return BaseTypeInfo->getTypeLoc().getBeginLoc();
196   }
197
198   /// Determines whether the base class is a virtual base class (or not).
199   bool isVirtual() const { return Virtual; }
200
201   /// Determine whether this base class is a base of a class declared
202   /// with the 'class' keyword (vs. one declared with the 'struct' keyword).
203   bool isBaseOfClass() const { return BaseOfClass; }
204
205   /// Determine whether this base specifier is a pack expansion.
206   bool isPackExpansion() const { return EllipsisLoc.isValid(); }
207
208   /// Determine whether this base class's constructors get inherited.
209   bool getInheritConstructors() const { return InheritConstructors; }
210
211   /// Set that this base class's constructors should be inherited.
212   void setInheritConstructors(bool Inherit = true) {
213     InheritConstructors = Inherit;
214   }
215
216   /// For a pack expansion, determine the location of the ellipsis.
217   SourceLocation getEllipsisLoc() const {
218     return EllipsisLoc;
219   }
220
221   /// Returns the access specifier for this base specifier.
222   ///
223   /// This is the actual base specifier as used for semantic analysis, so
224   /// the result can never be AS_none. To retrieve the access specifier as
225   /// written in the source code, use getAccessSpecifierAsWritten().
226   AccessSpecifier getAccessSpecifier() const {
227     if ((AccessSpecifier)Access == AS_none)
228       return BaseOfClass? AS_private : AS_public;
229     else
230       return (AccessSpecifier)Access;
231   }
232
233   /// Retrieves the access specifier as written in the source code
234   /// (which may mean that no access specifier was explicitly written).
235   ///
236   /// Use getAccessSpecifier() to retrieve the access specifier for use in
237   /// semantic analysis.
238   AccessSpecifier getAccessSpecifierAsWritten() const {
239     return (AccessSpecifier)Access;
240   }
241
242   /// Retrieves the type of the base class.
243   ///
244   /// This type will always be an unqualified class type.
245   QualType getType() const {
246     return BaseTypeInfo->getType().getUnqualifiedType();
247   }
248
249   /// Retrieves the type and source location of the base class.
250   TypeSourceInfo *getTypeSourceInfo() const { return BaseTypeInfo; }
251 };
252
253 /// Represents a C++ struct/union/class.
254 class CXXRecordDecl : public RecordDecl {
255   friend class ASTDeclReader;
256   friend class ASTDeclWriter;
257   friend class ASTNodeImporter;
258   friend class ASTReader;
259   friend class ASTRecordWriter;
260   friend class ASTWriter;
261   friend class DeclContext;
262   friend class LambdaExpr;
263
264   friend void FunctionDecl::setPure(bool);
265   friend void TagDecl::startDefinition();
266
267   /// Values used in DefinitionData fields to represent special members.
268   enum SpecialMemberFlags {
269     SMF_DefaultConstructor = 0x1,
270     SMF_CopyConstructor = 0x2,
271     SMF_MoveConstructor = 0x4,
272     SMF_CopyAssignment = 0x8,
273     SMF_MoveAssignment = 0x10,
274     SMF_Destructor = 0x20,
275     SMF_All = 0x3f
276   };
277
278   struct DefinitionData {
279     #define FIELD(Name, Width, Merge) \
280     unsigned Name : Width;
281     #include "CXXRecordDeclDefinitionBits.def"
282
283     /// Whether this class describes a C++ lambda.
284     unsigned IsLambda : 1;
285
286     /// Whether we are currently parsing base specifiers.
287     unsigned IsParsingBaseSpecifiers : 1;
288
289     /// True when visible conversion functions are already computed
290     /// and are available.
291     unsigned ComputedVisibleConversions : 1;
292
293     unsigned HasODRHash : 1;
294
295     /// A hash of parts of the class to help in ODR checking.
296     unsigned ODRHash = 0;
297
298     /// The number of base class specifiers in Bases.
299     unsigned NumBases = 0;
300
301     /// The number of virtual base class specifiers in VBases.
302     unsigned NumVBases = 0;
303
304     /// Base classes of this class.
305     ///
306     /// FIXME: This is wasted space for a union.
307     LazyCXXBaseSpecifiersPtr Bases;
308
309     /// direct and indirect virtual base classes of this class.
310     LazyCXXBaseSpecifiersPtr VBases;
311
312     /// The conversion functions of this C++ class (but not its
313     /// inherited conversion functions).
314     ///
315     /// Each of the entries in this overload set is a CXXConversionDecl.
316     LazyASTUnresolvedSet Conversions;
317
318     /// The conversion functions of this C++ class and all those
319     /// inherited conversion functions that are visible in this class.
320     ///
321     /// Each of the entries in this overload set is a CXXConversionDecl or a
322     /// FunctionTemplateDecl.
323     LazyASTUnresolvedSet VisibleConversions;
324
325     /// The declaration which defines this record.
326     CXXRecordDecl *Definition;
327
328     /// The first friend declaration in this class, or null if there
329     /// aren't any.
330     ///
331     /// This is actually currently stored in reverse order.
332     LazyDeclPtr FirstFriend;
333
334     DefinitionData(CXXRecordDecl *D);
335
336     /// Retrieve the set of direct base classes.
337     CXXBaseSpecifier *getBases() const {
338       if (!Bases.isOffset())
339         return Bases.get(nullptr);
340       return getBasesSlowCase();
341     }
342
343     /// Retrieve the set of virtual base classes.
344     CXXBaseSpecifier *getVBases() const {
345       if (!VBases.isOffset())
346         return VBases.get(nullptr);
347       return getVBasesSlowCase();
348     }
349
350     ArrayRef<CXXBaseSpecifier> bases() const {
351       return llvm::makeArrayRef(getBases(), NumBases);
352     }
353
354     ArrayRef<CXXBaseSpecifier> vbases() const {
355       return llvm::makeArrayRef(getVBases(), NumVBases);
356     }
357
358   private:
359     CXXBaseSpecifier *getBasesSlowCase() const;
360     CXXBaseSpecifier *getVBasesSlowCase() const;
361   };
362
363   struct DefinitionData *DefinitionData;
364
365   /// Describes a C++ closure type (generated by a lambda expression).
366   struct LambdaDefinitionData : public DefinitionData {
367     using Capture = LambdaCapture;
368
369     /// Whether this lambda is known to be dependent, even if its
370     /// context isn't dependent.
371     ///
372     /// A lambda with a non-dependent context can be dependent if it occurs
373     /// within the default argument of a function template, because the
374     /// lambda will have been created with the enclosing context as its
375     /// declaration context, rather than function. This is an unfortunate
376     /// artifact of having to parse the default arguments before.
377     unsigned Dependent : 1;
378
379     /// Whether this lambda is a generic lambda.
380     unsigned IsGenericLambda : 1;
381
382     /// The Default Capture.
383     unsigned CaptureDefault : 2;
384
385     /// The number of captures in this lambda is limited 2^NumCaptures.
386     unsigned NumCaptures : 15;
387
388     /// The number of explicit captures in this lambda.
389     unsigned NumExplicitCaptures : 13;
390
391     /// Has known `internal` linkage.
392     unsigned HasKnownInternalLinkage : 1;
393
394     /// The number used to indicate this lambda expression for name
395     /// mangling in the Itanium C++ ABI.
396     unsigned ManglingNumber : 31;
397
398     /// The declaration that provides context for this lambda, if the
399     /// actual DeclContext does not suffice. This is used for lambdas that
400     /// occur within default arguments of function parameters within the class
401     /// or within a data member initializer.
402     LazyDeclPtr ContextDecl;
403
404     /// The list of captures, both explicit and implicit, for this
405     /// lambda.
406     Capture *Captures = nullptr;
407
408     /// The type of the call method.
409     TypeSourceInfo *MethodTyInfo;
410
411     LambdaDefinitionData(CXXRecordDecl *D, TypeSourceInfo *Info, bool Dependent,
412                          bool IsGeneric, LambdaCaptureDefault CaptureDefault)
413         : DefinitionData(D), Dependent(Dependent), IsGenericLambda(IsGeneric),
414           CaptureDefault(CaptureDefault), NumCaptures(0),
415           NumExplicitCaptures(0), HasKnownInternalLinkage(0), ManglingNumber(0),
416           MethodTyInfo(Info) {
417       IsLambda = true;
418
419       // C++1z [expr.prim.lambda]p4:
420       //   This class type is not an aggregate type.
421       Aggregate = false;
422       PlainOldData = false;
423     }
424   };
425
426   struct DefinitionData *dataPtr() const {
427     // Complete the redecl chain (if necessary).
428     getMostRecentDecl();
429     return DefinitionData;
430   }
431
432   struct DefinitionData &data() const {
433     auto *DD = dataPtr();
434     assert(DD && "queried property of class with no definition");
435     return *DD;
436   }
437
438   struct LambdaDefinitionData &getLambdaData() const {
439     // No update required: a merged definition cannot change any lambda
440     // properties.
441     auto *DD = DefinitionData;
442     assert(DD && DD->IsLambda && "queried lambda property of non-lambda class");
443     return static_cast<LambdaDefinitionData&>(*DD);
444   }
445
446   /// The template or declaration that this declaration
447   /// describes or was instantiated from, respectively.
448   ///
449   /// For non-templates, this value will be null. For record
450   /// declarations that describe a class template, this will be a
451   /// pointer to a ClassTemplateDecl. For member
452   /// classes of class template specializations, this will be the
453   /// MemberSpecializationInfo referring to the member class that was
454   /// instantiated or specialized.
455   llvm::PointerUnion<ClassTemplateDecl *, MemberSpecializationInfo *>
456       TemplateOrInstantiation;
457
458   /// Called from setBases and addedMember to notify the class that a
459   /// direct or virtual base class or a member of class type has been added.
460   void addedClassSubobject(CXXRecordDecl *Base);
461
462   /// Notify the class that member has been added.
463   ///
464   /// This routine helps maintain information about the class based on which
465   /// members have been added. It will be invoked by DeclContext::addDecl()
466   /// whenever a member is added to this record.
467   void addedMember(Decl *D);
468
469   void markedVirtualFunctionPure();
470
471   /// Get the head of our list of friend declarations, possibly
472   /// deserializing the friends from an external AST source.
473   FriendDecl *getFirstFriend() const;
474
475   /// Determine whether this class has an empty base class subobject of type X
476   /// or of one of the types that might be at offset 0 within X (per the C++
477   /// "standard layout" rules).
478   bool hasSubobjectAtOffsetZeroOfEmptyBaseType(ASTContext &Ctx,
479                                                const CXXRecordDecl *X);
480
481 protected:
482   CXXRecordDecl(Kind K, TagKind TK, const ASTContext &C, DeclContext *DC,
483                 SourceLocation StartLoc, SourceLocation IdLoc,
484                 IdentifierInfo *Id, CXXRecordDecl *PrevDecl);
485
486 public:
487   /// Iterator that traverses the base classes of a class.
488   using base_class_iterator = CXXBaseSpecifier *;
489
490   /// Iterator that traverses the base classes of a class.
491   using base_class_const_iterator = const CXXBaseSpecifier *;
492
493   CXXRecordDecl *getCanonicalDecl() override {
494     return cast<CXXRecordDecl>(RecordDecl::getCanonicalDecl());
495   }
496
497   const CXXRecordDecl *getCanonicalDecl() const {
498     return const_cast<CXXRecordDecl*>(this)->getCanonicalDecl();
499   }
500
501   CXXRecordDecl *getPreviousDecl() {
502     return cast_or_null<CXXRecordDecl>(
503             static_cast<RecordDecl *>(this)->getPreviousDecl());
504   }
505
506   const CXXRecordDecl *getPreviousDecl() const {
507     return const_cast<CXXRecordDecl*>(this)->getPreviousDecl();
508   }
509
510   CXXRecordDecl *getMostRecentDecl() {
511     return cast<CXXRecordDecl>(
512             static_cast<RecordDecl *>(this)->getMostRecentDecl());
513   }
514
515   const CXXRecordDecl *getMostRecentDecl() const {
516     return const_cast<CXXRecordDecl*>(this)->getMostRecentDecl();
517   }
518
519   CXXRecordDecl *getMostRecentNonInjectedDecl() {
520     CXXRecordDecl *Recent =
521         static_cast<CXXRecordDecl *>(this)->getMostRecentDecl();
522     while (Recent->isInjectedClassName()) {
523       // FIXME: Does injected class name need to be in the redeclarations chain?
524       assert(Recent->getPreviousDecl());
525       Recent = Recent->getPreviousDecl();
526     }
527     return Recent;
528   }
529
530   const CXXRecordDecl *getMostRecentNonInjectedDecl() const {
531     return const_cast<CXXRecordDecl*>(this)->getMostRecentNonInjectedDecl();
532   }
533
534   CXXRecordDecl *getDefinition() const {
535     // We only need an update if we don't already know which
536     // declaration is the definition.
537     auto *DD = DefinitionData ? DefinitionData : dataPtr();
538     return DD ? DD->Definition : nullptr;
539   }
540
541   bool hasDefinition() const { return DefinitionData || dataPtr(); }
542
543   static CXXRecordDecl *Create(const ASTContext &C, TagKind TK, DeclContext *DC,
544                                SourceLocation StartLoc, SourceLocation IdLoc,
545                                IdentifierInfo *Id,
546                                CXXRecordDecl *PrevDecl = nullptr,
547                                bool DelayTypeCreation = false);
548   static CXXRecordDecl *CreateLambda(const ASTContext &C, DeclContext *DC,
549                                      TypeSourceInfo *Info, SourceLocation Loc,
550                                      bool DependentLambda, bool IsGeneric,
551                                      LambdaCaptureDefault CaptureDefault);
552   static CXXRecordDecl *CreateDeserialized(const ASTContext &C, unsigned ID);
553
554   bool isDynamicClass() const {
555     return data().Polymorphic || data().NumVBases != 0;
556   }
557
558   /// @returns true if class is dynamic or might be dynamic because the
559   /// definition is incomplete of dependent.
560   bool mayBeDynamicClass() const {
561     return !hasDefinition() || isDynamicClass() || hasAnyDependentBases();
562   }
563
564   /// @returns true if class is non dynamic or might be non dynamic because the
565   /// definition is incomplete of dependent.
566   bool mayBeNonDynamicClass() const {
567     return !hasDefinition() || !isDynamicClass() || hasAnyDependentBases();
568   }
569
570   void setIsParsingBaseSpecifiers() { data().IsParsingBaseSpecifiers = true; }
571
572   bool isParsingBaseSpecifiers() const {
573     return data().IsParsingBaseSpecifiers;
574   }
575
576   unsigned getODRHash() const;
577
578   /// Sets the base classes of this struct or class.
579   void setBases(CXXBaseSpecifier const * const *Bases, unsigned NumBases);
580
581   /// Retrieves the number of base classes of this class.
582   unsigned getNumBases() const { return data().NumBases; }
583
584   using base_class_range = llvm::iterator_range<base_class_iterator>;
585   using base_class_const_range =
586       llvm::iterator_range<base_class_const_iterator>;
587
588   base_class_range bases() {
589     return base_class_range(bases_begin(), bases_end());
590   }
591   base_class_const_range bases() const {
592     return base_class_const_range(bases_begin(), bases_end());
593   }
594
595   base_class_iterator bases_begin() { return data().getBases(); }
596   base_class_const_iterator bases_begin() const { return data().getBases(); }
597   base_class_iterator bases_end() { return bases_begin() + data().NumBases; }
598   base_class_const_iterator bases_end() const {
599     return bases_begin() + data().NumBases;
600   }
601
602   /// Retrieves the number of virtual base classes of this class.
603   unsigned getNumVBases() const { return data().NumVBases; }
604
605   base_class_range vbases() {
606     return base_class_range(vbases_begin(), vbases_end());
607   }
608   base_class_const_range vbases() const {
609     return base_class_const_range(vbases_begin(), vbases_end());
610   }
611
612   base_class_iterator vbases_begin() { return data().getVBases(); }
613   base_class_const_iterator vbases_begin() const { return data().getVBases(); }
614   base_class_iterator vbases_end() { return vbases_begin() + data().NumVBases; }
615   base_class_const_iterator vbases_end() const {
616     return vbases_begin() + data().NumVBases;
617   }
618
619   /// Determine whether this class has any dependent base classes which
620   /// are not the current instantiation.
621   bool hasAnyDependentBases() const;
622
623   /// Iterator access to method members.  The method iterator visits
624   /// all method members of the class, including non-instance methods,
625   /// special methods, etc.
626   using method_iterator = specific_decl_iterator<CXXMethodDecl>;
627   using method_range =
628       llvm::iterator_range<specific_decl_iterator<CXXMethodDecl>>;
629
630   method_range methods() const {
631     return method_range(method_begin(), method_end());
632   }
633
634   /// Method begin iterator.  Iterates in the order the methods
635   /// were declared.
636   method_iterator method_begin() const {
637     return method_iterator(decls_begin());
638   }
639
640   /// Method past-the-end iterator.
641   method_iterator method_end() const {
642     return method_iterator(decls_end());
643   }
644
645   /// Iterator access to constructor members.
646   using ctor_iterator = specific_decl_iterator<CXXConstructorDecl>;
647   using ctor_range =
648       llvm::iterator_range<specific_decl_iterator<CXXConstructorDecl>>;
649
650   ctor_range ctors() const { return ctor_range(ctor_begin(), ctor_end()); }
651
652   ctor_iterator ctor_begin() const {
653     return ctor_iterator(decls_begin());
654   }
655
656   ctor_iterator ctor_end() const {
657     return ctor_iterator(decls_end());
658   }
659
660   /// An iterator over friend declarations.  All of these are defined
661   /// in DeclFriend.h.
662   class friend_iterator;
663   using friend_range = llvm::iterator_range<friend_iterator>;
664
665   friend_range friends() const;
666   friend_iterator friend_begin() const;
667   friend_iterator friend_end() const;
668   void pushFriendDecl(FriendDecl *FD);
669
670   /// Determines whether this record has any friends.
671   bool hasFriends() const {
672     return data().FirstFriend.isValid();
673   }
674
675   /// \c true if a defaulted copy constructor for this class would be
676   /// deleted.
677   bool defaultedCopyConstructorIsDeleted() const {
678     assert((!needsOverloadResolutionForCopyConstructor() ||
679             (data().DeclaredSpecialMembers & SMF_CopyConstructor)) &&
680            "this property has not yet been computed by Sema");
681     return data().DefaultedCopyConstructorIsDeleted;
682   }
683
684   /// \c true if a defaulted move constructor for this class would be
685   /// deleted.
686   bool defaultedMoveConstructorIsDeleted() const {
687     assert((!needsOverloadResolutionForMoveConstructor() ||
688             (data().DeclaredSpecialMembers & SMF_MoveConstructor)) &&
689            "this property has not yet been computed by Sema");
690     return data().DefaultedMoveConstructorIsDeleted;
691   }
692
693   /// \c true if a defaulted destructor for this class would be deleted.
694   bool defaultedDestructorIsDeleted() const {
695     assert((!needsOverloadResolutionForDestructor() ||
696             (data().DeclaredSpecialMembers & SMF_Destructor)) &&
697            "this property has not yet been computed by Sema");
698     return data().DefaultedDestructorIsDeleted;
699   }
700
701   /// \c true if we know for sure that this class has a single,
702   /// accessible, unambiguous copy constructor that is not deleted.
703   bool hasSimpleCopyConstructor() const {
704     return !hasUserDeclaredCopyConstructor() &&
705            !data().DefaultedCopyConstructorIsDeleted;
706   }
707
708   /// \c true if we know for sure that this class has a single,
709   /// accessible, unambiguous move constructor that is not deleted.
710   bool hasSimpleMoveConstructor() const {
711     return !hasUserDeclaredMoveConstructor() && hasMoveConstructor() &&
712            !data().DefaultedMoveConstructorIsDeleted;
713   }
714
715   /// \c true if we know for sure that this class has a single,
716   /// accessible, unambiguous move assignment operator that is not deleted.
717   bool hasSimpleMoveAssignment() const {
718     return !hasUserDeclaredMoveAssignment() && hasMoveAssignment() &&
719            !data().DefaultedMoveAssignmentIsDeleted;
720   }
721
722   /// \c true if we know for sure that this class has an accessible
723   /// destructor that is not deleted.
724   bool hasSimpleDestructor() const {
725     return !hasUserDeclaredDestructor() &&
726            !data().DefaultedDestructorIsDeleted;
727   }
728
729   /// Determine whether this class has any default constructors.
730   bool hasDefaultConstructor() const {
731     return (data().DeclaredSpecialMembers & SMF_DefaultConstructor) ||
732            needsImplicitDefaultConstructor();
733   }
734
735   /// Determine if we need to declare a default constructor for
736   /// this class.
737   ///
738   /// This value is used for lazy creation of default constructors.
739   bool needsImplicitDefaultConstructor() const {
740     return !data().UserDeclaredConstructor &&
741            !(data().DeclaredSpecialMembers & SMF_DefaultConstructor) &&
742            (!isLambda() || lambdaIsDefaultConstructibleAndAssignable());
743   }
744
745   /// Determine whether this class has any user-declared constructors.
746   ///
747   /// When true, a default constructor will not be implicitly declared.
748   bool hasUserDeclaredConstructor() const {
749     return data().UserDeclaredConstructor;
750   }
751
752   /// Whether this class has a user-provided default constructor
753   /// per C++11.
754   bool hasUserProvidedDefaultConstructor() const {
755     return data().UserProvidedDefaultConstructor;
756   }
757
758   /// Determine whether this class has a user-declared copy constructor.
759   ///
760   /// When false, a copy constructor will be implicitly declared.
761   bool hasUserDeclaredCopyConstructor() const {
762     return data().UserDeclaredSpecialMembers & SMF_CopyConstructor;
763   }
764
765   /// Determine whether this class needs an implicit copy
766   /// constructor to be lazily declared.
767   bool needsImplicitCopyConstructor() const {
768     return !(data().DeclaredSpecialMembers & SMF_CopyConstructor);
769   }
770
771   /// Determine whether we need to eagerly declare a defaulted copy
772   /// constructor for this class.
773   bool needsOverloadResolutionForCopyConstructor() const {
774     // C++17 [class.copy.ctor]p6:
775     //   If the class definition declares a move constructor or move assignment
776     //   operator, the implicitly declared copy constructor is defined as
777     //   deleted.
778     // In MSVC mode, sometimes a declared move assignment does not delete an
779     // implicit copy constructor, so defer this choice to Sema.
780     if (data().UserDeclaredSpecialMembers &
781         (SMF_MoveConstructor | SMF_MoveAssignment))
782       return true;
783     return data().NeedOverloadResolutionForCopyConstructor;
784   }
785
786   /// Determine whether an implicit copy constructor for this type
787   /// would have a parameter with a const-qualified reference type.
788   bool implicitCopyConstructorHasConstParam() const {
789     return data().ImplicitCopyConstructorCanHaveConstParamForNonVBase &&
790            (isAbstract() ||
791             data().ImplicitCopyConstructorCanHaveConstParamForVBase);
792   }
793
794   /// Determine whether this class has a copy constructor with
795   /// a parameter type which is a reference to a const-qualified type.
796   bool hasCopyConstructorWithConstParam() const {
797     return data().HasDeclaredCopyConstructorWithConstParam ||
798            (needsImplicitCopyConstructor() &&
799             implicitCopyConstructorHasConstParam());
800   }
801
802   /// Whether this class has a user-declared move constructor or
803   /// assignment operator.
804   ///
805   /// When false, a move constructor and assignment operator may be
806   /// implicitly declared.
807   bool hasUserDeclaredMoveOperation() const {
808     return data().UserDeclaredSpecialMembers &
809              (SMF_MoveConstructor | SMF_MoveAssignment);
810   }
811
812   /// Determine whether this class has had a move constructor
813   /// declared by the user.
814   bool hasUserDeclaredMoveConstructor() const {
815     return data().UserDeclaredSpecialMembers & SMF_MoveConstructor;
816   }
817
818   /// Determine whether this class has a move constructor.
819   bool hasMoveConstructor() const {
820     return (data().DeclaredSpecialMembers & SMF_MoveConstructor) ||
821            needsImplicitMoveConstructor();
822   }
823
824   /// Set that we attempted to declare an implicit copy
825   /// constructor, but overload resolution failed so we deleted it.
826   void setImplicitCopyConstructorIsDeleted() {
827     assert((data().DefaultedCopyConstructorIsDeleted ||
828             needsOverloadResolutionForCopyConstructor()) &&
829            "Copy constructor should not be deleted");
830     data().DefaultedCopyConstructorIsDeleted = true;
831   }
832
833   /// Set that we attempted to declare an implicit move
834   /// constructor, but overload resolution failed so we deleted it.
835   void setImplicitMoveConstructorIsDeleted() {
836     assert((data().DefaultedMoveConstructorIsDeleted ||
837             needsOverloadResolutionForMoveConstructor()) &&
838            "move constructor should not be deleted");
839     data().DefaultedMoveConstructorIsDeleted = true;
840   }
841
842   /// Set that we attempted to declare an implicit destructor,
843   /// but overload resolution failed so we deleted it.
844   void setImplicitDestructorIsDeleted() {
845     assert((data().DefaultedDestructorIsDeleted ||
846             needsOverloadResolutionForDestructor()) &&
847            "destructor should not be deleted");
848     data().DefaultedDestructorIsDeleted = true;
849   }
850
851   /// Determine whether this class should get an implicit move
852   /// constructor or if any existing special member function inhibits this.
853   bool needsImplicitMoveConstructor() const {
854     return !(data().DeclaredSpecialMembers & SMF_MoveConstructor) &&
855            !hasUserDeclaredCopyConstructor() &&
856            !hasUserDeclaredCopyAssignment() &&
857            !hasUserDeclaredMoveAssignment() &&
858            !hasUserDeclaredDestructor();
859   }
860
861   /// Determine whether we need to eagerly declare a defaulted move
862   /// constructor for this class.
863   bool needsOverloadResolutionForMoveConstructor() const {
864     return data().NeedOverloadResolutionForMoveConstructor;
865   }
866
867   /// Determine whether this class has a user-declared copy assignment
868   /// operator.
869   ///
870   /// When false, a copy assignment operator will be implicitly declared.
871   bool hasUserDeclaredCopyAssignment() const {
872     return data().UserDeclaredSpecialMembers & SMF_CopyAssignment;
873   }
874
875   /// Determine whether this class needs an implicit copy
876   /// assignment operator to be lazily declared.
877   bool needsImplicitCopyAssignment() const {
878     return !(data().DeclaredSpecialMembers & SMF_CopyAssignment);
879   }
880
881   /// Determine whether we need to eagerly declare a defaulted copy
882   /// assignment operator for this class.
883   bool needsOverloadResolutionForCopyAssignment() const {
884     return data().HasMutableFields;
885   }
886
887   /// Determine whether an implicit copy assignment operator for this
888   /// type would have a parameter with a const-qualified reference type.
889   bool implicitCopyAssignmentHasConstParam() const {
890     return data().ImplicitCopyAssignmentHasConstParam;
891   }
892
893   /// Determine whether this class has a copy assignment operator with
894   /// a parameter type which is a reference to a const-qualified type or is not
895   /// a reference.
896   bool hasCopyAssignmentWithConstParam() const {
897     return data().HasDeclaredCopyAssignmentWithConstParam ||
898            (needsImplicitCopyAssignment() &&
899             implicitCopyAssignmentHasConstParam());
900   }
901
902   /// Determine whether this class has had a move assignment
903   /// declared by the user.
904   bool hasUserDeclaredMoveAssignment() const {
905     return data().UserDeclaredSpecialMembers & SMF_MoveAssignment;
906   }
907
908   /// Determine whether this class has a move assignment operator.
909   bool hasMoveAssignment() const {
910     return (data().DeclaredSpecialMembers & SMF_MoveAssignment) ||
911            needsImplicitMoveAssignment();
912   }
913
914   /// Set that we attempted to declare an implicit move assignment
915   /// operator, but overload resolution failed so we deleted it.
916   void setImplicitMoveAssignmentIsDeleted() {
917     assert((data().DefaultedMoveAssignmentIsDeleted ||
918             needsOverloadResolutionForMoveAssignment()) &&
919            "move assignment should not be deleted");
920     data().DefaultedMoveAssignmentIsDeleted = true;
921   }
922
923   /// Determine whether this class should get an implicit move
924   /// assignment operator or if any existing special member function inhibits
925   /// this.
926   bool needsImplicitMoveAssignment() const {
927     return !(data().DeclaredSpecialMembers & SMF_MoveAssignment) &&
928            !hasUserDeclaredCopyConstructor() &&
929            !hasUserDeclaredCopyAssignment() &&
930            !hasUserDeclaredMoveConstructor() &&
931            !hasUserDeclaredDestructor() &&
932            (!isLambda() || lambdaIsDefaultConstructibleAndAssignable());
933   }
934
935   /// Determine whether we need to eagerly declare a move assignment
936   /// operator for this class.
937   bool needsOverloadResolutionForMoveAssignment() const {
938     return data().NeedOverloadResolutionForMoveAssignment;
939   }
940
941   /// Determine whether this class has a user-declared destructor.
942   ///
943   /// When false, a destructor will be implicitly declared.
944   bool hasUserDeclaredDestructor() const {
945     return data().UserDeclaredSpecialMembers & SMF_Destructor;
946   }
947
948   /// Determine whether this class needs an implicit destructor to
949   /// be lazily declared.
950   bool needsImplicitDestructor() const {
951     return !(data().DeclaredSpecialMembers & SMF_Destructor);
952   }
953
954   /// Determine whether we need to eagerly declare a destructor for this
955   /// class.
956   bool needsOverloadResolutionForDestructor() const {
957     return data().NeedOverloadResolutionForDestructor;
958   }
959
960   /// Determine whether this class describes a lambda function object.
961   bool isLambda() const {
962     // An update record can't turn a non-lambda into a lambda.
963     auto *DD = DefinitionData;
964     return DD && DD->IsLambda;
965   }
966
967   /// Determine whether this class describes a generic
968   /// lambda function object (i.e. function call operator is
969   /// a template).
970   bool isGenericLambda() const;
971
972   /// Determine whether this lambda should have an implicit default constructor
973   /// and copy and move assignment operators.
974   bool lambdaIsDefaultConstructibleAndAssignable() const;
975
976   /// Retrieve the lambda call operator of the closure type
977   /// if this is a closure type.
978   CXXMethodDecl *getLambdaCallOperator() const;
979
980   /// Retrieve the dependent lambda call operator of the closure type
981   /// if this is a templated closure type.
982   FunctionTemplateDecl *getDependentLambdaCallOperator() const;
983
984   /// Retrieve the lambda static invoker, the address of which
985   /// is returned by the conversion operator, and the body of which
986   /// is forwarded to the lambda call operator.
987   CXXMethodDecl *getLambdaStaticInvoker() const;
988
989   /// Retrieve the generic lambda's template parameter list.
990   /// Returns null if the class does not represent a lambda or a generic
991   /// lambda.
992   TemplateParameterList *getGenericLambdaTemplateParameterList() const;
993
994   /// Retrieve the lambda template parameters that were specified explicitly.
995   ArrayRef<NamedDecl *> getLambdaExplicitTemplateParameters() const;
996
997   LambdaCaptureDefault getLambdaCaptureDefault() const {
998     assert(isLambda());
999     return static_cast<LambdaCaptureDefault>(getLambdaData().CaptureDefault);
1000   }
1001
1002   /// For a closure type, retrieve the mapping from captured
1003   /// variables and \c this to the non-static data members that store the
1004   /// values or references of the captures.
1005   ///
1006   /// \param Captures Will be populated with the mapping from captured
1007   /// variables to the corresponding fields.
1008   ///
1009   /// \param ThisCapture Will be set to the field declaration for the
1010   /// \c this capture.
1011   ///
1012   /// \note No entries will be added for init-captures, as they do not capture
1013   /// variables.
1014   void getCaptureFields(llvm::DenseMap<const VarDecl *, FieldDecl *> &Captures,
1015                         FieldDecl *&ThisCapture) const;
1016
1017   using capture_const_iterator = const LambdaCapture *;
1018   using capture_const_range = llvm::iterator_range<capture_const_iterator>;
1019
1020   capture_const_range captures() const {
1021     return capture_const_range(captures_begin(), captures_end());
1022   }
1023
1024   capture_const_iterator captures_begin() const {
1025     return isLambda() ? getLambdaData().Captures : nullptr;
1026   }
1027
1028   capture_const_iterator captures_end() const {
1029     return isLambda() ? captures_begin() + getLambdaData().NumCaptures
1030                       : nullptr;
1031   }
1032
1033   using conversion_iterator = UnresolvedSetIterator;
1034
1035   conversion_iterator conversion_begin() const {
1036     return data().Conversions.get(getASTContext()).begin();
1037   }
1038
1039   conversion_iterator conversion_end() const {
1040     return data().Conversions.get(getASTContext()).end();
1041   }
1042
1043   /// Removes a conversion function from this class.  The conversion
1044   /// function must currently be a member of this class.  Furthermore,
1045   /// this class must currently be in the process of being defined.
1046   void removeConversion(const NamedDecl *Old);
1047
1048   /// Get all conversion functions visible in current class,
1049   /// including conversion function templates.
1050   llvm::iterator_range<conversion_iterator>
1051   getVisibleConversionFunctions() const;
1052
1053   /// Determine whether this class is an aggregate (C++ [dcl.init.aggr]),
1054   /// which is a class with no user-declared constructors, no private
1055   /// or protected non-static data members, no base classes, and no virtual
1056   /// functions (C++ [dcl.init.aggr]p1).
1057   bool isAggregate() const { return data().Aggregate; }
1058
1059   /// Whether this class has any in-class initializers
1060   /// for non-static data members (including those in anonymous unions or
1061   /// structs).
1062   bool hasInClassInitializer() const { return data().HasInClassInitializer; }
1063
1064   /// Whether this class or any of its subobjects has any members of
1065   /// reference type which would make value-initialization ill-formed.
1066   ///
1067   /// Per C++03 [dcl.init]p5:
1068   ///  - if T is a non-union class type without a user-declared constructor,
1069   ///    then every non-static data member and base-class component of T is
1070   ///    value-initialized [...] A program that calls for [...]
1071   ///    value-initialization of an entity of reference type is ill-formed.
1072   bool hasUninitializedReferenceMember() const {
1073     return !isUnion() && !hasUserDeclaredConstructor() &&
1074            data().HasUninitializedReferenceMember;
1075   }
1076
1077   /// Whether this class is a POD-type (C++ [class]p4)
1078   ///
1079   /// For purposes of this function a class is POD if it is an aggregate
1080   /// that has no non-static non-POD data members, no reference data
1081   /// members, no user-defined copy assignment operator and no
1082   /// user-defined destructor.
1083   ///
1084   /// Note that this is the C++ TR1 definition of POD.
1085   bool isPOD() const { return data().PlainOldData; }
1086
1087   /// True if this class is C-like, without C++-specific features, e.g.
1088   /// it contains only public fields, no bases, tag kind is not 'class', etc.
1089   bool isCLike() const;
1090
1091   /// Determine whether this is an empty class in the sense of
1092   /// (C++11 [meta.unary.prop]).
1093   ///
1094   /// The CXXRecordDecl is a class type, but not a union type,
1095   /// with no non-static data members other than bit-fields of length 0,
1096   /// no virtual member functions, no virtual base classes,
1097   /// and no base class B for which is_empty<B>::value is false.
1098   ///
1099   /// \note This does NOT include a check for union-ness.
1100   bool isEmpty() const { return data().Empty; }
1101
1102   bool hasPrivateFields() const {
1103     return data().HasPrivateFields;
1104   }
1105
1106   bool hasProtectedFields() const {
1107     return data().HasProtectedFields;
1108   }
1109
1110   /// Determine whether this class has direct non-static data members.
1111   bool hasDirectFields() const {
1112     auto &D = data();
1113     return D.HasPublicFields || D.HasProtectedFields || D.HasPrivateFields;
1114   }
1115
1116   /// Whether this class is polymorphic (C++ [class.virtual]),
1117   /// which means that the class contains or inherits a virtual function.
1118   bool isPolymorphic() const { return data().Polymorphic; }
1119
1120   /// Determine whether this class has a pure virtual function.
1121   ///
1122   /// The class is is abstract per (C++ [class.abstract]p2) if it declares
1123   /// a pure virtual function or inherits a pure virtual function that is
1124   /// not overridden.
1125   bool isAbstract() const { return data().Abstract; }
1126
1127   /// Determine whether this class is standard-layout per
1128   /// C++ [class]p7.
1129   bool isStandardLayout() const { return data().IsStandardLayout; }
1130
1131   /// Determine whether this class was standard-layout per
1132   /// C++11 [class]p7, specifically using the C++11 rules without any DRs.
1133   bool isCXX11StandardLayout() const { return data().IsCXX11StandardLayout; }
1134
1135   /// Determine whether this class, or any of its class subobjects,
1136   /// contains a mutable field.
1137   bool hasMutableFields() const { return data().HasMutableFields; }
1138
1139   /// Determine whether this class has any variant members.
1140   bool hasVariantMembers() const { return data().HasVariantMembers; }
1141
1142   /// Determine whether this class has a trivial default constructor
1143   /// (C++11 [class.ctor]p5).
1144   bool hasTrivialDefaultConstructor() const {
1145     return hasDefaultConstructor() &&
1146            (data().HasTrivialSpecialMembers & SMF_DefaultConstructor);
1147   }
1148
1149   /// Determine whether this class has a non-trivial default constructor
1150   /// (C++11 [class.ctor]p5).
1151   bool hasNonTrivialDefaultConstructor() const {
1152     return (data().DeclaredNonTrivialSpecialMembers & SMF_DefaultConstructor) ||
1153            (needsImplicitDefaultConstructor() &&
1154             !(data().HasTrivialSpecialMembers & SMF_DefaultConstructor));
1155   }
1156
1157   /// Determine whether this class has at least one constexpr constructor
1158   /// other than the copy or move constructors.
1159   bool hasConstexprNonCopyMoveConstructor() const {
1160     return data().HasConstexprNonCopyMoveConstructor ||
1161            (needsImplicitDefaultConstructor() &&
1162             defaultedDefaultConstructorIsConstexpr());
1163   }
1164
1165   /// Determine whether a defaulted default constructor for this class
1166   /// would be constexpr.
1167   bool defaultedDefaultConstructorIsConstexpr() const {
1168     return data().DefaultedDefaultConstructorIsConstexpr &&
1169            (!isUnion() || hasInClassInitializer() || !hasVariantMembers() ||
1170             getLangOpts().CPlusPlus2a);
1171   }
1172
1173   /// Determine whether this class has a constexpr default constructor.
1174   bool hasConstexprDefaultConstructor() const {
1175     return data().HasConstexprDefaultConstructor ||
1176            (needsImplicitDefaultConstructor() &&
1177             defaultedDefaultConstructorIsConstexpr());
1178   }
1179
1180   /// Determine whether this class has a trivial copy constructor
1181   /// (C++ [class.copy]p6, C++11 [class.copy]p12)
1182   bool hasTrivialCopyConstructor() const {
1183     return data().HasTrivialSpecialMembers & SMF_CopyConstructor;
1184   }
1185
1186   bool hasTrivialCopyConstructorForCall() const {
1187     return data().HasTrivialSpecialMembersForCall & SMF_CopyConstructor;
1188   }
1189
1190   /// Determine whether this class has a non-trivial copy constructor
1191   /// (C++ [class.copy]p6, C++11 [class.copy]p12)
1192   bool hasNonTrivialCopyConstructor() const {
1193     return data().DeclaredNonTrivialSpecialMembers & SMF_CopyConstructor ||
1194            !hasTrivialCopyConstructor();
1195   }
1196
1197   bool hasNonTrivialCopyConstructorForCall() const {
1198     return (data().DeclaredNonTrivialSpecialMembersForCall &
1199             SMF_CopyConstructor) ||
1200            !hasTrivialCopyConstructorForCall();
1201   }
1202
1203   /// Determine whether this class has a trivial move constructor
1204   /// (C++11 [class.copy]p12)
1205   bool hasTrivialMoveConstructor() const {
1206     return hasMoveConstructor() &&
1207            (data().HasTrivialSpecialMembers & SMF_MoveConstructor);
1208   }
1209
1210   bool hasTrivialMoveConstructorForCall() const {
1211     return hasMoveConstructor() &&
1212            (data().HasTrivialSpecialMembersForCall & SMF_MoveConstructor);
1213   }
1214
1215   /// Determine whether this class has a non-trivial move constructor
1216   /// (C++11 [class.copy]p12)
1217   bool hasNonTrivialMoveConstructor() const {
1218     return (data().DeclaredNonTrivialSpecialMembers & SMF_MoveConstructor) ||
1219            (needsImplicitMoveConstructor() &&
1220             !(data().HasTrivialSpecialMembers & SMF_MoveConstructor));
1221   }
1222
1223   bool hasNonTrivialMoveConstructorForCall() const {
1224     return (data().DeclaredNonTrivialSpecialMembersForCall &
1225             SMF_MoveConstructor) ||
1226            (needsImplicitMoveConstructor() &&
1227             !(data().HasTrivialSpecialMembersForCall & SMF_MoveConstructor));
1228   }
1229
1230   /// Determine whether this class has a trivial copy assignment operator
1231   /// (C++ [class.copy]p11, C++11 [class.copy]p25)
1232   bool hasTrivialCopyAssignment() const {
1233     return data().HasTrivialSpecialMembers & SMF_CopyAssignment;
1234   }
1235
1236   /// Determine whether this class has a non-trivial copy assignment
1237   /// operator (C++ [class.copy]p11, C++11 [class.copy]p25)
1238   bool hasNonTrivialCopyAssignment() const {
1239     return data().DeclaredNonTrivialSpecialMembers & SMF_CopyAssignment ||
1240            !hasTrivialCopyAssignment();
1241   }
1242
1243   /// Determine whether this class has a trivial move assignment operator
1244   /// (C++11 [class.copy]p25)
1245   bool hasTrivialMoveAssignment() const {
1246     return hasMoveAssignment() &&
1247            (data().HasTrivialSpecialMembers & SMF_MoveAssignment);
1248   }
1249
1250   /// Determine whether this class has a non-trivial move assignment
1251   /// operator (C++11 [class.copy]p25)
1252   bool hasNonTrivialMoveAssignment() const {
1253     return (data().DeclaredNonTrivialSpecialMembers & SMF_MoveAssignment) ||
1254            (needsImplicitMoveAssignment() &&
1255             !(data().HasTrivialSpecialMembers & SMF_MoveAssignment));
1256   }
1257
1258   /// Determine whether a defaulted default constructor for this class
1259   /// would be constexpr.
1260   bool defaultedDestructorIsConstexpr() const {
1261     return data().DefaultedDestructorIsConstexpr &&
1262            getLangOpts().CPlusPlus2a;
1263   }
1264
1265   /// Determine whether this class has a constexpr destructor.
1266   bool hasConstexprDestructor() const;
1267
1268   /// Determine whether this class has a trivial destructor
1269   /// (C++ [class.dtor]p3)
1270   bool hasTrivialDestructor() const {
1271     return data().HasTrivialSpecialMembers & SMF_Destructor;
1272   }
1273
1274   bool hasTrivialDestructorForCall() const {
1275     return data().HasTrivialSpecialMembersForCall & SMF_Destructor;
1276   }
1277
1278   /// Determine whether this class has a non-trivial destructor
1279   /// (C++ [class.dtor]p3)
1280   bool hasNonTrivialDestructor() const {
1281     return !(data().HasTrivialSpecialMembers & SMF_Destructor);
1282   }
1283
1284   bool hasNonTrivialDestructorForCall() const {
1285     return !(data().HasTrivialSpecialMembersForCall & SMF_Destructor);
1286   }
1287
1288   void setHasTrivialSpecialMemberForCall() {
1289     data().HasTrivialSpecialMembersForCall =
1290         (SMF_CopyConstructor | SMF_MoveConstructor | SMF_Destructor);
1291   }
1292
1293   /// Determine whether declaring a const variable with this type is ok
1294   /// per core issue 253.
1295   bool allowConstDefaultInit() const {
1296     return !data().HasUninitializedFields ||
1297            !(data().HasDefaultedDefaultConstructor ||
1298              needsImplicitDefaultConstructor());
1299   }
1300
1301   /// Determine whether this class has a destructor which has no
1302   /// semantic effect.
1303   ///
1304   /// Any such destructor will be trivial, public, defaulted and not deleted,
1305   /// and will call only irrelevant destructors.
1306   bool hasIrrelevantDestructor() const {
1307     return data().HasIrrelevantDestructor;
1308   }
1309
1310   /// Determine whether this class has a non-literal or/ volatile type
1311   /// non-static data member or base class.
1312   bool hasNonLiteralTypeFieldsOrBases() const {
1313     return data().HasNonLiteralTypeFieldsOrBases;
1314   }
1315
1316   /// Determine whether this class has a using-declaration that names
1317   /// a user-declared base class constructor.
1318   bool hasInheritedConstructor() const {
1319     return data().HasInheritedConstructor;
1320   }
1321
1322   /// Determine whether this class has a using-declaration that names
1323   /// a base class assignment operator.
1324   bool hasInheritedAssignment() const {
1325     return data().HasInheritedAssignment;
1326   }
1327
1328   /// Determine whether this class is considered trivially copyable per
1329   /// (C++11 [class]p6).
1330   bool isTriviallyCopyable() const;
1331
1332   /// Determine whether this class is considered trivial.
1333   ///
1334   /// C++11 [class]p6:
1335   ///    "A trivial class is a class that has a trivial default constructor and
1336   ///    is trivially copyable."
1337   bool isTrivial() const {
1338     return isTriviallyCopyable() && hasTrivialDefaultConstructor();
1339   }
1340
1341   /// Determine whether this class is a literal type.
1342   ///
1343   /// C++11 [basic.types]p10:
1344   ///   A class type that has all the following properties:
1345   ///     - it has a trivial destructor
1346   ///     - every constructor call and full-expression in the
1347   ///       brace-or-equal-intializers for non-static data members (if any) is
1348   ///       a constant expression.
1349   ///     - it is an aggregate type or has at least one constexpr constructor
1350   ///       or constructor template that is not a copy or move constructor, and
1351   ///     - all of its non-static data members and base classes are of literal
1352   ///       types
1353   ///
1354   /// We resolve DR1361 by ignoring the second bullet. We resolve DR1452 by
1355   /// treating types with trivial default constructors as literal types.
1356   ///
1357   /// Only in C++17 and beyond, are lambdas literal types.
1358   bool isLiteral() const {
1359     const LangOptions &LangOpts = getLangOpts();
1360     return (LangOpts.CPlusPlus2a ? hasConstexprDestructor()
1361                                           : hasTrivialDestructor()) &&
1362            (!isLambda() || LangOpts.CPlusPlus17) &&
1363            !hasNonLiteralTypeFieldsOrBases() &&
1364            (isAggregate() || isLambda() ||
1365             hasConstexprNonCopyMoveConstructor() ||
1366             hasTrivialDefaultConstructor());
1367   }
1368
1369   /// If this record is an instantiation of a member class,
1370   /// retrieves the member class from which it was instantiated.
1371   ///
1372   /// This routine will return non-null for (non-templated) member
1373   /// classes of class templates. For example, given:
1374   ///
1375   /// \code
1376   /// template<typename T>
1377   /// struct X {
1378   ///   struct A { };
1379   /// };
1380   /// \endcode
1381   ///
1382   /// The declaration for X<int>::A is a (non-templated) CXXRecordDecl
1383   /// whose parent is the class template specialization X<int>. For
1384   /// this declaration, getInstantiatedFromMemberClass() will return
1385   /// the CXXRecordDecl X<T>::A. When a complete definition of
1386   /// X<int>::A is required, it will be instantiated from the
1387   /// declaration returned by getInstantiatedFromMemberClass().
1388   CXXRecordDecl *getInstantiatedFromMemberClass() const;
1389
1390   /// If this class is an instantiation of a member class of a
1391   /// class template specialization, retrieves the member specialization
1392   /// information.
1393   MemberSpecializationInfo *getMemberSpecializationInfo() const;
1394
1395   /// Specify that this record is an instantiation of the
1396   /// member class \p RD.
1397   void setInstantiationOfMemberClass(CXXRecordDecl *RD,
1398                                      TemplateSpecializationKind TSK);
1399
1400   /// Retrieves the class template that is described by this
1401   /// class declaration.
1402   ///
1403   /// Every class template is represented as a ClassTemplateDecl and a
1404   /// CXXRecordDecl. The former contains template properties (such as
1405   /// the template parameter lists) while the latter contains the
1406   /// actual description of the template's
1407   /// contents. ClassTemplateDecl::getTemplatedDecl() retrieves the
1408   /// CXXRecordDecl that from a ClassTemplateDecl, while
1409   /// getDescribedClassTemplate() retrieves the ClassTemplateDecl from
1410   /// a CXXRecordDecl.
1411   ClassTemplateDecl *getDescribedClassTemplate() const;
1412
1413   void setDescribedClassTemplate(ClassTemplateDecl *Template);
1414
1415   /// Determine whether this particular class is a specialization or
1416   /// instantiation of a class template or member class of a class template,
1417   /// and how it was instantiated or specialized.
1418   TemplateSpecializationKind getTemplateSpecializationKind() const;
1419
1420   /// Set the kind of specialization or template instantiation this is.
1421   void setTemplateSpecializationKind(TemplateSpecializationKind TSK);
1422
1423   /// Retrieve the record declaration from which this record could be
1424   /// instantiated. Returns null if this class is not a template instantiation.
1425   const CXXRecordDecl *getTemplateInstantiationPattern() const;
1426
1427   CXXRecordDecl *getTemplateInstantiationPattern() {
1428     return const_cast<CXXRecordDecl *>(const_cast<const CXXRecordDecl *>(this)
1429                                            ->getTemplateInstantiationPattern());
1430   }
1431
1432   /// Returns the destructor decl for this class.
1433   CXXDestructorDecl *getDestructor() const;
1434
1435   /// Returns true if the class destructor, or any implicitly invoked
1436   /// destructors are marked noreturn.
1437   bool isAnyDestructorNoReturn() const;
1438
1439   /// If the class is a local class [class.local], returns
1440   /// the enclosing function declaration.
1441   const FunctionDecl *isLocalClass() const {
1442     if (const auto *RD = dyn_cast<CXXRecordDecl>(getDeclContext()))
1443       return RD->isLocalClass();
1444
1445     return dyn_cast<FunctionDecl>(getDeclContext());
1446   }
1447
1448   FunctionDecl *isLocalClass() {
1449     return const_cast<FunctionDecl*>(
1450         const_cast<const CXXRecordDecl*>(this)->isLocalClass());
1451   }
1452
1453   /// Determine whether this dependent class is a current instantiation,
1454   /// when viewed from within the given context.
1455   bool isCurrentInstantiation(const DeclContext *CurContext) const;
1456
1457   /// Determine whether this class is derived from the class \p Base.
1458   ///
1459   /// This routine only determines whether this class is derived from \p Base,
1460   /// but does not account for factors that may make a Derived -> Base class
1461   /// ill-formed, such as private/protected inheritance or multiple, ambiguous
1462   /// base class subobjects.
1463   ///
1464   /// \param Base the base class we are searching for.
1465   ///
1466   /// \returns true if this class is derived from Base, false otherwise.
1467   bool isDerivedFrom(const CXXRecordDecl *Base) const;
1468
1469   /// Determine whether this class is derived from the type \p Base.
1470   ///
1471   /// This routine only determines whether this class is derived from \p Base,
1472   /// but does not account for factors that may make a Derived -> Base class
1473   /// ill-formed, such as private/protected inheritance or multiple, ambiguous
1474   /// base class subobjects.
1475   ///
1476   /// \param Base the base class we are searching for.
1477   ///
1478   /// \param Paths will contain the paths taken from the current class to the
1479   /// given \p Base class.
1480   ///
1481   /// \returns true if this class is derived from \p Base, false otherwise.
1482   ///
1483   /// \todo add a separate parameter to configure IsDerivedFrom, rather than
1484   /// tangling input and output in \p Paths
1485   bool isDerivedFrom(const CXXRecordDecl *Base, CXXBasePaths &Paths) const;
1486
1487   /// Determine whether this class is virtually derived from
1488   /// the class \p Base.
1489   ///
1490   /// This routine only determines whether this class is virtually
1491   /// derived from \p Base, but does not account for factors that may
1492   /// make a Derived -> Base class ill-formed, such as
1493   /// private/protected inheritance or multiple, ambiguous base class
1494   /// subobjects.
1495   ///
1496   /// \param Base the base class we are searching for.
1497   ///
1498   /// \returns true if this class is virtually derived from Base,
1499   /// false otherwise.
1500   bool isVirtuallyDerivedFrom(const CXXRecordDecl *Base) const;
1501
1502   /// Determine whether this class is provably not derived from
1503   /// the type \p Base.
1504   bool isProvablyNotDerivedFrom(const CXXRecordDecl *Base) const;
1505
1506   /// Function type used by forallBases() as a callback.
1507   ///
1508   /// \param BaseDefinition the definition of the base class
1509   ///
1510   /// \returns true if this base matched the search criteria
1511   using ForallBasesCallback =
1512       llvm::function_ref<bool(const CXXRecordDecl *BaseDefinition)>;
1513
1514   /// Determines if the given callback holds for all the direct
1515   /// or indirect base classes of this type.
1516   ///
1517   /// The class itself does not count as a base class.  This routine
1518   /// returns false if the class has non-computable base classes.
1519   ///
1520   /// \param BaseMatches Callback invoked for each (direct or indirect) base
1521   /// class of this type until a call returns false.
1522   bool forallBases(ForallBasesCallback BaseMatches) const;
1523
1524   /// Function type used by lookupInBases() to determine whether a
1525   /// specific base class subobject matches the lookup criteria.
1526   ///
1527   /// \param Specifier the base-class specifier that describes the inheritance
1528   /// from the base class we are trying to match.
1529   ///
1530   /// \param Path the current path, from the most-derived class down to the
1531   /// base named by the \p Specifier.
1532   ///
1533   /// \returns true if this base matched the search criteria, false otherwise.
1534   using BaseMatchesCallback =
1535       llvm::function_ref<bool(const CXXBaseSpecifier *Specifier,
1536                               CXXBasePath &Path)>;
1537
1538   /// Look for entities within the base classes of this C++ class,
1539   /// transitively searching all base class subobjects.
1540   ///
1541   /// This routine uses the callback function \p BaseMatches to find base
1542   /// classes meeting some search criteria, walking all base class subobjects
1543   /// and populating the given \p Paths structure with the paths through the
1544   /// inheritance hierarchy that resulted in a match. On a successful search,
1545   /// the \p Paths structure can be queried to retrieve the matching paths and
1546   /// to determine if there were any ambiguities.
1547   ///
1548   /// \param BaseMatches callback function used to determine whether a given
1549   /// base matches the user-defined search criteria.
1550   ///
1551   /// \param Paths used to record the paths from this class to its base class
1552   /// subobjects that match the search criteria.
1553   ///
1554   /// \param LookupInDependent can be set to true to extend the search to
1555   /// dependent base classes.
1556   ///
1557   /// \returns true if there exists any path from this class to a base class
1558   /// subobject that matches the search criteria.
1559   bool lookupInBases(BaseMatchesCallback BaseMatches, CXXBasePaths &Paths,
1560                      bool LookupInDependent = false) const;
1561
1562   /// Base-class lookup callback that determines whether the given
1563   /// base class specifier refers to a specific class declaration.
1564   ///
1565   /// This callback can be used with \c lookupInBases() to determine whether
1566   /// a given derived class has is a base class subobject of a particular type.
1567   /// The base record pointer should refer to the canonical CXXRecordDecl of the
1568   /// base class that we are searching for.
1569   static bool FindBaseClass(const CXXBaseSpecifier *Specifier,
1570                             CXXBasePath &Path, const CXXRecordDecl *BaseRecord);
1571
1572   /// Base-class lookup callback that determines whether the
1573   /// given base class specifier refers to a specific class
1574   /// declaration and describes virtual derivation.
1575   ///
1576   /// This callback can be used with \c lookupInBases() to determine
1577   /// whether a given derived class has is a virtual base class
1578   /// subobject of a particular type.  The base record pointer should
1579   /// refer to the canonical CXXRecordDecl of the base class that we
1580   /// are searching for.
1581   static bool FindVirtualBaseClass(const CXXBaseSpecifier *Specifier,
1582                                    CXXBasePath &Path,
1583                                    const CXXRecordDecl *BaseRecord);
1584
1585   /// Base-class lookup callback that determines whether there exists
1586   /// a tag with the given name.
1587   ///
1588   /// This callback can be used with \c lookupInBases() to find tag members
1589   /// of the given name within a C++ class hierarchy.
1590   static bool FindTagMember(const CXXBaseSpecifier *Specifier,
1591                             CXXBasePath &Path, DeclarationName Name);
1592
1593   /// Base-class lookup callback that determines whether there exists
1594   /// a member with the given name.
1595   ///
1596   /// This callback can be used with \c lookupInBases() to find members
1597   /// of the given name within a C++ class hierarchy.
1598   static bool FindOrdinaryMember(const CXXBaseSpecifier *Specifier,
1599                                  CXXBasePath &Path, DeclarationName Name);
1600
1601   /// Base-class lookup callback that determines whether there exists
1602   /// a member with the given name.
1603   ///
1604   /// This callback can be used with \c lookupInBases() to find members
1605   /// of the given name within a C++ class hierarchy, including dependent
1606   /// classes.
1607   static bool
1608   FindOrdinaryMemberInDependentClasses(const CXXBaseSpecifier *Specifier,
1609                                        CXXBasePath &Path, DeclarationName Name);
1610
1611   /// Base-class lookup callback that determines whether there exists
1612   /// an OpenMP declare reduction member with the given name.
1613   ///
1614   /// This callback can be used with \c lookupInBases() to find members
1615   /// of the given name within a C++ class hierarchy.
1616   static bool FindOMPReductionMember(const CXXBaseSpecifier *Specifier,
1617                                      CXXBasePath &Path, DeclarationName Name);
1618
1619   /// Base-class lookup callback that determines whether there exists
1620   /// an OpenMP declare mapper member with the given name.
1621   ///
1622   /// This callback can be used with \c lookupInBases() to find members
1623   /// of the given name within a C++ class hierarchy.
1624   static bool FindOMPMapperMember(const CXXBaseSpecifier *Specifier,
1625                                   CXXBasePath &Path, DeclarationName Name);
1626
1627   /// Base-class lookup callback that determines whether there exists
1628   /// a member with the given name that can be used in a nested-name-specifier.
1629   ///
1630   /// This callback can be used with \c lookupInBases() to find members of
1631   /// the given name within a C++ class hierarchy that can occur within
1632   /// nested-name-specifiers.
1633   static bool FindNestedNameSpecifierMember(const CXXBaseSpecifier *Specifier,
1634                                             CXXBasePath &Path,
1635                                             DeclarationName Name);
1636
1637   /// Retrieve the final overriders for each virtual member
1638   /// function in the class hierarchy where this class is the
1639   /// most-derived class in the class hierarchy.
1640   void getFinalOverriders(CXXFinalOverriderMap &FinaOverriders) const;
1641
1642   /// Get the indirect primary bases for this class.
1643   void getIndirectPrimaryBases(CXXIndirectPrimaryBaseSet& Bases) const;
1644
1645   /// Performs an imprecise lookup of a dependent name in this class.
1646   ///
1647   /// This function does not follow strict semantic rules and should be used
1648   /// only when lookup rules can be relaxed, e.g. indexing.
1649   std::vector<const NamedDecl *>
1650   lookupDependentName(const DeclarationName &Name,
1651                       llvm::function_ref<bool(const NamedDecl *ND)> Filter);
1652
1653   /// Renders and displays an inheritance diagram
1654   /// for this C++ class and all of its base classes (transitively) using
1655   /// GraphViz.
1656   void viewInheritance(ASTContext& Context) const;
1657
1658   /// Calculates the access of a decl that is reached
1659   /// along a path.
1660   static AccessSpecifier MergeAccess(AccessSpecifier PathAccess,
1661                                      AccessSpecifier DeclAccess) {
1662     assert(DeclAccess != AS_none);
1663     if (DeclAccess == AS_private) return AS_none;
1664     return (PathAccess > DeclAccess ? PathAccess : DeclAccess);
1665   }
1666
1667   /// Indicates that the declaration of a defaulted or deleted special
1668   /// member function is now complete.
1669   void finishedDefaultedOrDeletedMember(CXXMethodDecl *MD);
1670
1671   void setTrivialForCallFlags(CXXMethodDecl *MD);
1672
1673   /// Indicates that the definition of this class is now complete.
1674   void completeDefinition() override;
1675
1676   /// Indicates that the definition of this class is now complete,
1677   /// and provides a final overrider map to help determine
1678   ///
1679   /// \param FinalOverriders The final overrider map for this class, which can
1680   /// be provided as an optimization for abstract-class checking. If NULL,
1681   /// final overriders will be computed if they are needed to complete the
1682   /// definition.
1683   void completeDefinition(CXXFinalOverriderMap *FinalOverriders);
1684
1685   /// Determine whether this class may end up being abstract, even though
1686   /// it is not yet known to be abstract.
1687   ///
1688   /// \returns true if this class is not known to be abstract but has any
1689   /// base classes that are abstract. In this case, \c completeDefinition()
1690   /// will need to compute final overriders to determine whether the class is
1691   /// actually abstract.
1692   bool mayBeAbstract() const;
1693
1694   /// Determine whether it's impossible for a class to be derived from this
1695   /// class. This is best-effort, and may conservatively return false.
1696   bool isEffectivelyFinal() const;
1697
1698   /// If this is the closure type of a lambda expression, retrieve the
1699   /// number to be used for name mangling in the Itanium C++ ABI.
1700   ///
1701   /// Zero indicates that this closure type has internal linkage, so the
1702   /// mangling number does not matter, while a non-zero value indicates which
1703   /// lambda expression this is in this particular context.
1704   unsigned getLambdaManglingNumber() const {
1705     assert(isLambda() && "Not a lambda closure type!");
1706     return getLambdaData().ManglingNumber;
1707   }
1708
1709   /// The lambda is known to has internal linkage no matter whether it has name
1710   /// mangling number.
1711   bool hasKnownLambdaInternalLinkage() const {
1712     assert(isLambda() && "Not a lambda closure type!");
1713     return getLambdaData().HasKnownInternalLinkage;
1714   }
1715
1716   /// Retrieve the declaration that provides additional context for a
1717   /// lambda, when the normal declaration context is not specific enough.
1718   ///
1719   /// Certain contexts (default arguments of in-class function parameters and
1720   /// the initializers of data members) have separate name mangling rules for
1721   /// lambdas within the Itanium C++ ABI. For these cases, this routine provides
1722   /// the declaration in which the lambda occurs, e.g., the function parameter
1723   /// or the non-static data member. Otherwise, it returns NULL to imply that
1724   /// the declaration context suffices.
1725   Decl *getLambdaContextDecl() const;
1726
1727   /// Set the mangling number and context declaration for a lambda
1728   /// class.
1729   void setLambdaMangling(unsigned ManglingNumber, Decl *ContextDecl,
1730                          bool HasKnownInternalLinkage = false) {
1731     assert(isLambda() && "Not a lambda closure type!");
1732     getLambdaData().ManglingNumber = ManglingNumber;
1733     getLambdaData().ContextDecl = ContextDecl;
1734     getLambdaData().HasKnownInternalLinkage = HasKnownInternalLinkage;
1735   }
1736
1737   /// Returns the inheritance model used for this record.
1738   MSInheritanceModel getMSInheritanceModel() const;
1739
1740   /// Calculate what the inheritance model would be for this class.
1741   MSInheritanceModel calculateInheritanceModel() const;
1742
1743   /// In the Microsoft C++ ABI, use zero for the field offset of a null data
1744   /// member pointer if we can guarantee that zero is not a valid field offset,
1745   /// or if the member pointer has multiple fields.  Polymorphic classes have a
1746   /// vfptr at offset zero, so we can use zero for null.  If there are multiple
1747   /// fields, we can use zero even if it is a valid field offset because
1748   /// null-ness testing will check the other fields.
1749   bool nullFieldOffsetIsZero() const;
1750
1751   /// Controls when vtordisps will be emitted if this record is used as a
1752   /// virtual base.
1753   MSVtorDispMode getMSVtorDispMode() const;
1754
1755   /// Determine whether this lambda expression was known to be dependent
1756   /// at the time it was created, even if its context does not appear to be
1757   /// dependent.
1758   ///
1759   /// This flag is a workaround for an issue with parsing, where default
1760   /// arguments are parsed before their enclosing function declarations have
1761   /// been created. This means that any lambda expressions within those
1762   /// default arguments will have as their DeclContext the context enclosing
1763   /// the function declaration, which may be non-dependent even when the
1764   /// function declaration itself is dependent. This flag indicates when we
1765   /// know that the lambda is dependent despite that.
1766   bool isDependentLambda() const {
1767     return isLambda() && getLambdaData().Dependent;
1768   }
1769
1770   TypeSourceInfo *getLambdaTypeInfo() const {
1771     return getLambdaData().MethodTyInfo;
1772   }
1773
1774   // Determine whether this type is an Interface Like type for
1775   // __interface inheritance purposes.
1776   bool isInterfaceLike() const;
1777
1778   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1779   static bool classofKind(Kind K) {
1780     return K >= firstCXXRecord && K <= lastCXXRecord;
1781   }
1782 };
1783
1784 /// Store information needed for an explicit specifier.
1785 /// Used by CXXDeductionGuideDecl, CXXConstructorDecl and CXXConversionDecl.
1786 class ExplicitSpecifier {
1787   llvm::PointerIntPair<Expr *, 2, ExplicitSpecKind> ExplicitSpec{
1788       nullptr, ExplicitSpecKind::ResolvedFalse};
1789
1790 public:
1791   ExplicitSpecifier() = default;
1792   ExplicitSpecifier(Expr *Expression, ExplicitSpecKind Kind)
1793       : ExplicitSpec(Expression, Kind) {}
1794   ExplicitSpecKind getKind() const { return ExplicitSpec.getInt(); }
1795   const Expr *getExpr() const { return ExplicitSpec.getPointer(); }
1796   Expr *getExpr() { return ExplicitSpec.getPointer(); }
1797
1798   /// Determine if the declaration had an explicit specifier of any kind.
1799   bool isSpecified() const {
1800     return ExplicitSpec.getInt() != ExplicitSpecKind::ResolvedFalse ||
1801            ExplicitSpec.getPointer();
1802   }
1803
1804   /// Check for equivalence of explicit specifiers.
1805   /// \return true if the explicit specifier are equivalent, false otherwise.
1806   bool isEquivalent(const ExplicitSpecifier Other) const;
1807   /// Determine whether this specifier is known to correspond to an explicit
1808   /// declaration. Returns false if the specifier is absent or has an
1809   /// expression that is value-dependent or evaluates to false.
1810   bool isExplicit() const {
1811     return ExplicitSpec.getInt() == ExplicitSpecKind::ResolvedTrue;
1812   }
1813   /// Determine if the explicit specifier is invalid.
1814   /// This state occurs after a substitution failures.
1815   bool isInvalid() const {
1816     return ExplicitSpec.getInt() == ExplicitSpecKind::Unresolved &&
1817            !ExplicitSpec.getPointer();
1818   }
1819   void setKind(ExplicitSpecKind Kind) { ExplicitSpec.setInt(Kind); }
1820   void setExpr(Expr *E) { ExplicitSpec.setPointer(E); }
1821   // Retrieve the explicit specifier in the given declaration, if any.
1822   static ExplicitSpecifier getFromDecl(FunctionDecl *Function);
1823   static const ExplicitSpecifier getFromDecl(const FunctionDecl *Function) {
1824     return getFromDecl(const_cast<FunctionDecl *>(Function));
1825   }
1826   static ExplicitSpecifier Invalid() {
1827     return ExplicitSpecifier(nullptr, ExplicitSpecKind::Unresolved);
1828   }
1829 };
1830
1831 /// Represents a C++ deduction guide declaration.
1832 ///
1833 /// \code
1834 /// template<typename T> struct A { A(); A(T); };
1835 /// A() -> A<int>;
1836 /// \endcode
1837 ///
1838 /// In this example, there will be an explicit deduction guide from the
1839 /// second line, and implicit deduction guide templates synthesized from
1840 /// the constructors of \c A.
1841 class CXXDeductionGuideDecl : public FunctionDecl {
1842   void anchor() override;
1843
1844 private:
1845   CXXDeductionGuideDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
1846                         ExplicitSpecifier ES,
1847                         const DeclarationNameInfo &NameInfo, QualType T,
1848                         TypeSourceInfo *TInfo, SourceLocation EndLocation)
1849       : FunctionDecl(CXXDeductionGuide, C, DC, StartLoc, NameInfo, T, TInfo,
1850                      SC_None, false, CSK_unspecified),
1851         ExplicitSpec(ES) {
1852     if (EndLocation.isValid())
1853       setRangeEnd(EndLocation);
1854     setIsCopyDeductionCandidate(false);
1855   }
1856
1857   ExplicitSpecifier ExplicitSpec;
1858   void setExplicitSpecifier(ExplicitSpecifier ES) { ExplicitSpec = ES; }
1859
1860 public:
1861   friend class ASTDeclReader;
1862   friend class ASTDeclWriter;
1863
1864   static CXXDeductionGuideDecl *
1865   Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
1866          ExplicitSpecifier ES, const DeclarationNameInfo &NameInfo, QualType T,
1867          TypeSourceInfo *TInfo, SourceLocation EndLocation);
1868
1869   static CXXDeductionGuideDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1870
1871   ExplicitSpecifier getExplicitSpecifier() { return ExplicitSpec; }
1872   const ExplicitSpecifier getExplicitSpecifier() const { return ExplicitSpec; }
1873
1874   /// Return true if the declartion is already resolved to be explicit.
1875   bool isExplicit() const { return ExplicitSpec.isExplicit(); }
1876
1877   /// Get the template for which this guide performs deduction.
1878   TemplateDecl *getDeducedTemplate() const {
1879     return getDeclName().getCXXDeductionGuideTemplate();
1880   }
1881
1882   void setIsCopyDeductionCandidate(bool isCDC = true) {
1883     FunctionDeclBits.IsCopyDeductionCandidate = isCDC;
1884   }
1885
1886   bool isCopyDeductionCandidate() const {
1887     return FunctionDeclBits.IsCopyDeductionCandidate;
1888   }
1889
1890   // Implement isa/cast/dyncast/etc.
1891   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1892   static bool classofKind(Kind K) { return K == CXXDeductionGuide; }
1893 };
1894
1895 /// \brief Represents the body of a requires-expression.
1896 ///
1897 /// This decl exists merely to serve as the DeclContext for the local
1898 /// parameters of the requires expression as well as other declarations inside
1899 /// it.
1900 ///
1901 /// \code
1902 /// template<typename T> requires requires (T t) { {t++} -> regular; }
1903 /// \endcode
1904 ///
1905 /// In this example, a RequiresExpr object will be generated for the expression,
1906 /// and a RequiresExprBodyDecl will be created to hold the parameter t and the
1907 /// template argument list imposed by the compound requirement.
1908 class RequiresExprBodyDecl : public Decl, public DeclContext {
1909   RequiresExprBodyDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc)
1910       : Decl(RequiresExprBody, DC, StartLoc), DeclContext(RequiresExprBody) {}
1911
1912 public:
1913   friend class ASTDeclReader;
1914   friend class ASTDeclWriter;
1915
1916   static RequiresExprBodyDecl *Create(ASTContext &C, DeclContext *DC,
1917                                       SourceLocation StartLoc);
1918
1919   static RequiresExprBodyDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1920
1921   // Implement isa/cast/dyncast/etc.
1922   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
1923   static bool classofKind(Kind K) { return K == RequiresExprBody; }
1924 };
1925
1926 /// Represents a static or instance method of a struct/union/class.
1927 ///
1928 /// In the terminology of the C++ Standard, these are the (static and
1929 /// non-static) member functions, whether virtual or not.
1930 class CXXMethodDecl : public FunctionDecl {
1931   void anchor() override;
1932
1933 protected:
1934   CXXMethodDecl(Kind DK, ASTContext &C, CXXRecordDecl *RD,
1935                 SourceLocation StartLoc, const DeclarationNameInfo &NameInfo,
1936                 QualType T, TypeSourceInfo *TInfo, StorageClass SC,
1937                 bool isInline, ConstexprSpecKind ConstexprKind,
1938                 SourceLocation EndLocation,
1939                 Expr *TrailingRequiresClause = nullptr)
1940       : FunctionDecl(DK, C, RD, StartLoc, NameInfo, T, TInfo, SC, isInline,
1941                      ConstexprKind, TrailingRequiresClause) {
1942     if (EndLocation.isValid())
1943       setRangeEnd(EndLocation);
1944   }
1945
1946 public:
1947   static CXXMethodDecl *Create(ASTContext &C, CXXRecordDecl *RD,
1948                                SourceLocation StartLoc,
1949                                const DeclarationNameInfo &NameInfo, QualType T,
1950                                TypeSourceInfo *TInfo, StorageClass SC,
1951                                bool isInline, ConstexprSpecKind ConstexprKind,
1952                                SourceLocation EndLocation,
1953                                Expr *TrailingRequiresClause = nullptr);
1954
1955   static CXXMethodDecl *CreateDeserialized(ASTContext &C, unsigned ID);
1956
1957   bool isStatic() const;
1958   bool isInstance() const { return !isStatic(); }
1959
1960   /// Returns true if the given operator is implicitly static in a record
1961   /// context.
1962   static bool isStaticOverloadedOperator(OverloadedOperatorKind OOK) {
1963     // [class.free]p1:
1964     // Any allocation function for a class T is a static member
1965     // (even if not explicitly declared static).
1966     // [class.free]p6 Any deallocation function for a class X is a static member
1967     // (even if not explicitly declared static).
1968     return OOK == OO_New || OOK == OO_Array_New || OOK == OO_Delete ||
1969            OOK == OO_Array_Delete;
1970   }
1971
1972   bool isConst() const { return getType()->castAs<FunctionType>()->isConst(); }
1973   bool isVolatile() const { return getType()->castAs<FunctionType>()->isVolatile(); }
1974
1975   bool isVirtual() const {
1976     CXXMethodDecl *CD = const_cast<CXXMethodDecl*>(this)->getCanonicalDecl();
1977
1978     // Member function is virtual if it is marked explicitly so, or if it is
1979     // declared in __interface -- then it is automatically pure virtual.
1980     if (CD->isVirtualAsWritten() || CD->isPure())
1981       return true;
1982
1983     return CD->size_overridden_methods() != 0;
1984   }
1985
1986   /// If it's possible to devirtualize a call to this method, return the called
1987   /// function. Otherwise, return null.
1988
1989   /// \param Base The object on which this virtual function is called.
1990   /// \param IsAppleKext True if we are compiling for Apple kext.
1991   CXXMethodDecl *getDevirtualizedMethod(const Expr *Base, bool IsAppleKext);
1992
1993   const CXXMethodDecl *getDevirtualizedMethod(const Expr *Base,
1994                                               bool IsAppleKext) const {
1995     return const_cast<CXXMethodDecl *>(this)->getDevirtualizedMethod(
1996         Base, IsAppleKext);
1997   }
1998
1999   /// Determine whether this is a usual deallocation function (C++
2000   /// [basic.stc.dynamic.deallocation]p2), which is an overloaded delete or
2001   /// delete[] operator with a particular signature. Populates \p PreventedBy
2002   /// with the declarations of the functions of the same kind if they were the
2003   /// reason for this function returning false. This is used by
2004   /// Sema::isUsualDeallocationFunction to reconsider the answer based on the
2005   /// context.
2006   bool isUsualDeallocationFunction(
2007       SmallVectorImpl<const FunctionDecl *> &PreventedBy) const;
2008
2009   /// Determine whether this is a copy-assignment operator, regardless
2010   /// of whether it was declared implicitly or explicitly.
2011   bool isCopyAssignmentOperator() const;
2012
2013   /// Determine whether this is a move assignment operator.
2014   bool isMoveAssignmentOperator() const;
2015
2016   CXXMethodDecl *getCanonicalDecl() override {
2017     return cast<CXXMethodDecl>(FunctionDecl::getCanonicalDecl());
2018   }
2019   const CXXMethodDecl *getCanonicalDecl() const {
2020     return const_cast<CXXMethodDecl*>(this)->getCanonicalDecl();
2021   }
2022
2023   CXXMethodDecl *getMostRecentDecl() {
2024     return cast<CXXMethodDecl>(
2025             static_cast<FunctionDecl *>(this)->getMostRecentDecl());
2026   }
2027   const CXXMethodDecl *getMostRecentDecl() const {
2028     return const_cast<CXXMethodDecl*>(this)->getMostRecentDecl();
2029   }
2030
2031   void addOverriddenMethod(const CXXMethodDecl *MD);
2032
2033   using method_iterator = const CXXMethodDecl *const *;
2034
2035   method_iterator begin_overridden_methods() const;
2036   method_iterator end_overridden_methods() const;
2037   unsigned size_overridden_methods() const;
2038
2039   using overridden_method_range = llvm::iterator_range<
2040       llvm::TinyPtrVector<const CXXMethodDecl *>::const_iterator>;
2041
2042   overridden_method_range overridden_methods() const;
2043
2044   /// Return the parent of this method declaration, which
2045   /// is the class in which this method is defined.
2046   const CXXRecordDecl *getParent() const {
2047     return cast<CXXRecordDecl>(FunctionDecl::getParent());
2048   }
2049
2050   /// Return the parent of this method declaration, which
2051   /// is the class in which this method is defined.
2052   CXXRecordDecl *getParent() {
2053     return const_cast<CXXRecordDecl *>(
2054              cast<CXXRecordDecl>(FunctionDecl::getParent()));
2055   }
2056
2057   /// Return the type of the \c this pointer.
2058   ///
2059   /// Should only be called for instance (i.e., non-static) methods. Note
2060   /// that for the call operator of a lambda closure type, this returns the
2061   /// desugared 'this' type (a pointer to the closure type), not the captured
2062   /// 'this' type.
2063   QualType getThisType() const;
2064
2065   /// Return the type of the object pointed by \c this.
2066   ///
2067   /// See getThisType() for usage restriction.
2068   QualType getThisObjectType() const;
2069
2070   static QualType getThisType(const FunctionProtoType *FPT,
2071                               const CXXRecordDecl *Decl);
2072
2073   static QualType getThisObjectType(const FunctionProtoType *FPT,
2074                                     const CXXRecordDecl *Decl);
2075
2076   Qualifiers getMethodQualifiers() const {
2077     return getType()->castAs<FunctionProtoType>()->getMethodQuals();
2078   }
2079
2080   /// Retrieve the ref-qualifier associated with this method.
2081   ///
2082   /// In the following example, \c f() has an lvalue ref-qualifier, \c g()
2083   /// has an rvalue ref-qualifier, and \c h() has no ref-qualifier.
2084   /// @code
2085   /// struct X {
2086   ///   void f() &;
2087   ///   void g() &&;
2088   ///   void h();
2089   /// };
2090   /// @endcode
2091   RefQualifierKind getRefQualifier() const {
2092     return getType()->castAs<FunctionProtoType>()->getRefQualifier();
2093   }
2094
2095   bool hasInlineBody() const;
2096
2097   /// Determine whether this is a lambda closure type's static member
2098   /// function that is used for the result of the lambda's conversion to
2099   /// function pointer (for a lambda with no captures).
2100   ///
2101   /// The function itself, if used, will have a placeholder body that will be
2102   /// supplied by IR generation to either forward to the function call operator
2103   /// or clone the function call operator.
2104   bool isLambdaStaticInvoker() const;
2105
2106   /// Find the method in \p RD that corresponds to this one.
2107   ///
2108   /// Find if \p RD or one of the classes it inherits from override this method.
2109   /// If so, return it. \p RD is assumed to be a subclass of the class defining
2110   /// this method (or be the class itself), unless \p MayBeBase is set to true.
2111   CXXMethodDecl *
2112   getCorrespondingMethodInClass(const CXXRecordDecl *RD,
2113                                 bool MayBeBase = false);
2114
2115   const CXXMethodDecl *
2116   getCorrespondingMethodInClass(const CXXRecordDecl *RD,
2117                                 bool MayBeBase = false) const {
2118     return const_cast<CXXMethodDecl *>(this)
2119               ->getCorrespondingMethodInClass(RD, MayBeBase);
2120   }
2121
2122   /// Find if \p RD declares a function that overrides this function, and if so,
2123   /// return it. Does not search base classes.
2124   CXXMethodDecl *getCorrespondingMethodDeclaredInClass(const CXXRecordDecl *RD,
2125                                                        bool MayBeBase = false);
2126   const CXXMethodDecl *
2127   getCorrespondingMethodDeclaredInClass(const CXXRecordDecl *RD,
2128                                         bool MayBeBase = false) const {
2129     return const_cast<CXXMethodDecl *>(this)
2130         ->getCorrespondingMethodDeclaredInClass(RD, MayBeBase);
2131   }
2132
2133   // Implement isa/cast/dyncast/etc.
2134   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2135   static bool classofKind(Kind K) {
2136     return K >= firstCXXMethod && K <= lastCXXMethod;
2137   }
2138 };
2139
2140 /// Represents a C++ base or member initializer.
2141 ///
2142 /// This is part of a constructor initializer that
2143 /// initializes one non-static member variable or one base class. For
2144 /// example, in the following, both 'A(a)' and 'f(3.14159)' are member
2145 /// initializers:
2146 ///
2147 /// \code
2148 /// class A { };
2149 /// class B : public A {
2150 ///   float f;
2151 /// public:
2152 ///   B(A& a) : A(a), f(3.14159) { }
2153 /// };
2154 /// \endcode
2155 class CXXCtorInitializer final {
2156   /// Either the base class name/delegating constructor type (stored as
2157   /// a TypeSourceInfo*), an normal field (FieldDecl), or an anonymous field
2158   /// (IndirectFieldDecl*) being initialized.
2159   llvm::PointerUnion<TypeSourceInfo *, FieldDecl *, IndirectFieldDecl *>
2160       Initializee;
2161
2162   /// The source location for the field name or, for a base initializer
2163   /// pack expansion, the location of the ellipsis.
2164   ///
2165   /// In the case of a delegating
2166   /// constructor, it will still include the type's source location as the
2167   /// Initializee points to the CXXConstructorDecl (to allow loop detection).
2168   SourceLocation MemberOrEllipsisLocation;
2169
2170   /// The argument used to initialize the base or member, which may
2171   /// end up constructing an object (when multiple arguments are involved).
2172   Stmt *Init;
2173
2174   /// Location of the left paren of the ctor-initializer.
2175   SourceLocation LParenLoc;
2176
2177   /// Location of the right paren of the ctor-initializer.
2178   SourceLocation RParenLoc;
2179
2180   /// If the initializee is a type, whether that type makes this
2181   /// a delegating initialization.
2182   unsigned IsDelegating : 1;
2183
2184   /// If the initializer is a base initializer, this keeps track
2185   /// of whether the base is virtual or not.
2186   unsigned IsVirtual : 1;
2187
2188   /// Whether or not the initializer is explicitly written
2189   /// in the sources.
2190   unsigned IsWritten : 1;
2191
2192   /// If IsWritten is true, then this number keeps track of the textual order
2193   /// of this initializer in the original sources, counting from 0.
2194   unsigned SourceOrder : 13;
2195
2196 public:
2197   /// Creates a new base-class initializer.
2198   explicit
2199   CXXCtorInitializer(ASTContext &Context, TypeSourceInfo *TInfo, bool IsVirtual,
2200                      SourceLocation L, Expr *Init, SourceLocation R,
2201                      SourceLocation EllipsisLoc);
2202
2203   /// Creates a new member initializer.
2204   explicit
2205   CXXCtorInitializer(ASTContext &Context, FieldDecl *Member,
2206                      SourceLocation MemberLoc, SourceLocation L, Expr *Init,
2207                      SourceLocation R);
2208
2209   /// Creates a new anonymous field initializer.
2210   explicit
2211   CXXCtorInitializer(ASTContext &Context, IndirectFieldDecl *Member,
2212                      SourceLocation MemberLoc, SourceLocation L, Expr *Init,
2213                      SourceLocation R);
2214
2215   /// Creates a new delegating initializer.
2216   explicit
2217   CXXCtorInitializer(ASTContext &Context, TypeSourceInfo *TInfo,
2218                      SourceLocation L, Expr *Init, SourceLocation R);
2219
2220   /// \return Unique reproducible object identifier.
2221   int64_t getID(const ASTContext &Context) const;
2222
2223   /// Determine whether this initializer is initializing a base class.
2224   bool isBaseInitializer() const {
2225     return Initializee.is<TypeSourceInfo*>() && !IsDelegating;
2226   }
2227
2228   /// Determine whether this initializer is initializing a non-static
2229   /// data member.
2230   bool isMemberInitializer() const { return Initializee.is<FieldDecl*>(); }
2231
2232   bool isAnyMemberInitializer() const {
2233     return isMemberInitializer() || isIndirectMemberInitializer();
2234   }
2235
2236   bool isIndirectMemberInitializer() const {
2237     return Initializee.is<IndirectFieldDecl*>();
2238   }
2239
2240   /// Determine whether this initializer is an implicit initializer
2241   /// generated for a field with an initializer defined on the member
2242   /// declaration.
2243   ///
2244   /// In-class member initializers (also known as "non-static data member
2245   /// initializations", NSDMIs) were introduced in C++11.
2246   bool isInClassMemberInitializer() const {
2247     return Init->getStmtClass() == Stmt::CXXDefaultInitExprClass;
2248   }
2249
2250   /// Determine whether this initializer is creating a delegating
2251   /// constructor.
2252   bool isDelegatingInitializer() const {
2253     return Initializee.is<TypeSourceInfo*>() && IsDelegating;
2254   }
2255
2256   /// Determine whether this initializer is a pack expansion.
2257   bool isPackExpansion() const {
2258     return isBaseInitializer() && MemberOrEllipsisLocation.isValid();
2259   }
2260
2261   // For a pack expansion, returns the location of the ellipsis.
2262   SourceLocation getEllipsisLoc() const {
2263     assert(isPackExpansion() && "Initializer is not a pack expansion");
2264     return MemberOrEllipsisLocation;
2265   }
2266
2267   /// If this is a base class initializer, returns the type of the
2268   /// base class with location information. Otherwise, returns an NULL
2269   /// type location.
2270   TypeLoc getBaseClassLoc() const;
2271
2272   /// If this is a base class initializer, returns the type of the base class.
2273   /// Otherwise, returns null.
2274   const Type *getBaseClass() const;
2275
2276   /// Returns whether the base is virtual or not.
2277   bool isBaseVirtual() const {
2278     assert(isBaseInitializer() && "Must call this on base initializer!");
2279
2280     return IsVirtual;
2281   }
2282
2283   /// Returns the declarator information for a base class or delegating
2284   /// initializer.
2285   TypeSourceInfo *getTypeSourceInfo() const {
2286     return Initializee.dyn_cast<TypeSourceInfo *>();
2287   }
2288
2289   /// If this is a member initializer, returns the declaration of the
2290   /// non-static data member being initialized. Otherwise, returns null.
2291   FieldDecl *getMember() const {
2292     if (isMemberInitializer())
2293       return Initializee.get<FieldDecl*>();
2294     return nullptr;
2295   }
2296
2297   FieldDecl *getAnyMember() const {
2298     if (isMemberInitializer())
2299       return Initializee.get<FieldDecl*>();
2300     if (isIndirectMemberInitializer())
2301       return Initializee.get<IndirectFieldDecl*>()->getAnonField();
2302     return nullptr;
2303   }
2304
2305   IndirectFieldDecl *getIndirectMember() const {
2306     if (isIndirectMemberInitializer())
2307       return Initializee.get<IndirectFieldDecl*>();
2308     return nullptr;
2309   }
2310
2311   SourceLocation getMemberLocation() const {
2312     return MemberOrEllipsisLocation;
2313   }
2314
2315   /// Determine the source location of the initializer.
2316   SourceLocation getSourceLocation() const;
2317
2318   /// Determine the source range covering the entire initializer.
2319   SourceRange getSourceRange() const LLVM_READONLY;
2320
2321   /// Determine whether this initializer is explicitly written
2322   /// in the source code.
2323   bool isWritten() const { return IsWritten; }
2324
2325   /// Return the source position of the initializer, counting from 0.
2326   /// If the initializer was implicit, -1 is returned.
2327   int getSourceOrder() const {
2328     return IsWritten ? static_cast<int>(SourceOrder) : -1;
2329   }
2330
2331   /// Set the source order of this initializer.
2332   ///
2333   /// This can only be called once for each initializer; it cannot be called
2334   /// on an initializer having a positive number of (implicit) array indices.
2335   ///
2336   /// This assumes that the initializer was written in the source code, and
2337   /// ensures that isWritten() returns true.
2338   void setSourceOrder(int Pos) {
2339     assert(!IsWritten &&
2340            "setSourceOrder() used on implicit initializer");
2341     assert(SourceOrder == 0 &&
2342            "calling twice setSourceOrder() on the same initializer");
2343     assert(Pos >= 0 &&
2344            "setSourceOrder() used to make an initializer implicit");
2345     IsWritten = true;
2346     SourceOrder = static_cast<unsigned>(Pos);
2347   }
2348
2349   SourceLocation getLParenLoc() const { return LParenLoc; }
2350   SourceLocation getRParenLoc() const { return RParenLoc; }
2351
2352   /// Get the initializer.
2353   Expr *getInit() const { return static_cast<Expr *>(Init); }
2354 };
2355
2356 /// Description of a constructor that was inherited from a base class.
2357 class InheritedConstructor {
2358   ConstructorUsingShadowDecl *Shadow = nullptr;
2359   CXXConstructorDecl *BaseCtor = nullptr;
2360
2361 public:
2362   InheritedConstructor() = default;
2363   InheritedConstructor(ConstructorUsingShadowDecl *Shadow,
2364                        CXXConstructorDecl *BaseCtor)
2365       : Shadow(Shadow), BaseCtor(BaseCtor) {}
2366
2367   explicit operator bool() const { return Shadow; }
2368
2369   ConstructorUsingShadowDecl *getShadowDecl() const { return Shadow; }
2370   CXXConstructorDecl *getConstructor() const { return BaseCtor; }
2371 };
2372
2373 /// Represents a C++ constructor within a class.
2374 ///
2375 /// For example:
2376 ///
2377 /// \code
2378 /// class X {
2379 /// public:
2380 ///   explicit X(int); // represented by a CXXConstructorDecl.
2381 /// };
2382 /// \endcode
2383 class CXXConstructorDecl final
2384     : public CXXMethodDecl,
2385       private llvm::TrailingObjects<CXXConstructorDecl, InheritedConstructor,
2386                                     ExplicitSpecifier> {
2387   // This class stores some data in DeclContext::CXXConstructorDeclBits
2388   // to save some space. Use the provided accessors to access it.
2389
2390   /// \name Support for base and member initializers.
2391   /// \{
2392   /// The arguments used to initialize the base or member.
2393   LazyCXXCtorInitializersPtr CtorInitializers;
2394
2395   CXXConstructorDecl(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
2396                      const DeclarationNameInfo &NameInfo, QualType T,
2397                      TypeSourceInfo *TInfo, ExplicitSpecifier ES, bool isInline,
2398                      bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind,
2399                      InheritedConstructor Inherited,
2400                      Expr *TrailingRequiresClause);
2401
2402   void anchor() override;
2403
2404   size_t numTrailingObjects(OverloadToken<InheritedConstructor>) const {
2405     return CXXConstructorDeclBits.IsInheritingConstructor;
2406   }
2407   size_t numTrailingObjects(OverloadToken<ExplicitSpecifier>) const {
2408     return CXXConstructorDeclBits.HasTrailingExplicitSpecifier;
2409   }
2410
2411   ExplicitSpecifier getExplicitSpecifierInternal() const {
2412     if (CXXConstructorDeclBits.HasTrailingExplicitSpecifier)
2413       return *getTrailingObjects<ExplicitSpecifier>();
2414     return ExplicitSpecifier(
2415         nullptr, CXXConstructorDeclBits.IsSimpleExplicit
2416                      ? ExplicitSpecKind::ResolvedTrue
2417                      : ExplicitSpecKind::ResolvedFalse);
2418   }
2419
2420   enum TraillingAllocKind {
2421     TAKInheritsConstructor = 1,
2422     TAKHasTailExplicit = 1 << 1,
2423   };
2424
2425   uint64_t getTraillingAllocKind() const {
2426     return numTrailingObjects(OverloadToken<InheritedConstructor>()) |
2427            (numTrailingObjects(OverloadToken<ExplicitSpecifier>()) << 1);
2428   }
2429
2430 public:
2431   friend class ASTDeclReader;
2432   friend class ASTDeclWriter;
2433   friend TrailingObjects;
2434
2435   static CXXConstructorDecl *CreateDeserialized(ASTContext &C, unsigned ID,
2436                                                 uint64_t AllocKind);
2437   static CXXConstructorDecl *
2438   Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
2439          const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
2440          ExplicitSpecifier ES, bool isInline, bool isImplicitlyDeclared,
2441          ConstexprSpecKind ConstexprKind,
2442          InheritedConstructor Inherited = InheritedConstructor(),
2443          Expr *TrailingRequiresClause = nullptr);
2444
2445   void setExplicitSpecifier(ExplicitSpecifier ES) {
2446     assert((!ES.getExpr() ||
2447             CXXConstructorDeclBits.HasTrailingExplicitSpecifier) &&
2448            "cannot set this explicit specifier. no trail-allocated space for "
2449            "explicit");
2450     if (ES.getExpr())
2451       *getCanonicalDecl()->getTrailingObjects<ExplicitSpecifier>() = ES;
2452     else
2453       CXXConstructorDeclBits.IsSimpleExplicit = ES.isExplicit();
2454   }
2455
2456   ExplicitSpecifier getExplicitSpecifier() {
2457     return getCanonicalDecl()->getExplicitSpecifierInternal();
2458   }
2459   const ExplicitSpecifier getExplicitSpecifier() const {
2460     return getCanonicalDecl()->getExplicitSpecifierInternal();
2461   }
2462
2463   /// Return true if the declartion is already resolved to be explicit.
2464   bool isExplicit() const { return getExplicitSpecifier().isExplicit(); }
2465
2466   /// Iterates through the member/base initializer list.
2467   using init_iterator = CXXCtorInitializer **;
2468
2469   /// Iterates through the member/base initializer list.
2470   using init_const_iterator = CXXCtorInitializer *const *;
2471
2472   using init_range = llvm::iterator_range<init_iterator>;
2473   using init_const_range = llvm::iterator_range<init_const_iterator>;
2474
2475   init_range inits() { return init_range(init_begin(), init_end()); }
2476   init_const_range inits() const {
2477     return init_const_range(init_begin(), init_end());
2478   }
2479
2480   /// Retrieve an iterator to the first initializer.
2481   init_iterator init_begin() {
2482     const auto *ConstThis = this;
2483     return const_cast<init_iterator>(ConstThis->init_begin());
2484   }
2485
2486   /// Retrieve an iterator to the first initializer.
2487   init_const_iterator init_begin() const;
2488
2489   /// Retrieve an iterator past the last initializer.
2490   init_iterator       init_end()       {
2491     return init_begin() + getNumCtorInitializers();
2492   }
2493
2494   /// Retrieve an iterator past the last initializer.
2495   init_const_iterator init_end() const {
2496     return init_begin() + getNumCtorInitializers();
2497   }
2498
2499   using init_reverse_iterator = std::reverse_iterator<init_iterator>;
2500   using init_const_reverse_iterator =
2501       std::reverse_iterator<init_const_iterator>;
2502
2503   init_reverse_iterator init_rbegin() {
2504     return init_reverse_iterator(init_end());
2505   }
2506   init_const_reverse_iterator init_rbegin() const {
2507     return init_const_reverse_iterator(init_end());
2508   }
2509
2510   init_reverse_iterator init_rend() {
2511     return init_reverse_iterator(init_begin());
2512   }
2513   init_const_reverse_iterator init_rend() const {
2514     return init_const_reverse_iterator(init_begin());
2515   }
2516
2517   /// Determine the number of arguments used to initialize the member
2518   /// or base.
2519   unsigned getNumCtorInitializers() const {
2520       return CXXConstructorDeclBits.NumCtorInitializers;
2521   }
2522
2523   void setNumCtorInitializers(unsigned numCtorInitializers) {
2524     CXXConstructorDeclBits.NumCtorInitializers = numCtorInitializers;
2525     // This assert added because NumCtorInitializers is stored
2526     // in CXXConstructorDeclBits as a bitfield and its width has
2527     // been shrunk from 32 bits to fit into CXXConstructorDeclBitfields.
2528     assert(CXXConstructorDeclBits.NumCtorInitializers ==
2529            numCtorInitializers && "NumCtorInitializers overflow!");
2530   }
2531
2532   void setCtorInitializers(CXXCtorInitializer **Initializers) {
2533     CtorInitializers = Initializers;
2534   }
2535
2536   /// Determine whether this constructor is a delegating constructor.
2537   bool isDelegatingConstructor() const {
2538     return (getNumCtorInitializers() == 1) &&
2539            init_begin()[0]->isDelegatingInitializer();
2540   }
2541
2542   /// When this constructor delegates to another, retrieve the target.
2543   CXXConstructorDecl *getTargetConstructor() const;
2544
2545   /// Whether this constructor is a default
2546   /// constructor (C++ [class.ctor]p5), which can be used to
2547   /// default-initialize a class of this type.
2548   bool isDefaultConstructor() const;
2549
2550   /// Whether this constructor is a copy constructor (C++ [class.copy]p2,
2551   /// which can be used to copy the class.
2552   ///
2553   /// \p TypeQuals will be set to the qualifiers on the
2554   /// argument type. For example, \p TypeQuals would be set to \c
2555   /// Qualifiers::Const for the following copy constructor:
2556   ///
2557   /// \code
2558   /// class X {
2559   /// public:
2560   ///   X(const X&);
2561   /// };
2562   /// \endcode
2563   bool isCopyConstructor(unsigned &TypeQuals) const;
2564
2565   /// Whether this constructor is a copy
2566   /// constructor (C++ [class.copy]p2, which can be used to copy the
2567   /// class.
2568   bool isCopyConstructor() const {
2569     unsigned TypeQuals = 0;
2570     return isCopyConstructor(TypeQuals);
2571   }
2572
2573   /// Determine whether this constructor is a move constructor
2574   /// (C++11 [class.copy]p3), which can be used to move values of the class.
2575   ///
2576   /// \param TypeQuals If this constructor is a move constructor, will be set
2577   /// to the type qualifiers on the referent of the first parameter's type.
2578   bool isMoveConstructor(unsigned &TypeQuals) const;
2579
2580   /// Determine whether this constructor is a move constructor
2581   /// (C++11 [class.copy]p3), which can be used to move values of the class.
2582   bool isMoveConstructor() const {
2583     unsigned TypeQuals = 0;
2584     return isMoveConstructor(TypeQuals);
2585   }
2586
2587   /// Determine whether this is a copy or move constructor.
2588   ///
2589   /// \param TypeQuals Will be set to the type qualifiers on the reference
2590   /// parameter, if in fact this is a copy or move constructor.
2591   bool isCopyOrMoveConstructor(unsigned &TypeQuals) const;
2592
2593   /// Determine whether this a copy or move constructor.
2594   bool isCopyOrMoveConstructor() const {
2595     unsigned Quals;
2596     return isCopyOrMoveConstructor(Quals);
2597   }
2598
2599   /// Whether this constructor is a
2600   /// converting constructor (C++ [class.conv.ctor]), which can be
2601   /// used for user-defined conversions.
2602   bool isConvertingConstructor(bool AllowExplicit) const;
2603
2604   /// Determine whether this is a member template specialization that
2605   /// would copy the object to itself. Such constructors are never used to copy
2606   /// an object.
2607   bool isSpecializationCopyingObject() const;
2608
2609   /// Determine whether this is an implicit constructor synthesized to
2610   /// model a call to a constructor inherited from a base class.
2611   bool isInheritingConstructor() const {
2612     return CXXConstructorDeclBits.IsInheritingConstructor;
2613   }
2614
2615   /// State that this is an implicit constructor synthesized to
2616   /// model a call to a constructor inherited from a base class.
2617   void setInheritingConstructor(bool isIC = true) {
2618     CXXConstructorDeclBits.IsInheritingConstructor = isIC;
2619   }
2620
2621   /// Get the constructor that this inheriting constructor is based on.
2622   InheritedConstructor getInheritedConstructor() const {
2623     return isInheritingConstructor() ?
2624       *getTrailingObjects<InheritedConstructor>() : InheritedConstructor();
2625   }
2626
2627   CXXConstructorDecl *getCanonicalDecl() override {
2628     return cast<CXXConstructorDecl>(FunctionDecl::getCanonicalDecl());
2629   }
2630   const CXXConstructorDecl *getCanonicalDecl() const {
2631     return const_cast<CXXConstructorDecl*>(this)->getCanonicalDecl();
2632   }
2633
2634   // Implement isa/cast/dyncast/etc.
2635   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2636   static bool classofKind(Kind K) { return K == CXXConstructor; }
2637 };
2638
2639 /// Represents a C++ destructor within a class.
2640 ///
2641 /// For example:
2642 ///
2643 /// \code
2644 /// class X {
2645 /// public:
2646 ///   ~X(); // represented by a CXXDestructorDecl.
2647 /// };
2648 /// \endcode
2649 class CXXDestructorDecl : public CXXMethodDecl {
2650   friend class ASTDeclReader;
2651   friend class ASTDeclWriter;
2652
2653   // FIXME: Don't allocate storage for these except in the first declaration
2654   // of a virtual destructor.
2655   FunctionDecl *OperatorDelete = nullptr;
2656   Expr *OperatorDeleteThisArg = nullptr;
2657
2658   CXXDestructorDecl(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
2659                     const DeclarationNameInfo &NameInfo, QualType T,
2660                     TypeSourceInfo *TInfo, bool isInline,
2661                     bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind,
2662                     Expr *TrailingRequiresClause = nullptr)
2663       : CXXMethodDecl(CXXDestructor, C, RD, StartLoc, NameInfo, T, TInfo,
2664                       SC_None, isInline, ConstexprKind, SourceLocation(),
2665                       TrailingRequiresClause) {
2666     setImplicit(isImplicitlyDeclared);
2667   }
2668
2669   void anchor() override;
2670
2671 public:
2672   static CXXDestructorDecl *Create(ASTContext &C, CXXRecordDecl *RD,
2673                                    SourceLocation StartLoc,
2674                                    const DeclarationNameInfo &NameInfo,
2675                                    QualType T, TypeSourceInfo *TInfo,
2676                                    bool isInline, bool isImplicitlyDeclared,
2677                                    ConstexprSpecKind ConstexprKind,
2678                                    Expr *TrailingRequiresClause = nullptr);
2679   static CXXDestructorDecl *CreateDeserialized(ASTContext & C, unsigned ID);
2680
2681   void setOperatorDelete(FunctionDecl *OD, Expr *ThisArg);
2682
2683   const FunctionDecl *getOperatorDelete() const {
2684     return getCanonicalDecl()->OperatorDelete;
2685   }
2686
2687   Expr *getOperatorDeleteThisArg() const {
2688     return getCanonicalDecl()->OperatorDeleteThisArg;
2689   }
2690
2691   CXXDestructorDecl *getCanonicalDecl() override {
2692     return cast<CXXDestructorDecl>(FunctionDecl::getCanonicalDecl());
2693   }
2694   const CXXDestructorDecl *getCanonicalDecl() const {
2695     return const_cast<CXXDestructorDecl*>(this)->getCanonicalDecl();
2696   }
2697
2698   // Implement isa/cast/dyncast/etc.
2699   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2700   static bool classofKind(Kind K) { return K == CXXDestructor; }
2701 };
2702
2703 /// Represents a C++ conversion function within a class.
2704 ///
2705 /// For example:
2706 ///
2707 /// \code
2708 /// class X {
2709 /// public:
2710 ///   operator bool();
2711 /// };
2712 /// \endcode
2713 class CXXConversionDecl : public CXXMethodDecl {
2714   CXXConversionDecl(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
2715                     const DeclarationNameInfo &NameInfo, QualType T,
2716                     TypeSourceInfo *TInfo, bool isInline, ExplicitSpecifier ES,
2717                     ConstexprSpecKind ConstexprKind, SourceLocation EndLocation,
2718                     Expr *TrailingRequiresClause = nullptr)
2719       : CXXMethodDecl(CXXConversion, C, RD, StartLoc, NameInfo, T, TInfo,
2720                       SC_None, isInline, ConstexprKind, EndLocation,
2721                       TrailingRequiresClause),
2722         ExplicitSpec(ES) {}
2723   void anchor() override;
2724
2725   ExplicitSpecifier ExplicitSpec;
2726
2727 public:
2728   friend class ASTDeclReader;
2729   friend class ASTDeclWriter;
2730
2731   static CXXConversionDecl *
2732   Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
2733          const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
2734          bool isInline, ExplicitSpecifier ES, ConstexprSpecKind ConstexprKind,
2735          SourceLocation EndLocation, Expr *TrailingRequiresClause = nullptr);
2736   static CXXConversionDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2737
2738   ExplicitSpecifier getExplicitSpecifier() {
2739     return getCanonicalDecl()->ExplicitSpec;
2740   }
2741
2742   const ExplicitSpecifier getExplicitSpecifier() const {
2743     return getCanonicalDecl()->ExplicitSpec;
2744   }
2745
2746   /// Return true if the declartion is already resolved to be explicit.
2747   bool isExplicit() const { return getExplicitSpecifier().isExplicit(); }
2748   void setExplicitSpecifier(ExplicitSpecifier ES) { ExplicitSpec = ES; }
2749
2750   /// Returns the type that this conversion function is converting to.
2751   QualType getConversionType() const {
2752     return getType()->castAs<FunctionType>()->getReturnType();
2753   }
2754
2755   /// Determine whether this conversion function is a conversion from
2756   /// a lambda closure type to a block pointer.
2757   bool isLambdaToBlockPointerConversion() const;
2758
2759   CXXConversionDecl *getCanonicalDecl() override {
2760     return cast<CXXConversionDecl>(FunctionDecl::getCanonicalDecl());
2761   }
2762   const CXXConversionDecl *getCanonicalDecl() const {
2763     return const_cast<CXXConversionDecl*>(this)->getCanonicalDecl();
2764   }
2765
2766   // Implement isa/cast/dyncast/etc.
2767   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2768   static bool classofKind(Kind K) { return K == CXXConversion; }
2769 };
2770
2771 /// Represents a linkage specification.
2772 ///
2773 /// For example:
2774 /// \code
2775 ///   extern "C" void foo();
2776 /// \endcode
2777 class LinkageSpecDecl : public Decl, public DeclContext {
2778   virtual void anchor();
2779   // This class stores some data in DeclContext::LinkageSpecDeclBits to save
2780   // some space. Use the provided accessors to access it.
2781 public:
2782   /// Represents the language in a linkage specification.
2783   ///
2784   /// The values are part of the serialization ABI for
2785   /// ASTs and cannot be changed without altering that ABI.
2786   enum LanguageIDs { lang_c = 1, lang_cxx = 2 };
2787
2788 private:
2789   /// The source location for the extern keyword.
2790   SourceLocation ExternLoc;
2791
2792   /// The source location for the right brace (if valid).
2793   SourceLocation RBraceLoc;
2794
2795   LinkageSpecDecl(DeclContext *DC, SourceLocation ExternLoc,
2796                   SourceLocation LangLoc, LanguageIDs lang, bool HasBraces);
2797
2798 public:
2799   static LinkageSpecDecl *Create(ASTContext &C, DeclContext *DC,
2800                                  SourceLocation ExternLoc,
2801                                  SourceLocation LangLoc, LanguageIDs Lang,
2802                                  bool HasBraces);
2803   static LinkageSpecDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2804
2805   /// Return the language specified by this linkage specification.
2806   LanguageIDs getLanguage() const {
2807     return static_cast<LanguageIDs>(LinkageSpecDeclBits.Language);
2808   }
2809
2810   /// Set the language specified by this linkage specification.
2811   void setLanguage(LanguageIDs L) { LinkageSpecDeclBits.Language = L; }
2812
2813   /// Determines whether this linkage specification had braces in
2814   /// its syntactic form.
2815   bool hasBraces() const {
2816     assert(!RBraceLoc.isValid() || LinkageSpecDeclBits.HasBraces);
2817     return LinkageSpecDeclBits.HasBraces;
2818   }
2819
2820   SourceLocation getExternLoc() const { return ExternLoc; }
2821   SourceLocation getRBraceLoc() const { return RBraceLoc; }
2822   void setExternLoc(SourceLocation L) { ExternLoc = L; }
2823   void setRBraceLoc(SourceLocation L) {
2824     RBraceLoc = L;
2825     LinkageSpecDeclBits.HasBraces = RBraceLoc.isValid();
2826   }
2827
2828   SourceLocation getEndLoc() const LLVM_READONLY {
2829     if (hasBraces())
2830       return getRBraceLoc();
2831     // No braces: get the end location of the (only) declaration in context
2832     // (if present).
2833     return decls_empty() ? getLocation() : decls_begin()->getEndLoc();
2834   }
2835
2836   SourceRange getSourceRange() const override LLVM_READONLY {
2837     return SourceRange(ExternLoc, getEndLoc());
2838   }
2839
2840   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2841   static bool classofKind(Kind K) { return K == LinkageSpec; }
2842
2843   static DeclContext *castToDeclContext(const LinkageSpecDecl *D) {
2844     return static_cast<DeclContext *>(const_cast<LinkageSpecDecl*>(D));
2845   }
2846
2847   static LinkageSpecDecl *castFromDeclContext(const DeclContext *DC) {
2848     return static_cast<LinkageSpecDecl *>(const_cast<DeclContext*>(DC));
2849   }
2850 };
2851
2852 /// Represents C++ using-directive.
2853 ///
2854 /// For example:
2855 /// \code
2856 ///    using namespace std;
2857 /// \endcode
2858 ///
2859 /// \note UsingDirectiveDecl should be Decl not NamedDecl, but we provide
2860 /// artificial names for all using-directives in order to store
2861 /// them in DeclContext effectively.
2862 class UsingDirectiveDecl : public NamedDecl {
2863   /// The location of the \c using keyword.
2864   SourceLocation UsingLoc;
2865
2866   /// The location of the \c namespace keyword.
2867   SourceLocation NamespaceLoc;
2868
2869   /// The nested-name-specifier that precedes the namespace.
2870   NestedNameSpecifierLoc QualifierLoc;
2871
2872   /// The namespace nominated by this using-directive.
2873   NamedDecl *NominatedNamespace;
2874
2875   /// Enclosing context containing both using-directive and nominated
2876   /// namespace.
2877   DeclContext *CommonAncestor;
2878
2879   UsingDirectiveDecl(DeclContext *DC, SourceLocation UsingLoc,
2880                      SourceLocation NamespcLoc,
2881                      NestedNameSpecifierLoc QualifierLoc,
2882                      SourceLocation IdentLoc,
2883                      NamedDecl *Nominated,
2884                      DeclContext *CommonAncestor)
2885       : NamedDecl(UsingDirective, DC, IdentLoc, getName()), UsingLoc(UsingLoc),
2886         NamespaceLoc(NamespcLoc), QualifierLoc(QualifierLoc),
2887         NominatedNamespace(Nominated), CommonAncestor(CommonAncestor) {}
2888
2889   /// Returns special DeclarationName used by using-directives.
2890   ///
2891   /// This is only used by DeclContext for storing UsingDirectiveDecls in
2892   /// its lookup structure.
2893   static DeclarationName getName() {
2894     return DeclarationName::getUsingDirectiveName();
2895   }
2896
2897   void anchor() override;
2898
2899 public:
2900   friend class ASTDeclReader;
2901
2902   // Friend for getUsingDirectiveName.
2903   friend class DeclContext;
2904
2905   /// Retrieve the nested-name-specifier that qualifies the
2906   /// name of the namespace, with source-location information.
2907   NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
2908
2909   /// Retrieve the nested-name-specifier that qualifies the
2910   /// name of the namespace.
2911   NestedNameSpecifier *getQualifier() const {
2912     return QualifierLoc.getNestedNameSpecifier();
2913   }
2914
2915   NamedDecl *getNominatedNamespaceAsWritten() { return NominatedNamespace; }
2916   const NamedDecl *getNominatedNamespaceAsWritten() const {
2917     return NominatedNamespace;
2918   }
2919
2920   /// Returns the namespace nominated by this using-directive.
2921   NamespaceDecl *getNominatedNamespace();
2922
2923   const NamespaceDecl *getNominatedNamespace() const {
2924     return const_cast<UsingDirectiveDecl*>(this)->getNominatedNamespace();
2925   }
2926
2927   /// Returns the common ancestor context of this using-directive and
2928   /// its nominated namespace.
2929   DeclContext *getCommonAncestor() { return CommonAncestor; }
2930   const DeclContext *getCommonAncestor() const { return CommonAncestor; }
2931
2932   /// Return the location of the \c using keyword.
2933   SourceLocation getUsingLoc() const { return UsingLoc; }
2934
2935   // FIXME: Could omit 'Key' in name.
2936   /// Returns the location of the \c namespace keyword.
2937   SourceLocation getNamespaceKeyLocation() const { return NamespaceLoc; }
2938
2939   /// Returns the location of this using declaration's identifier.
2940   SourceLocation getIdentLocation() const { return getLocation(); }
2941
2942   static UsingDirectiveDecl *Create(ASTContext &C, DeclContext *DC,
2943                                     SourceLocation UsingLoc,
2944                                     SourceLocation NamespaceLoc,
2945                                     NestedNameSpecifierLoc QualifierLoc,
2946                                     SourceLocation IdentLoc,
2947                                     NamedDecl *Nominated,
2948                                     DeclContext *CommonAncestor);
2949   static UsingDirectiveDecl *CreateDeserialized(ASTContext &C, unsigned ID);
2950
2951   SourceRange getSourceRange() const override LLVM_READONLY {
2952     return SourceRange(UsingLoc, getLocation());
2953   }
2954
2955   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
2956   static bool classofKind(Kind K) { return K == UsingDirective; }
2957 };
2958
2959 /// Represents a C++ namespace alias.
2960 ///
2961 /// For example:
2962 ///
2963 /// \code
2964 /// namespace Foo = Bar;
2965 /// \endcode
2966 class NamespaceAliasDecl : public NamedDecl,
2967                            public Redeclarable<NamespaceAliasDecl> {
2968   friend class ASTDeclReader;
2969
2970   /// The location of the \c namespace keyword.
2971   SourceLocation NamespaceLoc;
2972
2973   /// The location of the namespace's identifier.
2974   ///
2975   /// This is accessed by TargetNameLoc.
2976   SourceLocation IdentLoc;
2977
2978   /// The nested-name-specifier that precedes the namespace.
2979   NestedNameSpecifierLoc QualifierLoc;
2980
2981   /// The Decl that this alias points to, either a NamespaceDecl or
2982   /// a NamespaceAliasDecl.
2983   NamedDecl *Namespace;
2984
2985   NamespaceAliasDecl(ASTContext &C, DeclContext *DC,
2986                      SourceLocation NamespaceLoc, SourceLocation AliasLoc,
2987                      IdentifierInfo *Alias, NestedNameSpecifierLoc QualifierLoc,
2988                      SourceLocation IdentLoc, NamedDecl *Namespace)
2989       : NamedDecl(NamespaceAlias, DC, AliasLoc, Alias), redeclarable_base(C),
2990         NamespaceLoc(NamespaceLoc), IdentLoc(IdentLoc),
2991         QualifierLoc(QualifierLoc), Namespace(Namespace) {}
2992
2993   void anchor() override;
2994
2995   using redeclarable_base = Redeclarable<NamespaceAliasDecl>;
2996
2997   NamespaceAliasDecl *getNextRedeclarationImpl() override;
2998   NamespaceAliasDecl *getPreviousDeclImpl() override;
2999   NamespaceAliasDecl *getMostRecentDeclImpl() override;
3000
3001 public:
3002   static NamespaceAliasDecl *Create(ASTContext &C, DeclContext *DC,
3003                                     SourceLocation NamespaceLoc,
3004                                     SourceLocation AliasLoc,
3005                                     IdentifierInfo *Alias,
3006                                     NestedNameSpecifierLoc QualifierLoc,
3007                                     SourceLocation IdentLoc,
3008                                     NamedDecl *Namespace);
3009
3010   static NamespaceAliasDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3011
3012   using redecl_range = redeclarable_base::redecl_range;
3013   using redecl_iterator = redeclarable_base::redecl_iterator;
3014
3015   using redeclarable_base::redecls_begin;
3016   using redeclarable_base::redecls_end;
3017   using redeclarable_base::redecls;
3018   using redeclarable_base::getPreviousDecl;
3019   using redeclarable_base::getMostRecentDecl;
3020
3021   NamespaceAliasDecl *getCanonicalDecl() override {
3022     return getFirstDecl();
3023   }
3024   const NamespaceAliasDecl *getCanonicalDecl() const {
3025     return getFirstDecl();
3026   }
3027
3028   /// Retrieve the nested-name-specifier that qualifies the
3029   /// name of the namespace, with source-location information.
3030   NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
3031
3032   /// Retrieve the nested-name-specifier that qualifies the
3033   /// name of the namespace.
3034   NestedNameSpecifier *getQualifier() const {
3035     return QualifierLoc.getNestedNameSpecifier();
3036   }
3037
3038   /// Retrieve the namespace declaration aliased by this directive.
3039   NamespaceDecl *getNamespace() {
3040     if (auto *AD = dyn_cast<NamespaceAliasDecl>(Namespace))
3041       return AD->getNamespace();
3042
3043     return cast<NamespaceDecl>(Namespace);
3044   }
3045
3046   const NamespaceDecl *getNamespace() const {
3047     return const_cast<NamespaceAliasDecl *>(this)->getNamespace();
3048   }
3049
3050   /// Returns the location of the alias name, i.e. 'foo' in
3051   /// "namespace foo = ns::bar;".
3052   SourceLocation getAliasLoc() const { return getLocation(); }
3053
3054   /// Returns the location of the \c namespace keyword.
3055   SourceLocation getNamespaceLoc() const { return NamespaceLoc; }
3056
3057   /// Returns the location of the identifier in the named namespace.
3058   SourceLocation getTargetNameLoc() const { return IdentLoc; }
3059
3060   /// Retrieve the namespace that this alias refers to, which
3061   /// may either be a NamespaceDecl or a NamespaceAliasDecl.
3062   NamedDecl *getAliasedNamespace() const { return Namespace; }
3063
3064   SourceRange getSourceRange() const override LLVM_READONLY {
3065     return SourceRange(NamespaceLoc, IdentLoc);
3066   }
3067
3068   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3069   static bool classofKind(Kind K) { return K == NamespaceAlias; }
3070 };
3071
3072 /// Implicit declaration of a temporary that was materialized by
3073 /// a MaterializeTemporaryExpr and lifetime-extended by a declaration
3074 class LifetimeExtendedTemporaryDecl final
3075     : public Decl,
3076       public Mergeable<LifetimeExtendedTemporaryDecl> {
3077   friend class MaterializeTemporaryExpr;
3078   friend class ASTDeclReader;
3079
3080   Stmt *ExprWithTemporary = nullptr;
3081
3082   /// The declaration which lifetime-extended this reference, if any.
3083   /// Either a VarDecl, or (for a ctor-initializer) a FieldDecl.
3084   ValueDecl *ExtendingDecl = nullptr;
3085   unsigned ManglingNumber;
3086
3087   mutable APValue *Value = nullptr;
3088
3089   virtual void anchor();
3090
3091   LifetimeExtendedTemporaryDecl(Expr *Temp, ValueDecl *EDecl, unsigned Mangling)
3092       : Decl(Decl::LifetimeExtendedTemporary, EDecl->getDeclContext(),
3093              EDecl->getLocation()),
3094         ExprWithTemporary(Temp), ExtendingDecl(EDecl),
3095         ManglingNumber(Mangling) {}
3096
3097   LifetimeExtendedTemporaryDecl(EmptyShell)
3098       : Decl(Decl::LifetimeExtendedTemporary, EmptyShell{}) {}
3099
3100 public:
3101   static LifetimeExtendedTemporaryDecl *Create(Expr *Temp, ValueDecl *EDec,
3102                                                unsigned Mangling) {
3103     return new (EDec->getASTContext(), EDec->getDeclContext())
3104         LifetimeExtendedTemporaryDecl(Temp, EDec, Mangling);
3105   }
3106   static LifetimeExtendedTemporaryDecl *CreateDeserialized(ASTContext &C,
3107                                                            unsigned ID) {
3108     return new (C, ID) LifetimeExtendedTemporaryDecl(EmptyShell{});
3109   }
3110
3111   ValueDecl *getExtendingDecl() { return ExtendingDecl; }
3112   const ValueDecl *getExtendingDecl() const { return ExtendingDecl; }
3113
3114   /// Retrieve the storage duration for the materialized temporary.
3115   StorageDuration getStorageDuration() const;
3116
3117   /// Retrieve the expression to which the temporary materialization conversion
3118   /// was applied. This isn't necessarily the initializer of the temporary due
3119   /// to the C++98 delayed materialization rules, but
3120   /// skipRValueSubobjectAdjustments can be used to find said initializer within
3121   /// the subexpression.
3122   Expr *getTemporaryExpr() { return cast<Expr>(ExprWithTemporary); }
3123   const Expr *getTemporaryExpr() const { return cast<Expr>(ExprWithTemporary); }
3124
3125   unsigned getManglingNumber() const { return ManglingNumber; }
3126
3127   /// Get the storage for the constant value of a materialized temporary
3128   /// of static storage duration.
3129   APValue *getOrCreateValue(bool MayCreate) const;
3130
3131   APValue *getValue() const { return Value; }
3132
3133   // Iterators
3134   Stmt::child_range childrenExpr() {
3135     return Stmt::child_range(&ExprWithTemporary, &ExprWithTemporary + 1);
3136   }
3137
3138   Stmt::const_child_range childrenExpr() const {
3139     return Stmt::const_child_range(&ExprWithTemporary, &ExprWithTemporary + 1);
3140   }
3141
3142   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3143   static bool classofKind(Kind K) {
3144     return K == Decl::LifetimeExtendedTemporary;
3145   }
3146 };
3147
3148 /// Represents a shadow declaration introduced into a scope by a
3149 /// (resolved) using declaration.
3150 ///
3151 /// For example,
3152 /// \code
3153 /// namespace A {
3154 ///   void foo();
3155 /// }
3156 /// namespace B {
3157 ///   using A::foo; // <- a UsingDecl
3158 ///                 // Also creates a UsingShadowDecl for A::foo() in B
3159 /// }
3160 /// \endcode
3161 class UsingShadowDecl : public NamedDecl, public Redeclarable<UsingShadowDecl> {
3162   friend class UsingDecl;
3163
3164   /// The referenced declaration.
3165   NamedDecl *Underlying = nullptr;
3166
3167   /// The using declaration which introduced this decl or the next using
3168   /// shadow declaration contained in the aforementioned using declaration.
3169   NamedDecl *UsingOrNextShadow = nullptr;
3170
3171   void anchor() override;
3172
3173   using redeclarable_base = Redeclarable<UsingShadowDecl>;
3174
3175   UsingShadowDecl *getNextRedeclarationImpl() override {
3176     return getNextRedeclaration();
3177   }
3178
3179   UsingShadowDecl *getPreviousDeclImpl() override {
3180     return getPreviousDecl();
3181   }
3182
3183   UsingShadowDecl *getMostRecentDeclImpl() override {
3184     return getMostRecentDecl();
3185   }
3186
3187 protected:
3188   UsingShadowDecl(Kind K, ASTContext &C, DeclContext *DC, SourceLocation Loc,
3189                   UsingDecl *Using, NamedDecl *Target);
3190   UsingShadowDecl(Kind K, ASTContext &C, EmptyShell);
3191
3192 public:
3193   friend class ASTDeclReader;
3194   friend class ASTDeclWriter;
3195
3196   static UsingShadowDecl *Create(ASTContext &C, DeclContext *DC,
3197                                  SourceLocation Loc, UsingDecl *Using,
3198                                  NamedDecl *Target) {
3199     return new (C, DC) UsingShadowDecl(UsingShadow, C, DC, Loc, Using, Target);
3200   }
3201
3202   static UsingShadowDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3203
3204   using redecl_range = redeclarable_base::redecl_range;
3205   using redecl_iterator = redeclarable_base::redecl_iterator;
3206
3207   using redeclarable_base::redecls_begin;
3208   using redeclarable_base::redecls_end;
3209   using redeclarable_base::redecls;
3210   using redeclarable_base::getPreviousDecl;
3211   using redeclarable_base::getMostRecentDecl;
3212   using redeclarable_base::isFirstDecl;
3213
3214   UsingShadowDecl *getCanonicalDecl() override {
3215     return getFirstDecl();
3216   }
3217   const UsingShadowDecl *getCanonicalDecl() const {
3218     return getFirstDecl();
3219   }
3220
3221   /// Gets the underlying declaration which has been brought into the
3222   /// local scope.
3223   NamedDecl *getTargetDecl() const { return Underlying; }
3224
3225   /// Sets the underlying declaration which has been brought into the
3226   /// local scope.
3227   void setTargetDecl(NamedDecl *ND) {
3228     assert(ND && "Target decl is null!");
3229     Underlying = ND;
3230     // A UsingShadowDecl is never a friend or local extern declaration, even
3231     // if it is a shadow declaration for one.
3232     IdentifierNamespace =
3233         ND->getIdentifierNamespace() &
3234         ~(IDNS_OrdinaryFriend | IDNS_TagFriend | IDNS_LocalExtern);
3235   }
3236
3237   /// Gets the using declaration to which this declaration is tied.
3238   UsingDecl *getUsingDecl() const;
3239
3240   /// The next using shadow declaration contained in the shadow decl
3241   /// chain of the using declaration which introduced this decl.
3242   UsingShadowDecl *getNextUsingShadowDecl() const {
3243     return dyn_cast_or_null<UsingShadowDecl>(UsingOrNextShadow);
3244   }
3245
3246   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3247   static bool classofKind(Kind K) {
3248     return K == Decl::UsingShadow || K == Decl::ConstructorUsingShadow;
3249   }
3250 };
3251
3252 /// Represents a shadow constructor declaration introduced into a
3253 /// class by a C++11 using-declaration that names a constructor.
3254 ///
3255 /// For example:
3256 /// \code
3257 /// struct Base { Base(int); };
3258 /// struct Derived {
3259 ///    using Base::Base; // creates a UsingDecl and a ConstructorUsingShadowDecl
3260 /// };
3261 /// \endcode
3262 class ConstructorUsingShadowDecl final : public UsingShadowDecl {
3263   /// If this constructor using declaration inherted the constructor
3264   /// from an indirect base class, this is the ConstructorUsingShadowDecl
3265   /// in the named direct base class from which the declaration was inherited.
3266   ConstructorUsingShadowDecl *NominatedBaseClassShadowDecl = nullptr;
3267
3268   /// If this constructor using declaration inherted the constructor
3269   /// from an indirect base class, this is the ConstructorUsingShadowDecl
3270   /// that will be used to construct the unique direct or virtual base class
3271   /// that receives the constructor arguments.
3272   ConstructorUsingShadowDecl *ConstructedBaseClassShadowDecl = nullptr;
3273
3274   /// \c true if the constructor ultimately named by this using shadow
3275   /// declaration is within a virtual base class subobject of the class that
3276   /// contains this declaration.
3277   unsigned IsVirtual : 1;
3278
3279   ConstructorUsingShadowDecl(ASTContext &C, DeclContext *DC, SourceLocation Loc,
3280                              UsingDecl *Using, NamedDecl *Target,
3281                              bool TargetInVirtualBase)
3282       : UsingShadowDecl(ConstructorUsingShadow, C, DC, Loc, Using,
3283                         Target->getUnderlyingDecl()),
3284         NominatedBaseClassShadowDecl(
3285             dyn_cast<ConstructorUsingShadowDecl>(Target)),
3286         ConstructedBaseClassShadowDecl(NominatedBaseClassShadowDecl),
3287         IsVirtual(TargetInVirtualBase) {
3288     // If we found a constructor that chains to a constructor for a virtual
3289     // base, we should directly call that virtual base constructor instead.
3290     // FIXME: This logic belongs in Sema.
3291     if (NominatedBaseClassShadowDecl &&
3292         NominatedBaseClassShadowDecl->constructsVirtualBase()) {
3293       ConstructedBaseClassShadowDecl =
3294           NominatedBaseClassShadowDecl->ConstructedBaseClassShadowDecl;
3295       IsVirtual = true;
3296     }
3297   }
3298
3299   ConstructorUsingShadowDecl(ASTContext &C, EmptyShell Empty)
3300       : UsingShadowDecl(ConstructorUsingShadow, C, Empty), IsVirtual(false) {}
3301
3302   void anchor() override;
3303
3304 public:
3305   friend class ASTDeclReader;
3306   friend class ASTDeclWriter;
3307
3308   static ConstructorUsingShadowDecl *Create(ASTContext &C, DeclContext *DC,
3309                                             SourceLocation Loc,
3310                                             UsingDecl *Using, NamedDecl *Target,
3311                                             bool IsVirtual);
3312   static ConstructorUsingShadowDecl *CreateDeserialized(ASTContext &C,
3313                                                         unsigned ID);
3314
3315   /// Returns the parent of this using shadow declaration, which
3316   /// is the class in which this is declared.
3317   //@{
3318   const CXXRecordDecl *getParent() const {
3319     return cast<CXXRecordDecl>(getDeclContext());
3320   }
3321   CXXRecordDecl *getParent() {
3322     return cast<CXXRecordDecl>(getDeclContext());
3323   }
3324   //@}
3325
3326   /// Get the inheriting constructor declaration for the direct base
3327   /// class from which this using shadow declaration was inherited, if there is
3328   /// one. This can be different for each redeclaration of the same shadow decl.
3329   ConstructorUsingShadowDecl *getNominatedBaseClassShadowDecl() const {
3330     return NominatedBaseClassShadowDecl;
3331   }
3332
3333   /// Get the inheriting constructor declaration for the base class
3334   /// for which we don't have an explicit initializer, if there is one.
3335   ConstructorUsingShadowDecl *getConstructedBaseClassShadowDecl() const {
3336     return ConstructedBaseClassShadowDecl;
3337   }
3338
3339   /// Get the base class that was named in the using declaration. This
3340   /// can be different for each redeclaration of this same shadow decl.
3341   CXXRecordDecl *getNominatedBaseClass() const;
3342
3343   /// Get the base class whose constructor or constructor shadow
3344   /// declaration is passed the constructor arguments.
3345   CXXRecordDecl *getConstructedBaseClass() const {
3346     return cast<CXXRecordDecl>((ConstructedBaseClassShadowDecl
3347                                     ? ConstructedBaseClassShadowDecl
3348                                     : getTargetDecl())
3349                                    ->getDeclContext());
3350   }
3351
3352   /// Returns \c true if the constructed base class is a virtual base
3353   /// class subobject of this declaration's class.
3354   bool constructsVirtualBase() const {
3355     return IsVirtual;
3356   }
3357
3358   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3359   static bool classofKind(Kind K) { return K == ConstructorUsingShadow; }
3360 };
3361
3362 /// Represents a C++ using-declaration.
3363 ///
3364 /// For example:
3365 /// \code
3366 ///    using someNameSpace::someIdentifier;
3367 /// \endcode
3368 class UsingDecl : public NamedDecl, public Mergeable<UsingDecl> {
3369   /// The source location of the 'using' keyword itself.
3370   SourceLocation UsingLocation;
3371
3372   /// The nested-name-specifier that precedes the name.
3373   NestedNameSpecifierLoc QualifierLoc;
3374
3375   /// Provides source/type location info for the declaration name
3376   /// embedded in the ValueDecl base class.
3377   DeclarationNameLoc DNLoc;
3378
3379   /// The first shadow declaration of the shadow decl chain associated
3380   /// with this using declaration.
3381   ///
3382   /// The bool member of the pair store whether this decl has the \c typename
3383   /// keyword.
3384   llvm::PointerIntPair<UsingShadowDecl *, 1, bool> FirstUsingShadow;
3385
3386   UsingDecl(DeclContext *DC, SourceLocation UL,
3387             NestedNameSpecifierLoc QualifierLoc,
3388             const DeclarationNameInfo &NameInfo, bool HasTypenameKeyword)
3389     : NamedDecl(Using, DC, NameInfo.getLoc(), NameInfo.getName()),
3390       UsingLocation(UL), QualifierLoc(QualifierLoc),
3391       DNLoc(NameInfo.getInfo()), FirstUsingShadow(nullptr, HasTypenameKeyword) {
3392   }
3393
3394   void anchor() override;
3395
3396 public:
3397   friend class ASTDeclReader;
3398   friend class ASTDeclWriter;
3399
3400   /// Return the source location of the 'using' keyword.
3401   SourceLocation getUsingLoc() const { return UsingLocation; }
3402
3403   /// Set the source location of the 'using' keyword.
3404   void setUsingLoc(SourceLocation L) { UsingLocation = L; }
3405
3406   /// Retrieve the nested-name-specifier that qualifies the name,
3407   /// with source-location information.
3408   NestedNameSpecifierLoc getQualifierLoc() const { return QualifierLoc; }
3409
3410   /// Retrieve the nested-name-specifier that qualifies the name.
3411   NestedNameSpecifier *getQualifier() const {
3412     return QualifierLoc.getNestedNameSpecifier();
3413   }
3414
3415   DeclarationNameInfo getNameInfo() const {
3416     return DeclarationNameInfo(getDeclName(), getLocation(), DNLoc);
3417   }
3418
3419   /// Return true if it is a C++03 access declaration (no 'using').
3420   bool isAccessDeclaration() const { return UsingLocation.isInvalid(); }
3421
3422   /// Return true if the using declaration has 'typename'.
3423   bool hasTypename() const { return FirstUsingShadow.getInt(); }
3424
3425   /// Sets whether the using declaration has 'typename'.
3426   void setTypename(bool TN) { FirstUsingShadow.setInt(TN); }
3427
3428   /// Iterates through the using shadow declarations associated with
3429   /// this using declaration.
3430   class shadow_iterator {
3431     /// The current using shadow declaration.
3432     UsingShadowDecl *Current = nullptr;
3433
3434   public:
3435     using value_type = UsingShadowDecl *;
3436     using reference = UsingShadowDecl *;
3437     using pointer = UsingShadowDecl *;
3438     using iterator_category = std::forward_iterator_tag;
3439     using difference_type = std::ptrdiff_t;
3440
3441     shadow_iterator() = default;
3442     explicit shadow_iterator(UsingShadowDecl *C) : Current(C) {}
3443
3444     reference operator*() const { return Current; }
3445     pointer operator->() const { return Current; }
3446
3447     shadow_iterator& operator++() {
3448       Current = Current->getNextUsingShadowDecl();
3449       return *this;
3450     }
3451
3452     shadow_iterator operator++(int) {
3453       shadow_iterator tmp(*this);
3454       ++(*this);
3455       return tmp;
3456     }
3457
3458     friend bool operator==(shadow_iterator x, shadow_iterator y) {
3459       return x.Current == y.Current;
3460     }
3461     friend bool operator!=(shadow_iterator x, shadow_iterator y) {
3462       return x.Current != y.Current;
3463     }
3464   };
3465
3466   using shadow_range = llvm::iterator_range<shadow_iterator>;
3467
3468   shadow_range shadows() const {
3469     return shadow_range(shadow_begin(), shadow_end());
3470   }
3471
3472   shadow_iterator shadow_begin() const {
3473     return shadow_iterator(FirstUsingShadow.getPointer());
3474   }
3475
3476   shadow_iterator shadow_end() const { return shadow_iterator(); }
3477
3478   /// Return the number of shadowed declarations associated with this
3479   /// using declaration.
3480   unsigned shadow_size() const {
3481     return std::distance(shadow_begin(), shadow_end());
3482   }
3483
3484   void addShadowDecl(UsingShadowDecl *S);
3485   void removeShadowDecl(UsingShadowDecl *S);
3486
3487   static UsingDecl *Create(ASTContext &C, DeclContext *DC,
3488                            SourceLocation UsingL,
3489                            NestedNameSpecifierLoc QualifierLoc,
3490                            const DeclarationNameInfo &NameInfo,
3491                            bool HasTypenameKeyword);
3492
3493   static UsingDecl *CreateDeserialized(ASTContext &C, unsigned ID);
3494
3495   SourceRange getSourceRange() const override LLVM_READONLY;
3496
3497   /// Retrieves the canonical declaration of this declaration.
3498   UsingDecl *getCanonicalDecl() override { return getFirstDecl(); }
3499   const UsingDecl *getCanonicalDecl() const { return getFirstDecl(); }
3500
3501   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3502   static bool classofKind(Kind K) { return K == Using; }
3503 };
3504
3505 /// Represents a pack of using declarations that a single
3506 /// using-declarator pack-expanded into.
3507 ///
3508 /// \code
3509 /// template<typename ...T> struct X : T... {
3510 ///   using T::operator()...;
3511 ///   using T::operator T...;
3512 /// };
3513 /// \endcode
3514 ///
3515 /// In the second case above, the UsingPackDecl will have the name
3516 /// 'operator T' (which contains an unexpanded pack), but the individual
3517 /// UsingDecls and UsingShadowDecls will have more reasonable names.
3518 class UsingPackDecl final
3519     : public NamedDecl, public Mergeable<UsingPackDecl>,
3520       private llvm::TrailingObjects<UsingPackDecl, NamedDecl *> {
3521   /// The UnresolvedUsingValueDecl or UnresolvedUsingTypenameDecl from
3522   /// which this waas instantiated.
3523   NamedDecl *InstantiatedFrom;
3524
3525   /// The number of using-declarations created by this pack expansion.
3526   unsigned NumExpansions;
3527
3528   UsingPackDecl(DeclContext *DC, NamedDecl *InstantiatedFrom,
3529                 ArrayRef<NamedDecl *> UsingDecls)
3530       : NamedDecl(UsingPack, DC,
3531                   InstantiatedFrom ? InstantiatedFrom->getLocation()
3532                                    : SourceLocation(),
3533                   InstantiatedFrom ? InstantiatedFrom->getDeclName()
3534                                    : DeclarationName()),
3535         InstantiatedFrom(InstantiatedFrom), NumExpansions(UsingDecls.size()) {
3536     std::uninitialized_copy(UsingDecls.begin(), UsingDecls.end(),
3537                             getTrailingObjects<NamedDecl *>());
3538   }
3539
3540   void anchor() override;
3541
3542 public:
3543   friend class ASTDeclReader;
3544   friend class ASTDeclWriter;
3545   friend TrailingObjects;
3546
3547   /// Get the using declaration from which this was instantiated. This will
3548   /// always be an UnresolvedUsingValueDecl or an UnresolvedUsingTypenameDecl
3549   /// that is a pack expansion.
3550   NamedDecl *getInstantiatedFromUsingDecl() const { return InstantiatedFrom; }
3551
3552   /// Get the set of using declarations that this pack expanded into. Note that
3553   /// some of these may still be unresolved.
3554   ArrayRef<NamedDecl *> expansions() const {
3555     return llvm::makeArrayRef(getTrailingObjects<NamedDecl *>(), NumExpansions);
3556   }
3557
3558   static UsingPackDecl *Create(ASTContext &C, DeclContext *DC,
3559                                NamedDecl *InstantiatedFrom,
3560                                ArrayRef<NamedDecl *> UsingDecls);
3561
3562   static UsingPackDecl *CreateDeserialized(ASTContext &C, unsigned ID,
3563                                            unsigned NumExpansions);
3564
3565   SourceRange getSourceRange() const override LLVM_READONLY {
3566     return InstantiatedFrom->getSourceRange();
3567   }
3568
3569   UsingPackDecl *getCanonicalDecl() override { return getFirstDecl(); }
3570   const UsingPackDecl *getCanonicalDecl() const { return getFirstDecl(); }
3571
3572   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
3573   static bool classofKind(Kind K) { return K == UsingPack; }
3574 };
3575
3576 /// Represents a dependent using declaration which was not marked with
3577 /// \c typename.
3578 ///
3579 /// Unlike non-dependent using declarations, these *only* bring through
3580 /// non-types; otherwise they would break two-phase lookup.
3581 ///
3582 /// \code
3583 /// template \<class T> class A : public Base<T> {
3584 ///   using Base<T>::foo;
3585 /// };
3586 /// \endcode
3587 class UnresolvedUsingValueDecl : public ValueDecl,
3588                                  public Mergeable<UnresolvedUsingValueDecl> {
3589   /// The source location of the 'using' keyword
3590   SourceLocation UsingLocation;
3591
3592   /// If this is a pack expansion, the location of the '...'.
3593   SourceLocation EllipsisLoc;
3594
3595   /// The nested-name-specifier that precedes the name.
3596   NestedNameSpecifierLoc QualifierLoc;
3597
3598   /// Provides source/type location info for the declaration name
3599   /// embedded in the ValueDecl base class.
3600   DeclarationNameLoc DNLoc;
3601
3602   UnresolvedUsingValueDecl(DeclContext *DC, QualType Ty,
3603                            SourceLocation UsingLoc,
3604                            NestedNameSpecifierLoc QualifierLoc,
3605                            const DeclarationNameInfo &NameInfo,
3606                            SourceLocation EllipsisLoc)
3607       : ValueDecl(UnresolvedUsingValue, DC,
3608                   NameInfo.getLoc(), NameInfo.getName(), Ty),
3609         UsingLocation(UsingLoc), EllipsisLoc(EllipsisLoc),
3610         QualifierLoc(QualifierLoc), DNLoc(NameInfo.getInfo()) {}
3611
3612   void anchor() override;
3613
3614 public:
3615   friend class ASTDeclReader;