1 //===--- DeclCXX.cpp - C++ Declaration AST Node Implementation ------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the C++ related Decl classes.
12 //===----------------------------------------------------------------------===//
14 #include "clang/AST/DeclCXX.h"
15 #include "clang/AST/DeclTemplate.h"
16 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/ASTMutationListener.h"
18 #include "clang/AST/CXXInheritance.h"
19 #include "clang/AST/Expr.h"
20 #include "clang/AST/TypeLoc.h"
21 #include "clang/Basic/IdentifierTable.h"
22 #include "llvm/ADT/STLExtras.h"
23 #include "llvm/ADT/SmallPtrSet.h"
24 using namespace clang;
26 //===----------------------------------------------------------------------===//
27 // Decl Allocation/Deallocation Method Implementations
28 //===----------------------------------------------------------------------===//
30 CXXRecordDecl::DefinitionData::DefinitionData(CXXRecordDecl *D)
31 : UserDeclaredConstructor(false), UserDeclaredCopyConstructor(false),
32 UserDeclaredMoveConstructor(false), UserDeclaredCopyAssignment(false),
33 UserDeclaredMoveAssignment(false), UserDeclaredDestructor(false),
34 Aggregate(true), PlainOldData(true), Empty(true), Polymorphic(false),
35 Abstract(false), IsStandardLayout(true), HasNoNonEmptyBases(true),
36 HasPrivateFields(false), HasProtectedFields(false), HasPublicFields(false),
37 HasMutableFields(false), HasTrivialDefaultConstructor(true),
38 HasConstexprNonCopyMoveConstructor(false), HasTrivialCopyConstructor(true),
39 HasTrivialMoveConstructor(true), HasTrivialCopyAssignment(true),
40 HasTrivialMoveAssignment(true), HasTrivialDestructor(true),
41 HasNonLiteralTypeFieldsOrBases(false), ComputedVisibleConversions(false),
42 UserProvidedDefaultConstructor(false), DeclaredDefaultConstructor(false),
43 DeclaredCopyConstructor(false), DeclaredMoveConstructor(false),
44 DeclaredCopyAssignment(false), DeclaredMoveAssignment(false),
45 DeclaredDestructor(false), FailedImplicitMoveConstructor(false),
46 FailedImplicitMoveAssignment(false), NumBases(0), NumVBases(0), Bases(),
47 VBases(), Definition(D), FirstFriend(0) {
50 CXXRecordDecl::CXXRecordDecl(Kind K, TagKind TK, DeclContext *DC,
51 SourceLocation StartLoc, SourceLocation IdLoc,
52 IdentifierInfo *Id, CXXRecordDecl *PrevDecl)
53 : RecordDecl(K, TK, DC, StartLoc, IdLoc, Id, PrevDecl),
54 DefinitionData(PrevDecl ? PrevDecl->DefinitionData : 0),
55 TemplateOrInstantiation() { }
57 CXXRecordDecl *CXXRecordDecl::Create(const ASTContext &C, TagKind TK,
58 DeclContext *DC, SourceLocation StartLoc,
59 SourceLocation IdLoc, IdentifierInfo *Id,
60 CXXRecordDecl* PrevDecl,
61 bool DelayTypeCreation) {
62 CXXRecordDecl* R = new (C) CXXRecordDecl(CXXRecord, TK, DC, StartLoc, IdLoc,
65 // FIXME: DelayTypeCreation seems like such a hack
66 if (!DelayTypeCreation)
67 C.getTypeDeclType(R, PrevDecl);
71 CXXRecordDecl *CXXRecordDecl::Create(const ASTContext &C, EmptyShell Empty) {
72 return new (C) CXXRecordDecl(CXXRecord, TTK_Struct, 0, SourceLocation(),
73 SourceLocation(), 0, 0);
77 CXXRecordDecl::setBases(CXXBaseSpecifier const * const *Bases,
79 ASTContext &C = getASTContext();
81 // C++ [dcl.init.aggr]p1:
82 // An aggregate is an array or a class (clause 9) with [...]
83 // no base classes [...].
84 data().Aggregate = false;
86 if (!data().Bases.isOffset() && data().NumBases > 0)
87 C.Deallocate(data().getBases());
89 // The set of seen virtual base types.
90 llvm::SmallPtrSet<CanQualType, 8> SeenVBaseTypes;
92 // The virtual bases of this class.
93 SmallVector<const CXXBaseSpecifier *, 8> VBases;
95 data().Bases = new(C) CXXBaseSpecifier [NumBases];
96 data().NumBases = NumBases;
97 for (unsigned i = 0; i < NumBases; ++i) {
98 data().getBases()[i] = *Bases[i];
99 // Keep track of inherited vbases for this base class.
100 const CXXBaseSpecifier *Base = Bases[i];
101 QualType BaseType = Base->getType();
102 // Skip dependent types; we can't do any checking on them now.
103 if (BaseType->isDependentType())
105 CXXRecordDecl *BaseClassDecl
106 = cast<CXXRecordDecl>(BaseType->getAs<RecordType>()->getDecl());
108 // C++ [dcl.init.aggr]p1:
109 // An aggregate is [...] a class with [...] no base classes [...].
110 data().Aggregate = false;
113 // A POD-struct is an aggregate class...
114 data().PlainOldData = false;
116 // A class with a non-empty base class is not empty.
117 // FIXME: Standard ref?
118 if (!BaseClassDecl->isEmpty()) {
121 // A standard-layout class is a class that:
123 // -- either has no non-static data members in the most derived
124 // class and at most one base class with non-static data members,
125 // or has no base classes with non-static data members, and
126 // If this is the second non-empty base, then neither of these two
127 // clauses can be true.
128 data().IsStandardLayout = false;
131 data().Empty = false;
132 data().HasNoNonEmptyBases = false;
135 // C++ [class.virtual]p1:
136 // A class that declares or inherits a virtual function is called a
137 // polymorphic class.
138 if (BaseClassDecl->isPolymorphic())
139 data().Polymorphic = true;
142 // A standard-layout class is a class that: [...]
143 // -- has no non-standard-layout base classes
144 if (!BaseClassDecl->isStandardLayout())
145 data().IsStandardLayout = false;
147 // Record if this base is the first non-literal field or base.
148 if (!hasNonLiteralTypeFieldsOrBases() && !BaseType->isLiteralType())
149 data().HasNonLiteralTypeFieldsOrBases = true;
151 // Now go through all virtual bases of this base and add them.
152 for (CXXRecordDecl::base_class_iterator VBase =
153 BaseClassDecl->vbases_begin(),
154 E = BaseClassDecl->vbases_end(); VBase != E; ++VBase) {
155 // Add this base if it's not already in the list.
156 if (SeenVBaseTypes.insert(C.getCanonicalType(VBase->getType())))
157 VBases.push_back(VBase);
160 if (Base->isVirtual()) {
161 // Add this base if it's not already in the list.
162 if (SeenVBaseTypes.insert(C.getCanonicalType(BaseType)))
163 VBases.push_back(Base);
165 // C++0x [meta.unary.prop] is_empty:
166 // T is a class type, but not a union type, with ... no virtual base
168 data().Empty = false;
170 // C++ [class.ctor]p5:
171 // A default constructor is trivial [...] if:
172 // -- its class has [...] no virtual bases
173 data().HasTrivialDefaultConstructor = false;
175 // C++0x [class.copy]p13:
176 // A copy/move constructor for class X is trivial if it is neither
177 // user-provided nor deleted and if
178 // -- class X has no virtual functions and no virtual base classes, and
179 data().HasTrivialCopyConstructor = false;
180 data().HasTrivialMoveConstructor = false;
182 // C++0x [class.copy]p27:
183 // A copy/move assignment operator for class X is trivial if it is
184 // neither user-provided nor deleted and if
185 // -- class X has no virtual functions and no virtual base classes, and
186 data().HasTrivialCopyAssignment = false;
187 data().HasTrivialMoveAssignment = false;
190 // A standard-layout class is a class that: [...]
191 // -- has [...] no virtual base classes
192 data().IsStandardLayout = false;
194 // C++ [class.ctor]p5:
195 // A default constructor is trivial [...] if:
196 // -- all the direct base classes of its class have trivial default
198 if (!BaseClassDecl->hasTrivialDefaultConstructor())
199 data().HasTrivialDefaultConstructor = false;
201 // C++0x [class.copy]p13:
202 // A copy/move constructor for class X is trivial if [...]
204 // -- the constructor selected to copy/move each direct base class
205 // subobject is trivial, and
206 // FIXME: C++0x: We need to only consider the selected constructor
207 // instead of all of them.
208 if (!BaseClassDecl->hasTrivialCopyConstructor())
209 data().HasTrivialCopyConstructor = false;
210 if (!BaseClassDecl->hasTrivialMoveConstructor())
211 data().HasTrivialMoveConstructor = false;
213 // C++0x [class.copy]p27:
214 // A copy/move assignment operator for class X is trivial if [...]
216 // -- the assignment operator selected to copy/move each direct base
217 // class subobject is trivial, and
218 // FIXME: C++0x: We need to only consider the selected operator instead
220 if (!BaseClassDecl->hasTrivialCopyAssignment())
221 data().HasTrivialCopyAssignment = false;
222 if (!BaseClassDecl->hasTrivialMoveAssignment())
223 data().HasTrivialMoveAssignment = false;
226 // C++ [class.ctor]p3:
227 // A destructor is trivial if all the direct base classes of its class
228 // have trivial destructors.
229 if (!BaseClassDecl->hasTrivialDestructor())
230 data().HasTrivialDestructor = false;
232 // A class has an Objective-C object member if... or any of its bases
233 // has an Objective-C object member.
234 if (BaseClassDecl->hasObjectMember())
235 setHasObjectMember(true);
237 // Keep track of the presence of mutable fields.
238 if (BaseClassDecl->hasMutableFields())
239 data().HasMutableFields = true;
245 // Create base specifier for any direct or indirect virtual bases.
246 data().VBases = new (C) CXXBaseSpecifier[VBases.size()];
247 data().NumVBases = VBases.size();
248 for (int I = 0, E = VBases.size(); I != E; ++I)
249 data().getVBases()[I] = *VBases[I];
252 /// Callback function for CXXRecordDecl::forallBases that acknowledges
253 /// that it saw a base class.
254 static bool SawBase(const CXXRecordDecl *, void *) {
258 bool CXXRecordDecl::hasAnyDependentBases() const {
259 if (!isDependentContext())
262 return !forallBases(SawBase, 0);
265 bool CXXRecordDecl::hasConstCopyConstructor() const {
266 return getCopyConstructor(Qualifiers::Const) != 0;
269 bool CXXRecordDecl::isTriviallyCopyable() const {
271 // A trivially copyable class is a class that:
272 // -- has no non-trivial copy constructors,
273 if (!hasTrivialCopyConstructor()) return false;
274 // -- has no non-trivial move constructors,
275 if (!hasTrivialMoveConstructor()) return false;
276 // -- has no non-trivial copy assignment operators,
277 if (!hasTrivialCopyAssignment()) return false;
278 // -- has no non-trivial move assignment operators, and
279 if (!hasTrivialMoveAssignment()) return false;
280 // -- has a trivial destructor.
281 if (!hasTrivialDestructor()) return false;
286 /// \brief Perform a simplistic form of overload resolution that only considers
287 /// cv-qualifiers on a single parameter, and return the best overload candidate
288 /// (if there is one).
289 static CXXMethodDecl *
290 GetBestOverloadCandidateSimple(
291 const SmallVectorImpl<std::pair<CXXMethodDecl *, Qualifiers> > &Cands) {
294 if (Cands.size() == 1)
295 return Cands[0].first;
297 unsigned Best = 0, N = Cands.size();
298 for (unsigned I = 1; I != N; ++I)
299 if (Cands[Best].second.compatiblyIncludes(Cands[I].second))
302 for (unsigned I = 1; I != N; ++I)
303 if (Cands[Best].second.compatiblyIncludes(Cands[I].second))
306 return Cands[Best].first;
309 CXXConstructorDecl *CXXRecordDecl::getCopyConstructor(unsigned TypeQuals) const{
310 ASTContext &Context = getASTContext();
312 = Context.getTypeDeclType(const_cast<CXXRecordDecl*>(this));
313 DeclarationName ConstructorName
314 = Context.DeclarationNames.getCXXConstructorName(
315 Context.getCanonicalType(ClassType));
317 SmallVector<std::pair<CXXMethodDecl *, Qualifiers>, 4> Found;
318 DeclContext::lookup_const_iterator Con, ConEnd;
319 for (llvm::tie(Con, ConEnd) = this->lookup(ConstructorName);
320 Con != ConEnd; ++Con) {
321 // C++ [class.copy]p2:
322 // A non-template constructor for class X is a copy constructor if [...]
323 if (isa<FunctionTemplateDecl>(*Con))
326 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(*Con);
327 if (Constructor->isCopyConstructor(FoundTQs)) {
328 if (((TypeQuals & Qualifiers::Const) == (FoundTQs & Qualifiers::Const)) ||
329 (!(TypeQuals & Qualifiers::Const) && (FoundTQs & Qualifiers::Const)))
330 Found.push_back(std::make_pair(
331 const_cast<CXXConstructorDecl *>(Constructor),
332 Qualifiers::fromCVRMask(FoundTQs)));
336 return cast_or_null<CXXConstructorDecl>(
337 GetBestOverloadCandidateSimple(Found));
340 CXXConstructorDecl *CXXRecordDecl::getMoveConstructor() const {
341 for (ctor_iterator I = ctor_begin(), E = ctor_end(); I != E; ++I)
342 if (I->isMoveConstructor())
348 CXXMethodDecl *CXXRecordDecl::getCopyAssignmentOperator(bool ArgIsConst) const {
349 ASTContext &Context = getASTContext();
350 QualType Class = Context.getTypeDeclType(const_cast<CXXRecordDecl *>(this));
351 DeclarationName Name = Context.DeclarationNames.getCXXOperatorName(OO_Equal);
353 SmallVector<std::pair<CXXMethodDecl *, Qualifiers>, 4> Found;
354 DeclContext::lookup_const_iterator Op, OpEnd;
355 for (llvm::tie(Op, OpEnd) = this->lookup(Name); Op != OpEnd; ++Op) {
356 // C++ [class.copy]p9:
357 // A user-declared copy assignment operator is a non-static non-template
358 // member function of class X with exactly one parameter of type X, X&,
359 // const X&, volatile X& or const volatile X&.
360 const CXXMethodDecl* Method = dyn_cast<CXXMethodDecl>(*Op);
361 if (!Method || Method->isStatic() || Method->getPrimaryTemplate())
364 const FunctionProtoType *FnType
365 = Method->getType()->getAs<FunctionProtoType>();
366 assert(FnType && "Overloaded operator has no prototype.");
367 // Don't assert on this; an invalid decl might have been left in the AST.
368 if (FnType->getNumArgs() != 1 || FnType->isVariadic())
371 QualType ArgType = FnType->getArgType(0);
373 if (const LValueReferenceType *Ref = ArgType->getAs<LValueReferenceType>()) {
374 ArgType = Ref->getPointeeType();
375 // If we have a const argument and we have a reference to a non-const,
376 // this function does not match.
377 if (ArgIsConst && !ArgType.isConstQualified())
380 Quals = ArgType.getQualifiers();
382 // By-value copy-assignment operators are treated like const X&
383 // copy-assignment operators.
384 Quals = Qualifiers::fromCVRMask(Qualifiers::Const);
387 if (!Context.hasSameUnqualifiedType(ArgType, Class))
390 // Save this copy-assignment operator. It might be "the one".
391 Found.push_back(std::make_pair(const_cast<CXXMethodDecl *>(Method), Quals));
394 // Use a simplistic form of overload resolution to find the candidate.
395 return GetBestOverloadCandidateSimple(Found);
398 CXXMethodDecl *CXXRecordDecl::getMoveAssignmentOperator() const {
399 for (method_iterator I = method_begin(), E = method_end(); I != E; ++I)
400 if (I->isMoveAssignmentOperator())
406 void CXXRecordDecl::markedVirtualFunctionPure() {
407 // C++ [class.abstract]p2:
408 // A class is abstract if it has at least one pure virtual function.
409 data().Abstract = true;
412 void CXXRecordDecl::addedMember(Decl *D) {
413 // Ignore friends and invalid declarations.
414 if (D->getFriendObjectKind() || D->isInvalidDecl())
417 FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D);
419 D = FunTmpl->getTemplatedDecl();
421 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
422 if (Method->isVirtual()) {
423 // C++ [dcl.init.aggr]p1:
424 // An aggregate is an array or a class with [...] no virtual functions.
425 data().Aggregate = false;
428 // A POD-struct is an aggregate class...
429 data().PlainOldData = false;
431 // Virtual functions make the class non-empty.
432 // FIXME: Standard ref?
433 data().Empty = false;
435 // C++ [class.virtual]p1:
436 // A class that declares or inherits a virtual function is called a
437 // polymorphic class.
438 data().Polymorphic = true;
440 // C++0x [class.ctor]p5
441 // A default constructor is trivial [...] if:
442 // -- its class has no virtual functions [...]
443 data().HasTrivialDefaultConstructor = false;
445 // C++0x [class.copy]p13:
446 // A copy/move constructor for class X is trivial if [...]
447 // -- class X has no virtual functions [...]
448 data().HasTrivialCopyConstructor = false;
449 data().HasTrivialMoveConstructor = false;
451 // C++0x [class.copy]p27:
452 // A copy/move assignment operator for class X is trivial if [...]
453 // -- class X has no virtual functions [...]
454 data().HasTrivialCopyAssignment = false;
455 data().HasTrivialMoveAssignment = false;
456 // FIXME: Destructor?
459 // A standard-layout class is a class that: [...]
460 // -- has no virtual functions
461 data().IsStandardLayout = false;
465 if (D->isImplicit()) {
466 // Notify that an implicit member was added after the definition
468 if (!isBeingDefined())
469 if (ASTMutationListener *L = getASTMutationListener())
470 L->AddedCXXImplicitMember(data().Definition, D);
472 // If this is a special member function, note that it was added and then
474 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
475 if (Constructor->isDefaultConstructor())
476 data().DeclaredDefaultConstructor = true;
477 else if (Constructor->isCopyConstructor())
478 data().DeclaredCopyConstructor = true;
479 else if (Constructor->isMoveConstructor())
480 data().DeclaredMoveConstructor = true;
482 goto NotASpecialMember;
484 } else if (isa<CXXDestructorDecl>(D)) {
485 data().DeclaredDestructor = true;
487 } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
488 if (Method->isCopyAssignmentOperator())
489 data().DeclaredCopyAssignment = true;
490 else if (Method->isMoveAssignmentOperator())
491 data().DeclaredMoveAssignment = true;
493 goto NotASpecialMember;
498 // Any other implicit declarations are handled like normal declarations.
501 // Handle (user-declared) constructors.
502 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(D)) {
503 // Note that we have a user-declared constructor.
504 data().UserDeclaredConstructor = true;
506 // Technically, "user-provided" is only defined for special member
507 // functions, but the intent of the standard is clearly that it should apply
509 bool UserProvided = Constructor->isUserProvided();
511 // C++0x [class.ctor]p5:
512 // A default constructor is trivial if it is not user-provided [...]
513 if (Constructor->isDefaultConstructor()) {
514 data().DeclaredDefaultConstructor = true;
516 data().HasTrivialDefaultConstructor = false;
517 data().UserProvidedDefaultConstructor = true;
521 // Note when we have a user-declared copy or move constructor, which will
522 // suppress the implicit declaration of those constructors.
524 if (Constructor->isCopyConstructor()) {
525 data().UserDeclaredCopyConstructor = true;
526 data().DeclaredCopyConstructor = true;
528 // C++0x [class.copy]p13:
529 // A copy/move constructor for class X is trivial if it is not
530 // user-provided [...]
532 data().HasTrivialCopyConstructor = false;
533 } else if (Constructor->isMoveConstructor()) {
534 data().UserDeclaredMoveConstructor = true;
535 data().DeclaredMoveConstructor = true;
537 // C++0x [class.copy]p13:
538 // A copy/move constructor for class X is trivial if it is not
539 // user-provided [...]
541 data().HasTrivialMoveConstructor = false;
544 if (Constructor->isConstexpr() && !Constructor->isCopyOrMoveConstructor()) {
545 // Record if we see any constexpr constructors which are neither copy
546 // nor move constructors.
547 data().HasConstexprNonCopyMoveConstructor = true;
550 // C++ [dcl.init.aggr]p1:
551 // An aggregate is an array or a class with no user-declared
552 // constructors [...].
553 // C++0x [dcl.init.aggr]p1:
554 // An aggregate is an array or a class with no user-provided
555 // constructors [...].
556 if (!getASTContext().getLangOptions().CPlusPlus0x || UserProvided)
557 data().Aggregate = false;
560 // A POD-struct is an aggregate class [...]
561 // Since the POD bit is meant to be C++03 POD-ness, clear it even if the
562 // type is technically an aggregate in C++0x since it wouldn't be in 03.
563 data().PlainOldData = false;
568 // Handle (user-declared) destructors.
569 if (CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(D)) {
570 data().DeclaredDestructor = true;
571 data().UserDeclaredDestructor = true;
574 // A POD-struct is an aggregate class that has [...] no user-defined
576 // This bit is the C++03 POD bit, not the 0x one.
577 data().PlainOldData = false;
579 // C++0x [class.dtor]p5:
580 // A destructor is trivial if it is not user-provided and [...]
581 if (DD->isUserProvided())
582 data().HasTrivialDestructor = false;
587 // Handle (user-declared) member functions.
588 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) {
589 if (Method->isCopyAssignmentOperator()) {
591 // A POD-struct is an aggregate class that [...] has no user-defined
592 // copy assignment operator [...].
593 // This is the C++03 bit only.
594 data().PlainOldData = false;
596 // This is a copy assignment operator.
598 // Suppress the implicit declaration of a copy constructor.
599 data().UserDeclaredCopyAssignment = true;
600 data().DeclaredCopyAssignment = true;
602 // C++0x [class.copy]p27:
603 // A copy/move assignment operator for class X is trivial if it is
604 // neither user-provided nor deleted [...]
605 if (Method->isUserProvided())
606 data().HasTrivialCopyAssignment = false;
611 if (Method->isMoveAssignmentOperator()) {
612 // This is an extension in C++03 mode, but we'll keep consistency by
613 // taking a move assignment operator to induce non-POD-ness
614 data().PlainOldData = false;
616 // This is a move assignment operator.
617 data().UserDeclaredMoveAssignment = true;
618 data().DeclaredMoveAssignment = true;
620 // C++0x [class.copy]p27:
621 // A copy/move assignment operator for class X is trivial if it is
622 // neither user-provided nor deleted [...]
623 if (Method->isUserProvided())
624 data().HasTrivialMoveAssignment = false;
627 // Keep the list of conversion functions up-to-date.
628 if (CXXConversionDecl *Conversion = dyn_cast<CXXConversionDecl>(D)) {
629 // We don't record specializations.
630 if (Conversion->getPrimaryTemplate())
633 // FIXME: We intentionally don't use the decl's access here because it
634 // hasn't been set yet. That's really just a misdesign in Sema.
637 if (FunTmpl->getPreviousDeclaration())
638 data().Conversions.replace(FunTmpl->getPreviousDeclaration(),
641 data().Conversions.addDecl(FunTmpl);
643 if (Conversion->getPreviousDeclaration())
644 data().Conversions.replace(Conversion->getPreviousDeclaration(),
647 data().Conversions.addDecl(Conversion);
654 // Handle non-static data members.
655 if (FieldDecl *Field = dyn_cast<FieldDecl>(D)) {
656 // C++ [class.bit]p2:
657 // A declaration for a bit-field that omits the identifier declares an
658 // unnamed bit-field. Unnamed bit-fields are not members and cannot be
660 if (Field->isUnnamedBitfield())
663 // C++ [dcl.init.aggr]p1:
664 // An aggregate is an array or a class (clause 9) with [...] no
665 // private or protected non-static data members (clause 11).
667 // A POD must be an aggregate.
668 if (D->getAccess() == AS_private || D->getAccess() == AS_protected) {
669 data().Aggregate = false;
670 data().PlainOldData = false;
674 // A standard-layout class is a class that:
676 // -- has the same access control for all non-static data members,
677 switch (D->getAccess()) {
678 case AS_private: data().HasPrivateFields = true; break;
679 case AS_protected: data().HasProtectedFields = true; break;
680 case AS_public: data().HasPublicFields = true; break;
681 case AS_none: llvm_unreachable("Invalid access specifier");
683 if ((data().HasPrivateFields + data().HasProtectedFields +
684 data().HasPublicFields) > 1)
685 data().IsStandardLayout = false;
687 // Keep track of the presence of mutable fields.
688 if (Field->isMutable())
689 data().HasMutableFields = true;
692 // A POD struct is a class that is both a trivial class and a
693 // standard-layout class, and has no non-static data members of type
694 // non-POD struct, non-POD union (or array of such types).
696 // Automatic Reference Counting: the presence of a member of Objective-C pointer type
697 // that does not explicitly have no lifetime makes the class a non-POD.
698 // However, we delay setting PlainOldData to false in this case so that
699 // Sema has a chance to diagnostic causes where the same class will be
700 // non-POD with Automatic Reference Counting but a POD without Instant Objects.
701 // In this case, the class will become a non-POD class when we complete
703 ASTContext &Context = getASTContext();
704 QualType T = Context.getBaseElementType(Field->getType());
705 if (T->isObjCRetainableType() || T.isObjCGCStrong()) {
706 if (!Context.getLangOptions().ObjCAutoRefCount ||
707 T.getObjCLifetime() != Qualifiers::OCL_ExplicitNone)
708 setHasObjectMember(true);
709 } else if (!T.isPODType(Context))
710 data().PlainOldData = false;
712 if (T->isReferenceType()) {
713 data().HasTrivialDefaultConstructor = false;
716 // A standard-layout class is a class that:
717 // -- has no non-static data members of type [...] reference,
718 data().IsStandardLayout = false;
721 // Record if this field is the first non-literal field or base.
722 // As a slight variation on the standard, we regard mutable members as being
723 // non-literal, since mutating a constexpr variable would break C++11
724 // constant expression semantics.
725 if ((!hasNonLiteralTypeFieldsOrBases() && !T->isLiteralType()) ||
727 data().HasNonLiteralTypeFieldsOrBases = true;
729 if (Field->hasInClassInitializer()) {
731 // A default constructor is trivial if [...] no non-static data member
732 // of its class has a brace-or-equal-initializer.
733 data().HasTrivialDefaultConstructor = false;
735 // C++0x [dcl.init.aggr]p1:
736 // An aggregate is a [...] class with [...] no
737 // brace-or-equal-initializers for non-static data members.
738 data().Aggregate = false;
741 // A POD struct is [...] a trivial class.
742 data().PlainOldData = false;
745 if (const RecordType *RecordTy = T->getAs<RecordType>()) {
746 CXXRecordDecl* FieldRec = cast<CXXRecordDecl>(RecordTy->getDecl());
747 if (FieldRec->getDefinition()) {
748 // C++0x [class.ctor]p5:
749 // A defulat constructor is trivial [...] if:
750 // -- for all the non-static data members of its class that are of
751 // class type (or array thereof), each such class has a trivial
752 // default constructor.
753 if (!FieldRec->hasTrivialDefaultConstructor())
754 data().HasTrivialDefaultConstructor = false;
756 // C++0x [class.copy]p13:
757 // A copy/move constructor for class X is trivial if [...]
759 // -- for each non-static data member of X that is of class type (or
760 // an array thereof), the constructor selected to copy/move that
761 // member is trivial;
762 // FIXME: C++0x: We don't correctly model 'selected' constructors.
763 if (!FieldRec->hasTrivialCopyConstructor())
764 data().HasTrivialCopyConstructor = false;
765 if (!FieldRec->hasTrivialMoveConstructor())
766 data().HasTrivialMoveConstructor = false;
768 // C++0x [class.copy]p27:
769 // A copy/move assignment operator for class X is trivial if [...]
771 // -- for each non-static data member of X that is of class type (or
772 // an array thereof), the assignment operator selected to
773 // copy/move that member is trivial;
774 // FIXME: C++0x: We don't correctly model 'selected' operators.
775 if (!FieldRec->hasTrivialCopyAssignment())
776 data().HasTrivialCopyAssignment = false;
777 if (!FieldRec->hasTrivialMoveAssignment())
778 data().HasTrivialMoveAssignment = false;
780 if (!FieldRec->hasTrivialDestructor())
781 data().HasTrivialDestructor = false;
782 if (FieldRec->hasObjectMember())
783 setHasObjectMember(true);
786 // A standard-layout class is a class that:
787 // -- has no non-static data members of type non-standard-layout
788 // class (or array of such types) [...]
789 if (!FieldRec->isStandardLayout())
790 data().IsStandardLayout = false;
793 // A standard-layout class is a class that:
795 // -- has no base classes of the same type as the first non-static
797 // We don't want to expend bits in the state of the record decl
798 // tracking whether this is the first non-static data member so we
799 // cheat a bit and use some of the existing state: the empty bit.
800 // Virtual bases and virtual methods make a class non-empty, but they
801 // also make it non-standard-layout so we needn't check here.
802 // A non-empty base class may leave the class standard-layout, but not
803 // if we have arrived here, and have at least on non-static data
804 // member. If IsStandardLayout remains true, then the first non-static
805 // data member must come through here with Empty still true, and Empty
806 // will subsequently be set to false below.
807 if (data().IsStandardLayout && data().Empty) {
808 for (CXXRecordDecl::base_class_const_iterator BI = bases_begin(),
811 if (Context.hasSameUnqualifiedType(BI->getType(), T)) {
812 data().IsStandardLayout = false;
818 // Keep track of the presence of mutable fields.
819 if (FieldRec->hasMutableFields())
820 data().HasMutableFields = true;
825 // A standard-layout class is a class that:
827 // -- either has no non-static data members in the most derived
828 // class and at most one base class with non-static data members,
829 // or has no base classes with non-static data members, and
830 // At this point we know that we have a non-static data member, so the last
832 if (!data().HasNoNonEmptyBases)
833 data().IsStandardLayout = false;
835 // If this is not a zero-length bit-field, then the class is not empty.
837 if (!Field->isBitField() ||
838 (!Field->getBitWidth()->isTypeDependent() &&
839 !Field->getBitWidth()->isValueDependent() &&
840 Field->getBitWidthValue(Context) != 0))
841 data().Empty = false;
845 // Handle using declarations of conversion functions.
846 if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(D))
847 if (Shadow->getDeclName().getNameKind()
848 == DeclarationName::CXXConversionFunctionName)
849 data().Conversions.addDecl(Shadow, Shadow->getAccess());
852 static CanQualType GetConversionType(ASTContext &Context, NamedDecl *Conv) {
854 if (isa<UsingShadowDecl>(Conv))
855 Conv = cast<UsingShadowDecl>(Conv)->getTargetDecl();
856 if (FunctionTemplateDecl *ConvTemp = dyn_cast<FunctionTemplateDecl>(Conv))
857 T = ConvTemp->getTemplatedDecl()->getResultType();
859 T = cast<CXXConversionDecl>(Conv)->getConversionType();
860 return Context.getCanonicalType(T);
863 /// Collect the visible conversions of a base class.
865 /// \param Base a base class of the class we're considering
866 /// \param InVirtual whether this base class is a virtual base (or a base
867 /// of a virtual base)
868 /// \param Access the access along the inheritance path to this base
869 /// \param ParentHiddenTypes the conversions provided by the inheritors
871 /// \param Output the set to which to add conversions from non-virtual bases
872 /// \param VOutput the set to which to add conversions from virtual bases
873 /// \param HiddenVBaseCs the set of conversions which were hidden in a
874 /// virtual base along some inheritance path
875 static void CollectVisibleConversions(ASTContext &Context,
876 CXXRecordDecl *Record,
878 AccessSpecifier Access,
879 const llvm::SmallPtrSet<CanQualType, 8> &ParentHiddenTypes,
880 UnresolvedSetImpl &Output,
881 UnresolvedSetImpl &VOutput,
882 llvm::SmallPtrSet<NamedDecl*, 8> &HiddenVBaseCs) {
883 // The set of types which have conversions in this class or its
884 // subclasses. As an optimization, we don't copy the derived set
885 // unless it might change.
886 const llvm::SmallPtrSet<CanQualType, 8> *HiddenTypes = &ParentHiddenTypes;
887 llvm::SmallPtrSet<CanQualType, 8> HiddenTypesBuffer;
889 // Collect the direct conversions and figure out which conversions
890 // will be hidden in the subclasses.
891 UnresolvedSetImpl &Cs = *Record->getConversionFunctions();
893 HiddenTypesBuffer = ParentHiddenTypes;
894 HiddenTypes = &HiddenTypesBuffer;
896 for (UnresolvedSetIterator I = Cs.begin(), E = Cs.end(); I != E; ++I) {
898 !HiddenTypesBuffer.insert(GetConversionType(Context, I.getDecl()));
900 // If this conversion is hidden and we're in a virtual base,
901 // remember that it's hidden along some inheritance path.
902 if (Hidden && InVirtual)
903 HiddenVBaseCs.insert(cast<NamedDecl>(I.getDecl()->getCanonicalDecl()));
905 // If this conversion isn't hidden, add it to the appropriate output.
907 AccessSpecifier IAccess
908 = CXXRecordDecl::MergeAccess(Access, I.getAccess());
911 VOutput.addDecl(I.getDecl(), IAccess);
913 Output.addDecl(I.getDecl(), IAccess);
918 // Collect information recursively from any base classes.
919 for (CXXRecordDecl::base_class_iterator
920 I = Record->bases_begin(), E = Record->bases_end(); I != E; ++I) {
921 const RecordType *RT = I->getType()->getAs<RecordType>();
924 AccessSpecifier BaseAccess
925 = CXXRecordDecl::MergeAccess(Access, I->getAccessSpecifier());
926 bool BaseInVirtual = InVirtual || I->isVirtual();
928 CXXRecordDecl *Base = cast<CXXRecordDecl>(RT->getDecl());
929 CollectVisibleConversions(Context, Base, BaseInVirtual, BaseAccess,
930 *HiddenTypes, Output, VOutput, HiddenVBaseCs);
934 /// Collect the visible conversions of a class.
936 /// This would be extremely straightforward if it weren't for virtual
937 /// bases. It might be worth special-casing that, really.
938 static void CollectVisibleConversions(ASTContext &Context,
939 CXXRecordDecl *Record,
940 UnresolvedSetImpl &Output) {
941 // The collection of all conversions in virtual bases that we've
942 // found. These will be added to the output as long as they don't
943 // appear in the hidden-conversions set.
944 UnresolvedSet<8> VBaseCs;
946 // The set of conversions in virtual bases that we've determined to
948 llvm::SmallPtrSet<NamedDecl*, 8> HiddenVBaseCs;
950 // The set of types hidden by classes derived from this one.
951 llvm::SmallPtrSet<CanQualType, 8> HiddenTypes;
953 // Go ahead and collect the direct conversions and add them to the
955 UnresolvedSetImpl &Cs = *Record->getConversionFunctions();
956 Output.append(Cs.begin(), Cs.end());
957 for (UnresolvedSetIterator I = Cs.begin(), E = Cs.end(); I != E; ++I)
958 HiddenTypes.insert(GetConversionType(Context, I.getDecl()));
960 // Recursively collect conversions from base classes.
961 for (CXXRecordDecl::base_class_iterator
962 I = Record->bases_begin(), E = Record->bases_end(); I != E; ++I) {
963 const RecordType *RT = I->getType()->getAs<RecordType>();
966 CollectVisibleConversions(Context, cast<CXXRecordDecl>(RT->getDecl()),
967 I->isVirtual(), I->getAccessSpecifier(),
968 HiddenTypes, Output, VBaseCs, HiddenVBaseCs);
971 // Add any unhidden conversions provided by virtual bases.
972 for (UnresolvedSetIterator I = VBaseCs.begin(), E = VBaseCs.end();
974 if (!HiddenVBaseCs.count(cast<NamedDecl>(I.getDecl()->getCanonicalDecl())))
975 Output.addDecl(I.getDecl(), I.getAccess());
979 /// getVisibleConversionFunctions - get all conversion functions visible
980 /// in current class; including conversion function templates.
981 const UnresolvedSetImpl *CXXRecordDecl::getVisibleConversionFunctions() {
982 // If root class, all conversions are visible.
983 if (bases_begin() == bases_end())
984 return &data().Conversions;
985 // If visible conversion list is already evaluated, return it.
986 if (data().ComputedVisibleConversions)
987 return &data().VisibleConversions;
988 CollectVisibleConversions(getASTContext(), this, data().VisibleConversions);
989 data().ComputedVisibleConversions = true;
990 return &data().VisibleConversions;
993 void CXXRecordDecl::removeConversion(const NamedDecl *ConvDecl) {
994 // This operation is O(N) but extremely rare. Sema only uses it to
995 // remove UsingShadowDecls in a class that were followed by a direct
996 // declaration, e.g.:
998 // using B::operator int;
1001 // This is uncommon by itself and even more uncommon in conjunction
1002 // with sufficiently large numbers of directly-declared conversions
1003 // that asymptotic behavior matters.
1005 UnresolvedSetImpl &Convs = *getConversionFunctions();
1006 for (unsigned I = 0, E = Convs.size(); I != E; ++I) {
1007 if (Convs[I].getDecl() == ConvDecl) {
1009 assert(std::find(Convs.begin(), Convs.end(), ConvDecl) == Convs.end()
1010 && "conversion was found multiple times in unresolved set");
1015 llvm_unreachable("conversion not found in set!");
1018 CXXRecordDecl *CXXRecordDecl::getInstantiatedFromMemberClass() const {
1019 if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo())
1020 return cast<CXXRecordDecl>(MSInfo->getInstantiatedFrom());
1025 MemberSpecializationInfo *CXXRecordDecl::getMemberSpecializationInfo() const {
1026 return TemplateOrInstantiation.dyn_cast<MemberSpecializationInfo *>();
1030 CXXRecordDecl::setInstantiationOfMemberClass(CXXRecordDecl *RD,
1031 TemplateSpecializationKind TSK) {
1032 assert(TemplateOrInstantiation.isNull() &&
1033 "Previous template or instantiation?");
1034 assert(!isa<ClassTemplateSpecializationDecl>(this));
1035 TemplateOrInstantiation
1036 = new (getASTContext()) MemberSpecializationInfo(RD, TSK);
1039 TemplateSpecializationKind CXXRecordDecl::getTemplateSpecializationKind() const{
1040 if (const ClassTemplateSpecializationDecl *Spec
1041 = dyn_cast<ClassTemplateSpecializationDecl>(this))
1042 return Spec->getSpecializationKind();
1044 if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo())
1045 return MSInfo->getTemplateSpecializationKind();
1047 return TSK_Undeclared;
1051 CXXRecordDecl::setTemplateSpecializationKind(TemplateSpecializationKind TSK) {
1052 if (ClassTemplateSpecializationDecl *Spec
1053 = dyn_cast<ClassTemplateSpecializationDecl>(this)) {
1054 Spec->setSpecializationKind(TSK);
1058 if (MemberSpecializationInfo *MSInfo = getMemberSpecializationInfo()) {
1059 MSInfo->setTemplateSpecializationKind(TSK);
1063 llvm_unreachable("Not a class template or member class specialization");
1066 CXXDestructorDecl *CXXRecordDecl::getDestructor() const {
1067 ASTContext &Context = getASTContext();
1068 QualType ClassType = Context.getTypeDeclType(this);
1070 DeclarationName Name
1071 = Context.DeclarationNames.getCXXDestructorName(
1072 Context.getCanonicalType(ClassType));
1074 DeclContext::lookup_const_iterator I, E;
1075 llvm::tie(I, E) = lookup(Name);
1079 CXXDestructorDecl *Dtor = cast<CXXDestructorDecl>(*I);
1083 void CXXRecordDecl::completeDefinition() {
1084 completeDefinition(0);
1087 void CXXRecordDecl::completeDefinition(CXXFinalOverriderMap *FinalOverriders) {
1088 RecordDecl::completeDefinition();
1090 if (hasObjectMember() && getASTContext().getLangOptions().ObjCAutoRefCount) {
1091 // Objective-C Automatic Reference Counting:
1092 // If a class has a non-static data member of Objective-C pointer
1093 // type (or array thereof), it is a non-POD type and its
1094 // default constructor (if any), copy constructor, copy assignment
1095 // operator, and destructor are non-trivial.
1096 struct DefinitionData &Data = data();
1097 Data.PlainOldData = false;
1098 Data.HasTrivialDefaultConstructor = false;
1099 Data.HasTrivialCopyConstructor = false;
1100 Data.HasTrivialCopyAssignment = false;
1101 Data.HasTrivialDestructor = false;
1104 // If the class may be abstract (but hasn't been marked as such), check for
1105 // any pure final overriders.
1106 if (mayBeAbstract()) {
1107 CXXFinalOverriderMap MyFinalOverriders;
1108 if (!FinalOverriders) {
1109 getFinalOverriders(MyFinalOverriders);
1110 FinalOverriders = &MyFinalOverriders;
1114 for (CXXFinalOverriderMap::iterator M = FinalOverriders->begin(),
1115 MEnd = FinalOverriders->end();
1116 M != MEnd && !Done; ++M) {
1117 for (OverridingMethods::iterator SO = M->second.begin(),
1118 SOEnd = M->second.end();
1119 SO != SOEnd && !Done; ++SO) {
1120 assert(SO->second.size() > 0 &&
1121 "All virtual functions have overridding virtual functions");
1123 // C++ [class.abstract]p4:
1124 // A class is abstract if it contains or inherits at least one
1125 // pure virtual function for which the final overrider is pure
1127 if (SO->second.front().Method->isPure()) {
1128 data().Abstract = true;
1136 // Set access bits correctly on the directly-declared conversions.
1137 for (UnresolvedSetIterator I = data().Conversions.begin(),
1138 E = data().Conversions.end();
1140 data().Conversions.setAccess(I, (*I)->getAccess());
1143 bool CXXRecordDecl::mayBeAbstract() const {
1144 if (data().Abstract || isInvalidDecl() || !data().Polymorphic ||
1145 isDependentContext())
1148 for (CXXRecordDecl::base_class_const_iterator B = bases_begin(),
1151 CXXRecordDecl *BaseDecl
1152 = cast<CXXRecordDecl>(B->getType()->getAs<RecordType>()->getDecl());
1153 if (BaseDecl->isAbstract())
1161 CXXMethodDecl::Create(ASTContext &C, CXXRecordDecl *RD,
1162 SourceLocation StartLoc,
1163 const DeclarationNameInfo &NameInfo,
1164 QualType T, TypeSourceInfo *TInfo,
1165 bool isStatic, StorageClass SCAsWritten, bool isInline,
1166 bool isConstexpr, SourceLocation EndLocation) {
1167 return new (C) CXXMethodDecl(CXXMethod, RD, StartLoc, NameInfo, T, TInfo,
1168 isStatic, SCAsWritten, isInline, isConstexpr,
1172 bool CXXMethodDecl::isUsualDeallocationFunction() const {
1173 if (getOverloadedOperator() != OO_Delete &&
1174 getOverloadedOperator() != OO_Array_Delete)
1177 // C++ [basic.stc.dynamic.deallocation]p2:
1178 // A template instance is never a usual deallocation function,
1179 // regardless of its signature.
1180 if (getPrimaryTemplate())
1183 // C++ [basic.stc.dynamic.deallocation]p2:
1184 // If a class T has a member deallocation function named operator delete
1185 // with exactly one parameter, then that function is a usual (non-placement)
1186 // deallocation function. [...]
1187 if (getNumParams() == 1)
1190 // C++ [basic.stc.dynamic.deallocation]p2:
1191 // [...] If class T does not declare such an operator delete but does
1192 // declare a member deallocation function named operator delete with
1193 // exactly two parameters, the second of which has type std::size_t (18.1),
1194 // then this function is a usual deallocation function.
1195 ASTContext &Context = getASTContext();
1196 if (getNumParams() != 2 ||
1197 !Context.hasSameUnqualifiedType(getParamDecl(1)->getType(),
1198 Context.getSizeType()))
1201 // This function is a usual deallocation function if there are no
1202 // single-parameter deallocation functions of the same kind.
1203 for (DeclContext::lookup_const_result R = getDeclContext()->lookup(getDeclName());
1204 R.first != R.second; ++R.first) {
1205 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*R.first))
1206 if (FD->getNumParams() == 1)
1213 bool CXXMethodDecl::isCopyAssignmentOperator() const {
1214 // C++0x [class.copy]p17:
1215 // A user-declared copy assignment operator X::operator= is a non-static
1216 // non-template member function of class X with exactly one parameter of
1217 // type X, X&, const X&, volatile X& or const volatile X&.
1218 if (/*operator=*/getOverloadedOperator() != OO_Equal ||
1219 /*non-static*/ isStatic() ||
1220 /*non-template*/getPrimaryTemplate() || getDescribedFunctionTemplate())
1223 QualType ParamType = getParamDecl(0)->getType();
1224 if (const LValueReferenceType *Ref = ParamType->getAs<LValueReferenceType>())
1225 ParamType = Ref->getPointeeType();
1227 ASTContext &Context = getASTContext();
1229 = Context.getCanonicalType(Context.getTypeDeclType(getParent()));
1230 return Context.hasSameUnqualifiedType(ClassType, ParamType);
1233 bool CXXMethodDecl::isMoveAssignmentOperator() const {
1234 // C++0x [class.copy]p19:
1235 // A user-declared move assignment operator X::operator= is a non-static
1236 // non-template member function of class X with exactly one parameter of type
1237 // X&&, const X&&, volatile X&&, or const volatile X&&.
1238 if (getOverloadedOperator() != OO_Equal || isStatic() ||
1239 getPrimaryTemplate() || getDescribedFunctionTemplate())
1242 QualType ParamType = getParamDecl(0)->getType();
1243 if (!isa<RValueReferenceType>(ParamType))
1245 ParamType = ParamType->getPointeeType();
1247 ASTContext &Context = getASTContext();
1249 = Context.getCanonicalType(Context.getTypeDeclType(getParent()));
1250 return Context.hasSameUnqualifiedType(ClassType, ParamType);
1253 void CXXMethodDecl::addOverriddenMethod(const CXXMethodDecl *MD) {
1254 assert(MD->isCanonicalDecl() && "Method is not canonical!");
1255 assert(!MD->getParent()->isDependentContext() &&
1256 "Can't add an overridden method to a class template!");
1258 getASTContext().addOverriddenMethod(this, MD);
1261 CXXMethodDecl::method_iterator CXXMethodDecl::begin_overridden_methods() const {
1262 return getASTContext().overridden_methods_begin(this);
1265 CXXMethodDecl::method_iterator CXXMethodDecl::end_overridden_methods() const {
1266 return getASTContext().overridden_methods_end(this);
1269 unsigned CXXMethodDecl::size_overridden_methods() const {
1270 return getASTContext().overridden_methods_size(this);
1273 QualType CXXMethodDecl::getThisType(ASTContext &C) const {
1274 // C++ 9.3.2p1: The type of this in a member function of a class X is X*.
1275 // If the member function is declared const, the type of this is const X*,
1276 // if the member function is declared volatile, the type of this is
1277 // volatile X*, and if the member function is declared const volatile,
1278 // the type of this is const volatile X*.
1280 assert(isInstance() && "No 'this' for static methods!");
1282 QualType ClassTy = C.getTypeDeclType(getParent());
1283 ClassTy = C.getQualifiedType(ClassTy,
1284 Qualifiers::fromCVRMask(getTypeQualifiers()));
1285 return C.getPointerType(ClassTy);
1288 bool CXXMethodDecl::hasInlineBody() const {
1289 // If this function is a template instantiation, look at the template from
1290 // which it was instantiated.
1291 const FunctionDecl *CheckFn = getTemplateInstantiationPattern();
1295 const FunctionDecl *fn;
1296 return CheckFn->hasBody(fn) && !fn->isOutOfLine();
1299 CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
1300 TypeSourceInfo *TInfo, bool IsVirtual,
1301 SourceLocation L, Expr *Init,
1303 SourceLocation EllipsisLoc)
1304 : Initializee(TInfo), MemberOrEllipsisLocation(EllipsisLoc), Init(Init),
1305 LParenLoc(L), RParenLoc(R), IsVirtual(IsVirtual), IsWritten(false),
1306 SourceOrderOrNumArrayIndices(0)
1310 CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
1312 SourceLocation MemberLoc,
1313 SourceLocation L, Expr *Init,
1315 : Initializee(Member), MemberOrEllipsisLocation(MemberLoc), Init(Init),
1316 LParenLoc(L), RParenLoc(R), IsVirtual(false),
1317 IsWritten(false), SourceOrderOrNumArrayIndices(0)
1321 CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
1322 IndirectFieldDecl *Member,
1323 SourceLocation MemberLoc,
1324 SourceLocation L, Expr *Init,
1326 : Initializee(Member), MemberOrEllipsisLocation(MemberLoc), Init(Init),
1327 LParenLoc(L), RParenLoc(R), IsVirtual(false),
1328 IsWritten(false), SourceOrderOrNumArrayIndices(0)
1332 CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
1333 SourceLocation D, SourceLocation L,
1334 CXXConstructorDecl *Target, Expr *Init,
1336 : Initializee(Target), MemberOrEllipsisLocation(D), Init(Init),
1337 LParenLoc(L), RParenLoc(R), IsVirtual(false),
1338 IsWritten(false), SourceOrderOrNumArrayIndices(0)
1342 CXXCtorInitializer::CXXCtorInitializer(ASTContext &Context,
1344 SourceLocation MemberLoc,
1345 SourceLocation L, Expr *Init,
1348 unsigned NumIndices)
1349 : Initializee(Member), MemberOrEllipsisLocation(MemberLoc), Init(Init),
1350 LParenLoc(L), RParenLoc(R), IsVirtual(false),
1351 IsWritten(false), SourceOrderOrNumArrayIndices(NumIndices)
1353 VarDecl **MyIndices = reinterpret_cast<VarDecl **> (this + 1);
1354 memcpy(MyIndices, Indices, NumIndices * sizeof(VarDecl *));
1357 CXXCtorInitializer *CXXCtorInitializer::Create(ASTContext &Context,
1359 SourceLocation MemberLoc,
1360 SourceLocation L, Expr *Init,
1363 unsigned NumIndices) {
1364 void *Mem = Context.Allocate(sizeof(CXXCtorInitializer) +
1365 sizeof(VarDecl *) * NumIndices,
1366 llvm::alignOf<CXXCtorInitializer>());
1367 return new (Mem) CXXCtorInitializer(Context, Member, MemberLoc, L, Init, R,
1368 Indices, NumIndices);
1371 TypeLoc CXXCtorInitializer::getBaseClassLoc() const {
1372 if (isBaseInitializer())
1373 return Initializee.get<TypeSourceInfo*>()->getTypeLoc();
1378 const Type *CXXCtorInitializer::getBaseClass() const {
1379 if (isBaseInitializer())
1380 return Initializee.get<TypeSourceInfo*>()->getType().getTypePtr();
1385 SourceLocation CXXCtorInitializer::getSourceLocation() const {
1386 if (isAnyMemberInitializer() || isDelegatingInitializer())
1387 return getMemberLocation();
1389 if (isInClassMemberInitializer())
1390 return getAnyMember()->getLocation();
1392 return getBaseClassLoc().getLocalSourceRange().getBegin();
1395 SourceRange CXXCtorInitializer::getSourceRange() const {
1396 if (isInClassMemberInitializer()) {
1397 FieldDecl *D = getAnyMember();
1398 if (Expr *I = D->getInClassInitializer())
1399 return I->getSourceRange();
1400 return SourceRange();
1403 return SourceRange(getSourceLocation(), getRParenLoc());
1406 CXXConstructorDecl *
1407 CXXConstructorDecl::Create(ASTContext &C, EmptyShell Empty) {
1408 return new (C) CXXConstructorDecl(0, SourceLocation(), DeclarationNameInfo(),
1409 QualType(), 0, false, false, false, false);
1412 CXXConstructorDecl *
1413 CXXConstructorDecl::Create(ASTContext &C, CXXRecordDecl *RD,
1414 SourceLocation StartLoc,
1415 const DeclarationNameInfo &NameInfo,
1416 QualType T, TypeSourceInfo *TInfo,
1417 bool isExplicit, bool isInline,
1418 bool isImplicitlyDeclared, bool isConstexpr) {
1419 assert(NameInfo.getName().getNameKind()
1420 == DeclarationName::CXXConstructorName &&
1421 "Name must refer to a constructor");
1422 return new (C) CXXConstructorDecl(RD, StartLoc, NameInfo, T, TInfo,
1423 isExplicit, isInline, isImplicitlyDeclared,
1427 bool CXXConstructorDecl::isDefaultConstructor() const {
1428 // C++ [class.ctor]p5:
1429 // A default constructor for a class X is a constructor of class
1430 // X that can be called without an argument.
1431 return (getNumParams() == 0) ||
1432 (getNumParams() > 0 && getParamDecl(0)->hasDefaultArg());
1436 CXXConstructorDecl::isCopyConstructor(unsigned &TypeQuals) const {
1437 return isCopyOrMoveConstructor(TypeQuals) &&
1438 getParamDecl(0)->getType()->isLValueReferenceType();
1441 bool CXXConstructorDecl::isMoveConstructor(unsigned &TypeQuals) const {
1442 return isCopyOrMoveConstructor(TypeQuals) &&
1443 getParamDecl(0)->getType()->isRValueReferenceType();
1446 /// \brief Determine whether this is a copy or move constructor.
1447 bool CXXConstructorDecl::isCopyOrMoveConstructor(unsigned &TypeQuals) const {
1448 // C++ [class.copy]p2:
1449 // A non-template constructor for class X is a copy constructor
1450 // if its first parameter is of type X&, const X&, volatile X& or
1451 // const volatile X&, and either there are no other parameters
1452 // or else all other parameters have default arguments (8.3.6).
1453 // C++0x [class.copy]p3:
1454 // A non-template constructor for class X is a move constructor if its
1455 // first parameter is of type X&&, const X&&, volatile X&&, or
1456 // const volatile X&&, and either there are no other parameters or else
1457 // all other parameters have default arguments.
1458 if ((getNumParams() < 1) ||
1459 (getNumParams() > 1 && !getParamDecl(1)->hasDefaultArg()) ||
1460 (getPrimaryTemplate() != 0) ||
1461 (getDescribedFunctionTemplate() != 0))
1464 const ParmVarDecl *Param = getParamDecl(0);
1466 // Do we have a reference type?
1467 const ReferenceType *ParamRefType = Param->getType()->getAs<ReferenceType>();
1471 // Is it a reference to our class type?
1472 ASTContext &Context = getASTContext();
1474 CanQualType PointeeType
1475 = Context.getCanonicalType(ParamRefType->getPointeeType());
1477 = Context.getCanonicalType(Context.getTagDeclType(getParent()));
1478 if (PointeeType.getUnqualifiedType() != ClassTy)
1481 // FIXME: other qualifiers?
1483 // We have a copy or move constructor.
1484 TypeQuals = PointeeType.getCVRQualifiers();
1488 bool CXXConstructorDecl::isConvertingConstructor(bool AllowExplicit) const {
1489 // C++ [class.conv.ctor]p1:
1490 // A constructor declared without the function-specifier explicit
1491 // that can be called with a single parameter specifies a
1492 // conversion from the type of its first parameter to the type of
1493 // its class. Such a constructor is called a converting
1495 if (isExplicit() && !AllowExplicit)
1498 return (getNumParams() == 0 &&
1499 getType()->getAs<FunctionProtoType>()->isVariadic()) ||
1500 (getNumParams() == 1) ||
1501 (getNumParams() > 1 && getParamDecl(1)->hasDefaultArg());
1504 bool CXXConstructorDecl::isSpecializationCopyingObject() const {
1505 if ((getNumParams() < 1) ||
1506 (getNumParams() > 1 && !getParamDecl(1)->hasDefaultArg()) ||
1507 (getPrimaryTemplate() == 0) ||
1508 (getDescribedFunctionTemplate() != 0))
1511 const ParmVarDecl *Param = getParamDecl(0);
1513 ASTContext &Context = getASTContext();
1514 CanQualType ParamType = Context.getCanonicalType(Param->getType());
1516 // Is it the same as our our class type?
1518 = Context.getCanonicalType(Context.getTagDeclType(getParent()));
1519 if (ParamType.getUnqualifiedType() != ClassTy)
1525 const CXXConstructorDecl *CXXConstructorDecl::getInheritedConstructor() const {
1526 // Hack: we store the inherited constructor in the overridden method table
1527 method_iterator It = begin_overridden_methods();
1528 if (It == end_overridden_methods())
1531 return cast<CXXConstructorDecl>(*It);
1535 CXXConstructorDecl::setInheritedConstructor(const CXXConstructorDecl *BaseCtor){
1536 // Hack: we store the inherited constructor in the overridden method table
1537 assert(size_overridden_methods() == 0 && "Base ctor already set.");
1538 addOverriddenMethod(BaseCtor);
1542 CXXDestructorDecl::Create(ASTContext &C, EmptyShell Empty) {
1543 return new (C) CXXDestructorDecl(0, SourceLocation(), DeclarationNameInfo(),
1544 QualType(), 0, false, false);
1548 CXXDestructorDecl::Create(ASTContext &C, CXXRecordDecl *RD,
1549 SourceLocation StartLoc,
1550 const DeclarationNameInfo &NameInfo,
1551 QualType T, TypeSourceInfo *TInfo,
1552 bool isInline, bool isImplicitlyDeclared) {
1553 assert(NameInfo.getName().getNameKind()
1554 == DeclarationName::CXXDestructorName &&
1555 "Name must refer to a destructor");
1556 return new (C) CXXDestructorDecl(RD, StartLoc, NameInfo, T, TInfo, isInline,
1557 isImplicitlyDeclared);
1561 CXXConversionDecl::Create(ASTContext &C, EmptyShell Empty) {
1562 return new (C) CXXConversionDecl(0, SourceLocation(), DeclarationNameInfo(),
1563 QualType(), 0, false, false, false,
1568 CXXConversionDecl::Create(ASTContext &C, CXXRecordDecl *RD,
1569 SourceLocation StartLoc,
1570 const DeclarationNameInfo &NameInfo,
1571 QualType T, TypeSourceInfo *TInfo,
1572 bool isInline, bool isExplicit,
1573 bool isConstexpr, SourceLocation EndLocation) {
1574 assert(NameInfo.getName().getNameKind()
1575 == DeclarationName::CXXConversionFunctionName &&
1576 "Name must refer to a conversion function");
1577 return new (C) CXXConversionDecl(RD, StartLoc, NameInfo, T, TInfo,
1578 isInline, isExplicit, isConstexpr,
1582 LinkageSpecDecl *LinkageSpecDecl::Create(ASTContext &C,
1584 SourceLocation ExternLoc,
1585 SourceLocation LangLoc,
1587 SourceLocation RBraceLoc) {
1588 return new (C) LinkageSpecDecl(DC, ExternLoc, LangLoc, Lang, RBraceLoc);
1591 UsingDirectiveDecl *UsingDirectiveDecl::Create(ASTContext &C, DeclContext *DC,
1593 SourceLocation NamespaceLoc,
1594 NestedNameSpecifierLoc QualifierLoc,
1595 SourceLocation IdentLoc,
1597 DeclContext *CommonAncestor) {
1598 if (NamespaceDecl *NS = dyn_cast_or_null<NamespaceDecl>(Used))
1599 Used = NS->getOriginalNamespace();
1600 return new (C) UsingDirectiveDecl(DC, L, NamespaceLoc, QualifierLoc,
1601 IdentLoc, Used, CommonAncestor);
1604 NamespaceDecl *UsingDirectiveDecl::getNominatedNamespace() {
1605 if (NamespaceAliasDecl *NA =
1606 dyn_cast_or_null<NamespaceAliasDecl>(NominatedNamespace))
1607 return NA->getNamespace();
1608 return cast_or_null<NamespaceDecl>(NominatedNamespace);
1611 NamespaceAliasDecl *NamespaceAliasDecl::Create(ASTContext &C, DeclContext *DC,
1612 SourceLocation UsingLoc,
1613 SourceLocation AliasLoc,
1614 IdentifierInfo *Alias,
1615 NestedNameSpecifierLoc QualifierLoc,
1616 SourceLocation IdentLoc,
1617 NamedDecl *Namespace) {
1618 if (NamespaceDecl *NS = dyn_cast_or_null<NamespaceDecl>(Namespace))
1619 Namespace = NS->getOriginalNamespace();
1620 return new (C) NamespaceAliasDecl(DC, UsingLoc, AliasLoc, Alias,
1621 QualifierLoc, IdentLoc, Namespace);
1624 UsingDecl *UsingShadowDecl::getUsingDecl() const {
1625 const UsingShadowDecl *Shadow = this;
1626 while (const UsingShadowDecl *NextShadow =
1627 dyn_cast<UsingShadowDecl>(Shadow->UsingOrNextShadow))
1628 Shadow = NextShadow;
1629 return cast<UsingDecl>(Shadow->UsingOrNextShadow);
1632 void UsingDecl::addShadowDecl(UsingShadowDecl *S) {
1633 assert(std::find(shadow_begin(), shadow_end(), S) == shadow_end() &&
1634 "declaration already in set");
1635 assert(S->getUsingDecl() == this);
1637 if (FirstUsingShadow)
1638 S->UsingOrNextShadow = FirstUsingShadow;
1639 FirstUsingShadow = S;
1642 void UsingDecl::removeShadowDecl(UsingShadowDecl *S) {
1643 assert(std::find(shadow_begin(), shadow_end(), S) != shadow_end() &&
1644 "declaration not in set");
1645 assert(S->getUsingDecl() == this);
1647 // Remove S from the shadow decl chain. This is O(n) but hopefully rare.
1649 if (FirstUsingShadow == S) {
1650 FirstUsingShadow = dyn_cast<UsingShadowDecl>(S->UsingOrNextShadow);
1651 S->UsingOrNextShadow = this;
1655 UsingShadowDecl *Prev = FirstUsingShadow;
1656 while (Prev->UsingOrNextShadow != S)
1657 Prev = cast<UsingShadowDecl>(Prev->UsingOrNextShadow);
1658 Prev->UsingOrNextShadow = S->UsingOrNextShadow;
1659 S->UsingOrNextShadow = this;
1662 UsingDecl *UsingDecl::Create(ASTContext &C, DeclContext *DC, SourceLocation UL,
1663 NestedNameSpecifierLoc QualifierLoc,
1664 const DeclarationNameInfo &NameInfo,
1665 bool IsTypeNameArg) {
1666 return new (C) UsingDecl(DC, UL, QualifierLoc, NameInfo, IsTypeNameArg);
1669 UnresolvedUsingValueDecl *
1670 UnresolvedUsingValueDecl::Create(ASTContext &C, DeclContext *DC,
1671 SourceLocation UsingLoc,
1672 NestedNameSpecifierLoc QualifierLoc,
1673 const DeclarationNameInfo &NameInfo) {
1674 return new (C) UnresolvedUsingValueDecl(DC, C.DependentTy, UsingLoc,
1675 QualifierLoc, NameInfo);
1678 UnresolvedUsingTypenameDecl *
1679 UnresolvedUsingTypenameDecl::Create(ASTContext &C, DeclContext *DC,
1680 SourceLocation UsingLoc,
1681 SourceLocation TypenameLoc,
1682 NestedNameSpecifierLoc QualifierLoc,
1683 SourceLocation TargetNameLoc,
1684 DeclarationName TargetName) {
1685 return new (C) UnresolvedUsingTypenameDecl(DC, UsingLoc, TypenameLoc,
1686 QualifierLoc, TargetNameLoc,
1687 TargetName.getAsIdentifierInfo());
1690 StaticAssertDecl *StaticAssertDecl::Create(ASTContext &C, DeclContext *DC,
1691 SourceLocation StaticAssertLoc,
1693 StringLiteral *Message,
1694 SourceLocation RParenLoc) {
1695 return new (C) StaticAssertDecl(DC, StaticAssertLoc, AssertExpr, Message,
1699 static const char *getAccessName(AccessSpecifier AS) {
1703 llvm_unreachable("Invalid access specifier!");
1713 const DiagnosticBuilder &clang::operator<<(const DiagnosticBuilder &DB,
1714 AccessSpecifier AS) {
1715 return DB << getAccessName(AS);