clang  14.0.0git
DeclCXX.cpp
Go to the documentation of this file.
1 //===- DeclCXX.cpp - C++ Declaration AST Node Implementation --------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the C++ related Decl classes.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "clang/AST/DeclCXX.h"
14 #include "clang/AST/ASTContext.h"
15 #include "clang/AST/ASTLambda.h"
18 #include "clang/AST/Attr.h"
20 #include "clang/AST/DeclBase.h"
21 #include "clang/AST/DeclTemplate.h"
23 #include "clang/AST/Expr.h"
24 #include "clang/AST/ExprCXX.h"
27 #include "clang/AST/ODRHash.h"
28 #include "clang/AST/Type.h"
29 #include "clang/AST/TypeLoc.h"
31 #include "clang/Basic/Diagnostic.h"
33 #include "clang/Basic/LLVM.h"
38 #include "clang/Basic/Specifiers.h"
39 #include "llvm/ADT/None.h"
40 #include "llvm/ADT/SmallPtrSet.h"
41 #include "llvm/ADT/SmallVector.h"
42 #include "llvm/ADT/iterator_range.h"
43 #include "llvm/Support/Casting.h"
44 #include "llvm/Support/ErrorHandling.h"
45 #include "llvm/Support/Format.h"
46 #include "llvm/Support/raw_ostream.h"
47 #include <algorithm>
48 #include <cassert>
49 #include <cstddef>
50 #include <cstdint>
51 
52 using namespace clang;
53 
54 //===----------------------------------------------------------------------===//
55 // Decl Allocation/Deallocation Method Implementations
56 //===----------------------------------------------------------------------===//
57 
58 void AccessSpecDecl::anchor() {}
59 
61  return new (C, ID) AccessSpecDecl(EmptyShell());
62 }
63 
64 void LazyASTUnresolvedSet::getFromExternalSource(ASTContext &C) const {
65  ExternalASTSource *Source = C.getExternalSource();
66  assert(Impl.Decls.isLazy() && "getFromExternalSource for non-lazy set");
67  assert(Source && "getFromExternalSource with no external source");
68 
69  for (ASTUnresolvedSet::iterator I = Impl.begin(); I != Impl.end(); ++I)
70  I.setDecl(cast<NamedDecl>(Source->GetExternalDecl(
71  reinterpret_cast<uintptr_t>(I.getDecl()) >> 2)));
72  Impl.Decls.setLazy(false);
73 }
74 
75 CXXRecordDecl::DefinitionData::DefinitionData(CXXRecordDecl *D)
76  : UserDeclaredConstructor(false), UserDeclaredSpecialMembers(0),
77  Aggregate(true), PlainOldData(true), Empty(true), Polymorphic(false),
78  Abstract(false), IsStandardLayout(true), IsCXX11StandardLayout(true),
79  HasBasesWithFields(false), HasBasesWithNonStaticDataMembers(false),
80  HasPrivateFields(false), HasProtectedFields(false),
81  HasPublicFields(false), HasMutableFields(false), HasVariantMembers(false),
82  HasOnlyCMembers(true), HasInClassInitializer(false),
83  HasUninitializedReferenceMember(false), HasUninitializedFields(false),
84  HasInheritedConstructor(false),
85  HasInheritedDefaultConstructor(false),
86  HasInheritedAssignment(false),
87  NeedOverloadResolutionForCopyConstructor(false),
88  NeedOverloadResolutionForMoveConstructor(false),
89  NeedOverloadResolutionForCopyAssignment(false),
90  NeedOverloadResolutionForMoveAssignment(false),
91  NeedOverloadResolutionForDestructor(false),
92  DefaultedCopyConstructorIsDeleted(false),
93  DefaultedMoveConstructorIsDeleted(false),
94  DefaultedCopyAssignmentIsDeleted(false),
95  DefaultedMoveAssignmentIsDeleted(false),
96  DefaultedDestructorIsDeleted(false), HasTrivialSpecialMembers(SMF_All),
97  HasTrivialSpecialMembersForCall(SMF_All),
98  DeclaredNonTrivialSpecialMembers(0),
99  DeclaredNonTrivialSpecialMembersForCall(0), HasIrrelevantDestructor(true),
100  HasConstexprNonCopyMoveConstructor(false),
101  HasDefaultedDefaultConstructor(false),
102  DefaultedDefaultConstructorIsConstexpr(true),
103  HasConstexprDefaultConstructor(false),
104  DefaultedDestructorIsConstexpr(true),
105  HasNonLiteralTypeFieldsOrBases(false), StructuralIfLiteral(true),
106  UserProvidedDefaultConstructor(false), DeclaredSpecialMembers(0),
107  ImplicitCopyConstructorCanHaveConstParamForVBase(true),
108  ImplicitCopyConstructorCanHaveConstParamForNonVBase(true),
109  ImplicitCopyAssignmentHasConstParam(true),
110  HasDeclaredCopyConstructorWithConstParam(false),
111  HasDeclaredCopyAssignmentWithConstParam(false),
112  IsAnyDestructorNoReturn(false), IsLambda(false),
113  IsParsingBaseSpecifiers(false), ComputedVisibleConversions(false),
114  HasODRHash(false), Definition(D) {}
115 
116 CXXBaseSpecifier *CXXRecordDecl::DefinitionData::getBasesSlowCase() const {
117  return Bases.get(Definition->getASTContext().getExternalSource());
118 }
119 
120 CXXBaseSpecifier *CXXRecordDecl::DefinitionData::getVBasesSlowCase() const {
121  return VBases.get(Definition->getASTContext().getExternalSource());
122 }
123 
125  DeclContext *DC, SourceLocation StartLoc,
127  CXXRecordDecl *PrevDecl)
128  : RecordDecl(K, TK, C, DC, StartLoc, IdLoc, Id, PrevDecl),
129  DefinitionData(PrevDecl ? PrevDecl->DefinitionData
130  : nullptr) {}
131 
133  DeclContext *DC, SourceLocation StartLoc,
135  CXXRecordDecl *PrevDecl,
136  bool DelayTypeCreation) {
137  auto *R = new (C, DC) CXXRecordDecl(CXXRecord, TK, C, DC, StartLoc, IdLoc, Id,
138  PrevDecl);
139  R->setMayHaveOutOfDateDef(C.getLangOpts().Modules);
140 
141  // FIXME: DelayTypeCreation seems like such a hack
142  if (!DelayTypeCreation)
143  C.getTypeDeclType(R, PrevDecl);
144  return R;
145 }
146 
149  TypeSourceInfo *Info, SourceLocation Loc,
150  bool Dependent, bool IsGeneric,
151  LambdaCaptureDefault CaptureDefault) {
152  auto *R = new (C, DC) CXXRecordDecl(CXXRecord, TTK_Class, C, DC, Loc, Loc,
153  nullptr, nullptr);
154  R->setBeingDefined(true);
155  R->DefinitionData =
156  new (C) struct LambdaDefinitionData(R, Info, Dependent, IsGeneric,
157  CaptureDefault);
158  R->setMayHaveOutOfDateDef(false);
159  R->setImplicit(true);
160  C.getTypeDeclType(R, /*PrevDecl=*/nullptr);
161  return R;
162 }
163 
166  auto *R = new (C, ID) CXXRecordDecl(
167  CXXRecord, TTK_Struct, C, nullptr, SourceLocation(), SourceLocation(),
168  nullptr, nullptr);
169  R->setMayHaveOutOfDateDef(false);
170  return R;
171 }
172 
173 /// Determine whether a class has a repeated base class. This is intended for
174 /// use when determining if a class is standard-layout, so makes no attempt to
175 /// handle virtual bases.
176 static bool hasRepeatedBaseClass(const CXXRecordDecl *StartRD) {
178  SmallVector<const CXXRecordDecl*, 8> WorkList = {StartRD};
179  while (!WorkList.empty()) {
180  const CXXRecordDecl *RD = WorkList.pop_back_val();
181  if (RD->getTypeForDecl()->isDependentType())
182  continue;
183  for (const CXXBaseSpecifier &BaseSpec : RD->bases()) {
184  if (const CXXRecordDecl *B = BaseSpec.getType()->getAsCXXRecordDecl()) {
185  if (!SeenBaseTypes.insert(B).second)
186  return true;
187  WorkList.push_back(B);
188  }
189  }
190  }
191  return false;
192 }
193 
194 void
196  unsigned NumBases) {
197  ASTContext &C = getASTContext();
198 
199  if (!data().Bases.isOffset() && data().NumBases > 0)
200  C.Deallocate(data().getBases());
201 
202  if (NumBases) {
203  if (!C.getLangOpts().CPlusPlus17) {
204  // C++ [dcl.init.aggr]p1:
205  // An aggregate is [...] a class with [...] no base classes [...].
206  data().Aggregate = false;
207  }
208 
209  // C++ [class]p4:
210  // A POD-struct is an aggregate class...
211  data().PlainOldData = false;
212  }
213 
214  // The set of seen virtual base types.
215  llvm::SmallPtrSet<CanQualType, 8> SeenVBaseTypes;
216 
217  // The virtual bases of this class.
219 
220  data().Bases = new(C) CXXBaseSpecifier [NumBases];
221  data().NumBases = NumBases;
222  for (unsigned i = 0; i < NumBases; ++i) {
223  data().getBases()[i] = *Bases[i];
224  // Keep track of inherited vbases for this base class.
225  const CXXBaseSpecifier *Base = Bases[i];
226  QualType BaseType = Base->getType();
227  // Skip dependent types; we can't do any checking on them now.
228  if (BaseType->isDependentType())
229  continue;
230  auto *BaseClassDecl =
231  cast<CXXRecordDecl>(BaseType->castAs<RecordType>()->getDecl());
232 
233  // C++2a [class]p7:
234  // A standard-layout class is a class that:
235  // [...]
236  // -- has all non-static data members and bit-fields in the class and
237  // its base classes first declared in the same class
238  if (BaseClassDecl->data().HasBasesWithFields ||
239  !BaseClassDecl->field_empty()) {
240  if (data().HasBasesWithFields)
241  // Two bases have members or bit-fields: not standard-layout.
242  data().IsStandardLayout = false;
243  data().HasBasesWithFields = true;
244  }
245 
246  // C++11 [class]p7:
247  // A standard-layout class is a class that:
248  // -- [...] has [...] at most one base class with non-static data
249  // members
250  if (BaseClassDecl->data().HasBasesWithNonStaticDataMembers ||
251  BaseClassDecl->hasDirectFields()) {
252  if (data().HasBasesWithNonStaticDataMembers)
253  data().IsCXX11StandardLayout = false;
254  data().HasBasesWithNonStaticDataMembers = true;
255  }
256 
257  if (!BaseClassDecl->isEmpty()) {
258  // C++14 [meta.unary.prop]p4:
259  // T is a class type [...] with [...] no base class B for which
260  // is_empty<B>::value is false.
261  data().Empty = false;
262  }
263 
264  // C++1z [dcl.init.agg]p1:
265  // An aggregate is a class with [...] no private or protected base classes
266  if (Base->getAccessSpecifier() != AS_public) {
267  data().Aggregate = false;
268 
269  // C++20 [temp.param]p7:
270  // A structural type is [...] a literal class type with [...] all base
271  // classes [...] public
272  data().StructuralIfLiteral = false;
273  }
274 
275  // C++ [class.virtual]p1:
276  // A class that declares or inherits a virtual function is called a
277  // polymorphic class.
278  if (BaseClassDecl->isPolymorphic()) {
279  data().Polymorphic = true;
280 
281  // An aggregate is a class with [...] no virtual functions.
282  data().Aggregate = false;
283  }
284 
285  // C++0x [class]p7:
286  // A standard-layout class is a class that: [...]
287  // -- has no non-standard-layout base classes
288  if (!BaseClassDecl->isStandardLayout())
289  data().IsStandardLayout = false;
290  if (!BaseClassDecl->isCXX11StandardLayout())
291  data().IsCXX11StandardLayout = false;
292 
293  // Record if this base is the first non-literal field or base.
294  if (!hasNonLiteralTypeFieldsOrBases() && !BaseType->isLiteralType(C))
295  data().HasNonLiteralTypeFieldsOrBases = true;
296 
297  // Now go through all virtual bases of this base and add them.
298  for (const auto &VBase : BaseClassDecl->vbases()) {
299  // Add this base if it's not already in the list.
300  if (SeenVBaseTypes.insert(C.getCanonicalType(VBase.getType())).second) {
301  VBases.push_back(&VBase);
302 
303  // C++11 [class.copy]p8:
304  // The implicitly-declared copy constructor for a class X will have
305  // the form 'X::X(const X&)' if each [...] virtual base class B of X
306  // has a copy constructor whose first parameter is of type
307  // 'const B&' or 'const volatile B&' [...]
308  if (CXXRecordDecl *VBaseDecl = VBase.getType()->getAsCXXRecordDecl())
309  if (!VBaseDecl->hasCopyConstructorWithConstParam())
310  data().ImplicitCopyConstructorCanHaveConstParamForVBase = false;
311 
312  // C++1z [dcl.init.agg]p1:
313  // An aggregate is a class with [...] no virtual base classes
314  data().Aggregate = false;
315  }
316  }
317 
318  if (Base->isVirtual()) {
319  // Add this base if it's not already in the list.
320  if (SeenVBaseTypes.insert(C.getCanonicalType(BaseType)).second)
321  VBases.push_back(Base);
322 
323  // C++14 [meta.unary.prop] is_empty:
324  // T is a class type, but not a union type, with ... no virtual base
325  // classes
326  data().Empty = false;
327 
328  // C++1z [dcl.init.agg]p1:
329  // An aggregate is a class with [...] no virtual base classes
330  data().Aggregate = false;
331 
332  // C++11 [class.ctor]p5, C++11 [class.copy]p12, C++11 [class.copy]p25:
333  // A [default constructor, copy/move constructor, or copy/move assignment
334  // operator for a class X] is trivial [...] if:
335  // -- class X has [...] no virtual base classes
336  data().HasTrivialSpecialMembers &= SMF_Destructor;
337  data().HasTrivialSpecialMembersForCall &= SMF_Destructor;
338 
339  // C++0x [class]p7:
340  // A standard-layout class is a class that: [...]
341  // -- has [...] no virtual base classes
342  data().IsStandardLayout = false;
343  data().IsCXX11StandardLayout = false;
344 
345  // C++20 [dcl.constexpr]p3:
346  // In the definition of a constexpr function [...]
347  // -- if the function is a constructor or destructor,
348  // its class shall not have any virtual base classes
349  data().DefaultedDefaultConstructorIsConstexpr = false;
350  data().DefaultedDestructorIsConstexpr = false;
351 
352  // C++1z [class.copy]p8:
353  // The implicitly-declared copy constructor for a class X will have
354  // the form 'X::X(const X&)' if each potentially constructed subobject
355  // has a copy constructor whose first parameter is of type
356  // 'const B&' or 'const volatile B&' [...]
357  if (!BaseClassDecl->hasCopyConstructorWithConstParam())
358  data().ImplicitCopyConstructorCanHaveConstParamForVBase = false;
359  } else {
360  // C++ [class.ctor]p5:
361  // A default constructor is trivial [...] if:
362  // -- all the direct base classes of its class have trivial default
363  // constructors.
364  if (!BaseClassDecl->hasTrivialDefaultConstructor())
365  data().HasTrivialSpecialMembers &= ~SMF_DefaultConstructor;
366 
367  // C++0x [class.copy]p13:
368  // A copy/move constructor for class X is trivial if [...]
369  // [...]
370  // -- the constructor selected to copy/move each direct base class
371  // subobject is trivial, and
372  if (!BaseClassDecl->hasTrivialCopyConstructor())
373  data().HasTrivialSpecialMembers &= ~SMF_CopyConstructor;
374 
375  if (!BaseClassDecl->hasTrivialCopyConstructorForCall())
376  data().HasTrivialSpecialMembersForCall &= ~SMF_CopyConstructor;
377 
378  // If the base class doesn't have a simple move constructor, we'll eagerly
379  // declare it and perform overload resolution to determine which function
380  // it actually calls. If it does have a simple move constructor, this
381  // check is correct.
382  if (!BaseClassDecl->hasTrivialMoveConstructor())
383  data().HasTrivialSpecialMembers &= ~SMF_MoveConstructor;
384 
385  if (!BaseClassDecl->hasTrivialMoveConstructorForCall())
386  data().HasTrivialSpecialMembersForCall &= ~SMF_MoveConstructor;
387 
388  // C++0x [class.copy]p27:
389  // A copy/move assignment operator for class X is trivial if [...]
390  // [...]
391  // -- the assignment operator selected to copy/move each direct base
392  // class subobject is trivial, and
393  if (!BaseClassDecl->hasTrivialCopyAssignment())
394  data().HasTrivialSpecialMembers &= ~SMF_CopyAssignment;
395  // If the base class doesn't have a simple move assignment, we'll eagerly
396  // declare it and perform overload resolution to determine which function
397  // it actually calls. If it does have a simple move assignment, this
398  // check is correct.
399  if (!BaseClassDecl->hasTrivialMoveAssignment())
400  data().HasTrivialSpecialMembers &= ~SMF_MoveAssignment;
401 
402  // C++11 [class.ctor]p6:
403  // If that user-written default constructor would satisfy the
404  // requirements of a constexpr constructor, the implicitly-defined
405  // default constructor is constexpr.
406  if (!BaseClassDecl->hasConstexprDefaultConstructor())
407  data().DefaultedDefaultConstructorIsConstexpr = false;
408 
409  // C++1z [class.copy]p8:
410  // The implicitly-declared copy constructor for a class X will have
411  // the form 'X::X(const X&)' if each potentially constructed subobject
412  // has a copy constructor whose first parameter is of type
413  // 'const B&' or 'const volatile B&' [...]
414  if (!BaseClassDecl->hasCopyConstructorWithConstParam())
415  data().ImplicitCopyConstructorCanHaveConstParamForNonVBase = false;
416  }
417 
418  // C++ [class.ctor]p3:
419  // A destructor is trivial if all the direct base classes of its class
420  // have trivial destructors.
421  if (!BaseClassDecl->hasTrivialDestructor())
422  data().HasTrivialSpecialMembers &= ~SMF_Destructor;
423 
424  if (!BaseClassDecl->hasTrivialDestructorForCall())
425  data().HasTrivialSpecialMembersForCall &= ~SMF_Destructor;
426 
427  if (!BaseClassDecl->hasIrrelevantDestructor())
428  data().HasIrrelevantDestructor = false;
429 
430  if (BaseClassDecl->isAnyDestructorNoReturn())
431  data().IsAnyDestructorNoReturn = true;
432 
433  // C++11 [class.copy]p18:
434  // The implicitly-declared copy assignment operator for a class X will
435  // have the form 'X& X::operator=(const X&)' if each direct base class B
436  // of X has a copy assignment operator whose parameter is of type 'const
437  // B&', 'const volatile B&', or 'B' [...]
438  if (!BaseClassDecl->hasCopyAssignmentWithConstParam())
439  data().ImplicitCopyAssignmentHasConstParam = false;
440 
441  // A class has an Objective-C object member if... or any of its bases
442  // has an Objective-C object member.
443  if (BaseClassDecl->hasObjectMember())
444  setHasObjectMember(true);
445 
446  if (BaseClassDecl->hasVolatileMember())
447  setHasVolatileMember(true);
448 
449  if (BaseClassDecl->getArgPassingRestrictions() ==
452 
453  // Keep track of the presence of mutable fields.
454  if (BaseClassDecl->hasMutableFields())
455  data().HasMutableFields = true;
456 
457  if (BaseClassDecl->hasUninitializedReferenceMember())
458  data().HasUninitializedReferenceMember = true;
459 
460  if (!BaseClassDecl->allowConstDefaultInit())
461  data().HasUninitializedFields = true;
462 
463  addedClassSubobject(BaseClassDecl);
464  }
465 
466  // C++2a [class]p7:
467  // A class S is a standard-layout class if it:
468  // -- has at most one base class subobject of any given type
469  //
470  // Note that we only need to check this for classes with more than one base
471  // class. If there's only one base class, and it's standard layout, then
472  // we know there are no repeated base classes.
473  if (data().IsStandardLayout && NumBases > 1 && hasRepeatedBaseClass(this))
474  data().IsStandardLayout = false;
475 
476  if (VBases.empty()) {
477  data().IsParsingBaseSpecifiers = false;
478  return;
479  }
480 
481  // Create base specifier for any direct or indirect virtual bases.
482  data().VBases = new (C) CXXBaseSpecifier[VBases.size()];
483  data().NumVBases = VBases.size();
484  for (int I = 0, E = VBases.size(); I != E; ++I) {
485  QualType Type = VBases[I]->getType();
486  if (!Type->isDependentType())
487  addedClassSubobject(Type->getAsCXXRecordDecl());
488  data().getVBases()[I] = *VBases[I];
489  }
490 
491  data().IsParsingBaseSpecifiers = false;
492 }
493 
494 unsigned CXXRecordDecl::getODRHash() const {
495  assert(hasDefinition() && "ODRHash only for records with definitions");
496 
497  // Previously calculated hash is stored in DefinitionData.
498  if (DefinitionData->HasODRHash)
499  return DefinitionData->ODRHash;
500 
501  // Only calculate hash on first call of getODRHash per record.
502  ODRHash Hash;
504  DefinitionData->HasODRHash = true;
505  DefinitionData->ODRHash = Hash.CalculateHash();
506 
507  return DefinitionData->ODRHash;
508 }
509 
510 void CXXRecordDecl::addedClassSubobject(CXXRecordDecl *Subobj) {
511  // C++11 [class.copy]p11:
512  // A defaulted copy/move constructor for a class X is defined as
513  // deleted if X has:
514  // -- a direct or virtual base class B that cannot be copied/moved [...]
515  // -- a non-static data member of class type M (or array thereof)
516  // that cannot be copied or moved [...]
517  if (!Subobj->hasSimpleCopyConstructor())
518  data().NeedOverloadResolutionForCopyConstructor = true;
519  if (!Subobj->hasSimpleMoveConstructor())
520  data().NeedOverloadResolutionForMoveConstructor = true;
521 
522  // C++11 [class.copy]p23:
523  // A defaulted copy/move assignment operator for a class X is defined as
524  // deleted if X has:
525  // -- a direct or virtual base class B that cannot be copied/moved [...]
526  // -- a non-static data member of class type M (or array thereof)
527  // that cannot be copied or moved [...]
528  if (!Subobj->hasSimpleCopyAssignment())
529  data().NeedOverloadResolutionForCopyAssignment = true;
530  if (!Subobj->hasSimpleMoveAssignment())
531  data().NeedOverloadResolutionForMoveAssignment = true;
532 
533  // C++11 [class.ctor]p5, C++11 [class.copy]p11, C++11 [class.dtor]p5:
534  // A defaulted [ctor or dtor] for a class X is defined as
535  // deleted if X has:
536  // -- any direct or virtual base class [...] has a type with a destructor
537  // that is deleted or inaccessible from the defaulted [ctor or dtor].
538  // -- any non-static data member has a type with a destructor
539  // that is deleted or inaccessible from the defaulted [ctor or dtor].
540  if (!Subobj->hasSimpleDestructor()) {
541  data().NeedOverloadResolutionForCopyConstructor = true;
542  data().NeedOverloadResolutionForMoveConstructor = true;
543  data().NeedOverloadResolutionForDestructor = true;
544  }
545 
546  // C++2a [dcl.constexpr]p4:
547  // The definition of a constexpr destructor [shall] satisfy the
548  // following requirement:
549  // -- for every subobject of class type or (possibly multi-dimensional)
550  // array thereof, that class type shall have a constexpr destructor
551  if (!Subobj->hasConstexprDestructor())
552  data().DefaultedDestructorIsConstexpr = false;
553 
554  // C++20 [temp.param]p7:
555  // A structural type is [...] a literal class type [for which] the types
556  // of all base classes and non-static data members are structural types or
557  // (possibly multi-dimensional) array thereof
558  if (!Subobj->data().StructuralIfLiteral)
559  data().StructuralIfLiteral = false;
560 }
561 
563  auto *Dtor = getDestructor();
564  return Dtor ? Dtor->isConstexpr() : defaultedDestructorIsConstexpr();
565 }
566 
568  if (!isDependentContext())
569  return false;
570 
571  return !forallBases([](const CXXRecordDecl *) { return true; });
572 }
573 
575  // C++0x [class]p5:
576  // A trivially copyable class is a class that:
577  // -- has no non-trivial copy constructors,
578  if (hasNonTrivialCopyConstructor()) return false;
579  // -- has no non-trivial move constructors,
580  if (hasNonTrivialMoveConstructor()) return false;
581  // -- has no non-trivial copy assignment operators,
582  if (hasNonTrivialCopyAssignment()) return false;
583  // -- has no non-trivial move assignment operators, and
584  if (hasNonTrivialMoveAssignment()) return false;
585  // -- has a trivial destructor.
586  if (!hasTrivialDestructor()) return false;
587 
588  return true;
589 }
590 
591 void CXXRecordDecl::markedVirtualFunctionPure() {
592  // C++ [class.abstract]p2:
593  // A class is abstract if it has at least one pure virtual function.
594  data().Abstract = true;
595 }
596 
597 bool CXXRecordDecl::hasSubobjectAtOffsetZeroOfEmptyBaseType(
598  ASTContext &Ctx, const CXXRecordDecl *XFirst) {
599  if (!getNumBases())
600  return false;
601 
605 
606  // Visit a type that we have determined is an element of M(S).
607  auto Visit = [&](const CXXRecordDecl *RD) -> bool {
608  RD = RD->getCanonicalDecl();
609 
610  // C++2a [class]p8:
611  // A class S is a standard-layout class if it [...] has no element of the
612  // set M(S) of types as a base class.
613  //
614  // If we find a subobject of an empty type, it might also be a base class,
615  // so we'll need to walk the base classes to check.
616  if (!RD->data().HasBasesWithFields) {
617  // Walk the bases the first time, stopping if we find the type. Build a
618  // set of them so we don't need to walk them again.
619  if (Bases.empty()) {
620  bool RDIsBase = !forallBases([&](const CXXRecordDecl *Base) -> bool {
621  Base = Base->getCanonicalDecl();
622  if (RD == Base)
623  return false;
624  Bases.insert(Base);
625  return true;
626  });
627  if (RDIsBase)
628  return true;
629  } else {
630  if (Bases.count(RD))
631  return true;
632  }
633  }
634 
635  if (M.insert(RD).second)
636  WorkList.push_back(RD);
637  return false;
638  };
639 
640  if (Visit(XFirst))
641  return true;
642 
643  while (!WorkList.empty()) {
644  const CXXRecordDecl *X = WorkList.pop_back_val();
645 
646  // FIXME: We don't check the bases of X. That matches the standard, but
647  // that sure looks like a wording bug.
648 
649  // -- If X is a non-union class type with a non-static data member
650  // [recurse to each field] that is either of zero size or is the
651  // first non-static data member of X
652  // -- If X is a union type, [recurse to union members]
653  bool IsFirstField = true;
654  for (auto *FD : X->fields()) {
655  // FIXME: Should we really care about the type of the first non-static
656  // data member of a non-union if there are preceding unnamed bit-fields?
657  if (FD->isUnnamedBitfield())
658  continue;
659 
660  if (!IsFirstField && !FD->isZeroSize(Ctx))
661  continue;
662 
663  // -- If X is n array type, [visit the element type]
664  QualType T = Ctx.getBaseElementType(FD->getType());
665  if (auto *RD = T->getAsCXXRecordDecl())
666  if (Visit(RD))
667  return true;
668 
669  if (!X->isUnion())
670  IsFirstField = false;
671  }
672  }
673 
674  return false;
675 }
676 
678  assert(isLambda() && "not a lambda");
679 
680  // C++2a [expr.prim.lambda.capture]p11:
681  // The closure type associated with a lambda-expression has no default
682  // constructor if the lambda-expression has a lambda-capture and a
683  // defaulted default constructor otherwise. It has a deleted copy
684  // assignment operator if the lambda-expression has a lambda-capture and
685  // defaulted copy and move assignment operators otherwise.
686  //
687  // C++17 [expr.prim.lambda]p21:
688  // The closure type associated with a lambda-expression has no default
689  // constructor and a deleted copy assignment operator.
690  if (getLambdaCaptureDefault() != LCD_None || capture_size() != 0)
691  return false;
692  return getASTContext().getLangOpts().CPlusPlus20;
693 }
694 
695 void CXXRecordDecl::addedMember(Decl *D) {
696  if (!D->isImplicit() &&
697  !isa<FieldDecl>(D) &&
698  !isa<IndirectFieldDecl>(D) &&
699  (!isa<TagDecl>(D) || cast<TagDecl>(D)->getTagKind() == TTK_Class ||
700  cast<TagDecl>(D)->getTagKind() == TTK_Interface))
701  data().HasOnlyCMembers = false;
702 
703  // Ignore friends and invalid declarations.
704  if (D->getFriendObjectKind() || D->isInvalidDecl())
705  return;
706 
707  auto *FunTmpl = dyn_cast<FunctionTemplateDecl>(D);
708  if (FunTmpl)
709  D = FunTmpl->getTemplatedDecl();
710 
711  // FIXME: Pass NamedDecl* to addedMember?
712  Decl *DUnderlying = D;
713  if (auto *ND = dyn_cast<NamedDecl>(DUnderlying)) {
714  DUnderlying = ND->getUnderlyingDecl();
715  if (auto *UnderlyingFunTmpl = dyn_cast<FunctionTemplateDecl>(DUnderlying))
716  DUnderlying = UnderlyingFunTmpl->getTemplatedDecl();
717  }
718 
719  if (const auto *Method = dyn_cast<CXXMethodDecl>(D)) {
720  if (Method->isVirtual()) {
721  // C++ [dcl.init.aggr]p1:
722  // An aggregate is an array or a class with [...] no virtual functions.
723  data().Aggregate = false;
724 
725  // C++ [class]p4:
726  // A POD-struct is an aggregate class...
727  data().PlainOldData = false;
728 
729  // C++14 [meta.unary.prop]p4:
730  // T is a class type [...] with [...] no virtual member functions...
731  data().Empty = false;
732 
733  // C++ [class.virtual]p1:
734  // A class that declares or inherits a virtual function is called a
735  // polymorphic class.
736  data().Polymorphic = true;
737 
738  // C++11 [class.ctor]p5, C++11 [class.copy]p12, C++11 [class.copy]p25:
739  // A [default constructor, copy/move constructor, or copy/move
740  // assignment operator for a class X] is trivial [...] if:
741  // -- class X has no virtual functions [...]
742  data().HasTrivialSpecialMembers &= SMF_Destructor;
743  data().HasTrivialSpecialMembersForCall &= SMF_Destructor;
744 
745  // C++0x [class]p7:
746  // A standard-layout class is a class that: [...]
747  // -- has no virtual functions
748  data().IsStandardLayout = false;
749  data().IsCXX11StandardLayout = false;
750  }
751  }
752 
753  // Notify the listener if an implicit member was added after the definition
754  // was completed.
755  if (!isBeingDefined() && D->isImplicit())
757  L->AddedCXXImplicitMember(data().Definition, D);
758 
759  // The kind of special member this declaration is, if any.
760  unsigned SMKind = 0;
761 
762  // Handle constructors.
763  if (const auto *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
764  if (Constructor->isInheritingConstructor()) {
765  // Ignore constructor shadow declarations. They are lazily created and
766  // so shouldn't affect any properties of the class.
767  } else {
768  if (!Constructor->isImplicit()) {
769  // Note that we have a user-declared constructor.
770  data().UserDeclaredConstructor = true;
771 
772  // C++ [class]p4:
773  // A POD-struct is an aggregate class [...]
774  // Since the POD bit is meant to be C++03 POD-ness, clear it even if
775  // the type is technically an aggregate in C++0x since it wouldn't be
776  // in 03.
777  data().PlainOldData = false;
778  }
779 
780  if (Constructor->isDefaultConstructor()) {
781  SMKind |= SMF_DefaultConstructor;
782 
783  if (Constructor->isUserProvided())
784  data().UserProvidedDefaultConstructor = true;
785  if (Constructor->isConstexpr())
786  data().HasConstexprDefaultConstructor = true;
787  if (Constructor->isDefaulted())
788  data().HasDefaultedDefaultConstructor = true;
789  }
790 
791  if (!FunTmpl) {
792  unsigned Quals;
793  if (Constructor->isCopyConstructor(Quals)) {
794  SMKind |= SMF_CopyConstructor;
795 
796  if (Quals & Qualifiers::Const)
797  data().HasDeclaredCopyConstructorWithConstParam = true;
798  } else if (Constructor->isMoveConstructor())
799  SMKind |= SMF_MoveConstructor;
800  }
801 
802  // C++11 [dcl.init.aggr]p1: DR1518
803  // An aggregate is an array or a class with no user-provided [or]
804  // explicit [...] constructors
805  // C++20 [dcl.init.aggr]p1:
806  // An aggregate is an array or a class with no user-declared [...]
807  // constructors
809  ? !Constructor->isImplicit()
810  : (Constructor->isUserProvided() || Constructor->isExplicit()))
811  data().Aggregate = false;
812  }
813  }
814 
815  // Handle constructors, including those inherited from base classes.
816  if (const auto *Constructor = dyn_cast<CXXConstructorDecl>(DUnderlying)) {
817  // Record if we see any constexpr constructors which are neither copy
818  // nor move constructors.
819  // C++1z [basic.types]p10:
820  // [...] has at least one constexpr constructor or constructor template
821  // (possibly inherited from a base class) that is not a copy or move
822  // constructor [...]
823  if (Constructor->isConstexpr() && !Constructor->isCopyOrMoveConstructor())
824  data().HasConstexprNonCopyMoveConstructor = true;
825  if (!isa<CXXConstructorDecl>(D) && Constructor->isDefaultConstructor())
826  data().HasInheritedDefaultConstructor = true;
827  }
828 
829  // Handle destructors.
830  if (const auto *DD = dyn_cast<CXXDestructorDecl>(D)) {
831  SMKind |= SMF_Destructor;
832 
833  if (DD->isUserProvided())
834  data().HasIrrelevantDestructor = false;
835  // If the destructor is explicitly defaulted and not trivial or not public
836  // or if the destructor is deleted, we clear HasIrrelevantDestructor in
837  // finishedDefaultedOrDeletedMember.
838 
839  // C++11 [class.dtor]p5:
840  // A destructor is trivial if [...] the destructor is not virtual.
841  if (DD->isVirtual()) {
842  data().HasTrivialSpecialMembers &= ~SMF_Destructor;
843  data().HasTrivialSpecialMembersForCall &= ~SMF_Destructor;
844  }
845 
846  if (DD->isNoReturn())
847  data().IsAnyDestructorNoReturn = true;
848  }
849 
850  // Handle member functions.
851  if (const auto *Method = dyn_cast<CXXMethodDecl>(D)) {
852  if (Method->isCopyAssignmentOperator()) {
853  SMKind |= SMF_CopyAssignment;
854 
855  const auto *ParamTy =
856  Method->getParamDecl(0)->getType()->getAs<ReferenceType>();
857  if (!ParamTy || ParamTy->getPointeeType().isConstQualified())
858  data().HasDeclaredCopyAssignmentWithConstParam = true;
859  }
860 
861  if (Method->isMoveAssignmentOperator())
862  SMKind |= SMF_MoveAssignment;
863 
864  // Keep the list of conversion functions up-to-date.
865  if (auto *Conversion = dyn_cast<CXXConversionDecl>(D)) {
866  // FIXME: We use the 'unsafe' accessor for the access specifier here,
867  // because Sema may not have set it yet. That's really just a misdesign
868  // in Sema. However, LLDB *will* have set the access specifier correctly,
869  // and adds declarations after the class is technically completed,
870  // so completeDefinition()'s overriding of the access specifiers doesn't
871  // work.
872  AccessSpecifier AS = Conversion->getAccessUnsafe();
873 
874  if (Conversion->getPrimaryTemplate()) {
875  // We don't record specializations.
876  } else {
877  ASTContext &Ctx = getASTContext();
878  ASTUnresolvedSet &Conversions = data().Conversions.get(Ctx);
879  NamedDecl *Primary =
880  FunTmpl ? cast<NamedDecl>(FunTmpl) : cast<NamedDecl>(Conversion);
881  if (Primary->getPreviousDecl())
882  Conversions.replace(cast<NamedDecl>(Primary->getPreviousDecl()),
883  Primary, AS);
884  else
885  Conversions.addDecl(Ctx, Primary, AS);
886  }
887  }
888 
889  if (SMKind) {
890  // If this is the first declaration of a special member, we no longer have
891  // an implicit trivial special member.
892  data().HasTrivialSpecialMembers &=
893  data().DeclaredSpecialMembers | ~SMKind;
894  data().HasTrivialSpecialMembersForCall &=
895  data().DeclaredSpecialMembers | ~SMKind;
896 
897  if (!Method->isImplicit() && !Method->isUserProvided()) {
898  // This method is user-declared but not user-provided. We can't work out
899  // whether it's trivial yet (not until we get to the end of the class).
900  // We'll handle this method in finishedDefaultedOrDeletedMember.
901  } else if (Method->isTrivial()) {
902  data().HasTrivialSpecialMembers |= SMKind;
903  data().HasTrivialSpecialMembersForCall |= SMKind;
904  } else if (Method->isTrivialForCall()) {
905  data().HasTrivialSpecialMembersForCall |= SMKind;
906  data().DeclaredNonTrivialSpecialMembers |= SMKind;
907  } else {
908  data().DeclaredNonTrivialSpecialMembers |= SMKind;
909  // If this is a user-provided function, do not set
910  // DeclaredNonTrivialSpecialMembersForCall here since we don't know
911  // yet whether the method would be considered non-trivial for the
912  // purpose of calls (attribute "trivial_abi" can be dropped from the
913  // class later, which can change the special method's triviality).
914  if (!Method->isUserProvided())
915  data().DeclaredNonTrivialSpecialMembersForCall |= SMKind;
916  }
917 
918  // Note when we have declared a declared special member, and suppress the
919  // implicit declaration of this special member.
920  data().DeclaredSpecialMembers |= SMKind;
921 
922  if (!Method->isImplicit()) {
923  data().UserDeclaredSpecialMembers |= SMKind;
924 
925  // C++03 [class]p4:
926  // A POD-struct is an aggregate class that has [...] no user-defined
927  // copy assignment operator and no user-defined destructor.
928  //
929  // Since the POD bit is meant to be C++03 POD-ness, and in C++03,
930  // aggregates could not have any constructors, clear it even for an
931  // explicitly defaulted or deleted constructor.
932  // type is technically an aggregate in C++0x since it wouldn't be in 03.
933  //
934  // Also, a user-declared move assignment operator makes a class non-POD.
935  // This is an extension in C++03.
936  data().PlainOldData = false;
937  }
938  }
939 
940  return;
941  }
942 
943  // Handle non-static data members.
944  if (const auto *Field = dyn_cast<FieldDecl>(D)) {
945  ASTContext &Context = getASTContext();
946 
947  // C++2a [class]p7:
948  // A standard-layout class is a class that:
949  // [...]
950  // -- has all non-static data members and bit-fields in the class and
951  // its base classes first declared in the same class
952  if (data().HasBasesWithFields)
953  data().IsStandardLayout = false;
954 
955  // C++ [class.bit]p2:
956  // A declaration for a bit-field that omits the identifier declares an
957  // unnamed bit-field. Unnamed bit-fields are not members and cannot be
958  // initialized.
959  if (Field->isUnnamedBitfield()) {
960  // C++ [meta.unary.prop]p4: [LWG2358]
961  // T is a class type [...] with [...] no unnamed bit-fields of non-zero
962  // length
963  if (data().Empty && !Field->isZeroLengthBitField(Context) &&
964  Context.getLangOpts().getClangABICompat() >
966  data().Empty = false;
967  return;
968  }
969 
970  // C++11 [class]p7:
971  // A standard-layout class is a class that:
972  // -- either has no non-static data members in the most derived class
973  // [...] or has no base classes with non-static data members
974  if (data().HasBasesWithNonStaticDataMembers)
975  data().IsCXX11StandardLayout = false;
976 
977  // C++ [dcl.init.aggr]p1:
978  // An aggregate is an array or a class (clause 9) with [...] no
979  // private or protected non-static data members (clause 11).
980  //
981  // A POD must be an aggregate.
982  if (D->getAccess() == AS_private || D->getAccess() == AS_protected) {
983  data().Aggregate = false;
984  data().PlainOldData = false;
985 
986  // C++20 [temp.param]p7:
987  // A structural type is [...] a literal class type [for which] all
988  // non-static data members are public
989  data().StructuralIfLiteral = false;
990  }
991 
992  // Track whether this is the first field. We use this when checking
993  // whether the class is standard-layout below.
994  bool IsFirstField = !data().HasPrivateFields &&
995  !data().HasProtectedFields && !data().HasPublicFields;
996 
997  // C++0x [class]p7:
998  // A standard-layout class is a class that:
999  // [...]
1000  // -- has the same access control for all non-static data members,
1001  switch (D->getAccess()) {
1002  case AS_private: data().HasPrivateFields = true; break;
1003  case AS_protected: data().HasProtectedFields = true; break;
1004  case AS_public: data().HasPublicFields = true; break;
1005  case AS_none: llvm_unreachable("Invalid access specifier");
1006  };
1007  if ((data().HasPrivateFields + data().HasProtectedFields +
1008  data().HasPublicFields) > 1) {
1009  data().IsStandardLayout = false;
1010  data().IsCXX11StandardLayout = false;
1011  }
1012 
1013  // Keep track of the presence of mutable fields.
1014  if (Field->isMutable()) {
1015  data().HasMutableFields = true;
1016 
1017  // C++20 [temp.param]p7:
1018  // A structural type is [...] a literal class type [for which] all
1019  // non-static data members are public
1020  data().StructuralIfLiteral = false;
1021  }
1022 
1023  // C++11 [class.union]p8, DR1460:
1024  // If X is a union, a non-static data member of X that is not an anonymous
1025  // union is a variant member of X.
1026  if (isUnion() && !Field->isAnonymousStructOrUnion())
1027  data().HasVariantMembers = true;
1028 
1029  // C++0x [class]p9:
1030  // A POD struct is a class that is both a trivial class and a
1031  // standard-layout class, and has no non-static data members of type
1032  // non-POD struct, non-POD union (or array of such types).
1033  //
1034  // Automatic Reference Counting: the presence of a member of Objective-C pointer type
1035  // that does not explicitly have no lifetime makes the class a non-POD.
1036  QualType T = Context.getBaseElementType(Field->getType());
1037  if (T->isObjCRetainableType() || T.isObjCGCStrong()) {
1038  if (T.hasNonTrivialObjCLifetime()) {
1039  // Objective-C Automatic Reference Counting:
1040  // If a class has a non-static data member of Objective-C pointer
1041  // type (or array thereof), it is a non-POD type and its
1042  // default constructor (if any), copy constructor, move constructor,
1043  // copy assignment operator, move assignment operator, and destructor are
1044  // non-trivial.
1045  setHasObjectMember(true);
1046  struct DefinitionData &Data = data();
1047  Data.PlainOldData = false;
1048  Data.HasTrivialSpecialMembers = 0;
1049 
1050  // __strong or __weak fields do not make special functions non-trivial
1051  // for the purpose of calls.
1054  data().HasTrivialSpecialMembersForCall = 0;
1055 
1056  // Structs with __weak fields should never be passed directly.
1057  if (LT == Qualifiers::OCL_Weak)
1059 
1060  Data.HasIrrelevantDestructor = false;
1061 
1062  if (isUnion()) {
1063  data().DefaultedCopyConstructorIsDeleted = true;
1064  data().DefaultedMoveConstructorIsDeleted = true;
1065  data().DefaultedCopyAssignmentIsDeleted = true;
1066  data().DefaultedMoveAssignmentIsDeleted = true;
1067  data().DefaultedDestructorIsDeleted = true;
1068  data().NeedOverloadResolutionForCopyConstructor = true;
1069  data().NeedOverloadResolutionForMoveConstructor = true;
1070  data().NeedOverloadResolutionForCopyAssignment = true;
1071  data().NeedOverloadResolutionForMoveAssignment = true;
1072  data().NeedOverloadResolutionForDestructor = true;
1073  }
1074  } else if (!Context.getLangOpts().ObjCAutoRefCount) {
1075  setHasObjectMember(true);
1076  }
1077  } else if (!T.isCXX98PODType(Context))
1078  data().PlainOldData = false;
1079 
1080  if (T->isReferenceType()) {
1081  if (!Field->hasInClassInitializer())
1082  data().HasUninitializedReferenceMember = true;
1083 
1084  // C++0x [class]p7:
1085  // A standard-layout class is a class that:
1086  // -- has no non-static data members of type [...] reference,
1087  data().IsStandardLayout = false;
1088  data().IsCXX11StandardLayout = false;
1089 
1090  // C++1z [class.copy.ctor]p10:
1091  // A defaulted copy constructor for a class X is defined as deleted if X has:
1092  // -- a non-static data member of rvalue reference type
1093  if (T->isRValueReferenceType())
1094  data().DefaultedCopyConstructorIsDeleted = true;
1095  }
1096 
1097  if (!Field->hasInClassInitializer() && !Field->isMutable()) {
1098  if (CXXRecordDecl *FieldType = T->getAsCXXRecordDecl()) {
1099  if (FieldType->hasDefinition() && !FieldType->allowConstDefaultInit())
1100  data().HasUninitializedFields = true;
1101  } else {
1102  data().HasUninitializedFields = true;
1103  }
1104  }
1105 
1106  // Record if this field is the first non-literal or volatile field or base.
1107  if (!T->isLiteralType(Context) || T.isVolatileQualified())
1108  data().HasNonLiteralTypeFieldsOrBases = true;
1109 
1110  if (Field->hasInClassInitializer() ||
1111  (Field->isAnonymousStructOrUnion() &&
1112  Field->getType()->getAsCXXRecordDecl()->hasInClassInitializer())) {
1113  data().HasInClassInitializer = true;
1114 
1115  // C++11 [class]p5:
1116  // A default constructor is trivial if [...] no non-static data member
1117  // of its class has a brace-or-equal-initializer.
1118  data().HasTrivialSpecialMembers &= ~SMF_DefaultConstructor;
1119 
1120  // C++11 [dcl.init.aggr]p1:
1121  // An aggregate is a [...] class with [...] no
1122  // brace-or-equal-initializers for non-static data members.
1123  //
1124  // This rule was removed in C++14.
1126  data().Aggregate = false;
1127 
1128  // C++11 [class]p10:
1129  // A POD struct is [...] a trivial class.
1130  data().PlainOldData = false;
1131  }
1132 
1133  // C++11 [class.copy]p23:
1134  // A defaulted copy/move assignment operator for a class X is defined
1135  // as deleted if X has:
1136  // -- a non-static data member of reference type
1137  if (T->isReferenceType()) {
1138  data().DefaultedCopyAssignmentIsDeleted = true;
1139  data().DefaultedMoveAssignmentIsDeleted = true;
1140  }
1141 
1142  // Bitfields of length 0 are also zero-sized, but we already bailed out for
1143  // those because they are always unnamed.
1144  bool IsZeroSize = Field->isZeroSize(Context);
1145 
1146  if (const auto *RecordTy = T->getAs<RecordType>()) {
1147  auto *FieldRec = cast<CXXRecordDecl>(RecordTy->getDecl());
1148  if (FieldRec->getDefinition()) {
1149  addedClassSubobject(FieldRec);
1150 
1151  // We may need to perform overload resolution to determine whether a
1152  // field can be moved if it's const or volatile qualified.
1154  // We need to care about 'const' for the copy constructor because an
1155  // implicit copy constructor might be declared with a non-const
1156  // parameter.
1157  data().NeedOverloadResolutionForCopyConstructor = true;
1158  data().NeedOverloadResolutionForMoveConstructor = true;
1159  data().NeedOverloadResolutionForCopyAssignment = true;
1160  data().NeedOverloadResolutionForMoveAssignment = true;
1161  }
1162 
1163  // C++11 [class.ctor]p5, C++11 [class.copy]p11:
1164  // A defaulted [special member] for a class X is defined as
1165  // deleted if:
1166  // -- X is a union-like class that has a variant member with a
1167  // non-trivial [corresponding special member]
1168  if (isUnion()) {
1169  if (FieldRec->hasNonTrivialCopyConstructor())
1170  data().DefaultedCopyConstructorIsDeleted = true;
1171  if (FieldRec->hasNonTrivialMoveConstructor())
1172  data().DefaultedMoveConstructorIsDeleted = true;
1173  if (FieldRec->hasNonTrivialCopyAssignment())
1174  data().DefaultedCopyAssignmentIsDeleted = true;
1175  if (FieldRec->hasNonTrivialMoveAssignment())
1176  data().DefaultedMoveAssignmentIsDeleted = true;
1177  if (FieldRec->hasNonTrivialDestructor())
1178  data().DefaultedDestructorIsDeleted = true;
1179  }
1180 
1181  // For an anonymous union member, our overload resolution will perform
1182  // overload resolution for its members.
1183  if (Field->isAnonymousStructOrUnion()) {
1184  data().NeedOverloadResolutionForCopyConstructor |=
1185  FieldRec->data().NeedOverloadResolutionForCopyConstructor;
1186  data().NeedOverloadResolutionForMoveConstructor |=
1187  FieldRec->data().NeedOverloadResolutionForMoveConstructor;
1188  data().NeedOverloadResolutionForCopyAssignment |=
1189  FieldRec->data().NeedOverloadResolutionForCopyAssignment;
1190  data().NeedOverloadResolutionForMoveAssignment |=
1191  FieldRec->data().NeedOverloadResolutionForMoveAssignment;
1192  data().NeedOverloadResolutionForDestructor |=
1193  FieldRec->data().NeedOverloadResolutionForDestructor;
1194  }
1195 
1196  // C++0x [class.ctor]p5:
1197  // A default constructor is trivial [...] if:
1198  // -- for all the non-static data members of its class that are of
1199  // class type (or array thereof), each such class has a trivial
1200  // default constructor.
1201  if (!FieldRec->hasTrivialDefaultConstructor())
1202  data().HasTrivialSpecialMembers &= ~SMF_DefaultConstructor;
1203 
1204  // C++0x [class.copy]p13:
1205  // A copy/move constructor for class X is trivial if [...]
1206  // [...]
1207  // -- for each non-static data member of X that is of class type (or
1208  // an array thereof), the constructor selected to copy/move that
1209  // member is trivial;
1210  if (!FieldRec->hasTrivialCopyConstructor())
1211  data().HasTrivialSpecialMembers &= ~SMF_CopyConstructor;
1212 
1213  if (!FieldRec->hasTrivialCopyConstructorForCall())
1214  data().HasTrivialSpecialMembersForCall &= ~SMF_CopyConstructor;
1215 
1216  // If the field doesn't have a simple move constructor, we'll eagerly
1217  // declare the move constructor for this class and we'll decide whether
1218  // it's trivial then.
1219  if (!FieldRec->hasTrivialMoveConstructor())
1220  data().HasTrivialSpecialMembers &= ~SMF_MoveConstructor;
1221 
1222  if (!FieldRec->hasTrivialMoveConstructorForCall())
1223  data().HasTrivialSpecialMembersForCall &= ~SMF_MoveConstructor;
1224 
1225  // C++0x [class.copy]p27:
1226  // A copy/move assignment operator for class X is trivial if [...]
1227  // [...]
1228  // -- for each non-static data member of X that is of class type (or
1229  // an array thereof), the assignment operator selected to
1230  // copy/move that member is trivial;
1231  if (!FieldRec->hasTrivialCopyAssignment())
1232  data().HasTrivialSpecialMembers &= ~SMF_CopyAssignment;
1233  // If the field doesn't have a simple move assignment, we'll eagerly
1234  // declare the move assignment for this class and we'll decide whether
1235  // it's trivial then.
1236  if (!FieldRec->hasTrivialMoveAssignment())
1237  data().HasTrivialSpecialMembers &= ~SMF_MoveAssignment;
1238 
1239  if (!FieldRec->hasTrivialDestructor())
1240  data().HasTrivialSpecialMembers &= ~SMF_Destructor;
1241  if (!FieldRec->hasTrivialDestructorForCall())
1242  data().HasTrivialSpecialMembersForCall &= ~SMF_Destructor;
1243  if (!FieldRec->hasIrrelevantDestructor())
1244  data().HasIrrelevantDestructor = false;
1245  if (FieldRec->isAnyDestructorNoReturn())
1246  data().IsAnyDestructorNoReturn = true;
1247  if (FieldRec->hasObjectMember())
1248  setHasObjectMember(true);
1249  if (FieldRec->hasVolatileMember())
1250  setHasVolatileMember(true);
1251  if (FieldRec->getArgPassingRestrictions() ==
1254 
1255  // C++0x [class]p7:
1256  // A standard-layout class is a class that:
1257  // -- has no non-static data members of type non-standard-layout
1258  // class (or array of such types) [...]
1259  if (!FieldRec->isStandardLayout())
1260  data().IsStandardLayout = false;
1261  if (!FieldRec->isCXX11StandardLayout())
1262  data().IsCXX11StandardLayout = false;
1263 
1264  // C++2a [class]p7:
1265  // A standard-layout class is a class that:
1266  // [...]
1267  // -- has no element of the set M(S) of types as a base class.
1268  if (data().IsStandardLayout &&
1269  (isUnion() || IsFirstField || IsZeroSize) &&
1270  hasSubobjectAtOffsetZeroOfEmptyBaseType(Context, FieldRec))
1271  data().IsStandardLayout = false;
1272 
1273  // C++11 [class]p7:
1274  // A standard-layout class is a class that:
1275  // -- has no base classes of the same type as the first non-static
1276  // data member
1277  if (data().IsCXX11StandardLayout && IsFirstField) {
1278  // FIXME: We should check all base classes here, not just direct
1279  // base classes.
1280  for (const auto &BI : bases()) {
1281  if (Context.hasSameUnqualifiedType(BI.getType(), T)) {
1282  data().IsCXX11StandardLayout = false;
1283  break;
1284  }
1285  }
1286  }
1287 
1288  // Keep track of the presence of mutable fields.
1289  if (FieldRec->hasMutableFields())
1290  data().HasMutableFields = true;
1291 
1292  if (Field->isMutable()) {
1293  // Our copy constructor/assignment might call something other than
1294  // the subobject's copy constructor/assignment if it's mutable and of
1295  // class type.
1296  data().NeedOverloadResolutionForCopyConstructor = true;
1297  data().NeedOverloadResolutionForCopyAssignment = true;
1298  }
1299 
1300  // C++11 [class.copy]p13:
1301  // If the implicitly-defined constructor would satisfy the
1302  // requirements of a constexpr constructor, the implicitly-defined
1303  // constructor is constexpr.
1304  // C++11 [dcl.constexpr]p4:
1305  // -- every constructor involved in initializing non-static data
1306  // members [...] shall be a constexpr constructor
1307  if (!Field->hasInClassInitializer() &&
1308  !FieldRec->hasConstexprDefaultConstructor() && !isUnion())
1309  // The standard requires any in-class initializer to be a constant
1310  // expression. We consider this to be a defect.
1311  data().DefaultedDefaultConstructorIsConstexpr = false;
1312 
1313  // C++11 [class.copy]p8:
1314  // The implicitly-declared copy constructor for a class X will have
1315  // the form 'X::X(const X&)' if each potentially constructed subobject
1316  // of a class type M (or array thereof) has a copy constructor whose
1317  // first parameter is of type 'const M&' or 'const volatile M&'.
1318  if (!FieldRec->hasCopyConstructorWithConstParam())
1319  data().ImplicitCopyConstructorCanHaveConstParamForNonVBase = false;
1320 
1321  // C++11 [class.copy]p18:
1322  // The implicitly-declared copy assignment oeprator for a class X will
1323  // have the form 'X& X::operator=(const X&)' if [...] for all the
1324  // non-static data members of X that are of a class type M (or array
1325  // thereof), each such class type has a copy assignment operator whose
1326  // parameter is of type 'const M&', 'const volatile M&' or 'M'.
1327  if (!FieldRec->hasCopyAssignmentWithConstParam())
1328  data().ImplicitCopyAssignmentHasConstParam = false;
1329 
1330  if (FieldRec->hasUninitializedReferenceMember() &&
1331  !Field->hasInClassInitializer())
1332  data().HasUninitializedReferenceMember = true;
1333 
1334  // C++11 [class.union]p8, DR1460:
1335  // a non-static data member of an anonymous union that is a member of
1336  // X is also a variant member of X.
1337  if (FieldRec->hasVariantMembers() &&
1338  Field->isAnonymousStructOrUnion())
1339  data().HasVariantMembers = true;
1340  }
1341  } else {
1342  // Base element type of field is a non-class type.
1343  if (!T->isLiteralType(Context) ||
1344  (!Field->hasInClassInitializer() && !isUnion() &&
1345  !Context.getLangOpts().CPlusPlus20))
1346  data().DefaultedDefaultConstructorIsConstexpr = false;
1347 
1348  // C++11 [class.copy]p23:
1349  // A defaulted copy/move assignment operator for a class X is defined
1350  // as deleted if X has:
1351  // -- a non-static data member of const non-class type (or array
1352  // thereof)
1353  if (T.isConstQualified()) {
1354  data().DefaultedCopyAssignmentIsDeleted = true;
1355  data().DefaultedMoveAssignmentIsDeleted = true;
1356  }
1357 
1358  // C++20 [temp.param]p7:
1359  // A structural type is [...] a literal class type [for which] the
1360  // types of all non-static data members are structural types or
1361  // (possibly multidimensional) array thereof
1362  // We deal with class types elsewhere.
1363  if (!T->isStructuralType())
1364  data().StructuralIfLiteral = false;
1365  }
1366 
1367  // C++14 [meta.unary.prop]p4:
1368  // T is a class type [...] with [...] no non-static data members other
1369  // than subobjects of zero size
1370  if (data().Empty && !IsZeroSize)
1371  data().Empty = false;
1372  }
1373 
1374  // Handle using declarations of conversion functions.
1375  if (auto *Shadow = dyn_cast<UsingShadowDecl>(D)) {
1376  if (Shadow->getDeclName().getNameKind()
1378  ASTContext &Ctx = getASTContext();
1379  data().Conversions.get(Ctx).addDecl(Ctx, Shadow, Shadow->getAccess());
1380  }
1381  }
1382 
1383  if (const auto *Using = dyn_cast<UsingDecl>(D)) {
1384  if (Using->getDeclName().getNameKind() ==
1386  data().HasInheritedConstructor = true;
1387  // C++1z [dcl.init.aggr]p1:
1388  // An aggregate is [...] a class [...] with no inherited constructors
1389  data().Aggregate = false;
1390  }
1391 
1392  if (Using->getDeclName().getCXXOverloadedOperator() == OO_Equal)
1393  data().HasInheritedAssignment = true;
1394  }
1395 }
1396 
1398  assert(!D->isImplicit() && !D->isUserProvided());
1399 
1400  // The kind of special member this declaration is, if any.
1401  unsigned SMKind = 0;
1402 
1403  if (const auto *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
1404  if (Constructor->isDefaultConstructor()) {
1405  SMKind |= SMF_DefaultConstructor;
1406  if (Constructor->isConstexpr())
1407  data().HasConstexprDefaultConstructor = true;
1408  }
1409  if (Constructor->isCopyConstructor())
1410  SMKind |= SMF_CopyConstructor;
1411  else if (Constructor->isMoveConstructor())
1412  SMKind |= SMF_MoveConstructor;
1413  else if (Constructor->isConstexpr())
1414  // We may now know that the constructor is constexpr.
1415  data().HasConstexprNonCopyMoveConstructor = true;
1416  } else if (isa<CXXDestructorDecl>(D)) {
1417  SMKind |= SMF_Destructor;
1418  if (!D->isTrivial() || D->getAccess() != AS_public || D->isDeleted())
1419  data().HasIrrelevantDestructor = false;
1420  } else if (D->isCopyAssignmentOperator())
1421  SMKind |= SMF_CopyAssignment;
1422  else if (D->isMoveAssignmentOperator())
1423  SMKind |= SMF_MoveAssignment;
1424 
1425  // Update which trivial / non-trivial special members we have.
1426  // addedMember will have skipped this step for this member.
1427  if (D->isTrivial())
1428  data().HasTrivialSpecialMembers |= SMKind;
1429  else
1430  data().DeclaredNonTrivialSpecialMembers |= SMKind;
1431 }
1432 
1434  ArrayRef<LambdaCapture> Captures) {
1435  CXXRecordDecl::LambdaDefinitionData &Data = getLambdaData();
1436 
1437  // Copy captures.
1438  Data.NumCaptures = Captures.size();
1439  Data.NumExplicitCaptures = 0;
1440  Data.Captures = (LambdaCapture *)Context.Allocate(sizeof(LambdaCapture) *
1441  Captures.size());
1442  LambdaCapture *ToCapture = Data.Captures;
1443  for (unsigned I = 0, N = Captures.size(); I != N; ++I) {
1444  if (Captures[I].isExplicit())
1445  ++Data.NumExplicitCaptures;
1446 
1447  *ToCapture++ = Captures[I];
1448  }
1449 
1451  Data.DefaultedCopyAssignmentIsDeleted = true;
1452 }
1453 
1455  unsigned SMKind = 0;
1456 
1457  if (const auto *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
1458  if (Constructor->isCopyConstructor())
1459  SMKind = SMF_CopyConstructor;
1460  else if (Constructor->isMoveConstructor())
1461  SMKind = SMF_MoveConstructor;
1462  } else if (isa<CXXDestructorDecl>(D))
1463  SMKind = SMF_Destructor;
1464 
1465  if (D->isTrivialForCall())
1466  data().HasTrivialSpecialMembersForCall |= SMKind;
1467  else
1468  data().DeclaredNonTrivialSpecialMembersForCall |= SMKind;
1469 }
1470 
1472  if (getTagKind() == TTK_Class || getTagKind() == TTK_Interface ||
1473  !TemplateOrInstantiation.isNull())
1474  return false;
1475  if (!hasDefinition())
1476  return true;
1477 
1478  return isPOD() && data().HasOnlyCMembers;
1479 }
1480 
1482  if (!isLambda()) return false;
1483  return getLambdaData().IsGenericLambda;
1484 }
1485 
1486 #ifndef NDEBUG
1488  for (auto *D : R)
1489  if (!declaresSameEntity(D, R.front()))
1490  return false;
1491  return true;
1492 }
1493 #endif
1494 
1496  if (!RD.isLambda()) return nullptr;
1497  DeclarationName Name =
1499  DeclContext::lookup_result Calls = RD.lookup(Name);
1500 
1501  assert(!Calls.empty() && "Missing lambda call operator!");
1502  assert(allLookupResultsAreTheSame(Calls) &&
1503  "More than one lambda call operator!");
1504  return Calls.front();
1505 }
1506 
1508  NamedDecl *CallOp = getLambdaCallOperatorHelper(*this);
1509  return dyn_cast_or_null<FunctionTemplateDecl>(CallOp);
1510 }
1511 
1513  NamedDecl *CallOp = getLambdaCallOperatorHelper(*this);
1514 
1515  if (CallOp == nullptr)
1516  return nullptr;
1517 
1518  if (const auto *CallOpTmpl = dyn_cast<FunctionTemplateDecl>(CallOp))
1519  return cast<CXXMethodDecl>(CallOpTmpl->getTemplatedDecl());
1520 
1521  return cast<CXXMethodDecl>(CallOp);
1522 }
1523 
1526  CallingConv CC = CallOp->getType()->castAs<FunctionType>()->getCallConv();
1527  return getLambdaStaticInvoker(CC);
1528 }
1529 
1532  assert(RD.isLambda() && "Must be a lambda");
1533  DeclarationName Name =
1535  return RD.lookup(Name);
1536 }
1537 
1539  if (const auto *InvokerTemplate = dyn_cast<FunctionTemplateDecl>(ND))
1540  return cast<CXXMethodDecl>(InvokerTemplate->getTemplatedDecl());
1541  return cast<CXXMethodDecl>(ND);
1542 }
1543 
1545  if (!isLambda())
1546  return nullptr;
1548 
1549  for (NamedDecl *ND : Invoker) {
1550  const auto *FTy =
1551  cast<ValueDecl>(ND->getAsFunction())->getType()->castAs<FunctionType>();
1552  if (FTy->getCallConv() == CC)
1553  return getInvokerAsMethod(ND);
1554  }
1555 
1556  return nullptr;
1557 }
1558 
1560  llvm::DenseMap<const VarDecl *, FieldDecl *> &Captures,
1561  FieldDecl *&ThisCapture) const {
1562  Captures.clear();
1563  ThisCapture = nullptr;
1564 
1565  LambdaDefinitionData &Lambda = getLambdaData();
1567  for (const LambdaCapture *C = Lambda.Captures, *CEnd = C + Lambda.NumCaptures;
1568  C != CEnd; ++C, ++Field) {
1569  if (C->capturesThis())
1570  ThisCapture = *Field;
1571  else if (C->capturesVariable())
1572  Captures[C->getCapturedVar()] = *Field;
1573  }
1574  assert(Field == field_end());
1575 }
1576 
1579  if (!isGenericLambda()) return nullptr;
1581  if (FunctionTemplateDecl *Tmpl = CallOp->getDescribedFunctionTemplate())
1582  return Tmpl->getTemplateParameters();
1583  return nullptr;
1584 }
1585 
1589  if (!List)
1590  return {};
1591 
1592  assert(std::is_partitioned(List->begin(), List->end(),
1593  [](const NamedDecl *D) { return !D->isImplicit(); })
1594  && "Explicit template params should be ordered before implicit ones");
1595 
1596  const auto ExplicitEnd = llvm::partition_point(
1597  *List, [](const NamedDecl *D) { return !D->isImplicit(); });
1598  return llvm::makeArrayRef(List->begin(), ExplicitEnd);
1599 }
1600 
1602  assert(isLambda() && "Not a lambda closure type!");
1604  return getLambdaData().ContextDecl.get(Source);
1605 }
1606 
1608  assert(isLambda() && "Not a lambda closure type!");
1609  if (Num)
1610  getASTContext().DeviceLambdaManglingNumbers[this] = Num;
1611 }
1612 
1614  assert(isLambda() && "Not a lambda closure type!");
1615  auto I = getASTContext().DeviceLambdaManglingNumbers.find(this);
1616  if (I != getASTContext().DeviceLambdaManglingNumbers.end())
1617  return I->second;
1618  return 0;
1619 }
1620 
1622  QualType T =
1623  cast<CXXConversionDecl>(Conv->getUnderlyingDecl()->getAsFunction())
1624  ->getConversionType();
1625  return Context.getCanonicalType(T);
1626 }
1627 
1628 /// Collect the visible conversions of a base class.
1629 ///
1630 /// \param Record a base class of the class we're considering
1631 /// \param InVirtual whether this base class is a virtual base (or a base
1632 /// of a virtual base)
1633 /// \param Access the access along the inheritance path to this base
1634 /// \param ParentHiddenTypes the conversions provided by the inheritors
1635 /// of this base
1636 /// \param Output the set to which to add conversions from non-virtual bases
1637 /// \param VOutput the set to which to add conversions from virtual bases
1638 /// \param HiddenVBaseCs the set of conversions which were hidden in a
1639 /// virtual base along some inheritance path
1641  ASTContext &Context, const CXXRecordDecl *Record, bool InVirtual,
1642  AccessSpecifier Access,
1643  const llvm::SmallPtrSet<CanQualType, 8> &ParentHiddenTypes,
1644  ASTUnresolvedSet &Output, UnresolvedSetImpl &VOutput,
1645  llvm::SmallPtrSet<NamedDecl *, 8> &HiddenVBaseCs) {
1646  // The set of types which have conversions in this class or its
1647  // subclasses. As an optimization, we don't copy the derived set
1648  // unless it might change.
1649  const llvm::SmallPtrSet<CanQualType, 8> *HiddenTypes = &ParentHiddenTypes;
1650  llvm::SmallPtrSet<CanQualType, 8> HiddenTypesBuffer;
1651 
1652  // Collect the direct conversions and figure out which conversions
1653  // will be hidden in the subclasses.
1656  if (ConvI != ConvE) {
1657  HiddenTypesBuffer = ParentHiddenTypes;
1658  HiddenTypes = &HiddenTypesBuffer;
1659 
1660  for (CXXRecordDecl::conversion_iterator I = ConvI; I != ConvE; ++I) {
1661  CanQualType ConvType(GetConversionType(Context, I.getDecl()));
1662  bool Hidden = ParentHiddenTypes.count(ConvType);
1663  if (!Hidden)
1664  HiddenTypesBuffer.insert(ConvType);
1665 
1666  // If this conversion is hidden and we're in a virtual base,
1667  // remember that it's hidden along some inheritance path.
1668  if (Hidden && InVirtual)
1669  HiddenVBaseCs.insert(cast<NamedDecl>(I.getDecl()->getCanonicalDecl()));
1670 
1671  // If this conversion isn't hidden, add it to the appropriate output.
1672  else if (!Hidden) {
1673  AccessSpecifier IAccess
1674  = CXXRecordDecl::MergeAccess(Access, I.getAccess());
1675 
1676  if (InVirtual)
1677  VOutput.addDecl(I.getDecl(), IAccess);
1678  else
1679  Output.addDecl(Context, I.getDecl(), IAccess);
1680  }
1681  }
1682  }
1683 
1684  // Collect information recursively from any base classes.
1685  for (const auto &I : Record->bases()) {
1686  const auto *RT = I.getType()->getAs<RecordType>();
1687  if (!RT) continue;
1688 
1689  AccessSpecifier BaseAccess
1690  = CXXRecordDecl::MergeAccess(Access, I.getAccessSpecifier());
1691  bool BaseInVirtual = InVirtual || I.isVirtual();
1692 
1693  auto *Base = cast<CXXRecordDecl>(RT->getDecl());
1694  CollectVisibleConversions(Context, Base, BaseInVirtual, BaseAccess,
1695  *HiddenTypes, Output, VOutput, HiddenVBaseCs);
1696  }
1697 }
1698 
1699 /// Collect the visible conversions of a class.
1700 ///
1701 /// This would be extremely straightforward if it weren't for virtual
1702 /// bases. It might be worth special-casing that, really.
1704  const CXXRecordDecl *Record,
1705  ASTUnresolvedSet &Output) {
1706  // The collection of all conversions in virtual bases that we've
1707  // found. These will be added to the output as long as they don't
1708  // appear in the hidden-conversions set.
1709  UnresolvedSet<8> VBaseCs;
1710 
1711  // The set of conversions in virtual bases that we've determined to
1712  // be hidden.
1713  llvm::SmallPtrSet<NamedDecl*, 8> HiddenVBaseCs;
1714 
1715  // The set of types hidden by classes derived from this one.
1717 
1718  // Go ahead and collect the direct conversions and add them to the
1719  // hidden-types set.
1722  Output.append(Context, ConvI, ConvE);
1723  for (; ConvI != ConvE; ++ConvI)
1724  HiddenTypes.insert(GetConversionType(Context, ConvI.getDecl()));
1725 
1726  // Recursively collect conversions from base classes.
1727  for (const auto &I : Record->bases()) {
1728  const auto *RT = I.getType()->getAs<RecordType>();
1729  if (!RT) continue;
1730 
1731  CollectVisibleConversions(Context, cast<CXXRecordDecl>(RT->getDecl()),
1732  I.isVirtual(), I.getAccessSpecifier(),
1733  HiddenTypes, Output, VBaseCs, HiddenVBaseCs);
1734  }
1735 
1736  // Add any unhidden conversions provided by virtual bases.
1737  for (UnresolvedSetIterator I = VBaseCs.begin(), E = VBaseCs.end();
1738  I != E; ++I) {
1739  if (!HiddenVBaseCs.count(cast<NamedDecl>(I.getDecl()->getCanonicalDecl())))
1740  Output.addDecl(Context, I.getDecl(), I.getAccess());
1741  }
1742 }
1743 
1744 /// getVisibleConversionFunctions - get all conversion functions visible
1745 /// in current class; including conversion function templates.
1746 llvm::iterator_range<CXXRecordDecl::conversion_iterator>
1748  ASTContext &Ctx = getASTContext();
1749 
1750  ASTUnresolvedSet *Set;
1751  if (bases_begin() == bases_end()) {
1752  // If root class, all conversions are visible.
1753  Set = &data().Conversions.get(Ctx);
1754  } else {
1755  Set = &data().VisibleConversions.get(Ctx);
1756  // If visible conversion list is not evaluated, evaluate it.
1757  if (!data().ComputedVisibleConversions) {
1758  CollectVisibleConversions(Ctx, this, *Set);
1759  data().ComputedVisibleConversions = true;
1760  }
1761  }
1762  return llvm::make_range(Set->begin(), Set->end());
1763 }
1764 
1766  // This operation is O(N) but extremely rare. Sema only uses it to
1767  // remove UsingShadowDecls in a class that were followed by a direct
1768  // declaration, e.g.:
1769  // class A : B {
1770  // using B::operator int;
1771  // operator int();
1772  // };
1773  // This is uncommon by itself and even more uncommon in conjunction
1774  // with sufficiently large numbers of directly-declared conversions
1775  // that asymptotic behavior matters.
1776 
1777  ASTUnresolvedSet &Convs = data().Conversions.get(getASTContext());
1778  for (unsigned I = 0, E = Convs.size(); I != E; ++I) {
1779  if (Convs[I].getDecl() == ConvDecl) {
1780  Convs.erase(I);
1781  assert(!llvm::is_contained(Convs, ConvDecl) &&
1782  "conversion was found multiple times in unresolved set");
1783  return;
1784  }
1785  }
1786 
1787  llvm_unreachable("conversion not found in set!");
1788 }
1789 
1792  return cast<CXXRecordDecl>(MSInfo->getInstantiatedFrom());
1793 
1794  return nullptr;
1795 }
1796 
1798  return TemplateOrInstantiation.dyn_cast<MemberSpecializationInfo *>();
1799 }
1800 
1801 void
1804  assert(TemplateOrInstantiation.isNull() &&
1805  "Previous template or instantiation?");
1806  assert(!isa<ClassTemplatePartialSpecializationDecl>(this));
1807  TemplateOrInstantiation
1808  = new (getASTContext()) MemberSpecializationInfo(RD, TSK);
1809 }
1810 
1812  return TemplateOrInstantiation.dyn_cast<ClassTemplateDecl *>();
1813 }
1814 
1816  TemplateOrInstantiation = Template;
1817 }
1818 
1820  if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(this))
1821  return Spec->getSpecializationKind();
1822 
1824  return MSInfo->getTemplateSpecializationKind();
1825 
1826  return TSK_Undeclared;
1827 }
1828 
1829 void
1831  if (auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(this)) {
1832  Spec->setSpecializationKind(TSK);
1833  return;
1834  }
1835 
1837  MSInfo->setTemplateSpecializationKind(TSK);
1838  return;
1839  }
1840 
1841  llvm_unreachable("Not a class template or member class specialization");
1842 }
1843 
1845  auto GetDefinitionOrSelf =
1846  [](const CXXRecordDecl *D) -> const CXXRecordDecl * {
1847  if (auto *Def = D->getDefinition())
1848  return Def;
1849  return D;
1850  };
1851 
1852  // If it's a class template specialization, find the template or partial
1853  // specialization from which it was instantiated.
1854  if (auto *TD = dyn_cast<ClassTemplateSpecializationDecl>(this)) {
1855  auto From = TD->getInstantiatedFrom();
1856  if (auto *CTD = From.dyn_cast<ClassTemplateDecl *>()) {
1857  while (auto *NewCTD = CTD->getInstantiatedFromMemberTemplate()) {
1858  if (NewCTD->isMemberSpecialization())
1859  break;
1860  CTD = NewCTD;
1861  }
1862  return GetDefinitionOrSelf(CTD->getTemplatedDecl());
1863  }
1864  if (auto *CTPSD =
1865  From.dyn_cast<ClassTemplatePartialSpecializationDecl *>()) {
1866  while (auto *NewCTPSD = CTPSD->getInstantiatedFromMember()) {
1867  if (NewCTPSD->isMemberSpecialization())
1868  break;
1869  CTPSD = NewCTPSD;
1870  }
1871  return GetDefinitionOrSelf(CTPSD);
1872  }
1873  }
1874 
1876  if (isTemplateInstantiation(MSInfo->getTemplateSpecializationKind())) {
1877  const CXXRecordDecl *RD = this;
1878  while (auto *NewRD = RD->getInstantiatedFromMemberClass())
1879  RD = NewRD;
1880  return GetDefinitionOrSelf(RD);
1881  }
1882  }
1883 
1885  "couldn't find pattern for class template instantiation");
1886  return nullptr;
1887 }
1888 
1890  ASTContext &Context = getASTContext();
1891  QualType ClassType = Context.getTypeDeclType(this);
1892 
1893  DeclarationName Name
1895  Context.getCanonicalType(ClassType));
1896 
1898 
1899  return R.empty() ? nullptr : dyn_cast<CXXDestructorDecl>(R.front());
1900 }
1901 
1902 static bool isDeclContextInNamespace(const DeclContext *DC) {
1903  while (!DC->isTranslationUnit()) {
1904  if (DC->isNamespace())
1905  return true;
1906  DC = DC->getParent();
1907  }
1908  return false;
1909 }
1910 
1912  assert(hasDefinition() && "checking for interface-like without a definition");
1913  // All __interfaces are inheritently interface-like.
1914  if (isInterface())
1915  return true;
1916 
1917  // Interface-like types cannot have a user declared constructor, destructor,
1918  // friends, VBases, conversion functions, or fields. Additionally, lambdas
1919  // cannot be interface types.
1920  if (isLambda() || hasUserDeclaredConstructor() ||
1922  getNumVBases() > 0 || conversion_end() - conversion_begin() > 0)
1923  return false;
1924 
1925  // No interface-like type can have a method with a definition.
1926  for (const auto *const Method : methods())
1927  if (Method->isDefined() && !Method->isImplicit())
1928  return false;
1929 
1930  // Check "Special" types.
1931  const auto *Uuid = getAttr<UuidAttr>();
1932  // MS SDK declares IUnknown/IDispatch both in the root of a TU, or in an
1933  // extern C++ block directly in the TU. These are only valid if in one
1934  // of these two situations.
1935  if (Uuid && isStruct() && !getDeclContext()->isExternCContext() &&
1937  ((getName() == "IUnknown" &&
1938  Uuid->getGuid() == "00000000-0000-0000-C000-000000000046") ||
1939  (getName() == "IDispatch" &&
1940  Uuid->getGuid() == "00020400-0000-0000-C000-000000000046"))) {
1941  if (getNumBases() > 0)
1942  return false;
1943  return true;
1944  }
1945 
1946  // FIXME: Any access specifiers is supposed to make this no longer interface
1947  // like.
1948 
1949  // If this isn't a 'special' type, it must have a single interface-like base.
1950  if (getNumBases() != 1)
1951  return false;
1952 
1953  const auto BaseSpec = *bases_begin();
1954  if (BaseSpec.isVirtual() || BaseSpec.getAccessSpecifier() != AS_public)
1955  return false;
1956  const auto *Base = BaseSpec.getType()->getAsCXXRecordDecl();
1957  if (Base->isInterface() || !Base->isInterfaceLike())
1958  return false;
1959  return true;
1960 }
1961 
1963  completeDefinition(nullptr);
1964 }
1965 
1968 
1969  // If the class may be abstract (but hasn't been marked as such), check for
1970  // any pure final overriders.
1971  if (mayBeAbstract()) {
1972  CXXFinalOverriderMap MyFinalOverriders;
1973  if (!FinalOverriders) {
1974  getFinalOverriders(MyFinalOverriders);
1975  FinalOverriders = &MyFinalOverriders;
1976  }
1977 
1978  bool Done = false;
1979  for (CXXFinalOverriderMap::iterator M = FinalOverriders->begin(),
1980  MEnd = FinalOverriders->end();
1981  M != MEnd && !Done; ++M) {
1982  for (OverridingMethods::iterator SO = M->second.begin(),
1983  SOEnd = M->second.end();
1984  SO != SOEnd && !Done; ++SO) {
1985  assert(SO->second.size() > 0 &&
1986  "All virtual functions have overriding virtual functions");
1987 
1988  // C++ [class.abstract]p4:
1989  // A class is abstract if it contains or inherits at least one
1990  // pure virtual function for which the final overrider is pure
1991  // virtual.
1992  if (SO->second.front().Method->isPure()) {
1993  data().Abstract = true;
1994  Done = true;
1995  break;
1996  }
1997  }
1998  }
1999  }
2000 
2001  // Set access bits correctly on the directly-declared conversions.
2003  I != E; ++I)
2004  I.setAccess((*I)->getAccess());
2005 }
2006 
2008  if (data().Abstract || isInvalidDecl() || !data().Polymorphic ||
2010  return false;
2011 
2012  for (const auto &B : bases()) {
2013  const auto *BaseDecl =
2014  cast<CXXRecordDecl>(B.getType()->castAs<RecordType>()->getDecl());
2015  if (BaseDecl->isAbstract())
2016  return true;
2017  }
2018 
2019  return false;
2020 }
2021 
2023  auto *Def = getDefinition();
2024  if (!Def)
2025  return false;
2026  if (Def->hasAttr<FinalAttr>())
2027  return true;
2028  if (const auto *Dtor = Def->getDestructor())
2029  if (Dtor->hasAttr<FinalAttr>())
2030  return true;
2031  return false;
2032 }
2033 
2034 void CXXDeductionGuideDecl::anchor() {}
2035 
2037  if ((getKind() != Other.getKind() ||
2041  ODRHash SelfHash, OtherHash;
2042  SelfHash.AddStmt(getExpr());
2043  OtherHash.AddStmt(Other.getExpr());
2044  return SelfHash.CalculateHash() == OtherHash.CalculateHash();
2045  } else
2046  return false;
2047  }
2048  return true;
2049 }
2050 
2052  switch (Function->getDeclKind()) {
2053  case Decl::Kind::CXXConstructor:
2054  return cast<CXXConstructorDecl>(Function)->getExplicitSpecifier();
2055  case Decl::Kind::CXXConversion:
2056  return cast<CXXConversionDecl>(Function)->getExplicitSpecifier();
2057  case Decl::Kind::CXXDeductionGuide:
2058  return cast<CXXDeductionGuideDecl>(Function)->getExplicitSpecifier();
2059  default:
2060  return {};
2061  }
2062 }
2063 
2066  SourceLocation StartLoc, ExplicitSpecifier ES,
2067  const DeclarationNameInfo &NameInfo, QualType T,
2068  TypeSourceInfo *TInfo, SourceLocation EndLocation,
2069  CXXConstructorDecl *Ctor) {
2070  return new (C, DC) CXXDeductionGuideDecl(C, DC, StartLoc, ES, NameInfo, T,
2071  TInfo, EndLocation, Ctor);
2072 }
2073 
2075  unsigned ID) {
2076  return new (C, ID) CXXDeductionGuideDecl(
2078  QualType(), nullptr, SourceLocation(), nullptr);
2079 }
2080 
2082  ASTContext &C, DeclContext *DC, SourceLocation StartLoc) {
2083  return new (C, DC) RequiresExprBodyDecl(C, DC, StartLoc);
2084 }
2085 
2087  unsigned ID) {
2088  return new (C, ID) RequiresExprBodyDecl(C, nullptr, SourceLocation());
2089 }
2090 
2091 void CXXMethodDecl::anchor() {}
2092 
2094  const CXXMethodDecl *MD = getCanonicalDecl();
2095 
2096  if (MD->getStorageClass() == SC_Static)
2097  return true;
2098 
2100  return isStaticOverloadedOperator(OOK);
2101 }
2102 
2103 static bool recursivelyOverrides(const CXXMethodDecl *DerivedMD,
2104  const CXXMethodDecl *BaseMD) {
2105  for (const CXXMethodDecl *MD : DerivedMD->overridden_methods()) {
2106  if (MD->getCanonicalDecl() == BaseMD->getCanonicalDecl())
2107  return true;
2108  if (recursivelyOverrides(MD, BaseMD))
2109  return true;
2110  }
2111  return false;
2112 }
2113 
2114 CXXMethodDecl *
2116  bool MayBeBase) {
2117  if (this->getParent()->getCanonicalDecl() == RD->getCanonicalDecl())
2118  return this;
2119 
2120  // Lookup doesn't work for destructors, so handle them separately.
2121  if (isa<CXXDestructorDecl>(this)) {
2122  CXXMethodDecl *MD = RD->getDestructor();
2123  if (MD) {
2124  if (recursivelyOverrides(MD, this))
2125  return MD;
2126  if (MayBeBase && recursivelyOverrides(this, MD))
2127  return MD;
2128  }
2129  return nullptr;
2130  }
2131 
2132  for (auto *ND : RD->lookup(getDeclName())) {
2133  auto *MD = dyn_cast<CXXMethodDecl>(ND);
2134  if (!MD)
2135  continue;
2136  if (recursivelyOverrides(MD, this))
2137  return MD;
2138  if (MayBeBase && recursivelyOverrides(this, MD))
2139  return MD;
2140  }
2141 
2142  return nullptr;
2143 }
2144 
2145 CXXMethodDecl *
2147  bool MayBeBase) {
2148  if (auto *MD = getCorrespondingMethodDeclaredInClass(RD, MayBeBase))
2149  return MD;
2150 
2151  llvm::SmallVector<CXXMethodDecl*, 4> FinalOverriders;
2152  auto AddFinalOverrider = [&](CXXMethodDecl *D) {
2153  // If this function is overridden by a candidate final overrider, it is not
2154  // a final overrider.
2155  for (CXXMethodDecl *OtherD : FinalOverriders) {
2156  if (declaresSameEntity(D, OtherD) || recursivelyOverrides(OtherD, D))
2157  return;
2158  }
2159 
2160  // Other candidate final overriders might be overridden by this function.
2161  llvm::erase_if(FinalOverriders, [&](CXXMethodDecl *OtherD) {
2162  return recursivelyOverrides(D, OtherD);
2163  });
2164 
2165  FinalOverriders.push_back(D);
2166  };
2167 
2168  for (const auto &I : RD->bases()) {
2169  const RecordType *RT = I.getType()->getAs<RecordType>();
2170  if (!RT)
2171  continue;
2172  const auto *Base = cast<CXXRecordDecl>(RT->getDecl());
2173  if (CXXMethodDecl *D = this->getCorrespondingMethodInClass(Base))
2174  AddFinalOverrider(D);
2175  }
2176 
2177  return FinalOverriders.size() == 1 ? FinalOverriders.front() : nullptr;
2178 }
2179 
2180 CXXMethodDecl *
2182  const DeclarationNameInfo &NameInfo, QualType T,
2183  TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin,
2184  bool isInline, ConstexprSpecKind ConstexprKind,
2185  SourceLocation EndLocation,
2186  Expr *TrailingRequiresClause) {
2187  return new (C, RD) CXXMethodDecl(
2188  CXXMethod, C, RD, StartLoc, NameInfo, T, TInfo, SC, UsesFPIntrin,
2189  isInline, ConstexprKind, EndLocation, TrailingRequiresClause);
2190 }
2191 
2193  return new (C, ID) CXXMethodDecl(
2194  CXXMethod, C, nullptr, SourceLocation(), DeclarationNameInfo(),
2195  QualType(), nullptr, SC_None, false, false,
2197 }
2198 
2200  bool IsAppleKext) {
2201  assert(isVirtual() && "this method is expected to be virtual");
2202 
2203  // When building with -fapple-kext, all calls must go through the vtable since
2204  // the kernel linker can do runtime patching of vtables.
2205  if (IsAppleKext)
2206  return nullptr;
2207 
2208  // If the member function is marked 'final', we know that it can't be
2209  // overridden and can therefore devirtualize it unless it's pure virtual.
2210  if (hasAttr<FinalAttr>())
2211  return isPure() ? nullptr : this;
2212 
2213  // If Base is unknown, we cannot devirtualize.
2214  if (!Base)
2215  return nullptr;
2216 
2217  // If the base expression (after skipping derived-to-base conversions) is a
2218  // class prvalue, then we can devirtualize.
2219  Base = Base->getBestDynamicClassTypeExpr();
2220  if (Base->isPRValue() && Base->getType()->isRecordType())
2221  return this;
2222 
2223  // If we don't even know what we would call, we can't devirtualize.
2224  const CXXRecordDecl *BestDynamicDecl = Base->getBestDynamicClassType();
2225  if (!BestDynamicDecl)
2226  return nullptr;
2227 
2228  // There may be a method corresponding to MD in a derived class.
2229  CXXMethodDecl *DevirtualizedMethod =
2230  getCorrespondingMethodInClass(BestDynamicDecl);
2231 
2232  // If there final overrider in the dynamic type is ambiguous, we can't
2233  // devirtualize this call.
2234  if (!DevirtualizedMethod)
2235  return nullptr;
2236 
2237  // If that method is pure virtual, we can't devirtualize. If this code is
2238  // reached, the result would be UB, not a direct call to the derived class
2239  // function, and we can't assume the derived class function is defined.
2240  if (DevirtualizedMethod->isPure())
2241  return nullptr;
2242 
2243  // If that method is marked final, we can devirtualize it.
2244  if (DevirtualizedMethod->hasAttr<FinalAttr>())
2245  return DevirtualizedMethod;
2246 
2247  // Similarly, if the class itself or its destructor is marked 'final',
2248  // the class can't be derived from and we can therefore devirtualize the
2249  // member function call.
2250  if (BestDynamicDecl->isEffectivelyFinal())
2251  return DevirtualizedMethod;
2252 
2253  if (const auto *DRE = dyn_cast<DeclRefExpr>(Base)) {
2254  if (const auto *VD = dyn_cast<VarDecl>(DRE->getDecl()))
2255  if (VD->getType()->isRecordType())
2256  // This is a record decl. We know the type and can devirtualize it.
2257  return DevirtualizedMethod;
2258 
2259  return nullptr;
2260  }
2261 
2262  // We can devirtualize calls on an object accessed by a class member access
2263  // expression, since by C++11 [basic.life]p6 we know that it can't refer to
2264  // a derived class object constructed in the same location.
2265  if (const auto *ME = dyn_cast<MemberExpr>(Base)) {
2266  const ValueDecl *VD = ME->getMemberDecl();
2267  return VD->getType()->isRecordType() ? DevirtualizedMethod : nullptr;
2268  }
2269 
2270  // Likewise for calls on an object accessed by a (non-reference) pointer to
2271  // member access.
2272  if (auto *BO = dyn_cast<BinaryOperator>(Base)) {
2273  if (BO->isPtrMemOp()) {
2274  auto *MPT = BO->getRHS()->getType()->castAs<MemberPointerType>();
2275  if (MPT->getPointeeType()->isRecordType())
2276  return DevirtualizedMethod;
2277  }
2278  }
2279 
2280  // We can't devirtualize the call.
2281  return nullptr;
2282 }
2283 
2285  SmallVectorImpl<const FunctionDecl *> &PreventedBy) const {
2286  assert(PreventedBy.empty() && "PreventedBy is expected to be empty");
2287  if (getOverloadedOperator() != OO_Delete &&
2288  getOverloadedOperator() != OO_Array_Delete)
2289  return false;
2290 
2291  // C++ [basic.stc.dynamic.deallocation]p2:
2292  // A template instance is never a usual deallocation function,
2293  // regardless of its signature.
2294  if (getPrimaryTemplate())
2295  return false;
2296 
2297  // C++ [basic.stc.dynamic.deallocation]p2:
2298  // If a class T has a member deallocation function named operator delete
2299  // with exactly one parameter, then that function is a usual (non-placement)
2300  // deallocation function. [...]
2301  if (getNumParams() == 1)
2302  return true;
2303  unsigned UsualParams = 1;
2304 
2305  // C++ P0722:
2306  // A destroying operator delete is a usual deallocation function if
2307  // removing the std::destroying_delete_t parameter and changing the
2308  // first parameter type from T* to void* results in the signature of
2309  // a usual deallocation function.
2311  ++UsualParams;
2312 
2313  // C++ <=14 [basic.stc.dynamic.deallocation]p2:
2314  // [...] If class T does not declare such an operator delete but does
2315  // declare a member deallocation function named operator delete with
2316  // exactly two parameters, the second of which has type std::size_t (18.1),
2317  // then this function is a usual deallocation function.
2318  //
2319  // C++17 says a usual deallocation function is one with the signature
2320  // (void* [, size_t] [, std::align_val_t] [, ...])
2321  // and all such functions are usual deallocation functions. It's not clear
2322  // that allowing varargs functions was intentional.
2323  ASTContext &Context = getASTContext();
2324  if (UsualParams < getNumParams() &&
2325  Context.hasSameUnqualifiedType(getParamDecl(UsualParams)->getType(),
2326  Context.getSizeType()))
2327  ++UsualParams;
2328 
2329  if (UsualParams < getNumParams() &&
2330  getParamDecl(UsualParams)->getType()->isAlignValT())
2331  ++UsualParams;
2332 
2333  if (UsualParams != getNumParams())
2334  return false;
2335 
2336  // In C++17 onwards, all potential usual deallocation functions are actual
2337  // usual deallocation functions. Honor this behavior when post-C++14
2338  // deallocation functions are offered as extensions too.
2339  // FIXME(EricWF): Destroying Delete should be a language option. How do we
2340  // handle when destroying delete is used prior to C++17?
2341  if (Context.getLangOpts().CPlusPlus17 ||
2342  Context.getLangOpts().AlignedAllocation ||
2344  return true;
2345 
2346  // This function is a usual deallocation function if there are no
2347  // single-parameter deallocation functions of the same kind.
2349  bool Result = true;
2350  for (const auto *D : R) {
2351  if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
2352  if (FD->getNumParams() == 1) {
2353  PreventedBy.push_back(FD);
2354  Result = false;
2355  }
2356  }
2357  }
2358  return Result;
2359 }
2360 
2362  // C++0x [class.copy]p17:
2363  // A user-declared copy assignment operator X::operator= is a non-static
2364  // non-template member function of class X with exactly one parameter of
2365  // type X, X&, const X&, volatile X& or const volatile X&.
2366  if (/*operator=*/getOverloadedOperator() != OO_Equal ||
2367  /*non-static*/ isStatic() ||
2368  /*non-template*/getPrimaryTemplate() || getDescribedFunctionTemplate() ||
2369  getNumParams() != 1)
2370  return false;
2371 
2372  QualType ParamType = getParamDecl(0)->getType();
2373  if (const auto *Ref = ParamType->getAs<LValueReferenceType>())
2374  ParamType = Ref->getPointeeType();
2375 
2376  ASTContext &Context = getASTContext();
2377  QualType ClassType
2378  = Context.getCanonicalType(Context.getTypeDeclType(getParent()));
2379  return Context.hasSameUnqualifiedType(ClassType, ParamType);
2380 }
2381 
2383  // C++0x [class.copy]p19:
2384  // A user-declared move assignment operator X::operator= is a non-static
2385  // non-template member function of class X with exactly one parameter of type
2386  // X&&, const X&&, volatile X&&, or const volatile X&&.
2387  if (getOverloadedOperator() != OO_Equal || isStatic() ||
2389  getNumParams() != 1)
2390  return false;
2391 
2392  QualType ParamType = getParamDecl(0)->getType();
2393  if (!isa<RValueReferenceType>(ParamType))
2394  return false;
2395  ParamType = ParamType->getPointeeType();
2396 
2397  ASTContext &Context = getASTContext();
2398  QualType ClassType
2399  = Context.getCanonicalType(Context.getTypeDeclType(getParent()));
2400  return Context.hasSameUnqualifiedType(ClassType, ParamType);
2401 }
2402 
2404  assert(MD->isCanonicalDecl() && "Method is not canonical!");
2405  assert(!MD->getParent()->isDependentContext() &&
2406  "Can't add an overridden method to a class template!");
2407  assert(MD->isVirtual() && "Method is not virtual!");
2408 
2409  getASTContext().addOverriddenMethod(this, MD);
2410 }
2411 
2413  if (isa<CXXConstructorDecl>(this)) return nullptr;
2414  return getASTContext().overridden_methods_begin(this);
2415 }
2416 
2418  if (isa<CXXConstructorDecl>(this)) return nullptr;
2419  return getASTContext().overridden_methods_end(this);
2420 }
2421 
2423  if (isa<CXXConstructorDecl>(this)) return 0;
2424  return getASTContext().overridden_methods_size(this);
2425 }
2426 
2429  if (isa<CXXConstructorDecl>(this))
2430  return overridden_method_range(nullptr, nullptr);
2431  return getASTContext().overridden_methods(this);
2432 }
2433 
2435  const CXXRecordDecl *Decl) {
2436  QualType ClassTy = C.getTypeDeclType(Decl);
2437  return C.getQualifiedType(ClassTy, FPT->getMethodQuals());
2438 }
2439 
2441  const CXXRecordDecl *Decl) {
2443  QualType ObjectTy = ::getThisObjectType(C, FPT, Decl);
2444  return C.getPointerType(ObjectTy);
2445 }
2446 
2448  const CXXRecordDecl *Decl) {
2451 }
2452 
2454  // C++ 9.3.2p1: The type of this in a member function of a class X is X*.
2455  // If the member function is declared const, the type of this is const X*,
2456  // if the member function is declared volatile, the type of this is
2457  // volatile X*, and if the member function is declared const volatile,
2458  // the type of this is const volatile X*.
2459  assert(isInstance() && "No 'this' for static methods!");
2460  return CXXMethodDecl::getThisType(getType()->castAs<FunctionProtoType>(),
2461  getParent());
2462 }
2463 
2465  // Ditto getThisType.
2466  assert(isInstance() && "No 'this' for static methods!");
2468  getType()->castAs<FunctionProtoType>(), getParent());
2469 }
2470 
2472  // If this function is a template instantiation, look at the template from
2473  // which it was instantiated.
2474  const FunctionDecl *CheckFn = getTemplateInstantiationPattern();
2475  if (!CheckFn)
2476  CheckFn = this;
2477 
2478  const FunctionDecl *fn;
2479  return CheckFn->isDefined(fn) && !fn->isOutOfLine() &&
2480  (fn->doesThisDeclarationHaveABody() || fn->willHaveBody());
2481 }
2482 
2484  const CXXRecordDecl *P = getParent();
2485  return P->isLambda() && getDeclName().isIdentifier() &&
2487 }
2488 
2490  TypeSourceInfo *TInfo, bool IsVirtual,
2491  SourceLocation L, Expr *Init,
2492  SourceLocation R,
2493  SourceLocation EllipsisLoc)
2494  : Initializee(TInfo), Init(Init), MemberOrEllipsisLocation(EllipsisLoc),
2495  LParenLoc(L), RParenLoc(R), IsDelegating(false), IsVirtual(IsVirtual),
2496  IsWritten(false), SourceOrder(0) {}
2497 
2499  SourceLocation MemberLoc,
2500  SourceLocation L, Expr *Init,
2501  SourceLocation R)
2502  : Initializee(Member), Init(Init), MemberOrEllipsisLocation(MemberLoc),
2503  LParenLoc(L), RParenLoc(R), IsDelegating(false), IsVirtual(false),
2504  IsWritten(false), SourceOrder(0) {}
2505 
2507  IndirectFieldDecl *Member,
2508  SourceLocation MemberLoc,
2509  SourceLocation L, Expr *Init,
2510  SourceLocation R)
2511  : Initializee(Member), Init(Init), MemberOrEllipsisLocation(MemberLoc),
2512  LParenLoc(L), RParenLoc(R), IsDelegating(false), IsVirtual(false),
2513  IsWritten(false), SourceOrder(0) {}
2514 
2516  TypeSourceInfo *TInfo,
2517  SourceLocation L, Expr *Init,
2518  SourceLocation R)
2519  : Initializee(TInfo), Init(Init), LParenLoc(L), RParenLoc(R),
2520  IsDelegating(true), IsVirtual(false), IsWritten(false), SourceOrder(0) {}
2521 
2522 int64_t CXXCtorInitializer::getID(const ASTContext &Context) const {
2523  return Context.getAllocator()
2524  .identifyKnownAlignedObject<CXXCtorInitializer>(this);
2525 }
2526 
2528  if (isBaseInitializer())
2529  return Initializee.get<TypeSourceInfo*>()->getTypeLoc();
2530  else
2531  return {};
2532 }
2533 
2535  if (isBaseInitializer())
2536  return Initializee.get<TypeSourceInfo*>()->getType().getTypePtr();
2537  else
2538  return nullptr;
2539 }
2540 
2543  return getAnyMember()->getLocation();
2544 
2545  if (isAnyMemberInitializer())
2546  return getMemberLocation();
2547 
2548  if (const auto *TSInfo = Initializee.get<TypeSourceInfo *>())
2549  return TSInfo->getTypeLoc().getLocalSourceRange().getBegin();
2550 
2551  return {};
2552 }
2553 
2556  FieldDecl *D = getAnyMember();
2557  if (Expr *I = D->getInClassInitializer())
2558  return I->getSourceRange();
2559  return {};
2560  }
2561 
2563 }
2564 
2565 CXXConstructorDecl::CXXConstructorDecl(
2566  ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
2567  const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
2568  ExplicitSpecifier ES, bool UsesFPIntrin, bool isInline,
2569  bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind,
2570  InheritedConstructor Inherited, Expr *TrailingRequiresClause)
2571  : CXXMethodDecl(CXXConstructor, C, RD, StartLoc, NameInfo, T, TInfo,
2572  SC_None, UsesFPIntrin, isInline, ConstexprKind,
2573  SourceLocation(), TrailingRequiresClause) {
2574  setNumCtorInitializers(0);
2575  setInheritingConstructor(static_cast<bool>(Inherited));
2576  setImplicit(isImplicitlyDeclared);
2577  CXXConstructorDeclBits.HasTrailingExplicitSpecifier = ES.getExpr() ? 1 : 0;
2578  if (Inherited)
2579  *getTrailingObjects<InheritedConstructor>() = Inherited;
2580  setExplicitSpecifier(ES);
2581 }
2582 
2583 void CXXConstructorDecl::anchor() {}
2584 
2586  unsigned ID,
2587  uint64_t AllocKind) {
2588  bool hasTrailingExplicit = static_cast<bool>(AllocKind & TAKHasTailExplicit);
2590  static_cast<bool>(AllocKind & TAKInheritsConstructor);
2591  unsigned Extra =
2592  additionalSizeToAlloc<InheritedConstructor, ExplicitSpecifier>(
2593  isInheritingConstructor, hasTrailingExplicit);
2594  auto *Result = new (C, ID, Extra) CXXConstructorDecl(
2595  C, nullptr, SourceLocation(), DeclarationNameInfo(), QualType(), nullptr,
2596  ExplicitSpecifier(), false, false, false, ConstexprSpecKind::Unspecified,
2597  InheritedConstructor(), nullptr);
2598  Result->setInheritingConstructor(isInheritingConstructor);
2599  Result->CXXConstructorDeclBits.HasTrailingExplicitSpecifier =
2600  hasTrailingExplicit;
2601  Result->setExplicitSpecifier(ExplicitSpecifier());
2602  return Result;
2603 }
2604 
2606  ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
2607  const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
2608  ExplicitSpecifier ES, bool UsesFPIntrin, bool isInline,
2609  bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind,
2610  InheritedConstructor Inherited, Expr *TrailingRequiresClause) {
2611  assert(NameInfo.getName().getNameKind()
2613  "Name must refer to a constructor");
2614  unsigned Extra =
2615  additionalSizeToAlloc<InheritedConstructor, ExplicitSpecifier>(
2616  Inherited ? 1 : 0, ES.getExpr() ? 1 : 0);
2617  return new (C, RD, Extra) CXXConstructorDecl(
2618  C, RD, StartLoc, NameInfo, T, TInfo, ES, UsesFPIntrin, isInline,
2619  isImplicitlyDeclared, ConstexprKind, Inherited, TrailingRequiresClause);
2620 }
2621 
2623  return CtorInitializers.get(getASTContext().getExternalSource());
2624 }
2625 
2627  assert(isDelegatingConstructor() && "Not a delegating constructor!");
2628  Expr *E = (*init_begin())->getInit()->IgnoreImplicit();
2629  if (const auto *Construct = dyn_cast<CXXConstructExpr>(E))
2630  return Construct->getConstructor();
2631 
2632  return nullptr;
2633 }
2634 
2636  // C++ [class.default.ctor]p1:
2637  // A default constructor for a class X is a constructor of class X for
2638  // which each parameter that is not a function parameter pack has a default
2639  // argument (including the case of a constructor with no parameters)
2640  return getMinRequiredArguments() == 0;
2641 }
2642 
2643 bool
2644 CXXConstructorDecl::isCopyConstructor(unsigned &TypeQuals) const {
2645  return isCopyOrMoveConstructor(TypeQuals) &&
2647 }
2648 
2649 bool CXXConstructorDecl::isMoveConstructor(unsigned &TypeQuals) const {
2650  return isCopyOrMoveConstructor(TypeQuals) &&
2652 }
2653 
2654 /// Determine whether this is a copy or move constructor.
2655 bool CXXConstructorDecl::isCopyOrMoveConstructor(unsigned &TypeQuals) const {
2656  // C++ [class.copy]p2:
2657  // A non-template constructor for class X is a copy constructor
2658  // if its first parameter is of type X&, const X&, volatile X& or
2659  // const volatile X&, and either there are no other parameters
2660  // or else all other parameters have default arguments (8.3.6).
2661  // C++0x [class.copy]p3:
2662  // A non-template constructor for class X is a move constructor if its
2663  // first parameter is of type X&&, const X&&, volatile X&&, or
2664  // const volatile X&&, and either there are no other parameters or else
2665  // all other parameters have default arguments.
2666  if (!hasOneParamOrDefaultArgs() || getPrimaryTemplate() != nullptr ||
2667  getDescribedFunctionTemplate() != nullptr)
2668  return false;
2669 
2670  const ParmVarDecl *Param = getParamDecl(0);
2671 
2672  // Do we have a reference type?
2673  const auto *ParamRefType = Param->getType()->getAs<ReferenceType>();
2674  if (!ParamRefType)
2675  return false;
2676 
2677  // Is it a reference to our class type?
2678  ASTContext &Context = getASTContext();
2679 
2680  CanQualType PointeeType
2681  = Context.getCanonicalType(ParamRefType->getPointeeType());
2682  CanQualType ClassTy
2683  = Context.getCanonicalType(Context.getTagDeclType(getParent()));
2684  if (PointeeType.getUnqualifiedType() != ClassTy)
2685  return false;
2686 
2687  // FIXME: other qualifiers?
2688 
2689  // We have a copy or move constructor.
2690  TypeQuals = PointeeType.getCVRQualifiers();
2691  return true;
2692 }
2693 
2694 bool CXXConstructorDecl::isConvertingConstructor(bool AllowExplicit) const {
2695  // C++ [class.conv.ctor]p1:
2696  // A constructor declared without the function-specifier explicit
2697  // that can be called with a single parameter specifies a
2698  // conversion from the type of its first parameter to the type of
2699  // its class. Such a constructor is called a converting
2700  // constructor.
2701  if (isExplicit() && !AllowExplicit)
2702  return false;
2703 
2704  // FIXME: This has nothing to do with the definition of converting
2705  // constructor, but is convenient for how we use this function in overload
2706  // resolution.
2707  return getNumParams() == 0
2709  : getMinRequiredArguments() <= 1;
2710 }
2711 
2714  return false;
2715 
2716  const ParmVarDecl *Param = getParamDecl(0);
2717 
2718  ASTContext &Context = getASTContext();
2719  CanQualType ParamType = Context.getCanonicalType(Param->getType());
2720 
2721  // Is it the same as our class type?
2722  CanQualType ClassTy
2723  = Context.getCanonicalType(Context.getTagDeclType(getParent()));
2724  if (ParamType.getUnqualifiedType() != ClassTy)
2725  return false;
2726 
2727  return true;
2728 }
2729 
2730 void CXXDestructorDecl::anchor() {}
2731 
2734  return new (C, ID) CXXDestructorDecl(
2735  C, nullptr, SourceLocation(), DeclarationNameInfo(), QualType(), nullptr,
2736  false, false, false, ConstexprSpecKind::Unspecified, nullptr);
2737 }
2738 
2740  ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
2741  const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
2742  bool UsesFPIntrin, bool isInline, bool isImplicitlyDeclared,
2743  ConstexprSpecKind ConstexprKind, Expr *TrailingRequiresClause) {
2744  assert(NameInfo.getName().getNameKind()
2746  "Name must refer to a destructor");
2747  return new (C, RD) CXXDestructorDecl(
2748  C, RD, StartLoc, NameInfo, T, TInfo, UsesFPIntrin, isInline,
2749  isImplicitlyDeclared, ConstexprKind, TrailingRequiresClause);
2750 }
2751 
2753  auto *First = cast<CXXDestructorDecl>(getFirstDecl());
2754  if (OD && !First->OperatorDelete) {
2755  First->OperatorDelete = OD;
2756  First->OperatorDeleteThisArg = ThisArg;
2757  if (auto *L = getASTMutationListener())
2758  L->ResolvedOperatorDelete(First, OD, ThisArg);
2759  }
2760 }
2761 
2762 void CXXConversionDecl::anchor() {}
2763 
2766  return new (C, ID) CXXConversionDecl(
2767  C, nullptr, SourceLocation(), DeclarationNameInfo(), QualType(), nullptr,
2769  SourceLocation(), nullptr);
2770 }
2771 
2773  ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc,
2774  const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo,
2775  bool UsesFPIntrin, bool isInline, ExplicitSpecifier ES,
2776  ConstexprSpecKind ConstexprKind, SourceLocation EndLocation,
2777  Expr *TrailingRequiresClause) {
2778  assert(NameInfo.getName().getNameKind()
2780  "Name must refer to a conversion function");
2781  return new (C, RD) CXXConversionDecl(
2782  C, RD, StartLoc, NameInfo, T, TInfo, UsesFPIntrin, isInline, ES,
2783  ConstexprKind, EndLocation, TrailingRequiresClause);
2784 }
2785 
2787  return isImplicit() && getParent()->isLambda() &&
2789 }
2790 
2791 LinkageSpecDecl::LinkageSpecDecl(DeclContext *DC, SourceLocation ExternLoc,
2792  SourceLocation LangLoc, LanguageIDs lang,
2793  bool HasBraces)
2794  : Decl(LinkageSpec, DC, LangLoc), DeclContext(LinkageSpec),
2795  ExternLoc(ExternLoc), RBraceLoc(SourceLocation()) {
2796  setLanguage(lang);
2797  LinkageSpecDeclBits.HasBraces = HasBraces;
2798 }
2799 
2800 void LinkageSpecDecl::anchor() {}
2801 
2803  DeclContext *DC,
2804  SourceLocation ExternLoc,
2805  SourceLocation LangLoc,
2806  LanguageIDs Lang,
2807  bool HasBraces) {
2808  return new (C, DC) LinkageSpecDecl(DC, ExternLoc, LangLoc, Lang, HasBraces);
2809 }
2810 
2812  unsigned ID) {
2813  return new (C, ID) LinkageSpecDecl(nullptr, SourceLocation(),
2814  SourceLocation(), lang_c, false);
2815 }
2816 
2817 void UsingDirectiveDecl::anchor() {}
2818 
2820  SourceLocation L,
2821  SourceLocation NamespaceLoc,
2822  NestedNameSpecifierLoc QualifierLoc,
2823  SourceLocation IdentLoc,
2824  NamedDecl *Used,
2825  DeclContext *CommonAncestor) {
2826  if (auto *NS = dyn_cast_or_null<NamespaceDecl>(Used))
2827  Used = NS->getOriginalNamespace();
2828  return new (C, DC) UsingDirectiveDecl(DC, L, NamespaceLoc, QualifierLoc,
2829  IdentLoc, Used, CommonAncestor);
2830 }
2831 
2833  unsigned ID) {
2834  return new (C, ID) UsingDirectiveDecl(nullptr, SourceLocation(),
2835  SourceLocation(),
2837  SourceLocation(), nullptr, nullptr);
2838 }
2839 
2841  if (auto *NA = dyn_cast_or_null<NamespaceAliasDecl>(NominatedNamespace))
2842  return NA->getNamespace();
2843  return cast_or_null<NamespaceDecl>(NominatedNamespace);
2844 }
2845 
2846 NamespaceDecl::NamespaceDecl(ASTContext &C, DeclContext *DC, bool Inline,
2847  SourceLocation StartLoc, SourceLocation IdLoc,
2848  IdentifierInfo *Id, NamespaceDecl *PrevDecl)
2849  : NamedDecl(Namespace, DC, IdLoc, Id), DeclContext(Namespace),
2850  redeclarable_base(C), LocStart(StartLoc),
2851  AnonOrFirstNamespaceAndInline(nullptr, Inline) {
2852  setPreviousDecl(PrevDecl);
2853 
2854  if (PrevDecl)
2855  AnonOrFirstNamespaceAndInline.setPointer(PrevDecl->getOriginalNamespace());
2856 }
2857 
2859  bool Inline, SourceLocation StartLoc,
2861  NamespaceDecl *PrevDecl) {
2862  return new (C, DC) NamespaceDecl(C, DC, Inline, StartLoc, IdLoc, Id,
2863  PrevDecl);
2864 }
2865 
2867  return new (C, ID) NamespaceDecl(C, nullptr, false, SourceLocation(),
2868  SourceLocation(), nullptr, nullptr);
2869 }
2870 
2872  if (isFirstDecl())
2873  return this;
2874 
2875  return AnonOrFirstNamespaceAndInline.getPointer();
2876 }
2877 
2879  if (isFirstDecl())
2880  return this;
2881 
2882  return AnonOrFirstNamespaceAndInline.getPointer();
2883 }
2884 
2886 
2887 NamespaceDecl *NamespaceDecl::getNextRedeclarationImpl() {
2888  return getNextRedeclaration();
2889 }
2890 
2891 NamespaceDecl *NamespaceDecl::getPreviousDeclImpl() {
2892  return getPreviousDecl();
2893 }
2894 
2895 NamespaceDecl *NamespaceDecl::getMostRecentDeclImpl() {
2896  return getMostRecentDecl();
2897 }
2898 
2899 void NamespaceAliasDecl::anchor() {}
2900 
2901 NamespaceAliasDecl *NamespaceAliasDecl::getNextRedeclarationImpl() {
2902  return getNextRedeclaration();
2903 }
2904 
2905 NamespaceAliasDecl *NamespaceAliasDecl::getPreviousDeclImpl() {
2906  return getPreviousDecl();
2907 }
2908 
2909 NamespaceAliasDecl *NamespaceAliasDecl::getMostRecentDeclImpl() {
2910  return getMostRecentDecl();
2911 }
2912 
2914  SourceLocation UsingLoc,
2915  SourceLocation AliasLoc,
2916  IdentifierInfo *Alias,
2917  NestedNameSpecifierLoc QualifierLoc,
2918  SourceLocation IdentLoc,
2919  NamedDecl *Namespace) {
2920  // FIXME: Preserve the aliased namespace as written.
2921  if (auto *NS = dyn_cast_or_null<NamespaceDecl>(Namespace))
2922  Namespace = NS->getOriginalNamespace();
2923  return new (C, DC) NamespaceAliasDecl(C, DC, UsingLoc, AliasLoc, Alias,
2924  QualifierLoc, IdentLoc, Namespace);
2925 }
2926 
2929  return new (C, ID) NamespaceAliasDecl(C, nullptr, SourceLocation(),
2930  SourceLocation(), nullptr,
2932  SourceLocation(), nullptr);
2933 }
2934 
2935 void LifetimeExtendedTemporaryDecl::anchor() {}
2936 
2937 /// Retrieve the storage duration for the materialized temporary.
2939  const ValueDecl *ExtendingDecl = getExtendingDecl();
2940  if (!ExtendingDecl)
2941  return SD_FullExpression;
2942  // FIXME: This is not necessarily correct for a temporary materialized
2943  // within a default initializer.
2944  if (isa<FieldDecl>(ExtendingDecl))
2945  return SD_Automatic;
2946  // FIXME: This only works because storage class specifiers are not allowed
2947  // on decomposition declarations.
2948  if (isa<BindingDecl>(ExtendingDecl))
2949  return ExtendingDecl->getDeclContext()->isFunctionOrMethod() ? SD_Automatic
2950  : SD_Static;
2951  return cast<VarDecl>(ExtendingDecl)->getStorageDuration();
2952 }
2953 
2955  assert(getStorageDuration() == SD_Static &&
2956  "don't need to cache the computed value for this temporary");
2957  if (MayCreate && !Value) {
2958  Value = (new (getASTContext()) APValue);
2960  }
2961  assert(Value && "may not be null");
2962  return Value;
2963 }
2964 
2965 void UsingShadowDecl::anchor() {}
2966 
2968  SourceLocation Loc, DeclarationName Name,
2969  BaseUsingDecl *Introducer, NamedDecl *Target)
2970  : NamedDecl(K, DC, Loc, Name), redeclarable_base(C),
2971  UsingOrNextShadow(Introducer) {
2972  if (Target)
2974  setImplicit();
2975 }
2976 
2978  : NamedDecl(K, nullptr, SourceLocation(), DeclarationName()),
2979  redeclarable_base(C) {}
2980 
2983  return new (C, ID) UsingShadowDecl(UsingShadow, C, EmptyShell());
2984 }
2985 
2987  const UsingShadowDecl *Shadow = this;
2988  while (const auto *NextShadow =
2989  dyn_cast<UsingShadowDecl>(Shadow->UsingOrNextShadow))
2990  Shadow = NextShadow;
2991  return cast<BaseUsingDecl>(Shadow->UsingOrNextShadow);
2992 }
2993 
2994 void ConstructorUsingShadowDecl::anchor() {}
2995 
2998  SourceLocation Loc, UsingDecl *Using,
2999  NamedDecl *Target, bool IsVirtual) {
3000  return new (C, DC) ConstructorUsingShadowDecl(C, DC, Loc, Using, Target,
3001  IsVirtual);
3002 }
3003 
3006  return new (C, ID) ConstructorUsingShadowDecl(C, EmptyShell());
3007 }
3008 
3011 }
3012 
3013 void BaseUsingDecl::anchor() {}
3014 
3016  assert(!llvm::is_contained(shadows(), S) && "declaration already in set");
3017  assert(S->getIntroducer() == this);
3018 
3019  if (FirstUsingShadow.getPointer())
3020  S->UsingOrNextShadow = FirstUsingShadow.getPointer();
3021  FirstUsingShadow.setPointer(S);
3022 }
3023 
3025  assert(llvm::is_contained(shadows(), S) && "declaration not in set");
3026  assert(S->getIntroducer() == this);
3027 
3028  // Remove S from the shadow decl chain. This is O(n) but hopefully rare.
3029 
3030  if (FirstUsingShadow.getPointer() == S) {
3031  FirstUsingShadow.setPointer(
3032  dyn_cast<UsingShadowDecl>(S->UsingOrNextShadow));
3033  S->UsingOrNextShadow = this;
3034  return;
3035  }
3036 
3037  UsingShadowDecl *Prev = FirstUsingShadow.getPointer();
3038  while (Prev->UsingOrNextShadow != S)
3039  Prev = cast<UsingShadowDecl>(Prev->UsingOrNextShadow);
3040  Prev->UsingOrNextShadow = S->UsingOrNextShadow;
3041  S->UsingOrNextShadow = this;
3042 }
3043 
3044 void UsingDecl::anchor() {}
3045 
3047  NestedNameSpecifierLoc QualifierLoc,
3048  const DeclarationNameInfo &NameInfo,
3049  bool HasTypename) {
3050  return new (C, DC) UsingDecl(DC, UL, QualifierLoc, NameInfo, HasTypename);
3051 }
3052 
3054  return new (C, ID) UsingDecl(nullptr, SourceLocation(),
3056  false);
3057 }
3058 
3061  ? getQualifierLoc().getBeginLoc() : UsingLocation;
3062  return SourceRange(Begin, getNameInfo().getEndLoc());
3063 }
3064 
3065 void UsingEnumDecl::anchor() {}
3066 
3069  SourceLocation NL, EnumDecl *Enum) {
3070  return new (C, DC) UsingEnumDecl(DC, Enum->getDeclName(), UL, EL, NL, Enum);
3071 }
3072 
3074  return new (C, ID) UsingEnumDecl(nullptr, DeclarationName(), SourceLocation(),
3075  SourceLocation(), SourceLocation(), nullptr);
3076 }
3077 
3079  return SourceRange(EnumLocation, getLocation());
3080 }
3081 
3082 void UsingPackDecl::anchor() {}
3083 
3085  NamedDecl *InstantiatedFrom,
3086  ArrayRef<NamedDecl *> UsingDecls) {
3087  size_t Extra = additionalSizeToAlloc<NamedDecl *>(UsingDecls.size());
3088  return new (C, DC, Extra) UsingPackDecl(DC, InstantiatedFrom, UsingDecls);
3089 }
3090 
3092  unsigned NumExpansions) {
3093  size_t Extra = additionalSizeToAlloc<NamedDecl *>(NumExpansions);
3094  auto *Result = new (C, ID, Extra) UsingPackDecl(nullptr, nullptr, None);
3095  Result->NumExpansions = NumExpansions;
3096  auto *Trail = Result->getTrailingObjects<NamedDecl *>();
3097  for (unsigned I = 0; I != NumExpansions; ++I)
3098  new (Trail + I) NamedDecl*(nullptr);
3099  return Result;
3100 }
3101 
3102 void UnresolvedUsingValueDecl::anchor() {}
3103 
3106  SourceLocation UsingLoc,
3107  NestedNameSpecifierLoc QualifierLoc,
3108  const DeclarationNameInfo &NameInfo,
3109  SourceLocation EllipsisLoc) {
3110  return new (C, DC) UnresolvedUsingValueDecl(DC, C.DependentTy, UsingLoc,
3111  QualifierLoc, NameInfo,
3112  EllipsisLoc);
3113 }
3114 
3117  return new (C, ID) UnresolvedUsingValueDecl(nullptr, QualType(),
3118  SourceLocation(),
3121  SourceLocation());
3122 }
3123 
3126  ? getQualifierLoc().getBeginLoc() : UsingLocation;
3127  return SourceRange(Begin, getNameInfo().getEndLoc());
3128 }
3129 
3130 void UnresolvedUsingTypenameDecl::anchor() {}
3131 
3134  SourceLocation UsingLoc,
3135  SourceLocation TypenameLoc,
3136  NestedNameSpecifierLoc QualifierLoc,
3137  SourceLocation TargetNameLoc,
3138  DeclarationName TargetName,
3139  SourceLocation EllipsisLoc) {
3140  return new (C, DC) UnresolvedUsingTypenameDecl(
3141  DC, UsingLoc, TypenameLoc, QualifierLoc, TargetNameLoc,
3142  TargetName.getAsIdentifierInfo(), EllipsisLoc);
3143 }
3144 
3147  return new (C, ID) UnresolvedUsingTypenameDecl(
3149  SourceLocation(), nullptr, SourceLocation());
3150 }
3151 
3154  SourceLocation Loc, DeclarationName Name) {
3155  return new (Ctx, DC) UnresolvedUsingIfExistsDecl(DC, Loc, Name);
3156 }
3157 
3160  return new (Ctx, ID)
3162 }
3163 
3164 UnresolvedUsingIfExistsDecl::UnresolvedUsingIfExistsDecl(DeclContext *DC,
3165  SourceLocation Loc,
3166  DeclarationName Name)
3167  : NamedDecl(Decl::UnresolvedUsingIfExists, DC, Loc, Name) {}
3168 
3169 void UnresolvedUsingIfExistsDecl::anchor() {}
3170 
3171 void StaticAssertDecl::anchor() {}
3172 
3174  SourceLocation StaticAssertLoc,
3175  Expr *AssertExpr,
3176  StringLiteral *Message,
3177  SourceLocation RParenLoc,
3178  bool Failed) {
3179  return new (C, DC) StaticAssertDecl(DC, StaticAssertLoc, AssertExpr, Message,
3180  RParenLoc, Failed);
3181 }
3182 
3184  unsigned ID) {
3185  return new (C, ID) StaticAssertDecl(nullptr, SourceLocation(), nullptr,
3186  nullptr, SourceLocation(), false);
3187 }
3188 
3189 void BindingDecl::anchor() {}
3190 
3192  SourceLocation IdLoc, IdentifierInfo *Id) {
3193  return new (C, DC) BindingDecl(DC, IdLoc, Id);
3194 }
3195 
3197  return new (C, ID) BindingDecl(nullptr, SourceLocation(), nullptr);
3198 }
3199 
3201  Expr *B = getBinding();
3202  if (!B)
3203  return nullptr;
3204  auto *DRE = dyn_cast<DeclRefExpr>(B->IgnoreImplicit());
3205  if (!DRE)
3206  return nullptr;
3207 
3208  auto *VD = cast<VarDecl>(DRE->getDecl());
3209  assert(VD->isImplicit() && "holding var for binding decl not implicit");
3210  return VD;
3211 }
3212 
3213 void DecompositionDecl::anchor() {}
3214 
3216  SourceLocation StartLoc,
3217  SourceLocation LSquareLoc,
3218  QualType T, TypeSourceInfo *TInfo,
3219  StorageClass SC,
3221  size_t Extra = additionalSizeToAlloc<BindingDecl *>(Bindings.size());
3222  return new (C, DC, Extra)
3223  DecompositionDecl(C, DC, StartLoc, LSquareLoc, T, TInfo, SC, Bindings);
3224 }
3225 
3227  unsigned ID,
3228  unsigned NumBindings) {
3229  size_t Extra = additionalSizeToAlloc<BindingDecl *>(NumBindings);
3230  auto *Result = new (C, ID, Extra)
3232  QualType(), nullptr, StorageClass(), None);
3233  // Set up and clean out the bindings array.
3234  Result->NumBindings = NumBindings;
3235  auto *Trail = Result->getTrailingObjects<BindingDecl *>();
3236  for (unsigned I = 0; I != NumBindings; ++I)
3237  new (Trail + I) BindingDecl*(nullptr);
3238  return Result;
3239 }
3240 
3241 void DecompositionDecl::printName(llvm::raw_ostream &os) const {
3242  os << '[';
3243  bool Comma = false;
3244  for (const auto *B : bindings()) {
3245  if (Comma)
3246  os << ", ";
3247  B->printName(os);
3248  Comma = true;
3249  }
3250  os << ']';
3251 }
3252 
3253 void MSPropertyDecl::anchor() {}
3254 
3257  QualType T, TypeSourceInfo *TInfo,
3258  SourceLocation StartL,
3259  IdentifierInfo *Getter,
3260  IdentifierInfo *Setter) {
3261  return new (C, DC) MSPropertyDecl(DC, L, N, T, TInfo, StartL, Getter, Setter);
3262 }
3263 
3265  unsigned ID) {
3266  return new (C, ID) MSPropertyDecl(nullptr, SourceLocation(),
3267  DeclarationName(), QualType(), nullptr,
3268  SourceLocation(), nullptr, nullptr);
3269 }
3270 
3271 void MSGuidDecl::anchor() {}
3272 
3273 MSGuidDecl::MSGuidDecl(DeclContext *DC, QualType T, Parts P)
3274  : ValueDecl(Decl::MSGuid, DC, SourceLocation(), DeclarationName(), T),
3275  PartVal(P) {}
3276 
3277 MSGuidDecl *MSGuidDecl::Create(const ASTContext &C, QualType T, Parts P) {
3278  DeclContext *DC = C.getTranslationUnitDecl();
3279  return new (C, DC) MSGuidDecl(DC, T, P);
3280 }
3281 
3282 MSGuidDecl *MSGuidDecl::CreateDeserialized(ASTContext &C, unsigned ID) {
3283  return new (C, ID) MSGuidDecl(nullptr, QualType(), Parts());
3284 }
3285 
3286 void MSGuidDecl::printName(llvm::raw_ostream &OS) const {
3287  OS << llvm::format("GUID{%08" PRIx32 "-%04" PRIx16 "-%04" PRIx16 "-",
3288  PartVal.Part1, PartVal.Part2, PartVal.Part3);
3289  unsigned I = 0;
3290  for (uint8_t Byte : PartVal.Part4And5) {
3291  OS << llvm::format("%02" PRIx8, Byte);
3292  if (++I == 2)
3293  OS << '-';
3294  }
3295  OS << '}';
3296 }
3297 
3298 /// Determine if T is a valid 'struct _GUID' of the shape that we expect.
3299 static bool isValidStructGUID(ASTContext &Ctx, QualType T) {
3300  // FIXME: We only need to check this once, not once each time we compute a
3301  // GUID APValue.
3302  using MatcherRef = llvm::function_ref<bool(QualType)>;
3303 
3304  auto IsInt = [&Ctx](unsigned N) {
3305  return [&Ctx, N](QualType T) {
3306  return T->isUnsignedIntegerOrEnumerationType() &&
3307  Ctx.getIntWidth(T) == N;
3308  };
3309  };
3310 
3311  auto IsArray = [&Ctx](MatcherRef Elem, unsigned N) {
3312  return [&Ctx, Elem, N](QualType T) {
3313  const ConstantArrayType *CAT = Ctx.getAsConstantArrayType(T);
3314  return CAT && CAT->getSize() == N && Elem(CAT->getElementType());
3315  };
3316  };
3317 
3318  auto IsStruct = [](std::initializer_list<MatcherRef> Fields) {
3319  return [Fields](QualType T) {
3320  const RecordDecl *RD = T->getAsRecordDecl();
3321  if (!RD || RD->isUnion())
3322  return false;
3323  RD = RD->getDefinition();
3324  if (!RD)
3325  return false;
3326  if (auto *CXXRD = dyn_cast<CXXRecordDecl>(RD))
3327  if (CXXRD->getNumBases())
3328  return false;
3329  auto MatcherIt = Fields.begin();
3330  for (const FieldDecl *FD : RD->fields()) {
3331  if (FD->isUnnamedBitfield()) continue;
3332  if (FD->isBitField() || MatcherIt == Fields.end() ||
3333  !(*MatcherIt)(FD->getType()))
3334  return false;
3335  ++MatcherIt;
3336  }
3337  return MatcherIt == Fields.end();
3338  };
3339  };
3340 
3341  // We expect an {i32, i16, i16, [8 x i8]}.
3342  return IsStruct({IsInt(32), IsInt(16), IsInt(16), IsArray(IsInt(8), 8)})(T);
3343 }
3344 
3346  if (APVal.isAbsent() && isValidStructGUID(getASTContext(), getType())) {
3347  using llvm::APInt;
3348  using llvm::APSInt;
3349  APVal = APValue(APValue::UninitStruct(), 0, 4);
3350  APVal.getStructField(0) = APValue(APSInt(APInt(32, PartVal.Part1), true));
3351  APVal.getStructField(1) = APValue(APSInt(APInt(16, PartVal.Part2), true));
3352  APVal.getStructField(2) = APValue(APSInt(APInt(16, PartVal.Part3), true));
3353  APValue &Arr = APVal.getStructField(3) =
3354  APValue(APValue::UninitArray(), 8, 8);
3355  for (unsigned I = 0; I != 8; ++I) {
3356  Arr.getArrayInitializedElt(I) =
3357  APValue(APSInt(APInt(8, PartVal.Part4And5[I]), true));
3358  }
3359  // Register this APValue to be destroyed if necessary. (Note that the
3360  // MSGuidDecl destructor is never run.)
3361  getASTContext().addDestruction(&APVal);
3362  }
3363 
3364  return APVal;
3365 }
3366 
3367 static const char *getAccessName(AccessSpecifier AS) {
3368  switch (AS) {
3369  case AS_none:
3370  llvm_unreachable("Invalid access specifier!");
3371  case AS_public:
3372  return "public";
3373  case AS_private:
3374  return "private";
3375  case AS_protected:
3376  return "protected";
3377  }
3378  llvm_unreachable("Invalid access specifier!");
3379 }
3380 
3382  AccessSpecifier AS) {
3383  return DB << getAccessName(AS);
3384 }
clang::DecompositionDecl::printName
void printName(raw_ostream &os) const override
Pretty-print the unqualified name of this declaration.
Definition: DeclCXX.cpp:3241
clang::ExplicitSpecifier
Store information needed for an explicit specifier.
Definition: DeclCXX.h:1794
clang::CXXMethodDecl::getThisType
QualType getThisType() const
Return the type of the this pointer.
Definition: DeclCXX.cpp:2453
clang::CXXRecordDecl::hasSimpleCopyConstructor
bool hasSimpleCopyConstructor() const
true if we know for sure that this class has a single, accessible, unambiguous copy constructor that ...
Definition: DeclCXX.h:703
clang::prec::Comma
@ Comma
Definition: OperatorPrecedence.h:28
clang::CXXCtorInitializer::getMemberLocation
SourceLocation getMemberLocation() const
Definition: DeclCXX.h:2328
clang::FunctionDecl::doesThisDeclarationHaveABody
bool doesThisDeclarationHaveABody() const
Returns whether this specific declaration of the function has a body.
Definition: Decl.h:2162
clang::CXXCtorInitializer::getAnyMember
FieldDecl * getAnyMember() const
Definition: DeclCXX.h:2314
clang::Type::isRecordType
bool isRecordType() const
Definition: Type.h:6788
clang::NamespaceDecl::Create
static NamespaceDecl * Create(ASTContext &C, DeclContext *DC, bool Inline, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, NamespaceDecl *PrevDecl)
Definition: DeclCXX.cpp:2858
clang::RequiresExprBodyDecl::Create
static RequiresExprBodyDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc)
Definition: DeclCXX.cpp:2081
clang::Decl::getASTContext
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:414
clang::AccessSpecDecl
Represents an access specifier followed by colon ':'.
Definition: DeclCXX.h:86
clang::UnresolvedSetIterator::getDecl
NamedDecl * getDecl() const
Definition: UnresolvedSet.h:50
clang::QualType::getCVRQualifiers
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
Definition: Type.h:6483
clang::RecordDecl::field_begin
field_iterator field_begin() const
Definition: Decl.cpp:4624
clang::CXXRecordDecl::getDeviceLambdaManglingNumber
unsigned getDeviceLambdaManglingNumber() const
Retrieve the device side mangling number.
Definition: DeclCXX.cpp:1613
clang::CXXMethodDecl::getThisObjectType
QualType getThisObjectType() const
Return the type of the object pointed by this.
Definition: DeclCXX.cpp:2464
clang::CXXConstructorDecl
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2400
clang::NestedNameSpecifier::getAsRecordDecl
CXXRecordDecl * getAsRecordDecl() const
Retrieve the record declaration stored in this nested name specifier.
Definition: NestedNameSpecifier.cpp:185
clang::CXXMethodDecl::isLambdaStaticInvoker
bool isLambdaStaticInvoker() const
Determine whether this is a lambda closure type's static member function that is used for the result ...
Definition: DeclCXX.cpp:2483
clang::ASTContext::getTypeDeclType
QualType getTypeDeclType(const TypeDecl *Decl, const TypeDecl *PrevDecl=nullptr) const
Return the unique reference to the type for the specified type declaration.
Definition: ASTContext.h:1542
clang::CXXMethodDecl::isCopyAssignmentOperator
bool isCopyAssignmentOperator() const
Determine whether this is a copy-assignment operator, regardless of whether it was declared implicitl...
Definition: DeclCXX.cpp:2361
clang::DeclContext::getParentASTContext
ASTContext & getParentASTContext() const
Definition: DeclBase.h:1883
clang::CXXConversionDecl::isLambdaToBlockPointerConversion
bool isLambdaToBlockPointerConversion() const
Determine whether this conversion function is a conversion from a lambda closure type to a block poin...
Definition: DeclCXX.cpp:2786
clang::FunctionDecl::getNumParams
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
Definition: Decl.cpp:3388
clang::Type::isBlockPointerType
bool isBlockPointerType() const
Definition: Type.h:6706
clang::CXXRecordDecl::getDependentLambdaCallOperator
FunctionTemplateDecl * getDependentLambdaCallOperator() const
Retrieve the dependent lambda call operator of the closure type if this is a templated closure type.
Definition: DeclCXX.cpp:1507
clang::RecordDecl::setArgPassingRestrictions
void setArgPassingRestrictions(ArgPassingKind Kind)
Definition: Decl.h:4024
Specifiers.h
clang::CXXRecordDecl::hasAnyDependentBases
bool hasAnyDependentBases() const
Determine whether this class has any dependent base classes which are not the current instantiation.
Definition: DeclCXX.cpp:567
clang::CXXRecordDecl::isTriviallyCopyable
bool isTriviallyCopyable() const
Determine whether this class is considered trivially copyable per (C++11 [class]p6).
Definition: DeclCXX.cpp:574
clang::interp::APInt
llvm::APInt APInt
Definition: Integral.h:27
clang::UsingDirectiveDecl::Create
static UsingDirectiveDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, SourceLocation NamespaceLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamedDecl *Nominated, DeclContext *CommonAncestor)
Definition: DeclCXX.cpp:2819
LT
ASTImporterLookupTable & LT
Definition: ASTImporterLookupTable.cpp:24
clang::CXXRecordDecl::hasSimpleDestructor
bool hasSimpleDestructor() const
true if we know for sure that this class has an accessible destructor that is not deleted.
Definition: DeclCXX.h:731
clang::DeclContext::specific_decl_iterator
specific_decl_iterator - Iterates over a subrange of declarations stored in a DeclContext,...
Definition: DeclBase.h:2129
clang::CXXCtorInitializer::getBaseClass
const Type * getBaseClass() const
If this is a base class initializer, returns the type of the base class.
Definition: DeclCXX.cpp:2534
clang::CXXRecordDecl::isEffectivelyFinal
bool isEffectivelyFinal() const
Determine whether it's impossible for a class to be derived from this class.
Definition: DeclCXX.cpp:2022
clang::UsingPackDecl::CreateDeserialized
static UsingPackDecl * CreateDeserialized(ASTContext &C, unsigned ID, unsigned NumExpansions)
Definition: DeclCXX.cpp:3091
clang::CXXMethodDecl::isStatic
bool isStatic() const
Definition: DeclCXX.cpp:2093
clang::CXXFinalOverriderMap
A mapping from each virtual member function to its set of final overriders.
Definition: CXXInheritance.h:357
clang::MemberSpecializationInfo
Provides information a specialization of a member of a class template, which may be a member function...
Definition: DeclTemplate.h:620
clang::UnresolvedSetImpl
A set of unresolved declarations.
Definition: UnresolvedSet.h:61
clang::ASTUnresolvedSet::size
unsigned size() const
Definition: ASTUnresolvedSet.h:77
clang::Decl::getEndLoc
SourceLocation getEndLoc() const LLVM_READONLY
Definition: DeclBase.h:420
clang::Type::isObjCRetainableType
bool isObjCRetainableType() const
Definition: Type.cpp:4302
clang::LinkageSpecDecl
Represents a linkage specification.
Definition: DeclCXX.h:2796
clang::SourceRange
A trivial tuple used to represent a source range.
Definition: SourceLocation.h:210
clang::DecompositionDecl::bindings
ArrayRef< BindingDecl * > bindings() const
Definition: DeclCXX.h:4049
clang::CXXRecordDecl::isCLike
bool isCLike() const
True if this class is C-like, without C++-specific features, e.g.
Definition: DeclCXX.cpp:1471
clang::DeclContext
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1341
clang::ASTUnresolvedSet::erase
void erase(unsigned I)
Definition: ASTUnresolvedSet.h:72
clang::BindingDecl::Create
static BindingDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id)
Definition: DeclCXX.cpp:3191
clang::StaticAssertDecl::Create
static StaticAssertDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StaticAssertLoc, Expr *AssertExpr, StringLiteral *Message, SourceLocation RParenLoc, bool Failed)
Definition: DeclCXX.cpp:3173
clang::ExplicitSpecKind::Unresolved
@ Unresolved
clang::LambdaCapture
Describes the capture of a variable or of this, or of a C++1y init-capture.
Definition: LambdaCapture.h:25
clang::CXXConversionDecl
Represents a C++ conversion function within a class.
Definition: DeclCXX.h:2730
clang::Decl::hasAttr
bool hasAttr() const
Definition: DeclBase.h:541
clang::Redeclarable< UsingShadowDecl >
clang::CXXRecordDecl::getMemberSpecializationInfo
MemberSpecializationInfo * getMemberSpecializationInfo() const
If this class is an instantiation of a member class of a class template specialization,...
Definition: DeclCXX.cpp:1797
clang::NamespaceAliasDecl
Represents a C++ namespace alias.
Definition: DeclCXX.h:2985
clang::LifetimeExtendedTemporaryDecl::getOrCreateValue
APValue * getOrCreateValue(bool MayCreate) const
Get the storage for the constant value of a materialized temporary of static storage duration.
Definition: DeclCXX.cpp:2954
clang::DecompositionDecl::Create
static DecompositionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation LSquareLoc, QualType T, TypeSourceInfo *TInfo, StorageClass S, ArrayRef< BindingDecl * > Bindings)
Definition: DeclCXX.cpp:3215
clang::QualType::isConstQualified
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition: Type.h:6509
clang::CXXRecordDecl::hasNonTrivialMoveConstructor
bool hasNonTrivialMoveConstructor() const
Determine whether this class has a non-trivial move constructor (C++11 [class.copy]p12)
Definition: DeclCXX.h:1257
clang::ConstantArrayType
Represents the canonical version of C arrays with a specified constant size.
Definition: Type.h:2930
clang::Decl::getAsFunction
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
Definition: DeclBase.cpp:218
Used
@ Used
Definition: ObjCUnusedIVarsChecker.cpp:29
clang::CXXRecordDecl::hasNonTrivialMoveAssignment
bool hasNonTrivialMoveAssignment() const
Determine whether this class has a non-trivial move assignment operator (C++11 [class....
Definition: DeclCXX.h:1292
clang::FunctionDecl::isDeleted
bool isDeleted() const
Whether this function has been deleted.
Definition: Decl.h:2337
clang::UsingDecl::getQualifier
NestedNameSpecifier * getQualifier() const
Retrieve the nested-name-specifier that qualifies the name.
Definition: DeclCXX.h:3415
clang::Qualifiers::OCL_Weak
@ OCL_Weak
Reading or writing from this object requires a barrier call.
Definition: Type.h:177
clang::UsingDirectiveDecl
Represents C++ using-directive.
Definition: DeclCXX.h:2881
clang::ConstantArrayType::getSize
const llvm::APInt & getSize() const
Definition: Type.h:2953
clang::CXXDestructorDecl::setOperatorDelete
void setOperatorDelete(FunctionDecl *OD, Expr *ThisArg)
Definition: DeclCXX.cpp:2752
clang::Decl::getASTMutationListener
ASTMutationListener * getASTMutationListener() const
Definition: DeclBase.cpp:424
clang::BindingDecl
A binding in a decomposition declaration.
Definition: DeclCXX.h:3958
clang::Expr::IgnoreImplicit
Expr * IgnoreImplicit() LLVM_READONLY
Skip past any implicit AST nodes which might surround this expression until reaching a fixed point.
Definition: Expr.cpp:2921
clang::DeclarationName::CXXConstructorName
@ CXXConstructorName
Definition: DeclarationName.h:204
clang::CXXRecordDecl::removeConversion
void removeConversion(const NamedDecl *Old)
Removes a conversion function from this class.
Definition: DeclCXX.cpp:1765
llvm::SmallVector
Definition: LLVM.h:38
clang::UsingDirectiveDecl::CreateDeserialized
static UsingDirectiveDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:2832
clang::IdentifierTable::get
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
Definition: IdentifierTable.h:592
clang::RecordDecl::field_empty
bool field_empty() const
Definition: Decl.h:4094
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:86
clang::CXXRecordDecl::conversion_begin
conversion_iterator conversion_begin() const
Definition: DeclCXX.h:1075
clang::QualType::getQualifiers
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
Definition: Type.h:6477
clang::ASTContext::getIntWidth
unsigned getIntWidth(QualType T) const
Definition: ASTContext.cpp:10293
clang::TTK_Struct
@ TTK_Struct
The "struct" keyword.
Definition: Type.h:5336
clang::FunctionDecl::hasOneParamOrDefaultArgs
bool hasOneParamOrDefaultArgs() const
Determine whether this function has a single parameter, or multiple parameters where all but the firs...
Definition: Decl.cpp:3427
clang::NamedDecl
This represents a decl that may have a name.
Definition: Decl.h:247
clang::AS_private
@ AS_private
Definition: Specifiers.h:111
clang::CXXConstructorDecl::isExplicit
bool isExplicit() const
Return true if the declartion is already resolved to be explicit.
Definition: DeclCXX.h:2482
clang::NamedDecl::getUnderlyingDecl
NamedDecl * getUnderlyingDecl()
Looks through UsingDecls and ObjCCompatibleAliasDecls for the underlying named decl.
Definition: Decl.h:457
clang::MultiVersionKind::Target
@ Target
CXXInheritance.h
clang::ASTContext::DeclarationNames
DeclarationNameTable DeclarationNames
Definition: ASTContext.h:650
clang::RecordDecl::setHasVolatileMember
void setHasVolatileMember(bool val)
Definition: Decl.h:3952
clang::CXXConstructorDecl::isDelegatingConstructor
bool isDelegatingConstructor() const
Determine whether this constructor is a delegating constructor.
Definition: DeclCXX.h:2555
clang::TSK_Undeclared
@ TSK_Undeclared
This template specialization was formed from a template-id but has not yet been declared,...
Definition: Specifiers.h:176
clang::CXXRecordDecl::getDefinition
CXXRecordDecl * getDefinition() const
Definition: DeclCXX.h:534
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:674
clang::TypeDecl::getTypeForDecl
const Type * getTypeForDecl() const
Definition: Decl.h:3165
Attr.h
clang::CXXRecordDecl::hasNonTrivialCopyAssignment
bool hasNonTrivialCopyAssignment() const
Determine whether this class has a non-trivial copy assignment operator (C++ [class....
Definition: DeclCXX.h:1278
recursivelyOverrides
static bool recursivelyOverrides(const CXXMethodDecl *DerivedMD, const CXXMethodDecl *BaseMD)
Definition: DeclCXX.cpp:2103
clang::FunctionDecl::getParamDecl
const ParmVarDecl * getParamDecl(unsigned i) const
Definition: Decl.h:2509
AttributeLangSupport::C
@ C
Definition: SemaDeclAttr.cpp:54
isValidStructGUID
static bool isValidStructGUID(ASTContext &Ctx, QualType T)
Determine if T is a valid 'struct _GUID' of the shape that we expect.
Definition: DeclCXX.cpp:3299
clang::CXXRecordDecl::setCaptures
void setCaptures(ASTContext &Context, ArrayRef< LambdaCapture > Captures)
Set the captures for this lambda closure type.
Definition: DeclCXX.cpp:1433
clang::cast
U cast(CodeGen::Address addr)
Definition: Address.h:132
clang::FunctionDecl::willHaveBody
bool willHaveBody() const
True if this function will eventually have a body, once it's fully parsed.
Definition: Decl.h:2430
clang::UnresolvedSetIterator
The iterator over UnresolvedSets.
Definition: UnresolvedSet.h:32
clang::CXXRecordDecl::MergeAccess
static AccessSpecifier MergeAccess(AccessSpecifier PathAccess, AccessSpecifier DeclAccess)
Calculates the access of a decl that is reached along a path.
Definition: DeclCXX.h:1661
clang::FieldDecl
Represents a member of a struct/union/class.
Definition: Decl.h:2838
clang::ASTContext::getBaseElementType
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
Definition: ASTContext.cpp:6372
clang::FieldDecl::getInClassInitializer
Expr * getInClassInitializer() const
Get the C++11 default member initializer for this member, or null if one has not been set.
Definition: Decl.h:2985
clang::UnresolvedUsingValueDecl::isAccessDeclaration
bool isAccessDeclaration() const
Return true if it is a C++03 access declaration (no 'using').
Definition: DeclCXX.h:3750
isDeclContextInNamespace
static bool isDeclContextInNamespace(const DeclContext *DC)
Definition: DeclCXX.cpp:1902
clang::index::SymbolRole::Definition
@ Definition
clang::ParmVarDecl
Represents a parameter to a function.
Definition: Decl.h:1663
clang::NamespaceAliasDecl::CreateDeserialized
static NamespaceAliasDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:2928
clang::Redeclarable< FunctionDecl >::getFirstDecl
FunctionDecl * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
Definition: Redeclarable.h:216
DeclCXX.h
clang::CXXMethodDecl::getCanonicalDecl
CXXMethodDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:2032
clang::MSPropertyDecl::Create
static MSPropertyDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation L, DeclarationName N, QualType T, TypeSourceInfo *TInfo, SourceLocation StartL, IdentifierInfo *Getter, IdentifierInfo *Setter)
Definition: DeclCXX.cpp:3255
clang::UnresolvedUsingValueDecl::getNameInfo
DeclarationNameInfo getNameInfo() const
Definition: DeclCXX.h:3761
clang::CXXCtorInitializer::isBaseInitializer
bool isBaseInitializer() const
Determine whether this initializer is initializing a base class.
Definition: DeclCXX.h:2240
clang::UsingShadowDecl
Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...
Definition: DeclCXX.h:3186
clang::DeclarationNameTable::getCXXDestructorName
DeclarationName getCXXDestructorName(CanQualType Ty)
Returns the name of a C++ destructor for the given Type.
Definition: DeclarationName.cpp:326
clang::FunctionDecl::getPrimaryTemplate
FunctionTemplateDecl * getPrimaryTemplate() const
Retrieve the primary template that this function template specialization either specializes or was in...
Definition: Decl.cpp:3820
clang::index::SymbolKind::Using
@ Using
clang::UsingEnumDecl::getSourceRange
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: DeclCXX.cpp:3078
clang::CXXRecordDecl::Create
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:132
clang::UnresolvedUsingValueDecl::CreateDeserialized
static UnresolvedUsingValueDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:3116
clang::RecordDecl::getDefinition
RecordDecl * getDefinition() const
Returns the RecordDecl that actually defines this struct/union/class.
Definition: Decl.h:4071
llvm::SmallPtrSet
Definition: ASTContext.h:82
clang::FunctionDecl::UsesFPIntrin
bool UsesFPIntrin() const
Determine whether the function was declared in source context that requires constrained FP intrinsics...
Definition: Decl.h:2604
hasRepeatedBaseClass
static bool hasRepeatedBaseClass(const CXXRecordDecl *StartRD)
Determine whether a class has a repeated base class.
Definition: DeclCXX.cpp:176
clang::CXXRecordDecl::isGenericLambda
bool isGenericLambda() const
Determine whether this class describes a generic lambda function object (i.e.
Definition: DeclCXX.cpp:1481
clang::FunctionDecl::isUserProvided
bool isUserProvided() const
True if this method is user-declared and was not deleted or defaulted on its first declaration.
Definition: Decl.h:2229
clang::QualType::isVolatileQualified
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition: Type.h:6520
clang::CXXRecordDecl::hasUserDeclaredConstructor
bool hasUserDeclaredConstructor() const
Determine whether this class has any user-declared constructors.
Definition: DeclCXX.h:760
clang::Decl::getLangOpts
const LangOptions & getLangOpts() const LLVM_READONLY
Helper to get the language options from the ASTContext.
Definition: DeclBase.cpp:420
clang::CPlusPlus14
@ CPlusPlus14
Definition: LangStandard.h:50
clang::tooling::X
static ToolExecutorPluginRegistry::Add< AllTUsToolExecutorPlugin > X("all-TUs", "Runs FrontendActions on all TUs in the compilation database. " "Tool results are stored in memory.")
clang::CXXCtorInitializer::isAnyMemberInitializer
bool isAnyMemberInitializer() const
Definition: DeclCXX.h:2248
clang::ClassTemplatePartialSpecializationDecl
Definition: DeclTemplate.h:2075
clang::UsingPackDecl
Represents a pack of using declarations that a single using-declarator pack-expanded into.
Definition: DeclCXX.h:3643
clang::RecordDecl::APK_CanNeverPassInRegs
@ APK_CanNeverPassInRegs
The argument of this type cannot be passed directly in registers.
Definition: Decl.h:3891
ASTLambda.h
clang::DeclarationName::getAsIdentifierInfo
IdentifierInfo * getAsIdentifierInfo() const
Retrieve the IdentifierInfo * stored in this declaration name, or null if this declaration name isn't...
Definition: DeclarationName.h:408
clang::MSGuidDeclParts::Part1
uint32_t Part1
{01234567-...
Definition: DeclCXX.h:4117
clang::Type::isRValueReferenceType
bool isRValueReferenceType() const
Definition: Type.h:6718
clang::FunctionType
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition: Type.h:3547
clang::SD_Automatic
@ SD_Automatic
Automatic storage duration (most local variables).
Definition: Specifiers.h:308
clang::TTK_Interface
@ TTK_Interface
The "__interface" keyword.
Definition: Type.h:5339
clang::DeclarationName
The name of a declaration.
Definition: DeclarationName.h:143
clang::CXXRecordDecl::bases_end
base_class_iterator bases_end()
Definition: DeclCXX.h:597
clang::index::SymbolKind::Constructor
@ Constructor
clang::BindingDecl::getHoldingVar
VarDecl * getHoldingVar() const
Get the variable (if any) that holds the value of evaluating the binding.
Definition: DeclCXX.cpp:3200
clang::CXXRecordDecl::lambdaIsDefaultConstructibleAndAssignable
bool lambdaIsDefaultConstructibleAndAssignable() const
Determine whether this lambda should have an implicit default constructor and copy and move assignmen...
Definition: DeclCXX.cpp:677
clang::CXXRecordDecl::getLambdaContextDecl
Decl * getLambdaContextDecl() const
Retrieve the declaration that provides additional context for a lambda, when the normal declaration c...
Definition: DeclCXX.cpp:1601
clang::CXXMethodDecl::getCorrespondingMethodInClass
CXXMethodDecl * getCorrespondingMethodInClass(const CXXRecordDecl *RD, bool MayBeBase=false)
Find the method in RD that corresponds to this one.
Definition: DeclCXX.cpp:2146
clang::CXXRecordDecl::getLambdaCallOperator
CXXMethodDecl * getLambdaCallOperator() const
Retrieve the lambda call operator of the closure type if this is a closure type.
Definition: DeclCXX.cpp:1512
clang::EnumDecl
Represents an enum.
Definition: Decl.h:3593
clang::CXXMethodDecl::isMoveAssignmentOperator
bool isMoveAssignmentOperator() const
Determine whether this is a move assignment operator.
Definition: DeclCXX.cpp:2382
clang::Type
The base class of the type hierarchy.
Definition: Type.h:1491
getLambdaStaticInvokers
static DeclContext::lookup_result getLambdaStaticInvokers(const CXXRecordDecl &RD)
Definition: DeclCXX.cpp:1531
clang::CXXCtorInitializer::getSourceLocation
SourceLocation getSourceLocation() const
Determine the source location of the initializer.
Definition: DeclCXX.cpp:2541
clang::StorageDuration
StorageDuration
The storage duration for an object (per C++ [basic.stc]).
Definition: Specifiers.h:306
clang::CXXMethodDecl::Create
static CXXMethodDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin, bool isInline, ConstexprSpecKind ConstexprKind, SourceLocation EndLocation, Expr *TrailingRequiresClause=nullptr)
Definition: DeclCXX.cpp:2181
clang::AS_none
@ AS_none
Definition: Specifiers.h:112
clang::NamespaceDecl::getOriginalNamespace
NamespaceDecl * getOriginalNamespace()
Get the original (first) namespace declaration.
Definition: DeclCXX.cpp:2871
clang::LinkageSpecDecl::lang_c
@ lang_c
Definition: DeclCXX.h:2805
clang::CXXConstructorDecl::Create
static CXXConstructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, ExplicitSpecifier ES, bool UsesFPIntrin, bool isInline, bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind, InheritedConstructor Inherited=InheritedConstructor(), Expr *TrailingRequiresClause=nullptr)
Definition: DeclCXX.cpp:2605
clang::RecordDecl::setHasObjectMember
void setHasObjectMember(bool val)
Definition: Decl.h:3948
clang::CXXRecordDecl::getDescribedClassTemplate
ClassTemplateDecl * getDescribedClassTemplate() const
Retrieves the class template that is described by this class declaration.
Definition: DeclCXX.cpp:1811
clang::CXXConstructorDecl::CreateDeserialized
static CXXConstructorDecl * CreateDeserialized(ASTContext &C, unsigned ID, uint64_t AllocKind)
Definition: DeclCXX.cpp:2585
APSInt
llvm::APSInt APSInt
Definition: ByteCodeEmitter.cpp:19
clang::UsingDecl::isAccessDeclaration
bool isAccessDeclaration() const
Return true if it is a C++03 access declaration (no 'using').
Definition: DeclCXX.h:3424
clang::ASTContext::Allocate
void * Allocate(size_t Size, unsigned Align=8) const
Definition: ASTContext.h:706
clang::UnresolvedUsingTypenameDecl
Represents a dependent using declaration which was marked with typename.
Definition: DeclCXX.h:3808
clang::CXXCtorInitializer::isInClassMemberInitializer
bool isInClassMemberInitializer() const
Determine whether this initializer is an implicit initializer generated for a field with an initializ...
Definition: DeclCXX.h:2262
clang::Type::isLiteralType
bool isLiteralType(const ASTContext &Ctx) const
Return true if this is a literal type (C++11 [basic.types]p10)
Definition: Type.cpp:2555
clang::UnresolvedUsingValueDecl::getSourceRange
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: DeclCXX.cpp:3124
clang::FunctionTemplateDecl
Declaration of a template function.
Definition: DeclTemplate.h:979
clang::Type::isStructuralType
bool isStructuralType() const
Determine if this type is a structural type, per C++20 [temp.param]p7.
Definition: Type.cpp:2620
clang::CXXRecordDecl::getInstantiatedFromMemberClass
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:1790
clang::Type::isReferenceType
bool isReferenceType() const
Definition: Type.h:6710
clang::UnresolvedUsingTypenameDecl::CreateDeserialized
static UnresolvedUsingTypenameDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:3146
clang::ASTContext::getExternalSource
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any.
Definition: ASTContext.h:1156
clang::QualType::hasNonTrivialObjCLifetime
bool hasNonTrivialObjCLifetime() const
Definition: Type.h:1125
clang::Decl::Kind
Kind
Lists the kind of concrete classes of Decl.
Definition: DeclBase.h:86
clang::CXXRecordDecl::getLambdaCaptureDefault
LambdaCaptureDefault getLambdaCaptureDefault() const
Definition: DeclCXX.h:1032
clang::RecordType
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4635
clang::CXXMethodDecl::overridden_methods
overridden_method_range overridden_methods() const
Definition: DeclCXX.cpp:2428
clang::CXXCtorInitializer::getBaseClassLoc
TypeLoc getBaseClassLoc() const
If this is a base class initializer, returns the type of the base class with location information.
Definition: DeclCXX.cpp:2527
getAccessName
static const char * getAccessName(AccessSpecifier AS)
Definition: DeclCXX.cpp:3367
DeclTemplate.h
clang::DeclarationName::getCXXOverloadedOperator
OverloadedOperatorKind getCXXOverloadedOperator() const
If this name is the name of an overloadable operator in C++ (e.g., operator+), retrieve the kind of o...
Definition: DeclarationName.h:460
clang::NamespaceDecl::CreateDeserialized
static NamespaceDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:2866
clang::ASTUnresolvedSet
An UnresolvedSet-like class which uses the ASTContext's allocator.
Definition: ASTUnresolvedSet.h:29
clang::OverridingMethods::iterator
MapType::iterator iterator
Definition: CXXInheritance.h:277
clang::UsingShadowDecl::getIntroducer
BaseUsingDecl * getIntroducer() const
Gets the (written or instantiated) using declaration that introduced this declaration.
Definition: DeclCXX.cpp:2986
clang::RequiresExprBodyDecl
Represents the body of a requires-expression.
Definition: DeclCXX.h:1925
clang::CXXMethodDecl::isInstance
bool isInstance() const
Definition: DeclCXX.h:1974
clang::ASTContext::getAsConstantArrayType
const ConstantArrayType * getAsConstantArrayType(QualType T) const
Definition: ASTContext.h:2639
clang::Decl::getAccess
AccessSpecifier getAccess() const
Definition: DeclBase.h:472
clang::CXXRecordDecl::methods
method_range methods() const
Definition: DeclCXX.h:630
clang::FunctionDecl::isTrivial
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
Definition: Decl.h:2206
clang::ASTUnresolvedSet::append
void append(ASTContext &C, iterator I, iterator E)
Definition: ASTUnresolvedSet.h:83
clang::TagTypeKind
TagTypeKind
The kind of a tag type.
Definition: Type.h:5334
clang::QualType::isObjCGCStrong
bool isObjCGCStrong() const
true when Type is objc's strong.
Definition: Type.h:1116
Id
int Id
Definition: ASTDiff.cpp:191
DeclBase.h
clang::Qualifiers::OCL_Strong
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
Definition: Type.h:174
clang::FunctionDecl::getTemplateInstantiationPattern
FunctionDecl * getTemplateInstantiationPattern(bool ForDefinition=true) const
Retrieve the function declaration from which this function could be instantiated, if it is an instant...
Definition: Decl.cpp:3771
OperatorKinds.h
clang::DeclarationName::CXXDestructorName
@ CXXDestructorName
Definition: DeclarationName.h:205
clang::UsingDecl::CreateDeserialized
static UsingDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:3053
clang::AS_public
@ AS_public
Definition: Specifiers.h:109
clang::CXXCtorInitializer::getSourceRange
SourceRange getSourceRange() const LLVM_READONLY
Determine the source range covering the entire initializer.
Definition: DeclCXX.cpp:2554
clang::ASTContext
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:209
clang::ASTContext::getSizeType
CanQualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
Definition: ASTContext.cpp:5784
clang::ASTContext::addOverriddenMethod
void addOverriddenMethod(const CXXMethodDecl *Method, const CXXMethodDecl *Overridden)
Note that the given C++ Method overrides the given Overridden method.
Definition: ASTContext.cpp:1657
clang::StreamingDiagnostic
The streaming interface shared between DiagnosticBuilder and PartialDiagnostic.
Definition: Diagnostic.h:1108
clang::DeclContextLookupResult::front
reference front() const
Definition: DeclBase.h:1309
clang::DeclarationNameTable::getCXXOperatorName
DeclarationName getCXXOperatorName(OverloadedOperatorKind Op)
Get the name of the overloadable C++ operator corresponding to Op.
Definition: DeclarationName.h:637
clang::ConstructorUsingShadowDecl::CreateDeserialized
static ConstructorUsingShadowDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:3005
NestedNameSpecifier.h
clang::DeclaratorContext::Member
@ Member
LangOptions.h
Diagnostic.h
clang::CXXRecordDecl::getLambdaStaticInvoker
CXXMethodDecl * getLambdaStaticInvoker() const
Retrieve the lambda static invoker, the address of which is returned by the conversion operator,...
Definition: DeclCXX.cpp:1524
clang::DecompositionDecl
A decomposition declaration.
Definition: DeclCXX.h:4015
clang::QualType::isCXX98PODType
bool isCXX98PODType(const ASTContext &Context) const
Return true if this is a POD type according to the rules of the C++98 standard, regardless of the cur...
Definition: Type.cpp:2358
clang::Type::getAs
const T * getAs() const
Member-template getAs<specific type>'.
Definition: Type.h:7187
clang::CXXRecordDecl::getNumBases
unsigned getNumBases() const
Retrieves the number of base classes of this class.
Definition: DeclCXX.h:582
clang::CXXConversionDecl::CreateDeserialized
static CXXConversionDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:2765
clang::Decl::isInvalidDecl
bool isInvalidDecl() const
Definition: DeclBase.h:552
clang::ASTMutationListener
An abstract interface that should be implemented by listeners that want to be notified when an AST en...
Definition: ASTMutationListener.h:46
clang::ConstructorUsingShadowDecl::getIntroducer
UsingDecl * getIntroducer() const
Override the UsingShadowDecl's getIntroducer, returning the UsingDecl that introduced this.
Definition: DeclCXX.h:3520
clang::LambdaCaptureDefault
LambdaCaptureDefault
The default, if any, capture method for a lambda expression.
Definition: Lambda.h:22
clang::Qualifiers::Volatile
@ Volatile
Definition: Type.h:151
clang::Type::isLValueReferenceType
bool isLValueReferenceType() const
Definition: Type.h:6714
clang::index::SymbolKind::Field
@ Field
clang::MSGuidDecl
A global _GUID constant.
Definition: DeclCXX.h:4138
uintptr_t
__UINTPTR_TYPE__ uintptr_t
An unsigned integer type with the property that any valid pointer to void can be converted to this ty...
Definition: opencl-c-base.h:124
clang::CXXDestructorDecl
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2667
IdentifierTable.h
clang::DeclContext::isTranslationUnit
bool isTranslationUnit() const
Definition: DeclBase.h:1929
Type.h
clang::UsingDecl::Create
static UsingDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingL, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, bool HasTypenameKeyword)
Definition: DeclCXX.cpp:3046
clang::BaseUsingDecl::shadows
shadow_range shadows() const
Definition: DeclCXX.h:3349
clang::CXXRecordDecl::isPOD
bool isPOD() const
Whether this class is a POD-type (C++ [class]p4)
Definition: DeclCXX.h:1125
clang::CPlusPlus20
@ CPlusPlus20
Definition: LangStandard.h:52
Expr.h
clang::CanQual::getCVRQualifiers
unsigned getCVRQualifiers() const
Retrieve the const/volatile/restrict qualifiers.
Definition: CanonicalType.h:132
bool
#define bool
Definition: stdbool.h:15
clang::BaseUsingDecl::removeShadowDecl
void removeShadowDecl(UsingShadowDecl *S)
Definition: DeclCXX.cpp:3024
clang::MSGuidDecl::getAsAPValue
APValue & getAsAPValue() const
Get the value of this MSGuidDecl as an APValue.
Definition: DeclCXX.cpp:3345
ASTContext.h
clang::UnresolvedSet< 8 >
clang::CallingConv
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition: Specifiers.h:263
clang::VarDecl
Represents a variable declaration or definition.
Definition: Decl.h:874
clang::UnresolvedUsingIfExistsDecl::CreateDeserialized
static UnresolvedUsingIfExistsDecl * CreateDeserialized(ASTContext &Ctx, unsigned ID)
Definition: DeclCXX.cpp:3159
clang::MSPropertyDecl::CreateDeserialized
static MSPropertyDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:3264
clang::Type::getPointeeType
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
Definition: Type.cpp:625
clang::TemplateParameterList
Stores a list of template parameters for a TemplateDecl and its derived classes.
Definition: DeclTemplate.h:69
clang::ASTUnresolvedSet::replace
bool replace(const NamedDecl *Old, NamedDecl *New, AccessSpecifier AS)
Replaces the given declaration with the new one, once.
Definition: ASTUnresolvedSet.h:62
clang::CXXRecordDecl::hasConstexprDestructor
bool hasConstexprDestructor() const
Determine whether this class has a constexpr destructor.
Definition: DeclCXX.cpp:562
clang::StringLiteral
StringLiteral - This represents a string literal expression, e.g.
Definition: Expr.h:1767
clang::SD_FullExpression
@ SD_FullExpression
Full-expression storage duration (for temporaries).
Definition: Specifiers.h:307
getLambdaCallOperatorHelper
static NamedDecl * getLambdaCallOperatorHelper(const CXXRecordDecl &RD)
Definition: DeclCXX.cpp:1495
clang::TTK_Class
@ TTK_Class
The "class" keyword.
Definition: Type.h:5345
clang::UsingShadowDecl::UsingShadowDecl
UsingShadowDecl(Kind K, ASTContext &C, DeclContext *DC, SourceLocation Loc, DeclarationName Name, BaseUsingDecl *Introducer, NamedDecl *Target)
Definition: DeclCXX.cpp:2967
clang::ASTContext::getCanonicalType
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
Definition: ASTContext.h:2478
clang::Type::getAsCXXRecordDecl
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1760
clang::TagDecl::isUnion
bool isUnion() const
Definition: Decl.h:3519
clang::LinkageSpecDecl::LanguageIDs
LanguageIDs
Represents the language in a linkage specification.
Definition: DeclCXX.h:2805
clang::DeclContext::isNamespace
bool isNamespace() const
Definition: DeclBase.h:1938
clang::CXXRecordDecl::bases
base_class_range bases()
Definition: DeclCXX.h:588
clang::CXXRecordDecl::hasFriends
bool hasFriends() const
Determines whether this record has any friends.
Definition: DeclCXX.h:671
clang::ASTContext::addDestruction
void addDestruction(T *Ptr) const
If T isn't trivially destructible, calls AddDeallocation to register it for destruction.
Definition: ASTContext.h:2962
clang::CXXRecordDecl::setInstantiationOfMemberClass
void setInstantiationOfMemberClass(CXXRecordDecl *RD, TemplateSpecializationKind TSK)
Specify that this record is an instantiation of the member class RD.
Definition: DeclCXX.cpp:1802
clang::MSGuidDecl::printName
void printName(llvm::raw_ostream &OS) const override
Print this UUID in a human-readable format.
Definition: DeclCXX.cpp:3286
clang::CXXDeductionGuideDecl::Create
static CXXDeductionGuideDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, ExplicitSpecifier ES, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, SourceLocation EndLocation, CXXConstructorDecl *Ctor=nullptr)
Definition: DeclCXX.cpp:2065
clang::CXXRecordDecl::forallBases
bool forallBases(ForallBasesCallback BaseMatches) const
Determines if the given callback holds for all the direct or indirect base classes of this type.
Definition: CXXInheritance.cpp:127
clang::NestedNameSpecifierLoc
A C++ nested-name-specifier augmented with source location information.
Definition: NestedNameSpecifier.h:243
clang::Redeclarable< NamespaceDecl >::getPreviousDecl
NamespaceDecl * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
Definition: Redeclarable.h:204
clang::FunctionDecl::getMinRequiredArguments
unsigned getMinRequiredArguments() const
Returns the minimum number of arguments needed to call this function.
Definition: Decl.cpp:3409
clang::CanQual< Type >
ExprCXX.h
clang::ExplicitSpecifier::getFromDecl
static ExplicitSpecifier getFromDecl(FunctionDecl *Function)
Definition: DeclCXX.cpp:2051
clang::MSGuidDecl::Parts
MSGuidDeclParts Parts
Definition: DeclCXX.h:4142
Base
clang::Type::isUnsignedIntegerOrEnumerationType
bool isUnsignedIntegerOrEnumerationType() const
Determines whether this is an integer type that is unsigned or an enumeration types whose underlying ...
Definition: Type.cpp:2084
clang::LCD_None
@ LCD_None
Definition: Lambda.h:23
clang::FunctionDecl::getOverloadedOperator
OverloadedOperatorKind getOverloadedOperator() const
getOverloadedOperator - Which C++ overloaded operator this function represents, if any.
Definition: Decl.cpp:3661
clang::UnresolvedUsingValueDecl
Represents a dependent using declaration which was not marked with typename.
Definition: DeclCXX.h:3712
clang::Redeclarable< NamespaceDecl >::isFirstDecl
bool isFirstDecl() const
True if this is the first declaration in its redeclaration chain.
Definition: Redeclarable.h:223
clang::CXXConstructorDecl::isConvertingConstructor
bool isConvertingConstructor(bool AllowExplicit) const
Whether this constructor is a converting constructor (C++ [class.conv.ctor]), which can be used for u...
Definition: DeclCXX.cpp:2694
clang::CXXRecordDecl::hasSimpleMoveAssignment
bool hasSimpleMoveAssignment() const
true if we know for sure that this class has a single, accessible, unambiguous move assignment operat...
Definition: DeclCXX.h:724
clang::APValue::getArrayInitializedElt
APValue & getArrayInitializedElt(unsigned I)
Definition: APValue.h:502
clang::operator<<
const StreamingDiagnostic & operator<<(const StreamingDiagnostic &DB, const ASTContext::SectionInfo &Section)
Insertion operator for diagnostics.
Definition: ASTContext.cpp:11871
clang::Decl::setImplicit
void setImplicit(bool I=true)
Definition: DeclBase.h:558
clang::NamespaceDecl::isOriginalNamespace
bool isOriginalNamespace() const
Return true if this declaration is an original (first) declaration of the namespace.
Definition: DeclCXX.cpp:2885
clang::ConstructorUsingShadowDecl::Create
static ConstructorUsingShadowDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation Loc, UsingDecl *Using, NamedDecl *Target, bool IsVirtual)
Definition: DeclCXX.cpp:2997
clang::Decl::isImplicit
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:557
clang::OverloadedOperatorKind
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Definition: OperatorKinds.h:21
clang::CXXDestructorDecl::Create
static CXXDestructorDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool UsesFPIntrin, bool isInline, bool isImplicitlyDeclared, ConstexprSpecKind ConstexprKind, Expr *TrailingRequiresClause=nullptr)
Definition: DeclCXX.cpp:2739
clang::Qualifiers::ObjCLifetime
ObjCLifetime
Definition: Type.h:161
clang::ODRHash
Definition: ODRHash.h:41
clang::SC_Static
@ SC_Static
Definition: Specifiers.h:237
clang::ExplicitSpecifier::isEquivalent
bool isEquivalent(const ExplicitSpecifier Other) const
Check for equivalence of explicit specifiers.
Definition: DeclCXX.cpp:2036
clang::CXXRecordDecl::getODRHash
unsigned getODRHash() const
Definition: DeclCXX.cpp:494
clang::UsingDecl
Represents a C++ using-declaration.
Definition: DeclCXX.h:3378
clang::DeclarationNameInfo::getName
DeclarationName getName() const
getName - Returns the embedded declaration name.
Definition: DeclarationName.h:779
clang::UsingEnumDecl::CreateDeserialized
static UsingEnumDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:3073
clang::NamedDecl::getMostRecentDecl
NamedDecl * getMostRecentDecl()
Definition: Decl.h:471
clang::ASTUnresolvedSet::addDecl
void addDecl(ASTContext &C, NamedDecl *D, AccessSpecifier AS)
Definition: ASTUnresolvedSet.h:55
clang::CXXConstructorDecl::isDefaultConstructor
bool isDefaultConstructor() const
Whether this constructor is a default constructor (C++ [class.ctor]p5), which can be used to default-...
Definition: DeclCXX.cpp:2635
clang::DeclarationName::CXXConversionFunctionName
@ CXXConversionFunctionName
Definition: DeclarationName.h:206
clang::ExplicitSpecifier::getExpr
const Expr * getExpr() const
Definition: DeclCXX.h:1803
clang::FunctionDecl::isDestroyingOperatorDelete
bool isDestroyingOperatorDelete() const
Determine whether this is a destroying operator delete.
Definition: Decl.cpp:3207
clang::LinkageSpecDecl::CreateDeserialized
static LinkageSpecDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:2811
clang::Type::castAs
const T * castAs() const
Member-template castAs<specific type>.
Definition: Type.h:7252
clang::ConstexprSpecKind
ConstexprSpecKind
Define the kind of constexpr specifier.
Definition: Specifiers.h:32
clang::AccessSpecifier
AccessSpecifier
A C++ access specifier (public, private, protected), plus the special value "none" which means differ...
Definition: Specifiers.h:108
clang::CXXMethodDecl::end_overridden_methods
method_iterator end_overridden_methods() const
Definition: DeclCXX.cpp:2417
clang::LifetimeExtendedTemporaryDecl::getStorageDuration
StorageDuration getStorageDuration() const
Retrieve the storage duration for the materialized temporary.
Definition: DeclCXX.cpp:2938
clang::ASTContext::overridden_methods_end
overridden_cxx_method_iterator overridden_methods_end(const CXXMethodDecl *Method) const
Definition: ASTContext.cpp:1638
clang::UsingEnumDecl
Represents a C++ using-enum-declaration.
Definition: DeclCXX.h:3578
clang::CXXRecordDecl
Represents a C++ struct/union/class.
Definition: DeclCXX.h:254
clang::ASTUnresolvedSet::begin
iterator begin()
Definition: ASTUnresolvedSet.h:49
clang::CXXMethodDecl::begin_overridden_methods
method_iterator begin_overridden_methods() const
Definition: DeclCXX.cpp:2412
clang::Redeclarable< FunctionDecl >::First
FunctionDecl * First
Definition: Redeclarable.h:187
SourceLocation.h
P
StringRef P
Definition: ASTMatchersInternal.cpp:563
clang::Type::isDependentType
bool isDependentType() const
Whether this type is a dependent type, meaning that its definition somehow depends on a template para...
Definition: Type.h:2175
clang::TemplateSpecializationKind
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
Definition: Specifiers.h:173
clang::CXXConstructorDecl::init_const_iterator
CXXCtorInitializer *const * init_const_iterator
Iterates through the member/base initializer list.
Definition: DeclCXX.h:2488
clang::CXXRecordDecl::conversion_end
conversion_iterator conversion_end() const
Definition: DeclCXX.h:1079
clang::CXXDeductionGuideDecl::CreateDeserialized
static CXXDeductionGuideDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:2074
clang::Decl::getPreviousDecl
Decl * getPreviousDecl()
Retrieve the previous declaration that declares the same entity as this declaration,...
Definition: DeclBase.h:978
clang::Decl::getFriendObjectKind
FriendObjectKind getFriendObjectKind() const
Determines whether this declaration is the object of a friend declaration and, if so,...
Definition: DeclBase.h:1137
clang::CXXCtorInitializer::getRParenLoc
SourceLocation getRParenLoc() const
Definition: DeclCXX.h:2367
clang::DecompositionDecl::CreateDeserialized
static DecompositionDecl * CreateDeserialized(ASTContext &C, unsigned ID, unsigned NumBindings)
Definition: DeclCXX.cpp:3226
clang::UsingPackDecl::Create
static UsingPackDecl * Create(ASTContext &C, DeclContext *DC, NamedDecl *InstantiatedFrom, ArrayRef< NamedDecl * > UsingDecls)
Definition: DeclCXX.cpp:3084
clang::CXXMethodDecl::size_overridden_methods
unsigned size_overridden_methods() const
Definition: DeclCXX.cpp:2422
clang::DeclContext::LinkageSpecDeclBits
LinkageSpecDeclBitfields LinkageSpecDeclBits
Definition: DeclBase.h:1799
clang::BindingDecl::CreateDeserialized
static BindingDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:3196
false
#define false
Definition: stdbool.h:17
clang::StaticAssertDecl
Represents a C++11 static_assert declaration.
Definition: DeclCXX.h:3909
clang::CXXRecordDecl::hasSimpleCopyAssignment
bool hasSimpleCopyAssignment() const
true if we know for sure that this class has a single, accessible, unambiguous copy assignment operat...
Definition: DeclCXX.h:717
clang::CXXRecordDecl::getNumVBases
unsigned getNumVBases() const
Retrieves the number of virtual base classes of this class.
Definition: DeclCXX.h:603
clang::CXXRecordDecl::setDeviceLambdaManglingNumber
void setDeviceLambdaManglingNumber(unsigned Num) const
Set the device side mangling number.
Definition: DeclCXX.cpp:1607
clang::TagDecl::isBeingDefined
bool isBeingDefined() const
Return true if this decl is currently being defined.
Definition: Decl.h:3456
clang::CXXRecordDecl::hasNonTrivialCopyConstructor
bool hasNonTrivialCopyConstructor() const
Determine whether this class has a non-trivial copy constructor (C++ [class.copy]p6,...
Definition: DeclCXX.h:1232
clang::ASTContext::overridden_methods
overridden_method_range overridden_methods(const CXXMethodDecl *Method) const
Definition: ASTContext.cpp:1649
clang::ClassTemplateDecl
Declaration of a class template.
Definition: DeclTemplate.h:2247
clang::ValueDecl
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition: Decl.h:674
clang::AS_protected
@ AS_protected
Definition: Specifiers.h:110
clang::RecordDecl::completeDefinition
virtual void completeDefinition()
Note that the definition of this type is now complete.
Definition: Decl.cpp:4633
clang::ASTUnresolvedSet::end
iterator end()
Definition: ASTUnresolvedSet.h:50
clang::ASTContext::getTagDeclType
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.
Definition: ASTContext.cpp:5774
clang::FunctionProtoType
Represents a prototype with parameter type info, e.g.
Definition: Type.h:3886
clang::ASTContext::Idents
IdentifierTable & Idents
Definition: ASTContext.h:646
clang::UnresolvedUsingIfExistsDecl::Create
static UnresolvedUsingIfExistsDecl * Create(ASTContext &Ctx, DeclContext *DC, SourceLocation Loc, DeclarationName Name)
Definition: DeclCXX.cpp:3153
clang::DeclContext::getParent
DeclContext * getParent()
getParent - Returns the containing DeclContext.
Definition: DeclBase.h:1854
clang::Redeclarable< NamespaceDecl >::getNextRedeclaration
NamespaceDecl * getNextRedeclaration() const
Definition: Redeclarable.h:189
clang::RecordDecl::fields
field_range fields() const
Definition: Decl.h:4086
clang::CXXConversionDecl::getConversionType
QualType getConversionType() const
Returns the type that this conversion function is converting to.
Definition: DeclCXX.h:2770
clang::DeclarationName::isIdentifier
bool isIdentifier() const
Predicate functions for querying what type of name this is.
Definition: DeclarationName.h:373
clang::CXXConstructorDecl::getTargetConstructor
CXXConstructorDecl * getTargetConstructor() const
When this constructor delegates to another, retrieve the target.
Definition: DeclCXX.cpp:2626
Begin
SourceLocation Begin
Definition: USRLocFinder.cpp:165
llvm::ArrayRef
Definition: LLVM.h:34
clang::ASTContext::overridden_methods_size
unsigned overridden_methods_size(const CXXMethodDecl *Method) const
Definition: ASTContext.cpp:1643
Value
Value
Definition: UninitializedValues.cpp:102
clang::Decl
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:83
clang::MSGuidDeclParts::Part2
uint16_t Part2
...-89ab-...
Definition: DeclCXX.h:4119
clang::FunctionDecl::isPure
bool isPure() const
Whether this virtual function is pure, i.e.
Definition: Decl.h:2189
clang::TypeLoc
Base wrapper for a particular "section" of type source info.
Definition: TypeLoc.h:58
clang::CXXConstructorDecl::isCopyOrMoveConstructor
bool isCopyOrMoveConstructor() const
Determine whether this a copy or move constructor.
Definition: DeclCXX.h:2612
clang::UsingDecl::getQualifierLoc
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name, with source-location information.
Definition: DeclCXX.h:3412
clang::UsingDecl::getNameInfo
DeclarationNameInfo getNameInfo() const
Definition: DeclCXX.h:3419
clang::CXXRecordDecl::getLambdaExplicitTemplateParameters
ArrayRef< NamedDecl * > getLambdaExplicitTemplateParameters() const
Retrieve the lambda template parameters that were specified explicitly.
Definition: DeclCXX.cpp:1587
clang::TagDecl::isStruct
bool isStruct() const
Definition: Decl.h:3516
clang::APValue::isAbsent
bool isAbsent() const
Definition: APValue.h:389
clang::FunctionDecl::isTrivialForCall
bool isTrivialForCall() const
Definition: Decl.h:2209
ASTMutationListener.h
clang::CXXMethodDecl::method_iterator
const CXXMethodDecl *const * method_iterator
Definition: DeclCXX.h:2049
clang::SD_Static
@ SD_Static
Static storage duration.
Definition: Specifiers.h:310
clang::UnresolvedUsingValueDecl::getQualifierLoc
NestedNameSpecifierLoc getQualifierLoc() const
Retrieve the nested-name-specifier that qualifies the name, with source-location information.
Definition: DeclCXX.h:3754
LLVM.h
clang::CXXCtorInitializer::CXXCtorInitializer
CXXCtorInitializer(ASTContext &Context, TypeSourceInfo *TInfo, bool IsVirtual, SourceLocation L, Expr *Init, SourceLocation R, SourceLocation EllipsisLoc)
Creates a new base-class initializer.
Definition: DeclCXX.cpp:2489
clang::CXXMethodDecl::isStaticOverloadedOperator
static bool isStaticOverloadedOperator(OverloadedOperatorKind OOK)
Returns true if the given operator is implicitly static in a record context.
Definition: DeclCXX.h:1978
clang::NamespaceAliasDecl::Create
static NamespaceAliasDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation NamespaceLoc, SourceLocation AliasLoc, IdentifierInfo *Alias, NestedNameSpecifierLoc QualifierLoc, SourceLocation IdentLoc, NamedDecl *Namespace)
Definition: DeclCXX.cpp:2913
clang::Type::getAsRecordDecl
RecordDecl * getAsRecordDecl() const
Retrieves the RecordDecl this type refers to.
Definition: Type.cpp:1764
clang::APValue::getStructField
APValue & getStructField(unsigned i)
Definition: APValue.h:543
clang::CXXConstructorDecl::init_begin
init_iterator init_begin()
Retrieve an iterator to the first initializer.
Definition: DeclCXX.h:2499
clang::CXXRecordDecl::capture_size
unsigned capture_size() const
Definition: DeclCXX.h:1071
clang::ODRHash::AddCXXRecordDecl
void AddCXXRecordDecl(const CXXRecordDecl *Record)
Definition: ODRHash.cpp:472
clang::CXXRecordDecl::mayBeAbstract
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:2007
GCCTypeClass::Enum
@ Enum
clang::TagDecl::isInterface
bool isInterface() const
Definition: Decl.h:3517
clang::CXXMethodDecl::overridden_method_range
llvm::iterator_range< llvm::TinyPtrVector< const CXXMethodDecl * >::const_iterator > overridden_method_range
Definition: DeclCXX.h:2056
clang::CXXRecordDecl::hasTrivialDestructor
bool hasTrivialDestructor() const
Determine whether this class has a trivial destructor (C++ [class.dtor]p3)
Definition: DeclCXX.h:1310
clang::IdentifierInfo
One of these records is kept for each identifier that is lexed.
Definition: IdentifierTable.h:84
clang::CXXRecordDecl::finishedDefaultedOrDeletedMember
void finishedDefaultedOrDeletedMember(CXXMethodDecl *MD)
Indicates that the declaration of a defaulted or deleted special member function is now complete.
Definition: DeclCXX.cpp:1397
clang::RecordDecl::field_end
field_iterator field_end() const
Definition: Decl.h:4089
clang::CXXMethodDecl::getCorrespondingMethodDeclaredInClass
CXXMethodDecl * getCorrespondingMethodDeclaredInClass(const CXXRecordDecl *RD, bool MayBeBase=false)
Find if RD declares a function that overrides this function, and if so, return it.
Definition: DeclCXX.cpp:2115
ODRHash.h
clang::FunctionProtoType::getMethodQuals
Qualifiers getMethodQuals() const
Definition: Type.h:4236
clang::CXXRecordDecl::getDestructor
CXXDestructorDecl * getDestructor() const
Returns the destructor decl for this class.
Definition: DeclCXX.cpp:1889
clang::CXXRecordDecl::CreateLambda
static CXXRecordDecl * CreateLambda(const ASTContext &C, DeclContext *DC, TypeSourceInfo *Info, SourceLocation Loc, bool DependentLambda, bool IsGeneric, LambdaCaptureDefault CaptureDefault)
Definition: DeclCXX.cpp:148
clang::CXXRecordDecl::getGenericLambdaTemplateParameterList
TemplateParameterList * getGenericLambdaTemplateParameterList() const
Retrieve the generic lambda's template parameter list.
Definition: DeclCXX.cpp:1578
clang::MemberPointerType
A pointer to member type per C++ 8.3.3 - Pointers to members.
Definition: Type.h:2832
clang::CXXRecordDecl::setTemplateSpecializationKind
void setTemplateSpecializationKind(TemplateSpecializationKind TSK)
Set the kind of specialization or template instantiation this is.
Definition: DeclCXX.cpp:1830
clang::BaseUsingDecl::addShadowDecl
void addShadowDecl(UsingShadowDecl *S)
Definition: DeclCXX.cpp:3015
clang::UnresolvedSetImpl::end
iterator end()
Definition: UnresolvedSet.h:84
clang::LazyOffsetPtr::get
T * get(ExternalASTSource *Source) const
Retrieve the pointer to the AST node that this lazy pointer points to.
Definition: ExternalASTSource.h:374
DeclarationName.h
clang::ODRHash::AddStmt
void AddStmt(const Stmt *S)
Definition: ODRHash.cpp:24
clang::CXXDeductionGuideDecl
Represents a C++ deduction guide declaration.
Definition: DeclCXX.h:1849
clang::CXXRecordDecl::hasNonLiteralTypeFieldsOrBases
bool hasNonLiteralTypeFieldsOrBases() const
Determine whether this class has a non-literal or/ volatile type non-static data member or base class...
Definition: DeclCXX.h:1352
clang::CXXRecordDecl::setBases
void setBases(CXXBaseSpecifier const *const *Bases, unsigned NumBases)
Sets the base classes of this struct or class.
Definition: DeclCXX.cpp:195
clang::UnresolvedUsingTypenameDecl::Create
static UnresolvedUsingTypenameDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, SourceLocation TypenameLoc, NestedNameSpecifierLoc QualifierLoc, SourceLocation TargetNameLoc, DeclarationName TargetName, SourceLocation EllipsisLoc)
Definition: DeclCXX.cpp:3133
clang::CanQual::getUnqualifiedType
CanQual< T > getUnqualifiedType() const
Retrieve the unqualified form of this type.
Definition: CanonicalType.h:620
clang::DeclarationName::getNameKind
NameKind getNameKind() const
Determine what kind of name this is.
Definition: DeclarationName.h:382
clang::CXXMethodDecl::addOverriddenMethod
void addOverriddenMethod(const CXXMethodDecl *MD)
Definition: DeclCXX.cpp:2403
clang::Builtin::ID
ID
Definition: Builtins.h:48
clang::LinkageSpecDecl::Create
static LinkageSpecDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation ExternLoc, SourceLocation LangLoc, LanguageIDs Lang, bool HasBraces)
Definition: DeclCXX.cpp:2802
PartialDiagnostic.h
clang::CXXRecordDecl::getTemplateSpecializationKind
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine whether this particular class is a specialization or instantiation of a class template or m...
Definition: DeclCXX.cpp:1819
clang
Definition: CalledOnceCheck.h:17
clang::IndirectFieldDecl
Represents a field injected from an anonymous union/struct into the parent scope.
Definition: Decl.h:3092
clang::DeclContext::lookup
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
Definition: DeclBase.cpp:1646
clang::CXXConstructorDecl::isSpecializationCopyingObject
bool isSpecializationCopyingObject() const
Determine whether this is a member template specialization that would copy the object to itself.
Definition: DeclCXX.cpp:2712
clang::MSGuidDeclParts::Part4And5
uint8_t Part4And5[8]
...-0123-456789abcdef}
Definition: DeclCXX.h:4123
UnresolvedSet.h
clang::UnresolvedSetImpl::addDecl
void addDecl(NamedDecl *D)
Definition: UnresolvedSet.h:91
clang::Qualifiers::getObjCLifetime
ObjCLifetime getObjCLifetime() const
Definition: Type.h:336
clang::RequiresExprBodyDecl::CreateDeserialized
static RequiresExprBodyDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:2086
clang::UsingEnumDecl::Create
static UsingEnumDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingL, SourceLocation EnumL, SourceLocation NameL, EnumDecl *ED)
Definition: DeclCXX.cpp:3067
clang::CXXRecordDecl::CreateDeserialized
static CXXRecordDecl * CreateDeserialized(const ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:165
clang::MSPropertyDecl
An instance of this class represents the declaration of a property member.
Definition: DeclCXX.h:4086
clang::CXXRecordDecl::getCanonicalDecl
CXXRecordDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition: DeclCXX.h:493
clang::CXXCtorInitializer::getID
int64_t getID(const ASTContext &Context) const
Definition: DeclCXX.cpp:2522
clang::ConstructorUsingShadowDecl::getNominatedBaseClass
CXXRecordDecl * getNominatedBaseClass() const
Get the base class that was named in the using declaration.
Definition: DeclCXX.cpp:3009
clang::CXXMethodDecl::hasInlineBody
bool hasInlineBody() const
Definition: DeclCXX.cpp:2471
clang::CXXRecordDecl::getCaptureFields
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:1559
clang::UnresolvedUsingValueDecl::Create
static UnresolvedUsingValueDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation UsingLoc, NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, SourceLocation EllipsisLoc)
Definition: DeclCXX.cpp:3105
clang::CXXRecordDecl::bases_begin
base_class_iterator bases_begin()
Definition: DeclCXX.h:595
clang::ASTContext::overridden_methods_begin
overridden_cxx_method_iterator overridden_methods_begin(const CXXMethodDecl *Method) const
Definition: ASTContext.cpp:1633
clang::CXXRecordDecl::isInterfaceLike
bool isInterfaceLike() const
Definition: DeclCXX.cpp:1911
clang::MSGuidDeclParts::Part3
uint16_t Part3
...-cdef-...
Definition: DeclCXX.h:4121
clang::CXXBaseSpecifier
Represents a base class of a C++ class.
Definition: DeclCXX.h:146
clang::CXXRecordDecl::hasDefinition
bool hasDefinition() const
Definition: DeclCXX.h:541
clang::TypeSourceInfo
A container of type source information.
Definition: Type.h:6421
clang::NamedDecl::getDeclName
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:311
getInvokerAsMethod
static CXXMethodDecl * getInvokerAsMethod(NamedDecl *ND)
Definition: DeclCXX.cpp:1538
clang::Qualifiers::Const
@ Const
Definition: Type.h:149
clang::DeclContext::isDependentContext
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:1142
getThisObjectType
static QualType getThisObjectType(ASTContext &C, const FunctionProtoType *FPT, const CXXRecordDecl *Decl)
Definition: DeclCXX.cpp:2434
clang::CXXRecordDecl::getFinalOverriders
void getFinalOverriders(CXXFinalOverriderMap &FinaOverriders) const
Retrieve the final overriders for each virtual member function in the class hierarchy where this clas...
Definition: CXXInheritance.cpp:642
clang::CXXMethodDecl::getDevirtualizedMethod
CXXMethodDecl * getDevirtualizedMethod(const Expr *Base, bool IsAppleKext)
If it's possible to devirtualize a call to this method, return the called function.
Definition: DeclCXX.cpp:2199
clang::FunctionDecl::isVariadic
bool isVariadic() const
Whether this function is variadic.
Definition: Decl.cpp:2926
clang::UnresolvedUsingIfExistsDecl
This node is generated when a using-declaration that was annotated with attribute((using_if_exists)) ...
Definition: DeclCXX.h:3891
clang::LifetimeExtendedTemporaryDecl::getExtendingDecl
ValueDecl * getExtendingDecl()
Definition: DeclCXX.h:3130
clang::TagDecl::getTagKind
TagKind getTagKind() const
Definition: Decl.h:3510
allLookupResultsAreTheSame
static bool allLookupResultsAreTheSame(const DeclContext::lookup_result &R)
Definition: DeclCXX.cpp:1487
clang::CXXRecordDecl::completeDefinition
void completeDefinition() override
Indicates that the definition of this class is now complete.
Definition: DeclCXX.cpp:1962
clang::ExplicitSpecifier::getKind
ExplicitSpecKind getKind() const
Definition: DeclCXX.h:1802
clang::DeclContextLookupResult
The results of name lookup within a DeclContext.
Definition: DeclBase.h:1286
LambdaCapture.h
clang::CXXMethodDecl::isUsualDeallocationFunction
bool isUsualDeallocationFunction(SmallVectorImpl< const FunctionDecl * > &PreventedBy) const
Determine whether this is a usual deallocation function (C++ [basic.stc.dynamic.deallocation]p2),...
Definition: DeclCXX.cpp:2284
clang::RecordType::getDecl
RecordDecl * getDecl() const
Definition: Type.h:4645
clang::BindingDecl::getBinding
Expr * getBinding() const
Get the expression to which this declaration is bound.
Definition: DeclCXX.h:3982
clang::Decl::EmptyShell
A placeholder type used to construct an empty shell of a decl-derived type that will be filled in lat...
Definition: DeclBase.h:99
clang::ReferenceType
Base for LValueReferenceType and RValueReferenceType.
Definition: Type.h:2752
clang::DeclContext::isExternCContext
bool isExternCContext() const
Determines whether this context or some of its ancestors is a linkage specification context that spec...
Definition: DeclBase.cpp:1191
clang::InheritedConstructor
Description of a constructor that was inherited from a base class.
Definition: DeclCXX.h:2374
clang::ExternalASTSource::GetExternalDecl
virtual Decl * GetExternalDecl(uint32_t ID)
Resolve a declaration ID into a declaration, potentially building a new declaration.
Definition: ExternalASTSource.cpp:71
clang::CXXRecordDecl::isLambda
bool isLambda() const
Determine whether this class describes a lambda function object.
Definition: DeclCXX.h:991
clang::CXXConstructorDecl::isCopyConstructor
bool isCopyConstructor() const
Whether this constructor is a copy constructor (C++ [class.copy]p2, which can be used to copy the cla...
Definition: DeclCXX.h:2586
clang::APValue
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
Definition: APValue.h:122
clang::isTemplateInstantiation
bool isTemplateInstantiation(TemplateSpecializationKind Kind)
Determine whether this template specialization kind refers to an instantiation of an entity (as oppos...
Definition: Specifiers.h:197
clang::CXXRecordDecl::hasSimpleMoveConstructor
bool hasSimpleMoveConstructor() const
true if we know for sure that this class has a single, accessible, unambiguous move constructor that ...
Definition: DeclCXX.h:710
clang::APValue::UninitArray
Definition: APValue.h:250
clang::ODRHash::CalculateHash
unsigned CalculateHash()
Definition: ODRHash.cpp:204
llvm::SmallVectorImpl
Definition: LLVM.h:39
clang::CXXRecordDecl::hasUserDeclaredDestructor
bool hasUserDeclaredDestructor() const
Determine whether this class has a user-declared destructor.
Definition: DeclCXX.h:974
clang::SC_None
@ SC_None
Definition: Specifiers.h:235
clang::ValueDecl::getType
QualType getType() const
Definition: Decl.h:685
true
#define true
Definition: stdbool.h:16
clang::NestedNameSpecifierLoc::getBeginLoc
SourceLocation getBeginLoc() const
Retrieve the location of the beginning of this nested-name-specifier.
Definition: NestedNameSpecifier.h:299
clang::ASTContext::hasSameUnqualifiedType
bool hasSameUnqualifiedType(QualType T1, QualType T2) const
Determine whether the given types are equivalent after cvr-qualifiers have been removed.
Definition: ASTContext.h:2518
clang::ArrayType::getElementType
QualType getElementType() const
Definition: Type.h:2905
clang::Expr
This represents one expression.
Definition: Expr.h:109
clang::BaseUsingDecl
Represents a C++ declaration that introduces decls from somewhere else.
Definition: DeclCXX.h:3283
clang::UsingDecl::getSourceRange
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
Definition: DeclCXX.cpp:3059
clang::CXXMethodDecl::CXXMethodDecl
CXXMethodDecl(Kind DK, ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin, bool isInline, ConstexprSpecKind ConstexprKind, SourceLocation EndLocation, Expr *TrailingRequiresClause=nullptr)
Definition: DeclCXX.h:1951
clang::FunctionDecl::getDescribedFunctionTemplate
FunctionTemplateDecl * getDescribedFunctionTemplate() const
Retrieves the function template that is described by this function declaration.
Definition: Decl.cpp:3719
clang::ConstructorUsingShadowDecl
Represents a shadow constructor declaration introduced into a class by a C++11 using-declaration that...
Definition: DeclCXX.h:3464
clang::UsingShadowDecl::CreateDeserialized
static UsingShadowDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:2982
clang::CXXRecordDecl::defaultedDestructorIsConstexpr
bool defaultedDestructorIsConstexpr() const
Determine whether a defaulted default constructor for this class would be constexpr.
Definition: DeclCXX.h:1300
clang::CXXCtorInitializer
Represents a C++ base or member initializer.
Definition: DeclCXX.h:2171
clang::ExternalASTSource
Abstract interface for external sources of AST nodes.
Definition: ExternalASTSource.h:60
clang::StaticAssertDecl::CreateDeserialized
static StaticAssertDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:3183
clang::DeclContext::isFunctionOrMethod
bool isFunctionOrMethod() const
Definition: DeclBase.h:1906
clang::DeclarationNameInfo
DeclarationNameInfo - A collector data type for bundling together a DeclarationName and the correspnd...
Definition: DeclarationName.h:756
clang::CXXDestructorDecl::CreateDeserialized
static CXXDestructorDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:2733
clang::Decl::getLocation
SourceLocation getLocation() const
Definition: DeclBase.h:424
clang::CXXRecordDecl::getTemplateInstantiationPattern
const CXXRecordDecl * getTemplateInstantiationPattern() const
Retrieve the record declaration from which this record could be instantiated.
Definition: DeclCXX.cpp:1844
clang::Decl::isCanonicalDecl
bool isCanonicalDecl() const
Whether this particular Decl is a canonical one.
Definition: DeclBase.h:901
GCCTypeClass::None
@ None
clang::NamespaceDecl
Represent a C++ namespace.
Definition: Decl.h:540
clang::DeclContextLookupResult::empty
bool empty() const
Definition: DeclBase.h:1307
clang::FunctionDecl
Represents a function declaration or definition.
Definition: Decl.h:1855
ASTUnresolvedSet.h
clang::CXXMethodDecl::CreateDeserialized
static CXXMethodDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:2192
clang::CXXRecordDecl::CXXRecordDecl
CXXRecordDecl(Kind K, TagKind TK, const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, CXXRecordDecl *PrevDecl)
Definition: DeclCXX.cpp:124
clang::RecordDecl
Represents a struct/union/class.
Definition: Decl.h:3866
clang::CXXConstructorDecl::isMoveConstructor
bool isMoveConstructor() const
Determine whether this constructor is a move constructor (C++11 [class.copy]p3), which can be used to...
Definition: DeclCXX.h:2600
clang::FunctionDecl::getStorageClass
StorageClass getStorageClass() const
Returns the storage class as written in the source.
Definition: Decl.h:2583
clang::AccessSpecDecl::CreateDeserialized
static AccessSpecDecl * CreateDeserialized(ASTContext &C, unsigned ID)
Definition: DeclCXX.cpp:60
clang::CXXConversionDecl::Create
static CXXConversionDecl * Create(ASTContext &C, CXXRecordDecl *RD, SourceLocation StartLoc, const DeclarationNameInfo &NameInfo, QualType T, TypeSourceInfo *TInfo, bool UsesFPIntrin, bool isInline, ExplicitSpecifier ES, ConstexprSpecKind ConstexprKind, SourceLocation EndLocation, Expr *TrailingRequiresClause=nullptr)
Definition: DeclCXX.cpp:2772
CollectVisibleConversions
static void CollectVisibleConversions(ASTContext &Context, const CXXRecordDecl *Record, bool InVirtual, AccessSpecifier Access, const llvm::SmallPtrSet< CanQualType, 8 > &ParentHiddenTypes, ASTUnresolvedSet &Output, UnresolvedSetImpl &VOutput, llvm::SmallPtrSet< NamedDecl *, 8 > &HiddenVBaseCs)
Collect the visible conversions of a base class.
Definition: DeclCXX.cpp:1640
clang::LangOptions::ClangABI::Ver6
@ Ver6
Attempt to be ABI-compatible with code generated by Clang 6.0.x (SVN r321711).
clang::getLambdaStaticInvokerName
StringRef getLambdaStaticInvokerName()
Definition: ASTLambda.h:22
clang::FunctionDecl::isDefined
bool isDefined(const FunctionDecl *&Definition, bool CheckForPendingFriendDefinition=false) const
Returns true if the function has a definition that does not need to be instantiated.
Definition: Decl.cpp:3005
clang::ASTContext::getLangOpts
const LangOptions & getLangOpts() const
Definition: ASTContext.h:763
clang::APValue::UninitStruct
Definition: APValue.h:251
clang::ASTContext::getAllocator
llvm::BumpPtrAllocator & getAllocator() const
Definition: ASTContext.h:702
clang::UsingDirectiveDecl::getNominatedNamespace
NamespaceDecl * getNominatedNamespace()
Returns the namespace nominated by this using-directive.
Definition: DeclCXX.cpp:2840
clang::UsingShadowDecl::setTargetDecl
void setTargetDecl(NamedDecl *ND)
Sets the underlying declaration which has been brought into the local scope.
Definition: DeclCXX.h:3254
clang::CXXConstructorDecl::isInheritingConstructor
bool isInheritingConstructor() const
Determine whether this is an implicit constructor synthesized to model a call to a constructor inheri...
Definition: DeclCXX.h:2629
clang::CXXRecordDecl::setTrivialForCallFlags
void setTrivialForCallFlags(CXXMethodDecl *MD)
Definition: DeclCXX.cpp:1454
clang::CXXMethodDecl::isVirtual
bool isVirtual() const
Definition: DeclCXX.h:1991
TypeLoc.h
clang::declaresSameEntity
bool declaresSameEntity(const Decl *D1, const Decl *D2)
Determine whether two declarations declare the same entity.
Definition: DeclBase.h:1192
clang::UnresolvedSetImpl::begin
iterator begin()
Definition: UnresolvedSet.h:83
GetConversionType
static CanQualType GetConversionType(ASTContext &Context, NamedDecl *Conv)
Definition: DeclCXX.cpp:1621
clang::CXXRecordDecl::setDescribedClassTemplate
void setDescribedClassTemplate(ClassTemplateDecl *Template)
Definition: DeclCXX.cpp:1815
clang::LValueReferenceType
An lvalue reference type, per C++11 [dcl.ref].
Definition: Type.h:2796
clang::CXXMethodDecl::getParent
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
Definition: DeclCXX.h:2062
clang::CXXMethodDecl
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:1947
clang::CXXRecordDecl::getVisibleConversionFunctions
llvm::iterator_range< conversion_iterator > getVisibleConversionFunctions() const
Get all conversion functions visible in current class, including conversion function templates.
Definition: DeclCXX.cpp:1747
clang::ConstexprSpecKind::Unspecified
@ Unspecified
clang::Decl::getDeclContext
DeclContext * getDeclContext()
Definition: DeclBase.h:433
clang::FunctionDecl::isOutOfLine
bool isOutOfLine() const override
Determine whether this is or was instantiated from an out-of-line definition of a member function.
Definition: Decl.cpp:4012
clang::StorageClass
StorageClass
Storage classes.
Definition: Specifiers.h:233
clang::NamedDecl::getName
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Definition: Decl.h:274