aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--include/clang/Basic/DiagnosticSemaKinds.td2
-rw-r--r--lib/AST/DeclCXX.cpp16
-rw-r--r--lib/Sema/SemaDecl.cpp3
-rw-r--r--lib/Sema/SemaOverload.cpp4
-rw-r--r--lib/Sema/SemaTemplateDeduction.cpp2
-rw-r--r--lib/Sema/SemaTemplateInstantiateDecl.cpp47
-rw-r--r--test/SemaCXX/constructor-recovery.cpp7
-rw-r--r--test/SemaCXX/copy-constructor-error.cpp8
-rw-r--r--test/SemaTemplate/constructor-template.cpp20
-rw-r--r--test/SemaTemplate/operator-template.cpp6
10 files changed, 39 insertions, 76 deletions
diff --git a/include/clang/Basic/DiagnosticSemaKinds.td b/include/clang/Basic/DiagnosticSemaKinds.td
index 7f44d53411..2cc29caa01 100644
--- a/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/include/clang/Basic/DiagnosticSemaKinds.td
@@ -487,8 +487,6 @@ 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 69a577f1e7..e325a25c76 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.
- CanQualType PointeeType = Context.getCanonicalType(Param->getType());
- if (CanQual<LValueReferenceType> ParamRefType =
- PointeeType->getAs<LValueReferenceType>())
- PointeeType = ParamRefType->getPointeeType();
+ const LValueReferenceType *ParamRefType =
+ Param->getType()->getAs<LValueReferenceType>();
+ if (!ParamRefType)
+ return false;
- // Do we have our class type?
+ // Is it a reference to our class type?
+ CanQualType PointeeType
+ = Context.getCanonicalType(ParamRefType->getPointeeType());
CanQualType ClassTy
= Context.getCanonicalType(Context.getTagDeclType(getParent()));
if (PointeeType.getUnqualifiedType() != ClassTy)
diff --git a/lib/Sema/SemaDecl.cpp b/lib/Sema/SemaDecl.cpp
index 30d046f3b9..fa31cc5ddb 100644
--- a/lib/Sema/SemaDecl.cpp
+++ b/lib/Sema/SemaDecl.cpp
@@ -3909,9 +3909,6 @@ 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 70b080e678..3948b22f7b 100644
--- a/lib/Sema/SemaOverload.cpp
+++ b/lib/Sema/SemaOverload.cpp
@@ -2237,9 +2237,7 @@ Sema::AddOverloadCandidate(FunctionDecl *Function,
// argument doesn't participate in overload resolution.
}
- // 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())
+ if (!CandidateSet.isNewCandidate(Function))
return;
// Add this candidate
diff --git a/lib/Sema/SemaTemplateDeduction.cpp b/lib/Sema/SemaTemplateDeduction.cpp
index fcec654334..244bb37c37 100644
--- a/lib/Sema/SemaTemplateDeduction.cpp
+++ b/lib/Sema/SemaTemplateDeduction.cpp
@@ -1286,7 +1286,7 @@ Sema::FinishTemplateArgumentDeduction(FunctionTemplateDecl *FunctionTemplate,
for (unsigned I = 0, N = Deduced.size(); I != N; ++I) {
if (Deduced[I].isNull()) {
Info.Param = makeTemplateParameter(
- const_cast<NamedDecl *>(TemplateParams->getParam(I)));
+ const_cast<NamedDecl *>(TemplateParams->getParam(I)));
return TDK_Incomplete;
}
diff --git a/lib/Sema/SemaTemplateInstantiateDecl.cpp b/lib/Sema/SemaTemplateInstantiateDecl.cpp
index 0e42bd65db..47d2701bcd 100644
--- a/lib/Sema/SemaTemplateInstantiateDecl.cpp
+++ b/lib/Sema/SemaTemplateInstantiateDecl.cpp
@@ -658,12 +658,6 @@ 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))
@@ -715,6 +709,14 @@ 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;
}
@@ -809,17 +811,9 @@ TemplateDeclInstantiator::VisitCXXMethodDecl(CXXMethodDecl *D,
if (D->isOutOfLine())
FunctionTemplate->setLexicalDeclContext(D->getLexicalDeclContext());
Method->setDescribedFunctionTemplate(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.
+ } else if (!FunctionTemplate)
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.
@@ -831,20 +825,6 @@ TemplateDeclInstantiator::VisitCXXMethodDecl(CXXMethodDecl *D,
Params[P]->setOwningFunction(Method);
Method->setParams(SemaRef.Context, Params.data(), Params.size());
- if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(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();
@@ -863,6 +843,13 @@ 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 f2f9f43a10..50fdc9622e 100644
--- a/test/SemaCXX/constructor-recovery.cpp
+++ b/test/SemaCXX/constructor-recovery.cpp
@@ -1,9 +1,10 @@
// RUN: clang-cc -fsyntax-only -verify %s
-struct C {
- virtual C() = 0; // expected-error{{constructor cannot be declared 'virtual'}}
+struct C { // expected-note {{candidate function}}
+ virtual C() = 0; // expected-error{{constructor cannot be declared 'virtual'}} \
+ expected-note {{candidate function}}
};
void f() {
- C c;
+ C c; // expected-error {{call to constructor of 'c' is ambiguous}}
}
diff --git a/test/SemaCXX/copy-constructor-error.cpp b/test/SemaCXX/copy-constructor-error.cpp
index c50a1579bb..2e42fcc3b1 100644
--- a/test/SemaCXX/copy-constructor-error.cpp
+++ b/test/SemaCXX/copy-constructor-error.cpp
@@ -1,11 +1,13 @@
// RUN: clang-cc -fsyntax-only -verify %s
-struct S {
- S (S); // expected-error {{copy constructor must pass its first argument by reference}}
+struct S { // expected-note {{candidate function}}
+ S (S); // expected-error {{copy constructor must pass its first argument by reference}} \\
+ // expected-note {{candidate function}}
};
S f();
void g() {
- S a( f() ); // expected-error {{no matching constructor}}
+ S a( f() ); // expected-error {{call to constructor of 'a' is ambiguous}}
}
+
diff --git a/test/SemaTemplate/constructor-template.cpp b/test/SemaTemplate/constructor-template.cpp
index f059766356..79bf7c585e 100644
--- a/test/SemaTemplate/constructor-template.cpp
+++ b/test/SemaTemplate/constructor-template.cpp
@@ -1,4 +1,5 @@
// RUN: clang-cc -fsyntax-only -verify %s
+
struct X0 { // expected-note{{candidate}}
X0(int); // expected-note{{candidate}}
template<typename T> X0(T);
@@ -51,22 +52,3 @@ template<class C> struct A {};
template <> struct A<int>{A(const A<int>&);};
struct B { A<int> x; B(B& a) : x(a.x) {} };
-struct X2 {
- X2();
- X2(X2&);
- template<typename T> 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<typename T> 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 af01a10042..7039e0ec83 100644
--- a/test/SemaTemplate/operator-template.cpp
+++ b/test/SemaTemplate/operator-template.cpp
@@ -11,8 +11,6 @@ int a0(A<int> x) { return x == 1; }
template<class X>struct B{typedef X Y;};
template<class X>bool operator==(B<X>*,typename B<X>::Y); // \
expected-error{{overloaded 'operator==' must have at least one parameter of class or enumeration type}} \
-expected-note{{in instantiation of function template specialization}}
-int a(B<int> x) {
- return operator==(&x,1); // expected-error{{no matching function}}
-}
+expected-note{{in instantiation of member function}}
+int a(B<int> x) { return operator==(&x,1); }
generated by cgit v1.2.3-18-g5258 (git 2.32.0) at 2025-08-03 15:08:40 +0000