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