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