From cad84b7c12564ff37feb66d6d004bb609bea8788 Mon Sep 17 00:00:00 2001 From: Douglas Gregor Date: Fri, 13 Nov 2009 23:14:53 +0000 Subject: [PATCH] A constructor template cannot be instantiated to a copy constructor. Make sure that such declarations can never be formed. git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@88718 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/clang/Basic/DiagnosticSemaKinds.td | 2 + lib/AST/DeclCXX.cpp | 16 ++++---- lib/Sema/SemaDecl.cpp | 3 ++ lib/Sema/SemaOverload.cpp | 4 +- lib/Sema/SemaTemplateDeduction.cpp | 2 +- lib/Sema/SemaTemplateInstantiateDecl.cpp | 47 ++++++++++++++-------- test/SemaCXX/constructor-recovery.cpp | 7 ++-- test/SemaCXX/copy-constructor-error.cpp | 8 ++-- test/SemaTemplate/constructor-template.cpp | 20 ++++++++- test/SemaTemplate/operator-template.cpp | 6 ++- 10 files changed, 76 insertions(+), 39 deletions(-) diff --git a/include/clang/Basic/DiagnosticSemaKinds.td b/include/clang/Basic/DiagnosticSemaKinds.td index 2cc29caa01..7f44d53411 100644 --- a/include/clang/Basic/DiagnosticSemaKinds.td +++ b/include/clang/Basic/DiagnosticSemaKinds.td @@ -487,6 +487,8 @@ def err_constructor_return_type : Error< def err_constructor_redeclared : Error<"constructor cannot be redeclared">; def err_constructor_byvalue_arg : Error< "copy constructor must pass its first argument by reference">; +def err_constructor_template_is_copy_constructor : Error< + "constructor template %0 instantiates to a copy constructor">; // C++ destructors def err_destructor_not_member : Error< diff --git a/lib/AST/DeclCXX.cpp b/lib/AST/DeclCXX.cpp index e325a25c76..69a577f1e7 100644 --- a/lib/AST/DeclCXX.cpp +++ b/lib/AST/DeclCXX.cpp @@ -707,23 +707,23 @@ CXXConstructorDecl::isCopyConstructor(ASTContext &Context, // if its first parameter is of type X&, const X&, volatile X& or // const volatile X&, and either there are no other parameters // or else all other parameters have default arguments (8.3.6). + // + // Note that we also test cv 'X' as a copy constructor, even though it is + // ill-formed, because this helps enforce C++ [class.copy]p3. if ((getNumParams() < 1) || (getNumParams() > 1 && !getParamDecl(1)->hasDefaultArg()) || - (getPrimaryTemplate() != 0) || (getDescribedFunctionTemplate() != 0)) return false; const ParmVarDecl *Param = getParamDecl(0); // Do we have a reference type? Rvalue references don't count. - const LValueReferenceType *ParamRefType = - Param->getType()->getAs(); - if (!ParamRefType) - return false; + CanQualType PointeeType = Context.getCanonicalType(Param->getType()); + if (CanQual ParamRefType = + PointeeType->getAs()) + PointeeType = ParamRefType->getPointeeType(); - // Is it a reference to our class type? - CanQualType PointeeType - = Context.getCanonicalType(ParamRefType->getPointeeType()); + // Do we have our class type? CanQualType ClassTy = Context.getCanonicalType(Context.getTagDeclType(getParent())); if (PointeeType.getUnqualifiedType() != ClassTy) diff --git a/lib/Sema/SemaDecl.cpp b/lib/Sema/SemaDecl.cpp index fa31cc5ddb..30d046f3b9 100644 --- a/lib/Sema/SemaDecl.cpp +++ b/lib/Sema/SemaDecl.cpp @@ -3909,6 +3909,9 @@ Sema::DeclPtrTy Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, DeclPtrTy D) { << FD->getNameAsCString() << "dllimport"; } } + + assert(ExprTemporaries.empty() && "Leftover temporaries before starting"); + return DeclPtrTy::make(FD); } diff --git a/lib/Sema/SemaOverload.cpp b/lib/Sema/SemaOverload.cpp index 3948b22f7b..70b080e678 100644 --- a/lib/Sema/SemaOverload.cpp +++ b/lib/Sema/SemaOverload.cpp @@ -2237,7 +2237,9 @@ Sema::AddOverloadCandidate(FunctionDecl *Function, // argument doesn't participate in overload resolution. } - if (!CandidateSet.isNewCandidate(Function)) + // FIXME: It would be nice if it were safe to keep invalid methods in the + // overload set (but it isn't due to broken copy constructors). + if (!CandidateSet.isNewCandidate(Function) || Function->isInvalidDecl()) return; // Add this candidate diff --git a/lib/Sema/SemaTemplateDeduction.cpp b/lib/Sema/SemaTemplateDeduction.cpp index fa45806a72..17b4e5fe82 100644 --- a/lib/Sema/SemaTemplateDeduction.cpp +++ b/lib/Sema/SemaTemplateDeduction.cpp @@ -1247,7 +1247,7 @@ Sema::FinishTemplateArgumentDeduction(FunctionTemplateDecl *FunctionTemplate, for (unsigned I = 0, N = Deduced.size(); I != N; ++I) { if (Deduced[I].isNull()) { Info.Param = makeTemplateParameter( - const_cast(TemplateParams->getParam(I))); + const_cast(TemplateParams->getParam(I))); return TDK_Incomplete; } diff --git a/lib/Sema/SemaTemplateInstantiateDecl.cpp b/lib/Sema/SemaTemplateInstantiateDecl.cpp index 47d2701bcd..0e42bd65db 100644 --- a/lib/Sema/SemaTemplateInstantiateDecl.cpp +++ b/lib/Sema/SemaTemplateInstantiateDecl.cpp @@ -658,6 +658,12 @@ Decl *TemplateDeclInstantiator::VisitCXXRecordDecl(CXXRecordDecl *D) { TemplateParams, Function); Function->setDescribedFunctionTemplate(FunctionTemplate); FunctionTemplate->setLexicalDeclContext(D->getLexicalDeclContext()); + } else if (FunctionTemplate) { + // Record this function template specialization. + Function->setFunctionTemplateSpecialization(SemaRef.Context, + FunctionTemplate, + &TemplateArgs.getInnermost(), + InsertPos); } if (InitFunctionInstantiation(Function, D)) @@ -709,14 +715,6 @@ Decl *TemplateDeclInstantiator::VisitCXXRecordDecl(CXXRecordDecl *D) { Function->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation); } - if (FunctionTemplate && !TemplateParams) { - // Record this function template specialization. - Function->setFunctionTemplateSpecialization(SemaRef.Context, - FunctionTemplate, - &TemplateArgs.getInnermost(), - InsertPos); - } - return Function; } @@ -811,9 +809,17 @@ TemplateDeclInstantiator::VisitCXXMethodDecl(CXXMethodDecl *D, if (D->isOutOfLine()) FunctionTemplate->setLexicalDeclContext(D->getLexicalDeclContext()); Method->setDescribedFunctionTemplate(FunctionTemplate); - } else if (!FunctionTemplate) + } else if (FunctionTemplate) { + // Record this function template specialization. + Method->setFunctionTemplateSpecialization(SemaRef.Context, + FunctionTemplate, + &TemplateArgs.getInnermost(), + InsertPos); + } else { + // Record this instantiation of a member function. Method->setInstantiationOfMemberFunction(D, TSK_ImplicitInstantiation); - + } + // If we are instantiating a member function defined // out-of-line, the instantiation will have the same lexical // context (which will be a namespace scope) as the template. @@ -825,6 +831,20 @@ TemplateDeclInstantiator::VisitCXXMethodDecl(CXXMethodDecl *D, Params[P]->setOwningFunction(Method); Method->setParams(SemaRef.Context, Params.data(), Params.size()); + if (CXXConstructorDecl *Constructor = dyn_cast(Method)) { + // C++ [class.copy]p3: + // [...] A member function template is never instantiated to perform the + // copy of a class object to an object of its class type. + if (FunctionTemplate && !TemplateParams && + Constructor->isCopyConstructor(SemaRef.Context)) { + SemaRef.Diag(Constructor->getLocation(), + diag::err_constructor_template_is_copy_constructor) + << Constructor; + Method->setInvalidDecl(); + return Method; + } + } + if (InitMethodInstantiation(Method, D)) Method->setInvalidDecl(); @@ -843,13 +863,6 @@ TemplateDeclInstantiator::VisitCXXMethodDecl(CXXMethodDecl *D, PrevDecl = 0; } - if (FunctionTemplate && !TemplateParams) - // Record this function template specialization. - Method->setFunctionTemplateSpecialization(SemaRef.Context, - FunctionTemplate, - &TemplateArgs.getInnermost(), - InsertPos); - bool Redeclaration = false; bool OverloadableAttrRequired = false; SemaRef.CheckFunctionDeclaration(Method, PrevDecl, false, Redeclaration, diff --git a/test/SemaCXX/constructor-recovery.cpp b/test/SemaCXX/constructor-recovery.cpp index 50fdc9622e..f2f9f43a10 100644 --- a/test/SemaCXX/constructor-recovery.cpp +++ b/test/SemaCXX/constructor-recovery.cpp @@ -1,10 +1,9 @@ // RUN: clang-cc -fsyntax-only -verify %s -struct C { // expected-note {{candidate function}} - virtual C() = 0; // expected-error{{constructor cannot be declared 'virtual'}} \ - expected-note {{candidate function}} +struct C { + virtual C() = 0; // expected-error{{constructor cannot be declared 'virtual'}} }; void f() { - C c; // expected-error {{call to constructor of 'c' is ambiguous}} + C c; } diff --git a/test/SemaCXX/copy-constructor-error.cpp b/test/SemaCXX/copy-constructor-error.cpp index 2e42fcc3b1..c50a1579bb 100644 --- a/test/SemaCXX/copy-constructor-error.cpp +++ b/test/SemaCXX/copy-constructor-error.cpp @@ -1,13 +1,11 @@ // RUN: clang-cc -fsyntax-only -verify %s -struct S { // expected-note {{candidate function}} - S (S); // expected-error {{copy constructor must pass its first argument by reference}} \\ - // expected-note {{candidate function}} +struct S { + S (S); // expected-error {{copy constructor must pass its first argument by reference}} }; S f(); void g() { - S a( f() ); // expected-error {{call to constructor of 'a' is ambiguous}} + S a( f() ); // expected-error {{no matching constructor}} } - diff --git a/test/SemaTemplate/constructor-template.cpp b/test/SemaTemplate/constructor-template.cpp index 79bf7c585e..f059766356 100644 --- a/test/SemaTemplate/constructor-template.cpp +++ b/test/SemaTemplate/constructor-template.cpp @@ -1,5 +1,4 @@ // RUN: clang-cc -fsyntax-only -verify %s - struct X0 { // expected-note{{candidate}} X0(int); // expected-note{{candidate}} template X0(T); @@ -52,3 +51,22 @@ template struct A {}; template <> struct A{A(const A&);}; struct B { A x; B(B& a) : x(a.x) {} }; +struct X2 { + X2(); + X2(X2&); + template X2(T, int = 17); +}; + +X2 test(bool Cond, X2 x2) { + if (Cond) + return x2; // okay, uses copy constructor + + return X2(); // expected-error{{incompatible type}} +} + +struct X3 { + template X3(T); +}; + +template<> X3::X3(X3); // expected-error{{no function template matches}} + diff --git a/test/SemaTemplate/operator-template.cpp b/test/SemaTemplate/operator-template.cpp index 7039e0ec83..af01a10042 100644 --- a/test/SemaTemplate/operator-template.cpp +++ b/test/SemaTemplate/operator-template.cpp @@ -11,6 +11,8 @@ int a0(A x) { return x == 1; } templatestruct B{typedef X Y;}; templatebool operator==(B*,typename B::Y); // \ expected-error{{overloaded 'operator==' must have at least one parameter of class or enumeration type}} \ -expected-note{{in instantiation of member function}} -int a(B x) { return operator==(&x,1); } +expected-note{{in instantiation of function template specialization}} +int a(B x) { + return operator==(&x,1); // expected-error{{no matching function}} +}