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