From patchwork Tue Jun 22 18:45:14 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Patrick Palka X-Patchwork-Id: 1495827 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=gcc.gnu.org (client-ip=8.43.85.97; helo=sourceware.org; envelope-from=gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=) Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.a=rsa-sha256 header.s=default header.b=tZI4poM/; dkim-atps=neutral Received: from sourceware.org (ip-8-43-85-97.sourceware.org [8.43.85.97]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 4G8b2t2g7Gz9sCD for ; Wed, 23 Jun 2021 04:46:28 +1000 (AEST) Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 5B6453951C68 for ; Tue, 22 Jun 2021 18:46:26 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 5B6453951C68 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org; s=default; t=1624387586; bh=cKpG+MvD5I0gkkX4ZoxOkB1IlegYenLPDv6Kv3hySzE=; h=To:Subject:Date:List-Id:List-Unsubscribe:List-Archive:List-Post: List-Help:List-Subscribe:From:Reply-To:Cc:From; b=tZI4poM/881FFtkclNteXM4ssfJTkkFf2aXhpMOIMkNVSH1i9Ep4NDZU9iiHhM1ag R1eZV1pvw4InYDaf4eA11/dMRmaNMiqOoMhrHbEgNdpdb1bT5R/byHNLevZncyVnGF kvPjl/o0aKO2UegxJmIQOoFwH62Y2Eue0FiTByHM= X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by sourceware.org (Postfix) with ESMTP id 1BF653950C17 for ; Tue, 22 Jun 2021 18:45:20 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 1BF653950C17 Received: from mail-qv1-f70.google.com (mail-qv1-f70.google.com [209.85.219.70]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-448-e144iWdUMHiQy31E0y1jkw-1; Tue, 22 Jun 2021 14:45:18 -0400 X-MC-Unique: e144iWdUMHiQy31E0y1jkw-1 Received: by mail-qv1-f70.google.com with SMTP id b2-20020a0cf0420000b029025f56d0b50dso152602qvl.0 for ; Tue, 22 Jun 2021 11:45:18 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:mime-version :content-transfer-encoding; bh=cKpG+MvD5I0gkkX4ZoxOkB1IlegYenLPDv6Kv3hySzE=; b=oJd0gar4l+VXKpAha1Be7nkYafTjWlo5uRko8Jh15mWSAwdV01UpYb5sBQBRdJw8gS n0gTnfKgPs2vqiKogCYBIwrp3E0OYYySFXrTAGe8C+1H4YghWb0ZwBqy4kaL+JusFxfb hYv4RZNcMGd+DPfnmkQQWKR9v59K0Y7Tj//JtGDNTRBkp1TJsSyLH2sPGOFtW2TuLsbv kIxsOtlncHPN+E3T/Z80gZsGfsKsAU2oA6VMyRCL/TOYdAnVHYzN0l63dMDongcvl6OW ZTJVO4YcDnTsgVkuM36J+TJ1N0hqKQq9a+SD3jYiZ92nwybBk8yxrXdNrWVuJYB2A7UA YmCg== X-Gm-Message-State: AOAM530g+mkfMUA3ClpbWC36Y6PHihGQwU5CRWmkYZ1dgGS7ePX1btxs u8fSmI5iVVCIOydXqVecSUkcZH1Wo3RPSjhFNux9ufDRgkvUy1IN5/GXmiILio3FwdNidCXtrbD xiJf+Tv8JzB/kg96vcK1Rk8gQigVd4MMXlpQev/SCucv97zW7zfNgU1CxSF06ld4MBZo= X-Received: by 2002:ac8:7412:: with SMTP id p18mr181262qtq.49.1624387517455; Tue, 22 Jun 2021 11:45:17 -0700 (PDT) X-Google-Smtp-Source: ABdhPJzSHbsAtY8244juTnW9j0qmeuz46rTYrOck0umV4buRlLaSw5jdjkJiCy1h3rr7D/p+D5lcag== X-Received: by 2002:ac8:7412:: with SMTP id p18mr181227qtq.49.1624387517000; Tue, 22 Jun 2021 11:45:17 -0700 (PDT) Received: from localhost.localdomain (ool-457d493a.dyn.optonline.net. [69.125.73.58]) by smtp.gmail.com with ESMTPSA id w22sm12587845qkf.61.2021.06.22.11.45.16 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 22 Jun 2021 11:45:16 -0700 (PDT) To: gcc-patches@gcc.gnu.org Subject: [PATCH] c++: CTAD and deduction guide selection [PR86439] Date: Tue, 22 Jun 2021 14:45:14 -0400 Message-Id: <20210622184514.1337889-1-ppalka@redhat.com> X-Mailer: git-send-email 2.32.0.93.g670b81a890 MIME-Version: 1.0 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com X-Spam-Status: No, score=-16.0 required=5.0 tests=BAYES_00, DKIMWL_WL_HIGH, DKIM_SIGNED, DKIM_VALID, DKIM_VALID_AU, DKIM_VALID_EF, GIT_PATCH_0, RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H4, RCVD_IN_MSPIKE_WL, SPF_HELO_NONE, SPF_PASS, TXREP autolearn=unavailable autolearn_force=no version=3.4.2 X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-Patchwork-Original-From: Patrick Palka via Gcc-patches From: Patrick Palka Reply-To: Patrick Palka Cc: libstdc++@gcc.gnu.org, jason@gcc.gnu.org Errors-To: gcc-patches-bounces+incoming=patchwork.ozlabs.org@gcc.gnu.org Sender: "Gcc-patches" During CTAD, we select the best viable deduction guide via build_new_function_call, which performs overload resolution on the set of candidate guides and then forms a call to the guide. As the PR points out, this latter step is unnecessary and occasionally gives us the wrong answer since a call to the selected guide may be ill-formed, or forming the call may have side effects such as prematurely deducing the type of a {}. This patch introduces a specialized subroutine modeled off of build_new_function_call that stops short of building a call to the selected function, and makes do_class_deduction use this subroutine instead. And since we no longer build a call, do_class_deduction doesn't need to set tf_decltype or cp_unevaluated_operand. This change causes us to reject some container CTAD examples in the libstdc++ testsuite due to deduction failure for {}, which AFAICT is the correct behavior. Previously, in the case of e.g. the first removed example for std::map, the type of {} would be deduced to less as a side effect of forming the call to the selected guide template, typename _Allocator = allocator>, typename = _RequireNotAllocator<_Compare>, typename = _RequireAllocator<_Allocator>> map(initializer_list>, _Compare = _Compare(), _Allocator = _Allocator()) -> map<_Key, _Tp, _Compare, _Allocator>; which made later overload resolution for the constructor call unambiguous. Now, the type of {} remains undeduced until constructor overload resolution, and we complain about ambiguity with the two constructors map(initializer_list __l, const _Compare& __comp = _Compare(), const allocator_type& __a = allocator_type()) map(initializer_list __l, const allocator_type& __a) This patch just removes these problematic container CTAD examples. Bootstrapped and regtested on x86_64-pc-linux-gnu, does this look OK for trunk? PR c++/86439 gcc/cp/ChangeLog: * call.c (print_error_for_call_failure): Constify 'args' parameter. (perform_dguide_overload_resolution): Define. * cp-tree.h: (perform_dguide_overload_resolution): Declare. * pt.c (do_class_deduction): Use perform_dguide_overload_resolution instead of build_new_function_call. Don't use tf_decltype or set cp_unevaluated_operand. Remove unnecessary NULL_TREE tests. libstdc++-v3/ChangeLog: * testsuite/23_containers/map/cons/deduction.cc: Remove ambiguous CTAD constructs. * testsuite/23_containers/multimap/cons/deduction.cc: Likewise. * testsuite/23_containers/multiset/cons/deduction.cc: Likewise. * testsuite/23_containers/set/cons/deduction.cc: Likewise. * testsuite/23_containers/unordered_map/cons/deduction.cc: Likewise. * testsuite/23_containers/unordered_multimap/cons/deduction.cc: Likewise. * testsuite/23_containers/unordered_multiset/cons/deduction.cc: Likewise. * testsuite/23_containers/unordered_set/cons/deduction.cc: Likewise. gcc/testsuite/ChangeLog: * g++.dg/cpp1z/class-deduction88.C: New test. * g++.dg/cpp1z/class-deduction89.C: New test. * g++.dg/cpp1z/class-deduction90.C: New test. --- gcc/cp/call.c | 36 +++++++++++++++- gcc/cp/cp-tree.h | 2 + gcc/cp/pt.c | 41 +++++++------------ .../g++.dg/cpp1z/class-deduction88.C | 20 +++++++++ .../g++.dg/cpp1z/class-deduction89.C | 15 +++++++ .../g++.dg/cpp1z/class-deduction90.C | 16 ++++++++ .../23_containers/map/cons/deduction.cc | 19 --------- .../23_containers/multimap/cons/deduction.cc | 20 --------- .../23_containers/multiset/cons/deduction.cc | 14 ------- .../23_containers/set/cons/deduction.cc | 15 ------- .../unordered_map/cons/deduction.cc | 16 -------- .../unordered_multimap/cons/deduction.cc | 16 -------- .../unordered_multiset/cons/deduction.cc | 10 ----- .../unordered_set/cons/deduction.cc | 10 ----- 14 files changed, 102 insertions(+), 148 deletions(-) create mode 100644 gcc/testsuite/g++.dg/cpp1z/class-deduction88.C create mode 100644 gcc/testsuite/g++.dg/cpp1z/class-deduction89.C create mode 100644 gcc/testsuite/g++.dg/cpp1z/class-deduction90.C diff --git a/gcc/cp/call.c b/gcc/cp/call.c index 9f03534c20c..aafc7acca24 100644 --- a/gcc/cp/call.c +++ b/gcc/cp/call.c @@ -4629,7 +4629,7 @@ perform_overload_resolution (tree fn, functions. */ static void -print_error_for_call_failure (tree fn, vec *args, +print_error_for_call_failure (tree fn, const vec *args, struct z_candidate *candidates) { tree targs = NULL_TREE; @@ -4654,6 +4654,40 @@ print_error_for_call_failure (tree fn, vec *args, print_z_candidates (loc, candidates); } +/* Perform overload resolution on the set of deduction guides DGUIDES + using ARGS. Returns the selected deduction guide, or error_mark_node + if overload resolution fails. */ + +tree +perform_dguide_overload_resolution (tree dguides, const vec *args, + tsubst_flags_t complain) +{ + z_candidate *candidates; + bool any_viable_p; + tree result; + + gcc_assert (deduction_guide_p (OVL_FIRST (dguides))); + + /* Get the high-water mark for the CONVERSION_OBSTACK. */ + void *p = conversion_obstack_alloc (0); + + z_candidate *cand = perform_overload_resolution (dguides, args, &candidates, + &any_viable_p, complain); + if (!cand) + { + if (complain & tf_error) + print_error_for_call_failure (dguides, args, candidates); + result = error_mark_node; + } + else + result = cand->fn; + + /* Free all the conversions we allocated. */ + obstack_free (&conversion_obstack, p); + + return result; +} + /* Return an expression for a call to FN (a namespace-scope function, or a static member function) with the ARGS. This may change ARGS. */ diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index 36f99ccf189..6f713719589 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -6437,6 +6437,8 @@ extern void complain_about_bad_argument (location_t arg_loc, tree from_type, tree to_type, tree fndecl, int parmnum); extern void maybe_inform_about_fndecl_for_bogus_argument_init (tree, int); +extern tree perform_dguide_overload_resolution (tree, const vec *, + tsubst_flags_t); /* A class for recording information about access failures (e.g. private diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c index 15947b2c812..732fb405adf 100644 --- a/gcc/cp/pt.c +++ b/gcc/cp/pt.c @@ -29382,7 +29382,7 @@ do_class_deduction (tree ptype, tree tmpl, tree init, if (tree guide = maybe_aggr_guide (tmpl, init, args)) cands = lookup_add (guide, cands); - tree call = error_mark_node; + tree fndecl = error_mark_node; /* If this is list-initialization and the class has a list constructor, first try deducing from the list as a single argument, as [over.match.list]. */ @@ -29396,11 +29396,9 @@ do_class_deduction (tree ptype, tree tmpl, tree init, } if (list_cands) { - ++cp_unevaluated_operand; - call = build_new_function_call (list_cands, &args, tf_decltype); - --cp_unevaluated_operand; + fndecl = perform_dguide_overload_resolution (list_cands, args, tf_none); - if (call == error_mark_node) + if (fndecl == error_mark_node) { /* That didn't work, now try treating the list as a sequence of arguments. */ @@ -29416,31 +29414,22 @@ do_class_deduction (tree ptype, tree tmpl, tree init, "user-declared constructors", type); return error_mark_node; } - else if (!cands && call == error_mark_node) + else if (!cands && fndecl == error_mark_node) { error ("cannot deduce template arguments of %qT, as it has no viable " "deduction guides", type); return error_mark_node; } - if (call == error_mark_node) - { - ++cp_unevaluated_operand; - call = build_new_function_call (cands, &args, tf_decltype); - --cp_unevaluated_operand; - } + if (fndecl == error_mark_node) + fndecl = perform_dguide_overload_resolution (cands, args, tf_none); - if (call == error_mark_node) + if (fndecl == error_mark_node) { if (complain & tf_warning_or_error) { error ("class template argument deduction failed:"); - - ++cp_unevaluated_operand; - call = build_new_function_call (cands, &args, - complain | tf_decltype); - --cp_unevaluated_operand; - + perform_dguide_overload_resolution (cands, args, complain); if (elided) inform (input_location, "explicit deduction guides not considered " "for copy-initialization"); @@ -29451,8 +29440,7 @@ do_class_deduction (tree ptype, tree tmpl, tree init, constructor is chosen, the initialization is ill-formed. */ else if (flags & LOOKUP_ONLYCONVERTING) { - tree fndecl = cp_get_callee_fndecl_nofold (call); - if (fndecl && DECL_NONCONVERTING_P (fndecl)) + if (DECL_NONCONVERTING_P (fndecl)) { if (complain & tf_warning_or_error) { @@ -29470,12 +29458,10 @@ do_class_deduction (tree ptype, tree tmpl, tree init, /* If CTAD succeeded but the type doesn't have any explicit deduction guides, this deduction might not be what the user intended. */ - if (call != error_mark_node && !any_dguides_p) + if (fndecl != error_mark_node && !any_dguides_p) { - tree fndecl = cp_get_callee_fndecl_nofold (call); - if (fndecl != NULL_TREE - && (!DECL_IN_SYSTEM_HEADER (fndecl) - || global_dc->dc_warn_system_headers) + if ((!DECL_IN_SYSTEM_HEADER (fndecl) + || global_dc->dc_warn_system_headers) && warning (OPT_Wctad_maybe_unsupported, "%qT may not intend to support class template argument " "deduction", type)) @@ -29483,7 +29469,8 @@ do_class_deduction (tree ptype, tree tmpl, tree init, "warning"); } - return cp_build_qualified_type (TREE_TYPE (call), cp_type_quals (ptype)); + return cp_build_qualified_type (TREE_TYPE (TREE_TYPE (fndecl)), + cp_type_quals (ptype)); } /* Replace occurrences of 'auto' in TYPE with the appropriate type deduced diff --git a/gcc/testsuite/g++.dg/cpp1z/class-deduction88.C b/gcc/testsuite/g++.dg/cpp1z/class-deduction88.C new file mode 100644 index 00000000000..f8fea966696 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp1z/class-deduction88.C @@ -0,0 +1,20 @@ +// PR c++/86439 +// { dg-do compile { target c++17 } } + +struct NC { + NC() = default; + NC(NC const&) = delete; + NC& operator=(NC const&) = delete; +}; + +template +struct C { + C(NC const&); +}; + +C(NC) -> C<0>; + +int main() { + NC nc; + C c(nc); +} diff --git a/gcc/testsuite/g++.dg/cpp1z/class-deduction89.C b/gcc/testsuite/g++.dg/cpp1z/class-deduction89.C new file mode 100644 index 00000000000..dd898573022 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp1z/class-deduction89.C @@ -0,0 +1,15 @@ +// PR c++/86439 +// { dg-do compile { target c++17 } } + +struct B { }; +struct C { }; + +template +struct A { + A(T, B); +}; + +template +A(T, C) -> A; + +A a(0, {}); diff --git a/gcc/testsuite/g++.dg/cpp1z/class-deduction90.C b/gcc/testsuite/g++.dg/cpp1z/class-deduction90.C new file mode 100644 index 00000000000..8b93193c7b0 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp1z/class-deduction90.C @@ -0,0 +1,16 @@ +// PR c++/86439 +// { dg-do compile { target c++17 } } + +struct less { }; +struct allocator { }; + +template +struct A { + A(T, U); + A(T, V); +}; + +template +A(T, U) -> A; + +A a(0, {}); // { dg-error "ambiguous" } diff --git a/libstdc++-v3/testsuite/23_containers/map/cons/deduction.cc b/libstdc++-v3/testsuite/23_containers/map/cons/deduction.cc index e9628c4ac32..8def11ed574 100644 --- a/libstdc++-v3/testsuite/23_containers/map/cons/deduction.cc +++ b/libstdc++-v3/testsuite/23_containers/map/cons/deduction.cc @@ -39,10 +39,6 @@ static_assert(std::is_same_v< std::map>); */ -static_assert(std::is_same_v< - decltype(std::map{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}}, {}}), - std::map>); - /* This is not deducible, ambiguous candidates: * map(initializer_list, const Compare&, const _Allocator& = {}) * map(initializer_list, const _Allocator&) @@ -90,11 +86,6 @@ void f() std::less{}, {}}), std::map>); - static_assert(std::is_same_v< - decltype(std::map(x.begin(), x.end(), - {})), - std::map>); - static_assert(std::is_same_v< decltype(std::map{x.begin(), x.end(), std::allocator{}}), @@ -143,11 +134,6 @@ void g() std::less{}, {}}), std::map>); - static_assert(std::is_same_v< - decltype(std::map(x.begin(), x.end(), - {})), - std::map>); - static_assert(std::is_same_v< decltype(std::map{x.begin(), x.end(), std::allocator{}}), @@ -193,11 +179,6 @@ void h() std::less{}, {}}), std::map>); - static_assert(std::is_same_v< - decltype(std::map(x.begin(), x.end(), - {})), - std::map>); - static_assert(std::is_same_v< decltype(std::map{x.begin(), x.end(), std::allocator{}}), diff --git a/libstdc++-v3/testsuite/23_containers/multimap/cons/deduction.cc b/libstdc++-v3/testsuite/23_containers/multimap/cons/deduction.cc index 791cc963479..ff855081ab3 100644 --- a/libstdc++-v3/testsuite/23_containers/multimap/cons/deduction.cc +++ b/libstdc++-v3/testsuite/23_containers/multimap/cons/deduction.cc @@ -40,11 +40,6 @@ static_assert(std::is_same_v< std::multimap>); */ -static_assert(std::is_same_v< - decltype(std::multimap{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}}, - {}}), - std::multimap>); - static_assert(std::is_same_v< decltype(std::multimap{{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}}, {}, SimpleAllocator{}}), @@ -75,11 +70,6 @@ void f() std::less{}, {}}), std::multimap>); - static_assert(std::is_same_v< - decltype(std::multimap(x.begin(), x.end(), - {})), - std::multimap>); - static_assert(std::is_same_v< decltype(std::multimap{x.begin(), x.end(), {}, @@ -117,11 +107,6 @@ void g() std::less{}, {}}), std::multimap>); - static_assert(std::is_same_v< - decltype(std::multimap(x.begin(), x.end(), - {})), - std::multimap>); - static_assert(std::is_same_v< decltype(std::multimap{x.begin(), x.end(), {}, @@ -156,11 +141,6 @@ void h() std::less{}, {}}), std::multimap>); - static_assert(std::is_same_v< - decltype(std::multimap(x.begin(), x.end(), - {})), - std::multimap>); - static_assert(std::is_same_v< decltype(std::multimap{x.begin(), x.end(), {}, diff --git a/libstdc++-v3/testsuite/23_containers/multiset/cons/deduction.cc b/libstdc++-v3/testsuite/23_containers/multiset/cons/deduction.cc index ad12755ccc6..be7ca237e78 100644 --- a/libstdc++-v3/testsuite/23_containers/multiset/cons/deduction.cc +++ b/libstdc++-v3/testsuite/23_containers/multiset/cons/deduction.cc @@ -19,10 +19,6 @@ static_assert(std::is_same_v< decltype(std::multiset{{1, 2, 3}, std::less{}, {}}), std::multiset>); -static_assert(std::is_same_v< - decltype(std::multiset{{1, 2, 3}, {}}), - std::multiset>); - static_assert(std::is_same_v< decltype(std::multiset{{1, 2, 3}, SimpleAllocator{}}), std::multiset, SimpleAllocator>>); @@ -50,11 +46,6 @@ void f() std::less{}, {}}), std::multiset>); - static_assert(std::is_same_v< - decltype(std::multiset(x.begin(), x.end(), - {})), - std::multiset>); - static_assert(std::is_same_v< decltype(std::multiset{x.begin(), x.end(), std::allocator{}}), @@ -101,11 +92,6 @@ void g() std::less{}, {}}), std::multiset>); - static_assert(std::is_same_v< - decltype(std::multiset(x.begin(), x.end(), - {})), - std::multiset>); - static_assert(std::is_same_v< decltype(std::multiset{x.begin(), x.end(), std::allocator{}}), diff --git a/libstdc++-v3/testsuite/23_containers/set/cons/deduction.cc b/libstdc++-v3/testsuite/23_containers/set/cons/deduction.cc index 89a2c43b937..48d1a3ebbe2 100644 --- a/libstdc++-v3/testsuite/23_containers/set/cons/deduction.cc +++ b/libstdc++-v3/testsuite/23_containers/set/cons/deduction.cc @@ -20,11 +20,6 @@ static_assert(std::is_same_v< std::less{}, {}}), std::set>); -static_assert(std::is_same_v< - decltype(std::set{{1, 2, 3}, - {}}), - std::set>); - static_assert(std::is_same_v< decltype(std::set{{1, 2, 3}, SimpleAllocator{}}), @@ -56,11 +51,6 @@ void f() std::less{}, {}}), std::set>); - static_assert(std::is_same_v< - decltype(std::set(x.begin(), x.end(), - {})), - std::set>); - static_assert(std::is_same_v< decltype(std::set{x.begin(), x.end(), {}, @@ -102,11 +92,6 @@ void g() std::less{}, {}}), std::set>); - static_assert(std::is_same_v< - decltype(std::set(x.begin(), x.end(), - {})), - std::set>); - static_assert(std::is_same_v< decltype(std::set{x.begin(), x.end(), std::allocator{}}), diff --git a/libstdc++-v3/testsuite/23_containers/unordered_map/cons/deduction.cc b/libstdc++-v3/testsuite/23_containers/unordered_map/cons/deduction.cc index d8489b23f8a..bd266492b2a 100644 --- a/libstdc++-v3/testsuite/23_containers/unordered_map/cons/deduction.cc +++ b/libstdc++-v3/testsuite/23_containers/unordered_map/cons/deduction.cc @@ -21,12 +21,6 @@ static_assert(std::is_same_v< 1}), std::unordered_map>); -static_assert(std::is_same_v< - decltype(std::unordered_map{{std::pair{1, 2.0}, - {2, 3.0}, {3, 4.0}}, - {}, std::hash{}, {}}), - std::unordered_map>); - static_assert(std::is_same_v< decltype(std::unordered_map{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}}, @@ -57,16 +51,6 @@ void f() std::allocator>{}}), std::unordered_map>); - static_assert(std::is_same_v< - decltype(std::unordered_map{x.begin(), x.end(), - {}, std::hash{}, {}}), - std::unordered_map>); - - static_assert(std::is_same_v< - decltype(std::unordered_map(x.begin(), x.end(), - {})), - std::unordered_map>); - static_assert(std::is_same_v< decltype(std::unordered_map{x.begin(), x.end(), 1}), std::unordered_map>); diff --git a/libstdc++-v3/testsuite/23_containers/unordered_multimap/cons/deduction.cc b/libstdc++-v3/testsuite/23_containers/unordered_multimap/cons/deduction.cc index 13f54d43451..74a0165574d 100644 --- a/libstdc++-v3/testsuite/23_containers/unordered_multimap/cons/deduction.cc +++ b/libstdc++-v3/testsuite/23_containers/unordered_multimap/cons/deduction.cc @@ -15,12 +15,6 @@ static_assert(std::is_same_v< {2, 3.0}, {3, 4.0}}}), std::unordered_multimap>); -static_assert(std::is_same_v< - decltype(std::unordered_multimap{{std::pair{1, 2.0}, - {2, 3.0}, {3, 4.0}}, - {}, std::hash{}, {}}), - std::unordered_multimap>); - static_assert(std::is_same_v< decltype(std::unordered_multimap{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}}, @@ -66,16 +60,6 @@ void f() std::allocator>{}}), std::unordered_multimap>); - static_assert(std::is_same_v< - decltype(std::unordered_multimap{x.begin(), x.end(), - {}, std::hash{}, {}}), - std::unordered_multimap>); - - static_assert(std::is_same_v< - decltype(std::unordered_multimap(x.begin(), x.end(), - {})), - std::unordered_multimap>); - static_assert(std::is_same_v< decltype(std::unordered_multimap(x.begin(), x.end(), 1)), std::unordered_multimap>); diff --git a/libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/deduction.cc b/libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/deduction.cc index 1850237e44c..e3006fdbfe3 100644 --- a/libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/deduction.cc +++ b/libstdc++-v3/testsuite/23_containers/unordered_multiset/cons/deduction.cc @@ -9,11 +9,6 @@ static_assert(std::is_same_v< decltype(std::unordered_multiset{1, 2, 3}), std::unordered_multiset>); -static_assert(std::is_same_v< - decltype(std::unordered_multiset{{1, 2, 3}, - 0, std::hash{}, {}}), - std::unordered_multiset>); - static_assert(std::is_same_v< decltype(std::unordered_multiset{{1, 2, 3}, {}}), @@ -76,11 +71,6 @@ void f() std::allocator{}}), std::unordered_multiset>); - static_assert(std::is_same_v< - decltype(std::unordered_multiset{x.begin(), x.end(), - {}, std::hash{}, {}}), - std::unordered_multiset>); - static_assert(std::is_same_v< decltype(std::unordered_multiset(x.begin(), x.end(), {})), diff --git a/libstdc++-v3/testsuite/23_containers/unordered_set/cons/deduction.cc b/libstdc++-v3/testsuite/23_containers/unordered_set/cons/deduction.cc index a745dce0fba..69922cd92e7 100644 --- a/libstdc++-v3/testsuite/23_containers/unordered_set/cons/deduction.cc +++ b/libstdc++-v3/testsuite/23_containers/unordered_set/cons/deduction.cc @@ -9,11 +9,6 @@ static_assert(std::is_same_v< decltype(std::unordered_set{1, 2, 3}), std::unordered_set>); -static_assert(std::is_same_v< - decltype(std::unordered_set{{1, 2, 3}, - 0, std::hash{}, {}}), - std::unordered_set>); - static_assert(std::is_same_v< decltype(std::unordered_set{{1, 2, 3}, {}}), @@ -71,11 +66,6 @@ void f() std::allocator{}}), std::unordered_set>); - static_assert(std::is_same_v< - decltype(std::unordered_set{x.begin(), x.end(), - {}, std::hash{}, {}}), - std::unordered_set>); - static_assert(std::is_same_v< decltype(std::unordered_set(x.begin(), x.end(), {})),