From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 2122) id 4F4343858C3A; Fri, 23 Jun 2023 16:43:26 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 4F4343858C3A DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1687538606; bh=wJjkTxqO5CGHXAqgnRpKmdlhzwTGo4Q+RZUjMGITqcY=; h=From:To:Subject:Date:From; b=lYbk7KrmZ+dUWzqQo9a+/CZ1jWXEUKncgU/hm0DFimNRm1B/ke3Zag5ej2O5qQhNv b1tlvsnRFzTwiKqWpYFUN9mawTTQfmo15efP15Wm5rDbyc6LuDGPvCb4OXDNOeL3PM adY5026deZxyesAO5IMhDpDbFysqqLzCT8V9rh2Y= MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Type: text/plain; charset="utf-8" From: Jason Merrill To: gcc-cvs@gcc.gnu.org Subject: [gcc r13-7470] c++: fix explicit/copy problem [PR109247] X-Act-Checkin: gcc X-Git-Author: Jason Merrill X-Git-Refname: refs/heads/releases/gcc-13 X-Git-Oldrev: 9da2ef362fa8dc54df26c704a38dda40baee3ce9 X-Git-Newrev: dc7f1bfbe5999e4639cf3f3afe70043b49352fdf Message-Id: <20230623164326.4F4343858C3A@sourceware.org> Date: Fri, 23 Jun 2023 16:43:26 +0000 (GMT) List-Id: https://gcc.gnu.org/g:dc7f1bfbe5999e4639cf3f3afe70043b49352fdf commit r13-7470-gdc7f1bfbe5999e4639cf3f3afe70043b49352fdf Author: Jason Merrill Date: Fri May 26 12:28:15 2023 -0400 c++: fix explicit/copy problem [PR109247] In the testcase, the user wants the assignment to use the operator= declared in the class, but because [over.match.list] says that explicit constructors are also considered for list-initialization, as affirmed in CWG1228, we end up choosing the implicitly-declared copy assignment operator, using the explicit constructor template for the argument, which is ill-formed. Other implementations haven't implemented CWG1228, so we keep getting bug reports. Discussion in CWG led to the idea for this targeted relaxation: if we use an explicit constructor for the conversion to the argument of a copy or move special member function, that makes the candidate worse than another. DR 2735 PR c++/109247 gcc/cp/ChangeLog: * call.cc (sfk_copy_or_move): New. (joust): Add tiebreaker for explicit conv and copy ctor. gcc/testsuite/ChangeLog: * g++.dg/cpp0x/initlist-explicit3.C: New test. Diff: --- gcc/cp/call.cc | 31 +++++++++++++++++++++++++ gcc/testsuite/g++.dg/cpp0x/initlist-explicit3.C | 15 ++++++++++++ 2 files changed, 46 insertions(+) diff --git a/gcc/cp/call.cc b/gcc/cp/call.cc index ee290fc03c4..867d7a5bee6 100644 --- a/gcc/cp/call.cc +++ b/gcc/cp/call.cc @@ -12608,6 +12608,17 @@ cand_parms_match (z_candidate *c1, z_candidate *c2) return compparms (parms1, parms2); } +/* True iff FN is a copy or move constructor or assignment operator. */ + +static bool +sfk_copy_or_move (tree fn) +{ + if (TREE_CODE (fn) != FUNCTION_DECL) + return false; + special_function_kind sfk = special_function_p (fn); + return sfk >= sfk_copy_constructor && sfk <= sfk_move_assignment; +} + /* Compare two candidates for overloading as described in [over.match.best]. Return values: @@ -12907,6 +12918,26 @@ joust (struct z_candidate *cand1, struct z_candidate *cand2, bool warn, return winner; } + /* CWG2735 (PR109247): A copy/move ctor/op= for which its operand uses an + explicit conversion (due to list-initialization) is worse. */ + { + z_candidate *sp = nullptr; + if (sfk_copy_or_move (cand1->fn)) + sp = cand1; + if (sfk_copy_or_move (cand2->fn)) + sp = sp ? nullptr : cand2; + if (sp) + { + conversion *conv = sp->convs[!DECL_CONSTRUCTOR_P (sp->fn)]; + if (conv->user_conv_p) + for (; conv; conv = next_conversion (conv)) + if (conv->kind == ck_user + && DECL_P (conv->cand->fn) + && DECL_NONCONVERTING_P (conv->cand->fn)) + return (sp == cand1) ? -1 : 1; + } + } + /* or, if not that, F1 is a non-template function and F2 is a template function specialization. */ diff --git a/gcc/testsuite/g++.dg/cpp0x/initlist-explicit3.C b/gcc/testsuite/g++.dg/cpp0x/initlist-explicit3.C new file mode 100644 index 00000000000..b0c92784566 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/initlist-explicit3.C @@ -0,0 +1,15 @@ +// PR c++/109247 +// { dg-do compile { target c++11 } } + +template struct optional { + template explicit optional(_Up); + template void operator=(_Up); +}; +int setPattern_pattern; +struct SourceBrush { + struct Brush { + int brush; + }; + void setPattern() { m_brush = {setPattern_pattern}; } + optional m_brush; +};