/// of -Wselector.
llvm::DenseMap<Selector, SourceLocation> ReferencedSelectors;
+ /// Kinds of C++ special members.
+ enum CXXSpecialMember {
+ CXXDefaultConstructor,
+ CXXCopyConstructor,
+ CXXMoveConstructor,
+ CXXCopyAssignment,
+ CXXMoveAssignment,
+ CXXDestructor,
+ CXXInvalid
+ };
+
+ typedef std::pair<CXXRecordDecl*, CXXSpecialMember> SpecialMemberDecl;
+
+ /// The C++ special members which we are currently in the process of
+ /// declaring. If this process recursively triggers the declaration of the
+ /// same special member, we should act as if it is not yet declared.
+ llvm::SmallSet<SpecialMemberDecl, 4> SpecialMembersBeingDeclared;
+
void ReadMethodPool(Selector Sel);
/// Private Helper predicate to check for 'self'.
AccessSpecifier AS, NamedDecl *PrevDecl,
Declarator *D = 0);
- enum CXXSpecialMember {
- CXXDefaultConstructor,
- CXXCopyConstructor,
- CXXMoveConstructor,
- CXXCopyAssignment,
- CXXMoveAssignment,
- CXXDestructor,
- CXXInvalid
- };
bool CheckNontrivialField(FieldDecl *FD);
void DiagnoseNontrivial(const RecordType* Record, CXXSpecialMember mem);
CXXSpecialMember getSpecialMember(const CXXMethodDecl *MD);
return ExceptSpec;
}
+namespace {
+/// RAII object to register a special member as being currently declared.
+struct DeclaringSpecialMember {
+ Sema &S;
+ Sema::SpecialMemberDecl D;
+ bool WasAlreadyBeingDeclared;
+
+ DeclaringSpecialMember(Sema &S, CXXRecordDecl *RD, Sema::CXXSpecialMember CSM)
+ : S(S), D(RD, CSM) {
+ WasAlreadyBeingDeclared = !S.SpecialMembersBeingDeclared.insert(D);
+ if (WasAlreadyBeingDeclared)
+ // This almost never happens, but if it does, ensure that our cache
+ // doesn't contain a stale result.
+ S.SpecialMemberCache.clear();
+
+ // FIXME: Register a note to be produced if we encounter an error while
+ // declaring the special member.
+ }
+ ~DeclaringSpecialMember() {
+ if (!WasAlreadyBeingDeclared)
+ S.SpecialMembersBeingDeclared.erase(D);
+ }
+
+ /// \brief Are we already trying to declare this special member?
+ bool isAlreadyBeingDeclared() const {
+ return WasAlreadyBeingDeclared;
+ }
+};
+}
+
CXXConstructorDecl *Sema::DeclareImplicitDefaultConstructor(
CXXRecordDecl *ClassDecl) {
// C++ [class.ctor]p5:
assert(ClassDecl->needsImplicitDefaultConstructor() &&
"Should not build implicit default constructor!");
+ DeclaringSpecialMember DSM(*this, ClassDecl, CXXDefaultConstructor);
+ if (DSM.isAlreadyBeingDeclared())
+ return 0;
+
bool Constexpr = defaultedSpecialMemberIsConstexpr(*this, ClassDecl,
CXXDefaultConstructor,
false);
// inline public member of its class.
assert(!ClassDecl->hasDeclaredDestructor());
+ DeclaringSpecialMember DSM(*this, ClassDecl, CXXDestructor);
+ if (DSM.isAlreadyBeingDeclared())
+ return 0;
+
// Create the actual destructor declaration.
CanQualType ClassType
= Context.getCanonicalType(Context.getTypeDeclType(ClassDecl));
// operators taking an object instead of a reference are allowed.
assert(!ClassDecl->hasDeclaredCopyAssignment());
+ DeclaringSpecialMember DSM(*this, ClassDecl, CXXCopyAssignment);
+ if (DSM.isAlreadyBeingDeclared())
+ return 0;
+
QualType ArgType = Context.getTypeDeclType(ClassDecl);
QualType RetType = Context.getLValueReferenceType(ArgType);
if (ClassDecl->implicitCopyAssignmentHasConstParam())
// - [first 4 bullets]
assert(ClassDecl->needsImplicitMoveAssignment());
+ DeclaringSpecialMember DSM(*this, ClassDecl, CXXMoveAssignment);
+ if (DSM.isAlreadyBeingDeclared())
+ return 0;
+
// [Checked after we build the declaration]
// - the move assignment operator would not be implicitly defined as
// deleted,
// constructor, one is declared implicitly.
assert(!ClassDecl->hasDeclaredCopyConstructor());
+ DeclaringSpecialMember DSM(*this, ClassDecl, CXXCopyConstructor);
+ if (DSM.isAlreadyBeingDeclared())
+ return 0;
+
QualType ClassType = Context.getTypeDeclType(ClassDecl);
QualType ArgType = ClassType;
bool Const = ClassDecl->implicitCopyConstructorHasConstParam();
// - [first 4 bullets]
assert(ClassDecl->needsImplicitMoveConstructor());
+ DeclaringSpecialMember DSM(*this, ClassDecl, CXXMoveConstructor);
+ if (DSM.isAlreadyBeingDeclared())
+ return 0;
+
// [Checked after we build the declaration]
// - the move assignment operator would not be implicitly defined as
// deleted,
-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
struct A { };
A::A() { } // expected-error {{definition of implicitly declared default constructor}}
};
C *C::c = new C();
}
+
+namespace Recursion {
+ template<typename T> struct InvokeCopyConstructor {
+ static const T &get();
+ typedef decltype(T(get())) type; // expected-error {{no matching conver}}
+ };
+ struct B;
+ struct A {
+ typedef B type;
+ template<typename T,
+ typename = typename InvokeCopyConstructor<typename T::type>::type>
+ // expected-note@-1 {{in instantiation of template class}}
+ A(const T &);
+ // expected-note@-1 {{in instantiation of default argument}}
+ // expected-note@-2 {{while substituting deduced template arguments}}
+ };
+ struct B { // expected-note {{candidate constructor (the implicit move }}
+ B(); // expected-note {{candidate constructor not viable}}
+ A a;
+ };
+ // Triggering the declaration of B's copy constructor causes overload
+ // resolution to occur for A's copying constructor, which instantiates
+ // InvokeCopyConstructor<B>, which triggers the declaration of B's copy
+ // constructor. Notionally, this happens when we get to the end of the
+ // definition of 'struct B', so there is no declared copy constructor yet.
+ //
+ // This behavior is g++-compatible, but isn't exactly right; the class is
+ // supposed to be incomplete when we implicitly declare its special members.
+ B b = B();
+
+
+ // Another case, which isn't ill-formed under our rules. This is inspired by
+ // a problem which occurs when combining CGAL with libstdc++-4.7.
+
+ template<typename T> T &&declval();
+ template<typename T, typename U> struct pair {
+ pair();
+ template<typename V, typename W,
+ typename = decltype(T(declval<const V&>())),
+ typename = decltype(U(declval<const W&>()))>
+ pair(const pair<V,W> &);
+ };
+
+ template<typename K> struct Line;
+
+ template<typename K> struct Vector {
+ Vector(const Line<K> &l);
+ };
+
+ template<typename K> struct Point {
+ Vector<K> v;
+ };
+
+ template<typename K> struct Line {
+ pair<Point<K>, Vector<K>> x;
+ };
+
+ // Trigger declaration of Line copy ctor, which causes substitution into
+ // pair's templated constructor, which triggers instantiation of the
+ // definition of Point's copy constructor, which performs overload resolution
+ // on Vector's constructors, which requires declaring all of Line's
+ // constructors. That should not find a copy constructor (because we've not
+ // declared it yet), but by the time we get all the way back here, we should
+ // find the copy constructor.
+ Line<void> L1;
+ Line<void> L2(L1);
+}