From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 1698) id 7C4663851C03; Mon, 29 Jun 2020 19:19:10 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 7C4663851C03 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1593458350; bh=zhiqFJCxr3ZxMgNehEj67fXeyr7EEot57sjxo1c6s2U=; h=From:To:Subject:Date:From; b=HiIUGFXxDr70iWa6qnQlzOea75U2z1GnxCDixFgWlPrIaVKVmX4Us6e5qIXTf31gl ReQ9j9Y+/ushvajHmsGRohvOxc8ncZPH+6TlQnVeosJ6mDgEe475ve5uF/35AGrABA E1rgYWc86SY/K401oXqidJpuDmj9uFkjRCKh3qZw= Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: Iain D Sandoe To: gcc-cvs@gcc.gnu.org Subject: [gcc/devel/c++-coroutines] c++: Fix CTAD for aggregates in template [PR95568] X-Act-Checkin: gcc X-Git-Author: Marek Polacek X-Git-Refname: refs/heads/devel/c++-coroutines X-Git-Oldrev: e6cc67f6616c96f3e18a434e0c74ba2f3818cb6d X-Git-Newrev: b1005f553d3543bb56dc6b9b34ee35455d697ca4 Message-Id: <20200629191910.7C4663851C03@sourceware.org> Date: Mon, 29 Jun 2020 19:19:10 +0000 (GMT) X-BeenThere: gcc-cvs@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Mon, 29 Jun 2020 19:19:10 -0000 https://gcc.gnu.org/g:b1005f553d3543bb56dc6b9b34ee35455d697ca4 commit b1005f553d3543bb56dc6b9b34ee35455d697ca4 Author: Marek Polacek Date: Tue Jun 23 18:07:34 2020 -0400 c++: Fix CTAD for aggregates in template [PR95568] 95568 complains that CTAD for aggregates doesn't work within requires-clause and it turned out that it doesn't work when we try the deduction in a template. The reason is that maybe_aggr_guide creates a guide that can look like this template X(decltype (X::x))-> X where the parameter is a decltype, which is a non-deduced context. So the subsequent build_new_function_call fails because unify_one_argument can't deduce anything from it ([temp.deduct.type]: "If a template parameter is used only in non-deduced contexts and is not explicitly specified, template argument deduction fails.") Those decltypes come from finish_decltype_type. We can just use TREE_TYPE instead. I pondered using unlowered_expr_type, but that didn't make any difference for the FIELD_DECLs I saw in class-deduction-aggr6.C. gcc/cp/ChangeLog: PR c++/95568 * pt.c (collect_ctor_idx_types): Use TREE_TYPE. gcc/testsuite/ChangeLog: PR c++/95568 * g++.dg/cpp2a/class-deduction-aggr5.C: New test. * g++.dg/cpp2a/class-deduction-aggr6.C: New test. Diff: --- gcc/cp/pt.c | 2 +- gcc/testsuite/g++.dg/cpp2a/class-deduction-aggr5.C | 20 +++++++++++++ gcc/testsuite/g++.dg/cpp2a/class-deduction-aggr6.C | 35 ++++++++++++++++++++++ 3 files changed, 56 insertions(+), 1 deletion(-) diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c index 53a64c3a15e..618bf68b2d6 100644 --- a/gcc/cp/pt.c +++ b/gcc/cp/pt.c @@ -28329,7 +28329,7 @@ collect_ctor_idx_types (tree ctor, tree list, tree elt = NULL_TREE) tree idx, val; unsigned i; FOR_EACH_CONSTRUCTOR_ELT (v, i, idx, val) { - tree ftype = elt ? elt : finish_decltype_type (idx, true, tf_none); + tree ftype = elt ? elt : TREE_TYPE (idx); if (BRACE_ENCLOSED_INITIALIZER_P (val) && CONSTRUCTOR_NELTS (val) /* As in reshape_init_r, a non-aggregate or array-of-dependent-bound diff --git a/gcc/testsuite/g++.dg/cpp2a/class-deduction-aggr5.C b/gcc/testsuite/g++.dg/cpp2a/class-deduction-aggr5.C new file mode 100644 index 00000000000..01253f42006 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp2a/class-deduction-aggr5.C @@ -0,0 +1,20 @@ +// PR c++/95568 +// { dg-do compile { target c++20 } } + +template struct X { T x; }; +template struct X2 { T x; U y; }; +template concept Y = requires { X{0}; }; + +template +void g() +{ + X{0}; + X2{1, 2.2}; + Y auto y = X{1}; +} + +void +fn () +{ + g(); +} diff --git a/gcc/testsuite/g++.dg/cpp2a/class-deduction-aggr6.C b/gcc/testsuite/g++.dg/cpp2a/class-deduction-aggr6.C new file mode 100644 index 00000000000..95d7c5eec18 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp2a/class-deduction-aggr6.C @@ -0,0 +1,35 @@ +// PR c++/95568 +// { dg-do compile { target c++20 } } +// CTAD with aggregates containing bit-fields. + +template struct same_type; +template struct same_type {}; + +enum E { e }; +enum class F { f }; + +template +struct X { + T a : 5; +}; + +template +void g() +{ + auto x = X{ 0 }; + same_type(); + auto x2 = X{ E::e }; + same_type(); + auto x3 = X{ false }; + same_type(); + auto x4 = X{ 0u }; + same_type(); + auto x5 = X{ F::f }; + same_type(); +} + +void +fn () +{ + g(); +}