From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.129.124]) by sourceware.org (Postfix) with ESMTPS id 0E1F73858D1E for ; Thu, 10 Feb 2022 17:27:57 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.1 sourceware.org 0E1F73858D1E Received: from mail-qv1-f70.google.com (mail-qv1-f70.google.com [209.85.219.70]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id us-mta-611-CX3L-uBvOSiIbFvwItsjYQ-1; Thu, 10 Feb 2022 12:27:55 -0500 X-MC-Unique: CX3L-uBvOSiIbFvwItsjYQ-1 Received: by mail-qv1-f70.google.com with SMTP id 6-20020a0562140d4600b004244d191fd4so4512317qvr.0 for ; Thu, 10 Feb 2022 09:27:55 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:date:to:cc:subject:in-reply-to:message-id :references:mime-version; bh=Q6DZryniM5lPiZ7WGUOHSYxBDkadeu228xm1TfiKJiY=; b=nAS8eCGRU/NPw0OmyqO/fwnvqbN/a0zGr3YP0wcwcem8Ign7bkNUqqcLvYcP42VyYm 0jfkaYKKuMZSFdPzw18EFTA7ZDec14NV6SzPhaHdcCZtfABukOwHceJT7LpRYTrxkzFy wW3E1yqpHMm0karFl9Cqzkygx7ZcKcakqCqAzFm/cZ7WtPU/egZZcwt9bo2KcmEqxh1c WSHUqlDuUsTAOMCJ0jceaEbiK3hZxVm1binad1x8Aawgt01F4iRQLylhTHhkIJplpTXv PRp02MA65LxO6hbKK7Co4pJelCkMbpMs71Yb84UJXDL0TWY0EnbBiRnxioMorbjWul0Y bquQ== X-Gm-Message-State: AOAM532O5ZpFAOj5UP4s4TRtL485BEhwUxcob8aLVZg0r99bGmO0Bwph mz4mPlnHLmsXwwmgTIjMtvwpO4jD0CMFYBscI/3O9dTtU6TyB0vRGhxBKyblgnnvYHLeD7OnIZI ful2vB/iM0gUKEKU= X-Received: by 2002:a05:622a:547:: with SMTP id m7mr5598065qtx.604.1644514074596; Thu, 10 Feb 2022 09:27:54 -0800 (PST) X-Google-Smtp-Source: ABdhPJwc0ORkB7TQxAgtPry8MDBRMk+kKabAaBSSUXO/Zc2u9o6TqaE2D9mH6JJrINjRkR4sxAe/6g== X-Received: by 2002:a05:622a:547:: with SMTP id m7mr5598014qtx.604.1644514073822; Thu, 10 Feb 2022 09:27:53 -0800 (PST) Received: from [192.168.1.130] (ool-18e40894.dyn.optonline.net. [24.228.8.148]) by smtp.gmail.com with ESMTPSA id v14sm9960484qkl.128.2022.02.10.09.27.53 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 10 Feb 2022 09:27:53 -0800 (PST) From: Patrick Palka X-Google-Original-From: Patrick Palka Date: Thu, 10 Feb 2022 12:27:52 -0500 (EST) To: Patrick Palka cc: gcc-patches@gcc.gnu.org, libstdc++@gcc.gnu.org Subject: Re: [PATCH 1/3, 11 backport] libstdc++: Implement P2325 changes to default-constructibility of views In-Reply-To: <20220210165624.2953676-1-ppalka@redhat.com> Message-ID: <76be2843-238f-ffd9-c638-3a53d7c85a7e@idea> References: <20220210165624.2953676-1-ppalka@redhat.com> MIME-Version: 1.0 X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Type: text/plain; charset=US-ASCII X-Spam-Status: No, score=-14.7 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, SPF_HELO_NONE, SPF_NONE, TXREP, T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.4 X-Spam-Checker-Version: SpamAssassin 3.4.4 (2020-01-24) on server2.sourceware.org X-BeenThere: libstdc++@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Libstdc++ mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 10 Feb 2022 17:28:03 -0000 On Thu, 10 Feb 2022, Patrick Palka wrote: > Tested on x86_64-pc-linux-gnu, does this look OK for the 11 branch? > The backport to the 10 branch hasn't been started yet, I figured it'd > be good to first get the 11 backport right then base the 10 backport > on the 11 one. > > NB: This backport of r12-1606 to the 11 branch deliberately omits parts > of P2325R3 so as to maximize backward compatibility with pre-P2325R3 code. > In particular, we don't remove the default ctors for back_insert_iterator, > front_insert_iterator, ostream_iterator, ref_view and basic_istream_view. > > This implements the wording changes of P2325R3 "Views should not be > required to be default constructible". Changes are relatively > straightforward, besides perhaps those to __box (which now stands > for copyable-box instead of semiregular-box) and __non_propagating_cache. > > For __box, this patch implements the recommended practice to also avoid > std::optional when the boxed type is nothrow_move/copy_constructible. > > For __non_propagating_cache, now that it's used by split_view::_M_current, > we need to add assignment from a value of the underlying type to the > subset of the std::optional API implemented for the cache (needed by > split_view::begin()). Hence the new __non_propagating_cache::operator= > overload. > > In passing, this fixes the undesirable list-init in the constructors of > the partial specialization of __box as reported in PR100475 comment #7. > > PR libstdc++/103904 > > libstdc++-v3/ChangeLog: > > * include/bits/iterator_concepts.h (weakly_incrementable): Remove > default_initializable requirement. > * include/bits/ranges_base.h (ranges::view): Likewise. > * include/bits/ranges_util.h (subrange): Constrain the default > ctor. > * include/bits/stl_iterator.h (common_iterator): Constrain the > default ctor. > (counted_iterator): Likewise. > * include/std/ranges (__detail::__box::operator=): Handle > self-assignment in the primary template. > (__detail::__box): In the partial specialization: adjust > constraints as per P2325. Add specialized operator= for the > case when the wrapped type is not copyable. Constrain the > default ctor. Avoid list-initialization. > (single_view): Constraint the default ctor. > (iota_view): Relax semiregular constraint to copyable. > Constrain the default ctor. > (iota_view::_Iterator): Constraint the default ctor. > (basic_istream_view): Remove the default ctor. Remove NSDMIs. > Remove redundant checks for empty _M_stream. > (basic_istream_view::_Iterator): Likewise. > (ref_view): Remove the default ctor. Remove NSDMIs. > (ref_view::_Iterator): Constrain the default ctor. > (__detail::__non_propagating_cache::operator=): Define overload > for assigning from a value of the underlying type. > (filter_view): Likewise. > (filter_view::_Iterator): Likewise. > (transform_view): Likewise. > (transform_view::_Iterator): Likewise. > (take_view): Likewise. > (take_view::_Iterator): Likewise. > (take_while_view): Likewise. > (take_while_view::_Iterator): Likewise. > (drop_while_view): Likewise. > (drop_while_view::_Iterator): Likewise. > (join_view): Likewise. > (split_view::_OuterIter::__current): Adjust after changing the > type of _M_current. > (split_view::_M_current): Wrap it in a __non_propagating_cache. > (split_view::split_view): Constrain the default ctor. > (common_view): Constrain the default ctor. > (reverse_view): Likewise. > (elements_view): Likewise. > * include/std/span (enable_view>): > Define this partial specialization to true unconditionally. > * include/std/version (__cpp_lib_ranges): Adjust value. > * testsuite/std/ranges/adaptors/detail/semiregular_box.cc: > Rename to ... > * testsuite/std/ranges/adaptors/detail/copyable_box.cc: ... this. > (test02): Adjust now that __box is copyable-box not > semiregular-box. > (test03): New test. > * testsuite/std/ranges/p2325.cc: New test. > * testsuite/std/ranges/single_view.cc (test06): New test. > * testsuite/std/ranges/view.cc: Adjust now that view doesn't > require default_initializable. > > (cherry picked from commit 4b4f5666b4c2f3aab2a9f3d53d394e390b9b682d) > --- > libstdc++-v3/include/bits/iterator_concepts.h | 3 +- > libstdc++-v3/include/bits/ranges_base.h | 3 +- > libstdc++-v3/include/bits/ranges_util.h | 2 +- > libstdc++-v3/include/bits/stl_iterator.h | 3 +- > libstdc++-v3/include/std/ranges | 136 +++++++++---- > libstdc++-v3/include/std/span | 3 +- > libstdc++-v3/include/std/version | 2 +- > .../{semiregular_box.cc => copyable_box.cc} | 51 ++++- > libstdc++-v3/testsuite/std/ranges/p2325.cc | 180 ++++++++++++++++++ > .../testsuite/std/ranges/single_view.cc | 15 ++ > libstdc++-v3/testsuite/std/ranges/view.cc | 2 +- > 11 files changed, 348 insertions(+), 52 deletions(-) > rename libstdc++-v3/testsuite/std/ranges/adaptors/detail/{semiregular_box.cc => copyable_box.cc} (70%) > create mode 100644 libstdc++-v3/testsuite/std/ranges/p2325.cc > > diff --git a/libstdc++-v3/include/bits/iterator_concepts.h b/libstdc++-v3/include/bits/iterator_concepts.h > index 11748e5ed7b..c273056c204 100644 > --- a/libstdc++-v3/include/bits/iterator_concepts.h > +++ b/libstdc++-v3/include/bits/iterator_concepts.h > @@ -594,8 +594,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > > /// Requirements on types that can be incremented with ++. > template > - concept weakly_incrementable = default_initializable<_Iter> > - && movable<_Iter> > + concept weakly_incrementable = movable<_Iter> > && requires(_Iter __i) > { > typename iter_difference_t<_Iter>; > diff --git a/libstdc++-v3/include/bits/ranges_base.h b/libstdc++-v3/include/bits/ranges_base.h > index a63ef8eb7f4..48a9d0d95bb 100644 > --- a/libstdc++-v3/include/bits/ranges_base.h > +++ b/libstdc++-v3/include/bits/ranges_base.h > @@ -619,8 +619,7 @@ namespace ranges > /// [range.view] The ranges::view concept. > template > concept view > - = range<_Tp> && movable<_Tp> && default_initializable<_Tp> > - && enable_view<_Tp>; > + = range<_Tp> && movable<_Tp> && enable_view<_Tp>; > > // [range.refinements] > > diff --git a/libstdc++-v3/include/bits/ranges_util.h b/libstdc++-v3/include/bits/ranges_util.h > index abbf48bf157..ebcd233fdb1 100644 > --- a/libstdc++-v3/include/bits/ranges_util.h > +++ b/libstdc++-v3/include/bits/ranges_util.h > @@ -219,7 +219,7 @@ namespace ranges > [[no_unique_address]] _Size<__size_type> _M_size = {}; > > public: > - subrange() = default; > + subrange() requires default_initializable<_It> = default; > > constexpr > subrange(__detail::__convertible_to_non_slicing<_It> auto __i, _Sent __s) > diff --git a/libstdc++-v3/include/bits/stl_iterator.h b/libstdc++-v3/include/bits/stl_iterator.h > index f7309e6bca8..549bc26dee5 100644 > --- a/libstdc++-v3/include/bits/stl_iterator.h > +++ b/libstdc++-v3/include/bits/stl_iterator.h > @@ -1741,6 +1741,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > constexpr > common_iterator() > noexcept(is_nothrow_default_constructible_v<_It>) > + requires default_initializable<_It> > : _M_it(), _M_index(0) > { } > > @@ -2118,7 +2119,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION > // iterator_concept defined in __counted_iter_concept > // iterator_category defined in __counted_iter_cat > > - constexpr counted_iterator() = default; > + constexpr counted_iterator() requires default_initializable<_It> = default; > > constexpr > counted_iterator(_It __i, iter_difference_t<_It> __n) > diff --git a/libstdc++-v3/include/std/ranges b/libstdc++-v3/include/std/ranges > index e46d9a059d2..bf6cfae2a6e 100644 > --- a/libstdc++-v3/include/std/ranges > +++ b/libstdc++-v3/include/std/ranges > @@ -113,10 +113,13 @@ namespace ranges > noexcept(is_nothrow_copy_constructible_v<_Tp>) > requires (!copyable<_Tp>) > { > - if ((bool)__that) > - this->emplace(*__that); > - else > - this->reset(); > + if (this != std::__addressof(__that)) > + { > + if ((bool)__that) > + this->emplace(*__that); > + else > + this->reset(); > + } > return *this; > } > > @@ -125,37 +128,42 @@ namespace ranges > noexcept(is_nothrow_move_constructible_v<_Tp>) > requires (!movable<_Tp>) > { > - if ((bool)__that) > - this->emplace(std::move(*__that)); > - else > - this->reset(); > + if (this != std::__addressof(__that)) > + { > + if ((bool)__that) > + this->emplace(std::move(*__that)); > + else > + this->reset(); > + } > return *this; > } > }; > > - // For types which are already semiregular, this specialization of the > - // semiregular wrapper stores the object directly without going through > + // For types which are already copyable, this specialization of the > + // copyable wrapper stores the object directly without going through > // std::optional. It provides just the subset of the primary template's > // API that we currently use. > - template<__boxable _Tp> requires semiregular<_Tp> > + template<__boxable _Tp> > + requires copyable<_Tp> || (is_nothrow_move_constructible_v<_Tp> > + && is_nothrow_copy_constructible_v<_Tp>) > struct __box<_Tp> > { > private: > [[no_unique_address]] _Tp _M_value = _Tp(); > > public: > - __box() = default; > + __box() requires default_initializable<_Tp> = default; > > constexpr explicit > __box(const _Tp& __t) > noexcept(is_nothrow_copy_constructible_v<_Tp>) > - : _M_value{__t} > + : _M_value(__t) > { } > > constexpr explicit > __box(_Tp&& __t) > noexcept(is_nothrow_move_constructible_v<_Tp>) > - : _M_value{std::move(__t)} > + : _M_value(std::move(__t)) > { } > > template > @@ -166,6 +174,38 @@ namespace ranges > : _M_value(std::forward<_Args>(__args)...) > { } > > + __box(const __box&) = default; > + __box(__box&&) = default; > + __box& operator=(const __box&) requires copyable<_Tp> = default; > + __box& operator=(__box&&) requires copyable<_Tp> = default; > + > + // When _Tp is nothrow_copy_constructible but not copy_assignable, > + // copy assignment is implemented via destroy-then-copy-construct. > + constexpr __box& > + operator=(const __box& __that) noexcept > + { > + static_assert(is_nothrow_copy_constructible_v<_Tp>); > + if (this != std::__addressof(__that)) > + { > + _M_value.~_Tp(); > + std::construct_at(std::__addressof(_M_value), *__that); > + } > + return *this; > + } > + > + // Likewise for move assignment. > + constexpr __box& > + operator=(__box&& __that) noexcept > + { > + static_assert(is_nothrow_move_constructible_v<_Tp>); > + if (this != std::__addressof(__that)) > + { > + _M_value.~_Tp(); > + std::construct_at(std::__addressof(_M_value), std::move(*__that)); > + } > + return *this; > + } > + > constexpr bool > has_value() const noexcept > { return true; }; > @@ -193,7 +233,7 @@ namespace ranges > class single_view : public view_interface> > { > public: > - single_view() = default; > + single_view() requires default_initializable<_Tp> = default; > > constexpr explicit > single_view(const _Tp& __t) > @@ -305,7 +345,7 @@ namespace ranges > template semiregular _Bound = unreachable_sentinel_t> > requires std::__detail::__weakly_eq_cmp_with<_Winc, _Bound> > - && semiregular<_Winc> > + && copyable<_Winc> > class iota_view : public view_interface> > { > private: > @@ -334,7 +374,7 @@ namespace ranges > using value_type = _Winc; > using difference_type = __detail::__iota_diff_t<_Winc>; > > - _Iterator() = default; > + _Iterator() requires default_initializable<_Winc> = default; > > constexpr explicit > _Iterator(_Winc __value) > @@ -531,7 +571,7 @@ namespace ranges > [[no_unique_address]] _Bound _M_bound = _Bound(); > > public: > - iota_view() = default; > + iota_view() requires default_initializable<_Winc> = default; > > constexpr explicit > iota_view(_Winc __value) > @@ -670,8 +710,6 @@ namespace views > using difference_type = ptrdiff_t; > using value_type = _Val; > > - _Iterator() = default; Drat, this default ctor (for basic_istream_view::iterator) should not be removed in the backport. Here's v2 which fixes this mistake (and thus the static_assert on line 77 of p2325.cc now fails as expected): -- >8 -- Subject: [PATCH] libstdc++: Implement P2325 changes to default-constructibility of views NB: This backport of r12-1606 to the 11 branch deliberately omits parts of P2325R3 so as to maximize backward compatibility with pre-P2325R3 code. In particular, we don't remove the default ctors for back_insert_iterator, front_insert_iterator, ostream_iterator, ref_view and basic_istream_view. This implements the wording changes of P2325R3 "Views should not be required to be default constructible". Changes are relatively straightforward, besides perhaps those to __box (which now stands for copyable-box instead of semiregular-box) and __non_propagating_cache. For __box, this patch implements the recommended practice to also avoid std::optional when the boxed type is nothrow_move/copy_constructible. For __non_propagating_cache, now that it's used by split_view::_M_current, we need to add assignment from a value of the underlying type to the subset of the std::optional API implemented for the cache (needed by split_view::begin()). Hence the new __non_propagating_cache::operator= overload. In passing, this fixes the undesirable list-init in the constructors of the partial specialization of __box as reported in PR100475 comment #7. PR libstdc++/103904 libstdc++-v3/ChangeLog: * include/bits/iterator_concepts.h (weakly_incrementable): Remove default_initializable requirement. * include/bits/ranges_base.h (ranges::view): Likewise. * include/bits/ranges_util.h (subrange): Constrain the default ctor. * include/bits/stl_iterator.h (common_iterator): Constrain the default ctor. (counted_iterator): Likewise. * include/std/ranges (__detail::__box::operator=): Handle self-assignment in the primary template. (__detail::__box): In the partial specialization: adjust constraints as per P2325. Add specialized operator= for the case when the wrapped type is not copyable. Constrain the default ctor. Avoid list-initialization. (single_view): Constraint the default ctor. (iota_view): Relax semiregular constraint to copyable. Constrain the default ctor. (iota_view::_Iterator): Constraint the default ctor. (ref_view): Remove the default ctor. Remove NSDMIs. (ref_view::_Iterator): Constrain the default ctor. (__detail::__non_propagating_cache::operator=): Define overload for assigning from a value of the underlying type. (filter_view): Likewise. (filter_view::_Iterator): Likewise. (transform_view): Likewise. (transform_view::_Iterator): Likewise. (take_view): Likewise. (take_view::_Iterator): Likewise. (take_while_view): Likewise. (take_while_view::_Iterator): Likewise. (drop_while_view): Likewise. (drop_while_view::_Iterator): Likewise. (join_view): Likewise. (split_view::_OuterIter::__current): Adjust after changing the type of _M_current. (split_view::_M_current): Wrap it in a __non_propagating_cache. (split_view::split_view): Constrain the default ctor. (common_view): Constrain the default ctor. (reverse_view): Likewise. (elements_view): Likewise. * include/std/span (enable_view>): Define this partial specialization to true unconditionally. * include/std/version (__cpp_lib_ranges): Adjust value. * testsuite/std/ranges/adaptors/detail/semiregular_box.cc: Rename to ... * testsuite/std/ranges/adaptors/detail/copyable_box.cc: ... this. (test02): Adjust now that __box is copyable-box not semiregular-box. (test03): New test. * testsuite/std/ranges/p2325.cc: New test. * testsuite/std/ranges/single_view.cc (test06): New test. * testsuite/std/ranges/view.cc: Adjust now that view doesn't require default_initializable. (cherry picked from commit 4b4f5666b4c2f3aab2a9f3d53d394e390b9b682d) --- libstdc++-v3/include/bits/iterator_concepts.h | 3 +- libstdc++-v3/include/bits/ranges_base.h | 3 +- libstdc++-v3/include/bits/ranges_util.h | 2 +- libstdc++-v3/include/bits/stl_iterator.h | 3 +- libstdc++-v3/include/std/ranges | 134 +++++++++---- libstdc++-v3/include/std/span | 3 +- libstdc++-v3/include/std/version | 2 +- .../{semiregular_box.cc => copyable_box.cc} | 51 ++++- libstdc++-v3/testsuite/std/ranges/p2325.cc | 181 ++++++++++++++++++ .../testsuite/std/ranges/single_view.cc | 15 ++ libstdc++-v3/testsuite/std/ranges/view.cc | 2 +- 11 files changed, 349 insertions(+), 50 deletions(-) rename libstdc++-v3/testsuite/std/ranges/adaptors/detail/{semiregular_box.cc => copyable_box.cc} (70%) create mode 100644 libstdc++-v3/testsuite/std/ranges/p2325.cc diff --git a/libstdc++-v3/include/bits/iterator_concepts.h b/libstdc++-v3/include/bits/iterator_concepts.h index 11748e5ed7b..c273056c204 100644 --- a/libstdc++-v3/include/bits/iterator_concepts.h +++ b/libstdc++-v3/include/bits/iterator_concepts.h @@ -594,8 +594,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// Requirements on types that can be incremented with ++. template - concept weakly_incrementable = default_initializable<_Iter> - && movable<_Iter> + concept weakly_incrementable = movable<_Iter> && requires(_Iter __i) { typename iter_difference_t<_Iter>; diff --git a/libstdc++-v3/include/bits/ranges_base.h b/libstdc++-v3/include/bits/ranges_base.h index a63ef8eb7f4..48a9d0d95bb 100644 --- a/libstdc++-v3/include/bits/ranges_base.h +++ b/libstdc++-v3/include/bits/ranges_base.h @@ -619,8 +619,7 @@ namespace ranges /// [range.view] The ranges::view concept. template concept view - = range<_Tp> && movable<_Tp> && default_initializable<_Tp> - && enable_view<_Tp>; + = range<_Tp> && movable<_Tp> && enable_view<_Tp>; // [range.refinements] diff --git a/libstdc++-v3/include/bits/ranges_util.h b/libstdc++-v3/include/bits/ranges_util.h index abbf48bf157..ebcd233fdb1 100644 --- a/libstdc++-v3/include/bits/ranges_util.h +++ b/libstdc++-v3/include/bits/ranges_util.h @@ -219,7 +219,7 @@ namespace ranges [[no_unique_address]] _Size<__size_type> _M_size = {}; public: - subrange() = default; + subrange() requires default_initializable<_It> = default; constexpr subrange(__detail::__convertible_to_non_slicing<_It> auto __i, _Sent __s) diff --git a/libstdc++-v3/include/bits/stl_iterator.h b/libstdc++-v3/include/bits/stl_iterator.h index f7309e6bca8..549bc26dee5 100644 --- a/libstdc++-v3/include/bits/stl_iterator.h +++ b/libstdc++-v3/include/bits/stl_iterator.h @@ -1741,6 +1741,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION constexpr common_iterator() noexcept(is_nothrow_default_constructible_v<_It>) + requires default_initializable<_It> : _M_it(), _M_index(0) { } @@ -2118,7 +2119,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // iterator_concept defined in __counted_iter_concept // iterator_category defined in __counted_iter_cat - constexpr counted_iterator() = default; + constexpr counted_iterator() requires default_initializable<_It> = default; constexpr counted_iterator(_It __i, iter_difference_t<_It> __n) diff --git a/libstdc++-v3/include/std/ranges b/libstdc++-v3/include/std/ranges index e46d9a059d2..c97ace4e4f7 100644 --- a/libstdc++-v3/include/std/ranges +++ b/libstdc++-v3/include/std/ranges @@ -113,10 +113,13 @@ namespace ranges noexcept(is_nothrow_copy_constructible_v<_Tp>) requires (!copyable<_Tp>) { - if ((bool)__that) - this->emplace(*__that); - else - this->reset(); + if (this != std::__addressof(__that)) + { + if ((bool)__that) + this->emplace(*__that); + else + this->reset(); + } return *this; } @@ -125,37 +128,42 @@ namespace ranges noexcept(is_nothrow_move_constructible_v<_Tp>) requires (!movable<_Tp>) { - if ((bool)__that) - this->emplace(std::move(*__that)); - else - this->reset(); + if (this != std::__addressof(__that)) + { + if ((bool)__that) + this->emplace(std::move(*__that)); + else + this->reset(); + } return *this; } }; - // For types which are already semiregular, this specialization of the - // semiregular wrapper stores the object directly without going through + // For types which are already copyable, this specialization of the + // copyable wrapper stores the object directly without going through // std::optional. It provides just the subset of the primary template's // API that we currently use. - template<__boxable _Tp> requires semiregular<_Tp> + template<__boxable _Tp> + requires copyable<_Tp> || (is_nothrow_move_constructible_v<_Tp> + && is_nothrow_copy_constructible_v<_Tp>) struct __box<_Tp> { private: [[no_unique_address]] _Tp _M_value = _Tp(); public: - __box() = default; + __box() requires default_initializable<_Tp> = default; constexpr explicit __box(const _Tp& __t) noexcept(is_nothrow_copy_constructible_v<_Tp>) - : _M_value{__t} + : _M_value(__t) { } constexpr explicit __box(_Tp&& __t) noexcept(is_nothrow_move_constructible_v<_Tp>) - : _M_value{std::move(__t)} + : _M_value(std::move(__t)) { } template @@ -166,6 +174,38 @@ namespace ranges : _M_value(std::forward<_Args>(__args)...) { } + __box(const __box&) = default; + __box(__box&&) = default; + __box& operator=(const __box&) requires copyable<_Tp> = default; + __box& operator=(__box&&) requires copyable<_Tp> = default; + + // When _Tp is nothrow_copy_constructible but not copy_assignable, + // copy assignment is implemented via destroy-then-copy-construct. + constexpr __box& + operator=(const __box& __that) noexcept + { + static_assert(is_nothrow_copy_constructible_v<_Tp>); + if (this != std::__addressof(__that)) + { + _M_value.~_Tp(); + std::construct_at(std::__addressof(_M_value), *__that); + } + return *this; + } + + // Likewise for move assignment. + constexpr __box& + operator=(__box&& __that) noexcept + { + static_assert(is_nothrow_move_constructible_v<_Tp>); + if (this != std::__addressof(__that)) + { + _M_value.~_Tp(); + std::construct_at(std::__addressof(_M_value), std::move(*__that)); + } + return *this; + } + constexpr bool has_value() const noexcept { return true; }; @@ -193,7 +233,7 @@ namespace ranges class single_view : public view_interface> { public: - single_view() = default; + single_view() requires default_initializable<_Tp> = default; constexpr explicit single_view(const _Tp& __t) @@ -305,7 +345,7 @@ namespace ranges template requires std::__detail::__weakly_eq_cmp_with<_Winc, _Bound> - && semiregular<_Winc> + && copyable<_Winc> class iota_view : public view_interface> { private: @@ -334,7 +374,7 @@ namespace ranges using value_type = _Winc; using difference_type = __detail::__iota_diff_t<_Winc>; - _Iterator() = default; + _Iterator() requires default_initializable<_Winc> = default; constexpr explicit _Iterator(_Winc __value) @@ -531,7 +571,7 @@ namespace ranges [[no_unique_address]] _Bound _M_bound = _Bound(); public: - iota_view() = default; + iota_view() requires default_initializable<_Winc> = default; constexpr explicit iota_view(_Winc __value) @@ -1140,6 +1180,16 @@ namespace views::__adaptor return *this; } + constexpr __non_propagating_cache& + operator=(_Tp __val) + { + this->_M_reset(); + std::construct_at(std::__addressof(this->_M_payload._M_payload), + std::in_place, std::move(__val)); + this->_M_payload._M_engaged = true; + return *this; + } + constexpr _Tp& operator*() noexcept { return this->_M_get(); } @@ -1317,7 +1367,7 @@ namespace views::__adaptor using value_type = range_value_t<_Vp>; using difference_type = range_difference_t<_Vp>; - _Iterator() = default; + _Iterator() requires default_initializable<_Vp_iter> = default; constexpr _Iterator(filter_view* __parent, _Vp_iter __current) @@ -1429,7 +1479,9 @@ namespace views::__adaptor _Vp _M_base = _Vp(); public: - filter_view() = default; + filter_view() requires (default_initializable<_Vp> + && default_initializable<_Pred>) + = default; constexpr filter_view(_Vp __base, _Pred __pred) @@ -1578,7 +1630,7 @@ namespace views::__adaptor = remove_cvref_t>>; using difference_type = range_difference_t<_Base>; - _Iterator() = default; + _Iterator() requires default_initializable<_Base_iter> = default; constexpr _Iterator(_Parent* __parent, _Base_iter __current) @@ -1793,7 +1845,9 @@ namespace views::__adaptor _Vp _M_base = _Vp(); public: - transform_view() = default; + transform_view() requires (default_initializable<_Vp> + && default_initializable<_Fp>) + = default; constexpr transform_view(_Vp __base, _Fp __fun) @@ -1928,7 +1982,7 @@ namespace views::__adaptor _Vp _M_base = _Vp(); public: - take_view() = default; + take_view() requires default_initializable<_Vp> = default; constexpr take_view(_Vp base, range_difference_t<_Vp> __count) @@ -2112,7 +2166,9 @@ namespace views::__adaptor _Vp _M_base = _Vp(); public: - take_while_view() = default; + take_while_view() requires (default_initializable<_Vp> + && default_initializable<_Pred>) + = default; constexpr take_while_view(_Vp base, _Pred __pred) @@ -2200,7 +2256,7 @@ namespace views::__adaptor _M_cached_begin; public: - drop_view() = default; + drop_view() requires default_initializable<_Vp> = default; constexpr drop_view(_Vp __base, range_difference_t<_Vp> __count) @@ -2316,7 +2372,9 @@ namespace views::__adaptor _Vp _M_base = _Vp(); public: - drop_while_view() = default; + drop_while_view() requires (default_initializable<_Vp> + && default_initializable<_Pred>) + = default; constexpr drop_while_view(_Vp __base, _Pred __pred) @@ -2506,7 +2564,9 @@ namespace views::__adaptor = common_type_t, range_difference_t>>; - _Iterator() = default; + _Iterator() requires (default_initializable<_Outer_iter> + && default_initializable<_Inner_iter>) + = default; constexpr _Iterator(_Parent* __parent, _Outer_iter __outer) @@ -2659,7 +2719,7 @@ namespace views::__adaptor _Vp _M_base = _Vp(); public: - join_view() = default; + join_view() requires default_initializable<_Vp> = default; constexpr explicit join_view(_Vp __base) @@ -2826,7 +2886,7 @@ namespace views::__adaptor if constexpr (forward_range<_Vp>) return _M_current; else - return _M_parent->_M_current; + return *_M_parent->_M_current; } constexpr auto& @@ -2835,7 +2895,7 @@ namespace views::__adaptor if constexpr (forward_range<_Vp>) return _M_current; else - return _M_parent->_M_current; + return *_M_parent->_M_current; } _Parent* _M_parent = nullptr; @@ -3083,12 +3143,14 @@ namespace views::__adaptor // XXX: _M_current is "present only if !forward_range" [[no_unique_address]] __detail::__maybe_present_t, - iterator_t<_Vp>> _M_current; + __detail::__non_propagating_cache>> _M_current; _Vp _M_base = _Vp(); public: - split_view() = default; + split_view() requires (default_initializable<_Vp> + && default_initializable<_Pattern>) + = default; constexpr split_view(_Vp __base, _Pattern __pattern) @@ -3219,7 +3281,7 @@ namespace views::__adaptor _Vp _M_base = _Vp(); public: - common_view() = default; + common_view() requires default_initializable<_Vp> = default; constexpr explicit common_view(_Vp __r) @@ -3348,7 +3410,7 @@ namespace views::__adaptor _Vp _M_base = _Vp(); public: - reverse_view() = default; + reverse_view() requires default_initializable<_Vp> = default; constexpr explicit reverse_view(_Vp __r) @@ -3490,7 +3552,7 @@ namespace views::__adaptor class elements_view : public view_interface> { public: - elements_view() = default; + elements_view() requires default_initializable<_Vp> = default; constexpr explicit elements_view(_Vp base) @@ -3611,7 +3673,7 @@ namespace views::__adaptor = remove_cvref_t>>; using difference_type = range_difference_t<_Base>; - _Iterator() = default; + _Iterator() requires default_initializable> = default; constexpr explicit _Iterator(iterator_t<_Base> current) diff --git a/libstdc++-v3/include/std/span b/libstdc++-v3/include/std/span index 503b71fc8bd..af0d24b29f2 100644 --- a/libstdc++-v3/include/std/span +++ b/libstdc++-v3/include/std/span @@ -450,8 +450,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION // Opt-in to view concept template inline constexpr bool - enable_view> - = _Extent == 0 || _Extent == dynamic_extent; + enable_view> = true; } _GLIBCXX_END_NAMESPACE_VERSION } // namespace std diff --git a/libstdc++-v3/include/std/version b/libstdc++-v3/include/std/version index c591398e877..b565e8d976a 100644 --- a/libstdc++-v3/include/std/version +++ b/libstdc++-v3/include/std/version @@ -247,7 +247,7 @@ #define __cpp_lib_optional 202106L #define __cpp_lib_polymorphic_allocator 201902L #if __cpp_lib_concepts -# define __cpp_lib_ranges 201911L +# define __cpp_lib_ranges 202106L #endif #if __cpp_lib_atomic_wait || _GLIBCXX_HAVE_POSIX_SEMAPHORE # define __cpp_lib_semaphore 201907L diff --git a/libstdc++-v3/testsuite/std/ranges/adaptors/detail/semiregular_box.cc b/libstdc++-v3/testsuite/std/ranges/adaptors/detail/copyable_box.cc similarity index 70% rename from libstdc++-v3/testsuite/std/ranges/adaptors/detail/semiregular_box.cc rename to libstdc++-v3/testsuite/std/ranges/adaptors/detail/copyable_box.cc index ed694e04fd1..fa6d4d56816 100644 --- a/libstdc++-v3/testsuite/std/ranges/adaptors/detail/semiregular_box.cc +++ b/libstdc++-v3/testsuite/std/ranges/adaptors/detail/copyable_box.cc @@ -82,9 +82,10 @@ test01() } static_assert(test01()); -template +template struct A { - A() requires make_semiregular; + A(const A&) = default; + A& operator=(const A&) requires make_copyable; A(int, int); A(std::initializer_list) = delete; }; @@ -93,9 +94,51 @@ void test02() { // PR libstdc++/100475 - static_assert(std::semiregular>); + static_assert(std::copyable>); __box> x2(std::in_place, 0, 0); - static_assert(!std::semiregular>); + static_assert(!std::copyable>); __box> x1(std::in_place, 0, 0); } + +constexpr bool +test03() +{ + // Verify correctness of the non-defaulted operator= for the partial + // specialization of __box. + struct B { + constexpr B(int* p) : p(p) { } + constexpr ~B() { ++*p; }; + B(const B&) = default; + B& operator=(const B&) = delete; + int* p; + }; + static_assert(!std::copyable); + static_assert(std::is_nothrow_copy_constructible_v); + static_assert(sizeof(__box) == sizeof(B)); + + int m = 0; + __box x(std::in_place, &m); + __glibcxx_assert(m == 0); + x = x; + __glibcxx_assert(m == 0); + x = std::move(x); + __glibcxx_assert(m == 0); + + int n = 0; + __box y(std::in_place, &n); + auto z = x; + x = y; + __glibcxx_assert(m == 1); + __glibcxx_assert(n == 0); + __glibcxx_assert(x->p == &n); + __glibcxx_assert(y->p == &n); + y = std::move(z); + __glibcxx_assert(m == 1); + __glibcxx_assert(n == 1); + __glibcxx_assert(y->p == &m); + __glibcxx_assert(z->p == &m); + + return true; +} +static_assert(test03()); diff --git a/libstdc++-v3/testsuite/std/ranges/p2325.cc b/libstdc++-v3/testsuite/std/ranges/p2325.cc new file mode 100644 index 00000000000..205b3458928 --- /dev/null +++ b/libstdc++-v3/testsuite/std/ranges/p2325.cc @@ -0,0 +1,181 @@ +// { dg-options "-std=gnu++20" } +// { dg-do compile { target c++20 } } +// P2325R3 "Views should not be required to be default constructible" + +// Parts of P2325R3 are deliberately omitted in libstdc++ 11, in particular the +// removal of default ctors for back_/front_insert_iterator, ostream_iterator, +// ref_view and basic_istream_view/::iterator, so as to maximize backward +// compatibility with pre-P2325R3 code. So most static_asserts in this test fail, +// see the xfails at the end of this file. + +#include +#include +#include +#include +#include +#include + +using namespace std; + +template void f(); +template requires weakly_incrementable || ranges::view void f(); + +void +test01() +{ + // Verify neither std::weakly_incrementable nor ranges::view require + // default_initializable. + f(); // { dg-error "ambiguous" } +} + +void +test02() +{ + // Verify these iterators are not default constructible. + static_assert(!default_initializable>>); + static_assert(!default_initializable>>); + static_assert(!default_initializable>>); + static_assert(!default_initializable>); + + using iter = ostream_iterator; + + // Verify common_iterator is conditionally default constructible. + static_assert(!default_initializable>); + static_assert(default_initializable>); + + // Verify counted_iterator is conditionally default constructible. + static_assert(!default_initializable>); + static_assert(default_initializable>); +} + +void +test03() +{ + using iter = ostream_iterator; + + // Verify iota_view is conditionally default constructible. + static_assert(!default_initializable>); + static_assert(!default_initializable>().begin())>); + static_assert(default_initializable>); + static_assert(default_initializable>().begin())>); + + // Verify subrange is conditionally default constructible. + static_assert(!default_initializable>); + static_assert(default_initializable>); + + // Verify single_view is conditionally default constructible. + static_assert(!default_initializable>); + static_assert(default_initializable>); +} + +void +test04() +{ + // Verify basic_istream_view is not default constructible. + using type = ranges::basic_istream_view>; + static_assert(!default_initializable); + static_assert(!default_initializable().begin())>); +} + +void +test05() +{ + // Verify ref_view is not default constructible. + static_assert(!default_initializable>); +} + +template +void +test06() +{ + auto f1 = [] (auto) { return true; }; + auto f2 = [i=0] (auto) { return true; }; + static_assert(default_initializable); + static_assert(!default_initializable); + + struct S { S() = delete; }; + static_assert(!default_initializable()) | adaptor(f1))>); + static_assert(!default_initializable()) | adaptor(f2))>); +} + +// Verify filter_view, transform_view, take_while_view and drop_while_view are +// conditionally default constructible. +template void test06(); +template void test06(); +template void test06(); +template void test06(); + +void +test07() +{ + // Verify join_view is conditionally default constructible. + struct S { S() = delete; }; + using type1 = ranges::join_view>>; + static_assert(!default_initializable); + using type2 = ranges::join_view>>; + static_assert(default_initializable); +} + +void +test08() +{ + // Verify split_view is conditionally default constructible. + using type1 = ranges::split_view, ranges::single_view>; + static_assert(!default_initializable); + using type2 = ranges::split_view, ranges::ref_view>; + static_assert(!default_initializable); + using type3 = ranges::split_view, ranges::ref_view>; + static_assert(!default_initializable); + using type4 = ranges::split_view, ranges::single_view>; + static_assert(default_initializable); +} + +void +test09() +{ + // Verify common_view is conditionally default constructible. + using type1 = ranges::common_view>>; + static_assert(!default_initializable); + using type2 = ranges::common_view>; + static_assert(default_initializable); +} + +void +test10() +{ + // Verify reverse_view is conditionally default constructible. + using type1 = ranges::reverse_view>; + static_assert(!default_initializable); + using type2 = ranges::reverse_view>; + static_assert(default_initializable); +} + +void +test11() +{ + // Verify elements_view is conditionally default constructible. + using type1 = ranges::elements_view[2]>, 0>; + static_assert(!default_initializable); + using type2 = ranges::elements_view>, 0>; + static_assert(default_initializable); +} + +// { dg-bogus "static assertion failed" "" { xfail *-*-* } 35 } +// { dg-bogus "static assertion failed" "" { xfail *-*-* } 36 } +// { dg-bogus "static assertion failed" "" { xfail *-*-* } 37 } +// { dg-bogus "static assertion failed" "" { xfail *-*-* } 38 } +// { dg-bogus "static assertion failed" "" { xfail *-*-* } 43 } +// { dg-bogus "static assertion failed" "" { xfail *-*-* } 47 } +// { dg-bogus "static assertion failed" "" { xfail *-*-* } 57 } +// { dg-bogus "static assertion failed" "" { xfail *-*-* } 58 } +// { dg-bogus "static assertion failed" "" { xfail *-*-* } 63 } +// { dg-bogus "static assertion failed" "" { xfail *-*-* } 67 } +// { dg-bogus "static assertion failed" "" { xfail *-*-* } 76 } +// { dg-bogus "static assertion failed" "" { xfail *-*-* } 77 } +// { dg-bogus "static assertion failed" "" { xfail *-*-* } 84 } +// { dg-bogus "static assertion failed" "" { xfail *-*-* } 124 } +// { dg-bogus "static assertion failed" "" { xfail *-*-* } 126 } +// { dg-bogus "static assertion failed" "" { xfail *-*-* } 128 } +// { dg-bogus "static assertion failed" "" { xfail *-*-* } 138 } +// { dg-bogus "static assertion failed" "" { xfail *-*-* } 148 } +// { dg-bogus "static assertion failed" "" { xfail *-*-* } 158 } diff --git a/libstdc++-v3/testsuite/std/ranges/single_view.cc b/libstdc++-v3/testsuite/std/ranges/single_view.cc index f530cc07565..dd86d351beb 100644 --- a/libstdc++-v3/testsuite/std/ranges/single_view.cc +++ b/libstdc++-v3/testsuite/std/ranges/single_view.cc @@ -73,10 +73,25 @@ test04() std::as_const(s).data(); } +void +test06() +{ + // PR libstdc++/100475 comment #7 + struct S { + S() = default; + S(std::initializer_list) = delete; + S(const S&) {} + }; + S obj; + auto x = std::views::single(obj); + auto y = std::views::single(std::move(obj)); +} + int main() { test01(); test02(); test03(); test04(); + test06(); } diff --git a/libstdc++-v3/testsuite/std/ranges/view.cc b/libstdc++-v3/testsuite/std/ranges/view.cc index d8972ab3e46..dd8258220ed 100644 --- a/libstdc++-v3/testsuite/std/ranges/view.cc +++ b/libstdc++-v3/testsuite/std/ranges/view.cc @@ -31,7 +31,7 @@ static_assert(std::ranges::view>); static_assert(std::ranges::view>); -static_assert(!std::ranges::view>); +static_assert(std::ranges::view>); // Changed with P2325R3 static_assert(std::ranges::view); static_assert(std::ranges::view); -- 2.35.1.102.g2b9c120970