On Sat, 18 Nov 2023 at 19:50, Arsen Arsenović <ar...@aarsen.me> wrote:
>
> libstdc++-v3/ChangeLog:
>
> * include/Makefile.am: Install std/generator, bits/elements_of.h
> as freestanding.
> * include/Makefile.in: Regenerate.
> * include/bits/version.def: Add __cpp_lib_generator.
> * include/bits/version.h: Regenerate.
> * include/precompiled/stdc++.h: Include <generator>.
> * include/std/ranges: Include bits/elements_of.h
> * include/bits/elements_of.h: New file.
> * include/std/generator: New file.
> * testsuite/24_iterators/range_generators/01.cc: New test.
> * testsuite/24_iterators/range_generators/02.cc: New test.
> * testsuite/24_iterators/range_generators/copy.cc: New test.
> * testsuite/24_iterators/range_generators/except.cc: New test.
> * testsuite/24_iterators/range_generators/synopsis.cc: New test.
> * testsuite/24_iterators/range_generators/subrange.cc: New test.
> ---
> Evening,
>
> This is an implementation of <generator> from C++23. It should be
> feature-complete, though it doesn't have all the tests that it ought to
> and is missing a few tweaks.
>
> Posting to get reviews in the meanwhile, in case something obvious was
> missed.
>
> Have a lovely night :-)
>
> libstdc++-v3/include/Makefile.am | 2 +
> libstdc++-v3/include/Makefile.in | 2 +
> libstdc++-v3/include/bits/elements_of.h | 72 ++
> libstdc++-v3/include/bits/version.def | 9 +
> libstdc++-v3/include/bits/version.h | 11 +
> libstdc++-v3/include/precompiled/stdc++.h | 1 +
> libstdc++-v3/include/std/generator | 820 ++++++++++++++++++
> libstdc++-v3/include/std/ranges | 4 +
> .../24_iterators/range_generators/01.cc | 55 ++
> .../24_iterators/range_generators/02.cc | 219 +++++
> .../24_iterators/range_generators/copy.cc | 97 +++
> .../24_iterators/range_generators/except.cc | 97 +++
> .../24_iterators/range_generators/subrange.cc | 45 +
> .../24_iterators/range_generators/synopsis.cc | 38 +
> 14 files changed, 1472 insertions(+)
> create mode 100644 libstdc++-v3/include/bits/elements_of.h
> create mode 100644 libstdc++-v3/include/std/generator
> create mode 100644 libstdc++-v3/testsuite/24_iterators/range_generators/01.cc
> create mode 100644 libstdc++-v3/testsuite/24_iterators/range_generators/02.cc
> create mode 100644
> libstdc++-v3/testsuite/24_iterators/range_generators/copy.cc
> create mode 100644
> libstdc++-v3/testsuite/24_iterators/range_generators/except.cc
> create mode 100644
> libstdc++-v3/testsuite/24_iterators/range_generators/subrange.cc
> create mode 100644
> libstdc++-v3/testsuite/24_iterators/range_generators/synopsis.cc
>
> diff --git a/libstdc++-v3/include/Makefile.am
> b/libstdc++-v3/include/Makefile.am
> index 17d9d9cec313..0b764f2b8a9e 100644
> --- a/libstdc++-v3/include/Makefile.am
> +++ b/libstdc++-v3/include/Makefile.am
> @@ -35,6 +35,7 @@ std_freestanding = \
> ${std_srcdir}/coroutine \
> ${std_srcdir}/expected \
> ${std_srcdir}/functional \
> + ${std_srcdir}/generator \
> ${std_srcdir}/iterator \
> ${std_srcdir}/limits \
> ${std_srcdir}/memory \
> @@ -122,6 +123,7 @@ bits_freestanding = \
> ${bits_srcdir}/concept_check.h \
> ${bits_srcdir}/char_traits.h \
> ${bits_srcdir}/cpp_type_traits.h \
> + ${bits_srcdir}/elements_of.h \
> ${bits_srcdir}/enable_special_members.h \
> ${bits_srcdir}/functexcept.h \
> ${bits_srcdir}/functional_hash.h \
> diff --git a/libstdc++-v3/include/Makefile.in
> b/libstdc++-v3/include/Makefile.in
> index f038af709cc4..7f1a6592942e 100644
> --- a/libstdc++-v3/include/Makefile.in
> +++ b/libstdc++-v3/include/Makefile.in
> @@ -393,6 +393,7 @@ std_freestanding = \
> ${std_srcdir}/coroutine \
> ${std_srcdir}/expected \
> ${std_srcdir}/functional \
> + ${std_srcdir}/generator \
> ${std_srcdir}/iterator \
> ${std_srcdir}/limits \
> ${std_srcdir}/memory \
> @@ -477,6 +478,7 @@ bits_freestanding = \
> ${bits_srcdir}/concept_check.h \
> ${bits_srcdir}/char_traits.h \
> ${bits_srcdir}/cpp_type_traits.h \
> + ${bits_srcdir}/elements_of.h \
> ${bits_srcdir}/enable_special_members.h \
> ${bits_srcdir}/functexcept.h \
> ${bits_srcdir}/functional_hash.h \
> diff --git a/libstdc++-v3/include/bits/elements_of.h
> b/libstdc++-v3/include/bits/elements_of.h
> new file mode 100644
> index 000000000000..663e15a94aa7
> --- /dev/null
> +++ b/libstdc++-v3/include/bits/elements_of.h
> @@ -0,0 +1,72 @@
> +// Tag type for yielding ranges rather than values in <generator> -*- C++
> -*-
> +
> +// Copyright (C) 2023 Free Software Foundation, Inc.
> +//
> +// This file is part of the GNU ISO C++ Library. This library is free
> +// software; you can redistribute it and/or modify it under the
> +// terms of the GNU General Public License as published by the
> +// Free Software Foundation; either version 3, or (at your option)
> +// any later version.
> +
> +// This library is distributed in the hope that it will be useful,
> +// but WITHOUT ANY WARRANTY; without even the implied warranty of
> +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> +// GNU General Public License for more details.
> +
> +// Under Section 7 of GPL version 3, you are granted additional
> +// permissions described in the GCC Runtime Library Exception, version
> +// 3.1, as published by the Free Software Foundation.
> +
> +// You should have received a copy of the GNU General Public License and
> +// a copy of the GCC Runtime Library Exception along with this program;
> +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
> +// <http://www.gnu.org/licenses/>.
> +
> +#ifndef _GLIBCXX_BITS_ELEMENTS_OF
> +#define _GLIBCXX_BITS_ELEMENTS_OF
> +
> +#pragma GCC system_header
> +
> +#include <bits/c++config.h>
> +
> +#include <bits/version.h>
> +
> +// C++ >= 23 && __glibcxx_coroutine
> +#if defined(__glibcxx_ranges) && defined(__glibcxx_generator)
> +#include <bits/ranges_base.h>
> +#include <bits/memoryfwd.h>
> +
> +#if _GLIBCXX_HOSTED
> +# include <bits/allocator.h> // likely desirable if hosted.
> +#endif // HOSTED
> +
> +namespace std _GLIBCXX_VISIBILITY(default)
> +{
> +_GLIBCXX_BEGIN_NAMESPACE_VERSION
> +namespace ranges
> +{
> +
> + /**
> + * @ingroup ranges
> + * @since C++23
> + * @{
> + */
> +
> + template<range _Range, typename _Alloc = allocator<byte>>
> + struct elements_of
> + {
> + [[no_unique_address]] _Range range;
> + [[no_unique_address]] _Alloc allocator = _Alloc();
> + };
> +
> + template<typename _Range, typename _Alloc = allocator<byte>>
> + elements_of(_Range&&, _Alloc = _Alloc())
> + -> elements_of<_Range&&, _Alloc>;
> +
> + /// @}
> +}
> +_GLIBCXX_END_NAMESPACE_VERSION
> +} // namespace std
> +
> +#endif // __glibcxx_generator && __glibcxx_ranges
> +#endif // _GLIBCXX_BITS_ELEMENTS_OF
> diff --git a/libstdc++-v3/include/bits/version.def
> b/libstdc++-v3/include/bits/version.def
> index 447fdeb95193..1edee0dbd27b 100644
> --- a/libstdc++-v3/include/bits/version.def
> +++ b/libstdc++-v3/include/bits/version.def
> @@ -1649,6 +1649,15 @@ ftms = {
> };
> };
>
> +ftms = {
> + name = generator;
> + values = {
> + v = 202207;
> + cxxmin = 23;
> + extra_cond = "__glibcxx_coroutine";
> + };
> +};
> +
> // Standard test specifications.
> stds[97] = ">= 199711L";
> stds[03] = ">= 199711L";
> diff --git a/libstdc++-v3/include/bits/version.h
> b/libstdc++-v3/include/bits/version.h
> index 97c6d8508f48..b323ea9dab9e 100644
> --- a/libstdc++-v3/include/bits/version.h
> +++ b/libstdc++-v3/include/bits/version.h
> @@ -2021,4 +2021,15 @@
> #endif /* !defined(__cpp_lib_to_string) && defined(__glibcxx_want_to_string)
> */
> #undef __glibcxx_want_to_string
>
> +// from version.def line 1637
> +#if !defined(__cpp_lib_generator)
> +# if (__cplusplus >= 202302L) && (__glibcxx_coroutine)
> +# define __glibcxx_generator 202207L
> +# if defined(__glibcxx_want_all) || defined(__glibcxx_want_generator)
> +# define __cpp_lib_generator 202207L
> +# endif
> +# endif
> +#endif /* !defined(__cpp_lib_generator) && defined(__glibcxx_want_generator)
> */
> +#undef __glibcxx_want_generator
> +
> #undef __glibcxx_want_all
> diff --git a/libstdc++-v3/include/precompiled/stdc++.h
> b/libstdc++-v3/include/precompiled/stdc++.h
> index 176ad79ff3c3..baad95dd6c3e 100644
> --- a/libstdc++-v3/include/precompiled/stdc++.h
> +++ b/libstdc++-v3/include/precompiled/stdc++.h
> @@ -222,6 +222,7 @@
>
> #if __cplusplus > 202002L
> #include <expected>
> +#include <generator>
> #include <spanstream>
> #if __has_include(<stacktrace>)
> # include <stacktrace>
> diff --git a/libstdc++-v3/include/std/generator
> b/libstdc++-v3/include/std/generator
> new file mode 100644
> index 000000000000..a06811d3dd96
> --- /dev/null
> +++ b/libstdc++-v3/include/std/generator
> @@ -0,0 +1,820 @@
> +// <generator> -*- C++ -*-
> +
> +// Copyright (C) 2023 Free Software Foundation, Inc.
> +//
> +// This file is part of the GNU ISO C++ Library. This library is free
> +// software; you can redistribute it and/or modify it under the
> +// terms of the GNU General Public License as published by the
> +// Free Software Foundation; either version 3, or (at your option)
> +// any later version.
> +
> +// This library is distributed in the hope that it will be useful,
> +// but WITHOUT ANY WARRANTY; without even the implied warranty of
> +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> +// GNU General Public License for more details.
> +
> +// Under Section 7 of GPL version 3, you are granted additional
> +// permissions described in the GCC Runtime Library Exception, version
> +// 3.1, as published by the Free Software Foundation.
> +
> +// You should have received a copy of the GNU General Public License and
> +// a copy of the GCC Runtime Library Exception along with this program;
> +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
> +// <http://www.gnu.org/licenses/>.
> +
> +/** @file include/generator
> + * This is a Standard C++ Library header.
> + */
> +
> +#ifndef _GLIBCXX_GENERATOR
> +#define _GLIBCXX_GENERATOR
> +
> +#include <ranges>
> +#pragma GCC system_header
> +
> +#include <bits/c++config.h>
> +
> +#define __glibcxx_want_generator
> +#include <bits/version.h>
> +
> +#if __cplusplus < 202302L
> +# error "std::generator is a C++23 extension"
> +#endif
Please remove this. Giving an error when a header is included breaks
this pattern:
#if __has_include(<generator>)
#include <generator>
#ifdef __cpp_lib_generator
// ... use it ...
#endif
We have such errors for C++11 headers, but those predate the existence
of __has_include and feature test macros anyway. For new headers from
C++14 and later we don't do an #error. The header should just be
empty.
> +
> +#ifdef __cpp_lib_generator // C++ >= 23 && __glibcxx_coroutine
> +#include <new>
> +#include <bits/move.h>
> +#include <bits/ranges_util.h>
> +#include <bits/elements_of.h>
> +#include <bits/uses_allocator.h>
> +#include <bits/exception_ptr.h>
> +#include <cstddef>
> +#include <cstdint>
> +#include <cstring>
> +#include <coroutine>
> +
> +#include <type_traits>
> +#include <variant>
> +#include <concepts>
> +
> +#if _GLIBCXX_HOSTED
> +# include <bits/memory_resource.h>
> +#endif // HOSTED
> +
> +namespace std _GLIBCXX_VISIBILITY(default)
> +{
> +_GLIBCXX_BEGIN_NAMESPACE_VERSION
> +
> + /**
> + * @defgroup generator_coros Range generator coroutines
> + * @addtogroup ranges
> + * @since C++23
> + * @{
> + */
> +
> + /** @brief A range specified using a yielding coroutine.
> + *
> + * `std::generator` is a utility class for defining ranges using coroutines
> + * that yield elements as a range. Generator coroutines are synchronous.
> + *
> + * @headerfile generator
> + * @since C++23
> + */
> + template<typename _Ref, typename _V = void, typename _Alloc = void>
> + class generator;
> +
> + /// @cond undocumented
> + namespace __gen
> + {
> + /// _Reference type for a generator whose reference (first argument) and
> + /// value (second argument) types are _Ref and _V.
> + template<typename _Ref, typename _V>
We avoid single letter names, because they clash with libc macros like
_T and _X. I don't think _V is actually used by any libc, but for
consistency please avoid it. So maybe _Val instead.
> + using _Reference_t = __conditional_t<is_void_v<_V>,
> + _Ref&&, _Ref>;
> +
> + /// Type yielded by a generator whose _Reference type is _Reference.
> + template<typename _Reference>
> + using _Yield_t = __conditional_t<is_reference_v<_Reference>,
> + _Reference,
> + const _Reference&>;
> +
> + /// _Yield_t * _Reference_t
> + template<typename _Ref, typename _V>
> + using _Yield2_t = _Yield_t<_Reference_t<_Ref, _V>>;
> +
> + template<typename> struct _Is_generator_t : std::false_type {};
> + template<typename _V, typename _R, typename _A>
> + struct _Is_generator_t<::std::generator<_V, _R, _A>> : std::true_type
> {};
> +
> + template<typename _T>
> + concept _Is_generator = _Is_generator_t<remove_cvref_t<_T>>::value;
We usually name concepts all lowercase, so __is_generator. But it
looks like we don't need a concept here anyway, it's only tested in a
static_assert, which can use any boolean constant. We don't need to
use _Is_generator in requires-clauses or anything like that. Unless
the intention is to allow users to specialize the _Is_generator_t
class template for their own types (is it?) then that class template
and the concept can be replaced with a variable template, which will
compile more efficiently:
template<typename> constexpr bool __is_generator = false;
template<typename _Val, typename _Ref, typename _Alloc>
constexpr bool __is_generator<std::generator<_Val, _Ref, _Alloc>> = true;
Then this can be used directly in the static_assert.
Alternatively, the __is_specialization_of variable template in
<format> could be moved to another header, and then you could just use
__is_specialization_of<std::generator>.
> +
> + /// Allocator and value type erased generator promise type.
> + /// \tparam _Yielded The corresponding generators yielded type.
> + template<typename _Yielded>
> + class _Promise_erased
> + {
> + static_assert(is_reference_v<_Yielded>);
> + using _Yielded_deref = remove_reference_t<_Yielded>;
> + using _Yielded_decvref = remove_cvref_t<_Yielded>;
> + using _ValuePtr = add_pointer_t<_Yielded>;
> + using _Coro_handle = std::coroutine_handle<_Promise_erased>;
> +
> + template<typename, typename, typename>
> + friend struct std::generator;
s/struct/class/
> +
> + template<typename _Gen>
> + struct _Recursive_awaiter;
> + template<typename>
> + friend struct _Recursive_awaiter;
> + struct _Copy_awaiter;
> + struct _Subyield_state;
> + struct _Final_awaiter;
> + public:
> + suspend_always
> + initial_suspend() const noexcept
> + { return {}; }
> +
> + suspend_always
> + yield_value(_Yielded __val) noexcept
> + {
> + _M_bottom_value() = ::std::addressof(__val);
> + return {};
> + }
> +
> + auto
> + yield_value(const _Yielded_deref& __val)
> + noexcept (is_nothrow_constructible_v<_Yielded_decvref,
> + const _Yielded_deref&>)
> + requires (is_rvalue_reference_v<_Yielded>
> + && constructible_from<_Yielded_decvref,
> + const _Yielded_deref&>)
> + { return _Copy_awaiter(__val, _M_bottom_value()); }
> +
> + template<typename _R2, typename _V2, typename _A2, typename _U2>
> + requires std::same_as<_Yield2_t<_R2, _V2>, _Yielded>
> + auto
> + yield_value(ranges::elements_of<generator<_R2, _V2, _A2>&&, _U2> __r)
> + noexcept
> + { return _Recursive_awaiter { std::move(__r.range) }; }
> +
> + template<ranges::input_range _R, typename _Alloc>
> + requires convertible_to<ranges::range_reference_t<_R>, _Yielded>
> + auto
> + yield_value(ranges::elements_of<_R, _Alloc> __r)
> + noexcept
> + {
> + auto __n = [] (allocator_arg_t, _Alloc,
> + ranges::iterator_t<_R> __i,
> + ranges::sentinel_t<_R> __s)
> + -> generator<_Yielded, ranges::range_value_t<_R>, _Alloc> {
> + for (; __i != __s; ++__i)
> + co_yield static_cast<_Yielded>(*__i);
> + };
> + return yield_value(ranges::elements_of(__n(allocator_arg,
> + __r.allocator,
> + ranges::begin(__r.range),
> +
> ranges::end(__r.range))));
> + }
> +
> +
> + _Final_awaiter
> + final_suspend() noexcept
> + { return {}; }
> +
> + void
> + unhandled_exception()
> + {
> + // To get to this point, this coroutine must have been active. In
> that
> + // case, it must be the top of the stack. The current coroutine is
> + // the sole entry of the stack iff it is both the top and the
> bottom. As
> + // it is the top implicitly in this context it will be the sole
> entry iff
> + // it is the bottom.
> + if (_M_nest._M_is_bottom())
> + throw;
> + else
> + this->_M_except = std::current_exception();
> + }
> +
> + void await_transform() = delete;
> + void return_void() const noexcept {}
> +
> + private:
> + _ValuePtr&
> + _M_bottom_value() noexcept
> + { return _M_nest._M_bottom_value(*this); }
> +
> + _ValuePtr&
> + _M_value() noexcept
> + { return _M_nest._M_value(*this); }
> +
> + _Subyield_state _M_nest;
> + std::exception_ptr _M_except;
> + };
> +
> + template<typename _Yielded>
> + struct _Promise_erased<_Yielded>::_Subyield_state
> + {
> + struct _Frame
> + {
> + _Coro_handle _M_bottom;
> + _Coro_handle _M_parent;
> + };
> +
> + struct _Bottom_frame
> + {
> + _Coro_handle _M_top;
> + _ValuePtr _M_value = nullptr;
> + };
> +
> + std::variant<
> + _Bottom_frame,
> + _Frame
> + > _M_stack;
> +
> + bool
> + _M_is_bottom() const noexcept
> + { return !std::holds_alternative<_Frame>(this->_M_stack); }
> +
> + _Coro_handle&
> + _M_top() noexcept
> + {
> + if (auto __f = std::get_if<_Frame>(&this->_M_stack))
> + return __f->_M_bottom.promise()._M_nest._M_top();
> +
> + auto __bf = std::get_if<_Bottom_frame>(&this->_M_stack);
> + __glibcxx_assert(__bf);
> + return __bf->_M_top;
> + }
> +
> + void
> + _M_push(_Coro_handle __current, _Coro_handle __subyield) noexcept
> + {
> + __glibcxx_assert(&__current.promise()._M_nest == this);
> + __glibcxx_assert(this->_M_top() == __current);
> +
> + __subyield.promise()._M_nest._M_jump_in(__current, __subyield);
> + }
> +
> + std::coroutine_handle<>
> + _M_pop() noexcept
> + {
> + if (auto __f = std::get_if<_Frame>(&this->_M_stack))
> + {
> + // We aren't a bottom coroutine. Restore the parent to the top
> + // and resume.
> + auto __p = this->_M_top() = __f->_M_parent;
> + return __p;
> + }
> + else
> + // Otherwise, there's nothing to resume.
> + return std::noop_coroutine();
> + }
> +
> + void
> + _M_jump_in(_Coro_handle __rest, _Coro_handle __new) noexcept
> + {
> + __glibcxx_assert(&__new.promise()._M_nest == this);
> + __glibcxx_assert(this->_M_is_bottom());
> + // We're bottom. We're also top of top is unset (note that this is
> + // not true if something was added to the coro stack and then
> popped,
> + // but in that case we can't possibly be yielded from, as it would
> + // require rerunning begin()).
> + __glibcxx_assert(!this->_M_top());
> +
> + auto& __rn = __rest.promise()._M_nest;
> + __rn._M_top() = __new;
> +
> + // Presume we're the second frame...
> + auto& __bott = __rest;
> + if (auto __f = std::get_if<_Frame>(&__rn._M_stack))
> + // But, if we aren't, get the actual bottom. We're only the
> second
> + // frame if our parent is the bottom frame, i.e. it doesn't have a
> + // _Frame member.
> + __bott = __f->_M_bottom;
> +
> + this->_M_stack = _Frame {
> + ._M_bottom = __bott,
> + ._M_parent = __rest
> + };
> + }
> +
> + _ValuePtr&
> + _M_bottom_value(_Promise_erased& __current) noexcept
> + {
> + __glibcxx_assert(&__current._M_nest == this);
> + if (auto __bf = std::get_if<_Bottom_frame>(&this->_M_stack))
> + return __bf->_M_value;
> + auto __f = std::get_if<_Frame>(&this->_M_stack);
> + __glibcxx_assert(__f);
> + auto& __p = __f->_M_bottom.promise();
> + return __p._M_nest._M_value(__p);
> + }
> +
> + _ValuePtr&
> + _M_value(_Promise_erased& __current) noexcept
> + {
> + __glibcxx_assert(&__current._M_nest == this);
> + auto __bf = std::get_if<_Bottom_frame>(&this->_M_stack);
> + __glibcxx_assert(__bf);
> + return __bf->_M_value;
> + }
> + };
> +
> + template<typename _Yielded>
> + struct _Promise_erased<_Yielded>::_Final_awaiter
> + {
> + bool await_ready() noexcept
> + { return false; }
> +
> + template<typename _Promise>
> + auto await_suspend(std::coroutine_handle<_Promise> __c) noexcept
> + {
> + static_assert(is_pointer_interconvertible_base_of_v<
> + _Promise_erased, _Promise>);
> +
> + auto& __n = __c.promise()._M_nest;
> + return __n._M_pop();
> + }
> +
> + void await_resume() noexcept {}
> + };
> +
> + template<typename _Yielded>
> + struct _Promise_erased<_Yielded>::_Copy_awaiter
> + {
> + _Yielded_decvref _M_value;
> + _ValuePtr& _M_bottom_value;
> +
> + constexpr bool await_ready() noexcept
> + { return false; }
> +
> + template<typename _Promise>
> + void await_suspend(std::coroutine_handle<_Promise>) noexcept
> + {
> + static_assert(is_pointer_interconvertible_base_of_v<
> + _Promise_erased, _Promise>);
> + _M_bottom_value = ::std::addressof(_M_value);
> + }
> +
> + constexpr void
> + await_resume() const noexcept
> + {}
> + };
> +
> + template<typename _Yielded>
> + template<typename _Gen>
> + struct _Promise_erased<_Yielded>::_Recursive_awaiter
> + {
> + _Gen _M_gen;
> + static_assert(_Is_generator<_Gen>);
> + static_assert(std::same_as<typename _Gen::yielded, _Yielded>);
> +
> + _Recursive_awaiter(_Gen __gen) noexcept
> + : _M_gen(std::move(__gen))
> + { this->_M_gen._M_mark_as_started(); }
> +
> + constexpr bool
> + await_ready() const noexcept
> + { return false; }
> +
> +
> + template<typename _Promise>
> + std::coroutine_handle<>
> + await_suspend(std::coroutine_handle<_Promise> __p) noexcept
> + {
> + static_assert(is_pointer_interconvertible_base_of_v<
> + _Promise_erased, _Promise>);
> +
> + auto __c = _Coro_handle::from_address(__p.address());
> + auto __t =
> _Coro_handle::from_address(this->_M_gen._M_coro.address());
> + __p.promise()._M_nest._M_push(__c, __t);
> + return __t;
> + }
> +
> + void await_resume()
> + {
> + if (auto __e = _M_gen._M_coro.promise()._M_except)
> + std::rethrow_exception(__e);
> + }
> + };
> +
> + struct _Alloc_block
> + {
> + alignas(__STDCPP_DEFAULT_NEW_ALIGNMENT__)
> + char _M_data[__STDCPP_DEFAULT_NEW_ALIGNMENT__];
> +
> + static auto
> + _M_cnt(std::size_t __sz) noexcept
> + {
> + auto __blksz = sizeof(_Alloc_block);
> + return (__sz + __blksz - 1) / __blksz;
> + }
> + };
> +
> + template<typename _A>
> + concept _Stateless_alloc = (allocator_traits<_A>::is_always_equal::value
> + && default_initializable<_A>);
> +
> + template<typename _Alloc>
> + class _Promise_alloc
> + {
> + using _ATr = allocator_traits<_Alloc>;
> + using _Rebound = typename _ATr::template rebind_alloc<_Alloc_block>;
> + using _Rebound_ATr = typename _ATr
> + ::template rebind_traits<_Alloc_block>;
> + static_assert(is_pointer_v<typename _Rebound_ATr::pointer>,
> + "Must use allocators for true pointers with
> generators");
> +
> + static auto
> + _M_alloc_address(std::uintptr_t __fn, std::uintptr_t __fsz) noexcept
> + {
> + auto __an = __fn + __fsz;
> + auto __ba = alignof(_Rebound);
> + return reinterpret_cast<_Rebound*>(((__an + __ba - 1) / __ba) *
> __ba);
> + }
> +
> + static auto
> + _M_alloc_size(std::size_t __csz) noexcept
> + {
> + auto __ba = alignof(_Rebound);
> + // Our desired layout is placing the coroutine frame, then pad out
> to
> + // align, then place the allocator. The total size of that is the
> + // size of the coroutine frame, plus up to __ba bytes, plus the size
> + // of the allocator.
> + return __csz + __ba + sizeof(_Rebound);
> + }
> +
> + static void*
> + _M_allocate(_Rebound __b, std::size_t __csz)
> + {
> + if constexpr (_Stateless_alloc<_Rebound>)
> + // Only need room for the coroutine.
> + return __b.allocate(_Alloc_block::_M_cnt(__csz));
> + else
> + {
> + auto __nsz = _Alloc_block::_M_cnt(_M_alloc_size(__csz));
> + auto __f = __b.allocate(__nsz);
> + auto __fn = reinterpret_cast<std::uintptr_t>(__f);
> + auto __an = _M_alloc_address(__fn, __csz);
> + ::new (__an) _Rebound(std::move(__b));
> + return __f;
> + }
> + }
> +
> + public:
> + void*
> + operator new(std::size_t __sz)
> + requires default_initializable<_Rebound> // _Alloc is non-void
> + { return _M_allocate({}, __sz); }
> +
> + template<typename _NA, typename... _Args>
> + void*
> + operator new(std::size_t __sz,
> + allocator_arg_t, const _NA& __na,
> + const _Args&...)
> + requires convertible_to<const _NA&, _Alloc>
> + {
> + return _M_allocate(static_cast<_Rebound>(static_cast<_Alloc>(__na)),
> + __sz);
> + }
> +
> + template<typename _This, typename _NA, typename... _Args>
> + void*
> + operator new(std::size_t __sz,
> + const _This&,
> + allocator_arg_t, const _NA& __na,
> + const _Args&...)
> + requires convertible_to<const _NA&, _Alloc>
> + {
> + return _M_allocate(static_cast<_Rebound>(static_cast<_Alloc>(__na)),
> + __sz);
> + }
> +
> + void
> + operator delete(void* __ptr, std::size_t __csz) noexcept
> + {
> + if constexpr (_Stateless_alloc<_Rebound>)
> + {
> + _Rebound __b;
> + return __b.deallocate(reinterpret_cast<_Alloc_block*>(__ptr),
> + _Alloc_block::_M_cnt(__csz));
> + }
> + else
> + {
> + auto __nsz = _Alloc_block::_M_cnt(_M_alloc_size(__csz));
> + auto __fn = reinterpret_cast<std::uintptr_t>(__ptr);
> + auto __an = _M_alloc_address(__fn, __csz);
> + _Rebound __b(std::move(*__an));
> + __an->~_Rebound();
> + __b.deallocate(reinterpret_cast<_Alloc_block*>(__ptr), __nsz);
> + }
> + }
> + };
> +
> + template<>
> + class _Promise_alloc<void>
> + {
> + using _Dealloc_fn = void (*)(void*, std::size_t);
> +
> + static auto
> + _M_dealloc_address(std::uintptr_t __fn, std::uintptr_t __fsz) noexcept
> + {
> + auto __an = __fn + __fsz;
> + auto __ba = alignof(_Dealloc_fn);
> + auto __aligned = ((__an + __ba - 1) / __ba) * __ba;
> + return reinterpret_cast<_Dealloc_fn*>(__aligned);
> + }
> +
> + template<typename _Rebound>
> + static auto
> + _M_alloc_address(std::uintptr_t __fn, std::uintptr_t __fsz) noexcept
> + requires (!_Stateless_alloc<_Rebound>)
> + {
> + auto __ba = alignof(_Rebound);
> + auto __da = _M_dealloc_address(__fn, __fsz);
> + auto __aan = reinterpret_cast<std::uintptr_t>(__da);
> + __aan += sizeof(_Dealloc_fn);
> + auto __aligned = ((__aan + __ba - 1) / __ba) * __ba;
> + return reinterpret_cast<_Rebound*>(__aligned);
> + }
> +
> + template<typename _Rebound>
> + static auto
> + _M_alloc_size(std::size_t __csz) noexcept
> + {
> + // This time, we want the coroutine frame, then the deallocator
> + // pointer, then the allocator itself, if any.
> + std::size_t __aa = 0;
> + std::size_t __as = 0;
> + if constexpr (!std::same_as<_Rebound, void>)
> + {
> + __aa = alignof(_Rebound);
> + __as = sizeof(_Rebound);
> + }
> + auto __ba = __aa + alignof(_Dealloc_fn);
> + return __csz + __ba + __as + sizeof(_Dealloc_fn);
> + }
> +
> + template<typename _Rebound>
> + static void
> + _M_deallocator(void* __ptr, std::size_t __csz) noexcept
> + {
> + auto __asz = _M_alloc_size<_Rebound>(__csz);
> + auto __nblk = _Alloc_block::_M_cnt(__asz);
> +
> + if constexpr (_Stateless_alloc<_Rebound>)
> + {
> + _Rebound __b;
> + __b.deallocate(reinterpret_cast<_Alloc_block*>(__ptr), __nblk);
> + }
> + else
> + {
> + auto __fn = reinterpret_cast<std::uintptr_t>(__ptr);
> + auto __an = _M_alloc_address<_Rebound>(__fn, __csz);
> + _Rebound __b(std::move(*__an));
> + __an->~_Rebound();
> + __b.deallocate(reinterpret_cast<_Alloc_block*>(__ptr), __nblk);
> + }
> + }
> +
> + template<typename _NA>
> + static void*
> + _M_allocate(const _NA& __na, std::size_t __csz)
> + {
> + using _Rebound = typename std::allocator_traits<_NA>
> + ::template rebind_alloc<_Alloc_block>;
> + using _Rebound_ATr = typename std::allocator_traits<_NA>
> + ::template rebind_traits<_Alloc_block>;
> +
> + static_assert(is_pointer_v<typename _Rebound_ATr::pointer>,
> + "Must use allocators for true pointers with
> generators");
> +
> + _Dealloc_fn __d = &_M_deallocator<_Rebound>;
> + auto __b = static_cast<_Rebound>(__na);
> + auto __asz = _M_alloc_size<_Rebound>(__csz);
> + auto __nblk = _Alloc_block::_M_cnt(__asz);
> + void* __p = __b.allocate(__nblk);
> + auto __pn = reinterpret_cast<std::uintptr_t>(__p);
> + *_M_dealloc_address(__pn, __csz) = __d;
> + if constexpr (!_Stateless_alloc<_Rebound>)
> + {
> + auto __an = _M_alloc_address<_Rebound>(__pn, __csz);
> + ::new (__an) _Rebound(std::move(__b));
> + }
> + return __p;
> + }
> + public:
> + void*
> + operator new(std::size_t __sz)
> + {
> + auto __nsz = _M_alloc_size<void>(__sz);
> + _Dealloc_fn __d = [] (void* __ptr, std::size_t __sz)
> + {
> + ::operator delete(__ptr, _M_alloc_size<void>(__sz));
> + };
> + auto __p = ::operator new(__nsz);
> + auto __pn = reinterpret_cast<uintptr_t>(__p);
> + *_M_dealloc_address(__pn, __sz) = __d;
> + return __p;
> + }
> +
> + template<typename _NA, typename... _Args>
Please use _Na instead of _NA so it's not all-caps.
> + void*
> + operator new(std::size_t __sz,
> + allocator_arg_t, const _NA& __na,
> + const _Args&...)
> + { return _M_allocate(__na, __sz); }
> +
> + template<typename _This, typename _NA, typename... _Args>
> + void*
> + operator new(std::size_t __sz,
> + const _This&,
> + allocator_arg_t, const _NA& __na,
> + const _Args&...)
> + { return _M_allocate(__na, __sz); }
> +
> + void
> + operator delete(void* __ptr, std::size_t __sz) noexcept
> + {
> + _Dealloc_fn __d;
> + auto __pn = reinterpret_cast<uintptr_t>(__ptr);
> + __d = *_M_dealloc_address(__pn, __sz);
> + __d(__ptr, __sz);
> + }
> + };
> +
> + template<typename _T>
s/T/_Tp/
> + concept _Cv_unqualified_object = is_object_v<_T>
> + && same_as<_T, remove_cv_t<_T>>;
> + } // namespace __gen
> + /// @endcond
> +
> + template<typename _Ref, typename _V, typename _Alloc>
> + class generator
> + : public ranges::view_interface<generator<_Ref, _V, _Alloc>>
> + {
> + using _Value = __conditional_t<is_void_v<_V>, remove_cvref_t<_Ref>,
> _V>;
> + static_assert(__gen::_Cv_unqualified_object<_Value>,
> + "Generator value must be a cv-unqualified object type");
> + using _Reference = __gen::_Reference_t<_Ref, _V>;
> + static_assert(is_reference_v<_Reference>
> + || (__gen::_Cv_unqualified_object<_Reference>
> + && copy_constructible<_Reference>),
> + "Generator reference type must be either a cv-unqualified
> "
> + "object type that is trivially constructible or a "
> + "reference type");
> +
> + using _RRef = __conditional_t<
> + is_reference_v<_Reference>,
> + remove_reference_t<_Reference>&&,
> + _Reference>;
> +
> + /* Required to model indirectly_readable, and input_iterator. */
> + static_assert(common_reference_with<_Reference&&, _Value&&>);
> + static_assert(common_reference_with<_Reference&&, _RRef&&>);
> + static_assert(common_reference_with<_RRef&&, const _Value&>);
> +
> + using _Yielded = __gen::_Yield_t<_Reference>;
> + using _Erased_promise = __gen::_Promise_erased<_Yielded>;
> +
> + struct _Iterator;
> +
> + friend _Erased_promise;
> + friend struct _Erased_promise::_Subyield_state;
> + public:
> + using yielded = _Yielded;
> +
> + struct promise_type : _Erased_promise, __gen::_Promise_alloc<_Alloc>
> + {
> + generator get_return_object() noexcept
> + { return { coroutine_handle<promise_type>::from_promise(*this) }; }
> + };
> +
> + static_assert(is_pointer_interconvertible_base_of_v<_Erased_promise,
> + promise_type>);
> +
> + generator(const generator&) = delete;
> +
> + generator(generator&& __other) noexcept
> + : _M_coro(std::__exchange(__other._M_coro, nullptr)),
> + _M_began(std::__exchange(__other._M_began, false))
> + {}
> +
> + ~generator()
> + {
> + if (auto& __c = this->_M_coro)
> + __c.destroy();
> + }
> +
> + generator&
> + operator=(generator __other) noexcept
> + {
> + swap(__other._M_coro, this->_M_coro);
> + swap(__other._M_began, this->_M_began);
> + }
> +
> + _Iterator
> + begin()
> + {
> + this->_M_mark_as_started();
> + auto __h = _Coro_handle::from_promise(_M_coro.promise());
> + __h.promise()._M_nest._M_top() = __h;
> + return { __h };
> + }
> +
> + default_sentinel_t
> + end() const noexcept
> + { return default_sentinel; }
> +
> + private:
> + using _Coro_handle = std::coroutine_handle<_Erased_promise>;
> +
> + generator(coroutine_handle<promise_type> __coro) noexcept
> + : _M_coro { move(__coro) }
> + {}
> +
> + void
> + _M_mark_as_started() noexcept
> + {
> + __glibcxx_assert(!this->_M_began);
> + this->_M_began = true;
> + }
> +
> + coroutine_handle<promise_type> _M_coro;
> + bool _M_began = false;
> + };
> +
> + template<class _Ref, class _V, class _Alloc>
> + struct generator<_Ref, _V, _Alloc>::_Iterator
> + {
> + using value_type = _Value;
> + using difference_type = ptrdiff_t;
> +
> + friend bool
> + operator==(const _Iterator& i, default_sentinel_t) noexcept
> + { return i._M_coro.done(); }
__i
> +
> + friend class generator;
> +
> + _Iterator(_Iterator&& __o) noexcept
> + : _M_coro(std::__exchange(__o._M_coro, {}))
> + {}
> +
> + _Iterator&
> + operator=(_Iterator&& __o) noexcept
> + {
> + this->_M_coro = std::__exchange(__o._M_coro, {});
> + return *this;
> + }
> +
> + _Iterator&
> + operator++()
> + {
> + _M_next();
> + return *this;
> + }
> +
> + void
> + operator++(int)
> + { this->operator++(); }
> +
> + yielded
> + operator*()
> + const noexcept(is_nothrow_move_constructible_v<_Reference>)
> + {
> + auto& __p = this->_M_coro.promise();
> + return static_cast<yielded>(*__p._M_value());
> + }
> +
> + private:
> + friend class generator;
> +
> + _Iterator(_Coro_handle __g)
> + : _M_coro { __g }
> + { this->_M_next(); }
> +
> + void _M_next()
> + {
> + auto& __t = this->_M_coro.promise()._M_nest._M_top();
> + __t.resume();
> + }
> +
> + _Coro_handle _M_coro;
> + };
> +
> + /// @}
> +
> +#if _GLIBCXX_HOSTED
> + namespace pmr {
> + template<class R, class V = void>
s/class/typename/
And uglify the names (_Ref and _Val).
> + using generator = std::generator<R, V, polymorphic_allocator<std::byte>>;
> + }
> +#endif // HOSTED
> +
> +_GLIBCXX_END_NAMESPACE_VERSION
> +} // namespace std
> +#endif // __cpp_lib_generator
> +
> +#endif // _GLIBCXX_GENERATOR
> diff --git a/libstdc++-v3/include/std/ranges b/libstdc++-v3/include/std/ranges
> index 26d6c013ad04..fde8c6cd706d 100644
> --- a/libstdc++-v3/include/std/ranges
> +++ b/libstdc++-v3/include/std/ranges
> @@ -67,6 +67,10 @@
> #define __glibcxx_want_ranges_zip
> #include <bits/version.h>
>
> +#ifdef __glibcxx_generator // C++ >= 23 && __glibcxx_coroutine
> +# include <bits/elements_of.h>
> +#endif
> +
> /**
> * @defgroup ranges Ranges
> *
> diff --git a/libstdc++-v3/testsuite/24_iterators/range_generators/01.cc
> b/libstdc++-v3/testsuite/24_iterators/range_generators/01.cc
> new file mode 100644
> index 000000000000..bedbec3d353f
> --- /dev/null
> +++ b/libstdc++-v3/testsuite/24_iterators/range_generators/01.cc
> @@ -0,0 +1,55 @@
> +// { dg-do run { target c++23 } }
> +// Copyright (C) 2023 Free Software Foundation, Inc.
> +//
> +// This file is part of the GNU ISO C++ Library. This library is free
> +// software; you can redistribute it and/or modify it under the
> +// terms of the GNU General Public License as published by the
> +// Free Software Foundation; either version 3, or (at your option)
> +// any later version.
> +
> +// This library is distributed in the hope that it will be useful,
> +// but WITHOUT ANY WARRANTY; without even the implied warranty of
> +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> +// GNU General Public License for more details.
> +
> +// Under Section 7 of GPL version 3, you are granted additional
> +// permissions described in the GCC Runtime Library Exception, version
> +// 3.1, as published by the Free Software Foundation.
> +
> +// You should have received a copy of the GNU General Public License and
> +// a copy of the GCC Runtime Library Exception along with this program;
> +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
> +// <http://www.gnu.org/licenses/>.
> +
> +#include <generator>
> +#include <iostream>
> +
> +// basic example
> +std::generator<int>
> +bar()
> +{
> + co_yield 3;
> + co_yield 4;
> +}
> +
> +std::generator<int>
> +foo()
> +{
> + co_yield 1;
> + co_yield 2;
> + co_yield std::ranges::elements_of { bar() };
> + co_yield 5;
> +}
> +
> +int
> +main()
> +{
> + for (auto x : foo())
> + std::cout << x << '\n';
> +}
> +
> +// { dg-output {1(\n|\r\n|\r)} }
> +// { dg-output {2(\n|\r\n|\r)} }
> +// { dg-output {3(\n|\r\n|\r)} }
> +// { dg-output {4(\n|\r\n|\r)} }
> +// { dg-output {5(\n|\r\n|\r)} }
> diff --git a/libstdc++-v3/testsuite/24_iterators/range_generators/02.cc
> b/libstdc++-v3/testsuite/24_iterators/range_generators/02.cc
> new file mode 100644
> index 000000000000..570daedca75b
> --- /dev/null
> +++ b/libstdc++-v3/testsuite/24_iterators/range_generators/02.cc
> @@ -0,0 +1,219 @@
> +// { dg-do run { target c++23 } }
> +// Copyright (C) 2023 Free Software Foundation, Inc.
> +//
> +// This file is part of the GNU ISO C++ Library. This library is free
> +// software; you can redistribute it and/or modify it under the
> +// terms of the GNU General Public License as published by the
> +// Free Software Foundation; either version 3, or (at your option)
> +// any later version.
> +
> +// This library is distributed in the hope that it will be useful,
> +// but WITHOUT ANY WARRANTY; without even the implied warranty of
> +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> +// GNU General Public License for more details.
> +
> +// Under Section 7 of GPL version 3, you are granted additional
> +// permissions described in the GCC Runtime Library Exception, version
> +// 3.1, as published by the Free Software Foundation.
> +
> +// You should have received a copy of the GNU General Public License and
> +// a copy of the GCC Runtime Library Exception along with this program;
> +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
> +// <http://www.gnu.org/licenses/>.
> +
> +#include <iostream>
> +#include <generator>
> +#include <testsuite_hooks.h>
> +
> +struct foo
> +{
> + int id;
> +
> + foo(int id)
> + : id { id }
> + {}
> +
> + foo(const foo& o)
> + : id { o.id * 100 }
> + {
> + std::cout << "copy-consed " << o.id << "->" << id << '\n';
> + }
> +
> + foo&
> + operator=(const foo& o)
> + {
> + id = o.id * 100;
> + std::cout << "copied " << o.id << "->" << id << '\n';
> + return *this;
> + }
> +
> + foo(foo&& o)
> + : id { o.id }
> + {
> + o.id = -1;
> + std::cout << "moved " << id << '\n';
> + }
> +
> + foo&
> + operator=(foo&& o)
> + {
> + std::swap(o.id, id);
> + std::cout << "swapped " << id << '\n';
> + return *this;
> + }
> +};
> +
> +std::generator<foo>
> +foogen()
> +{
> + co_yield foo{0};
> +
> + {
> + foo f {1};
> + co_yield f;
> + }
> +
> + {
> + const foo f {2};
> + co_yield f;
> + }
> +
> + {
> + foo f {3};
> + co_yield std::move(f);
> + }
> +}
> +
> +std::generator<const foo&>
> +foogen2()
> +{
> + co_yield foo{0};
> +
> + {
> + foo f {1};
> + co_yield f;
> + }
> +
> + {
> + const foo f {2};
> + co_yield f;
> + }
> +
> + {
> + foo f {3};
> + co_yield std::move(f);
> + }
> +}
> +
> +std::generator<foo&&>
> +foogen3()
> +{
> + co_yield foo{0};
> +
> + {
> + foo f {1};
> + co_yield f;
> + }
> +
> + {
> + const foo f {2};
> + co_yield f;
> + }
> +
> + {
> + foo f {3};
> + co_yield std::move(f);
> + }
> +}
> +
> +int
> +main()
> +{
> + for (auto f : foogen())
> + std::cout << f.id << '\n';
> + for (const auto& f : foogen())
> + std::cout << f.id << '\n';
> + for (auto&& f : foogen())
> + std::cout << f.id << '\n';
> +
> + std::cout << "---\n";
> +
> + for (auto f : foogen2())
> + std::cout << f.id << '\n';
> + for (const auto& f : foogen2())
> + std::cout << f.id << '\n';
> + for (auto&& f : foogen2())
> + std::cout << f.id << '\n';
> +
> + std::cout << "---\n";
> +
> + for (auto f : foogen3())
> + std::cout << f.id << '\n';
> + for (const auto& f : foogen3())
> + std::cout << f.id << '\n';
> + for (auto&& f : foogen3())
> + std::cout << f.id << '\n';
> +}
> +
> +// { dg-output {moved 0(\n|\r\n|\r)} }
> +// { dg-output {0(\n|\r\n|\r)} }
> +// { dg-output {copy-consed 1->100(\n|\r\n|\r)} }
> +// { dg-output {moved 100(\n|\r\n|\r)} }
> +// { dg-output {100(\n|\r\n|\r)} }
> +// { dg-output {copy-consed 2->200(\n|\r\n|\r)} }
> +// { dg-output {moved 200(\n|\r\n|\r)} }
> +// { dg-output {200(\n|\r\n|\r)} }
> +// { dg-output {moved 3(\n|\r\n|\r)} }
> +// { dg-output {3(\n|\r\n|\r)} }
> +// { dg-output {0(\n|\r\n|\r)} }
> +// { dg-output {copy-consed 1->100(\n|\r\n|\r)} }
> +// { dg-output {100(\n|\r\n|\r)} }
> +// { dg-output {copy-consed 2->200(\n|\r\n|\r)} }
> +// { dg-output {200(\n|\r\n|\r)} }
> +// { dg-output {3(\n|\r\n|\r)} }
> +// { dg-output {0(\n|\r\n|\r)} }
> +// { dg-output {copy-consed 1->100(\n|\r\n|\r)} }
> +// { dg-output {100(\n|\r\n|\r)} }
> +// { dg-output {copy-consed 2->200(\n|\r\n|\r)} }
> +// { dg-output {200(\n|\r\n|\r)} }
> +// { dg-output {3(\n|\r\n|\r)} }
> +// { dg-output {---(\n|\r\n|\r)} }
> +// { dg-output {copy-consed 0->0(\n|\r\n|\r)} }
> +// { dg-output {0(\n|\r\n|\r)} }
> +// { dg-output {copy-consed 1->100(\n|\r\n|\r)} }
> +// { dg-output {100(\n|\r\n|\r)} }
> +// { dg-output {copy-consed 2->200(\n|\r\n|\r)} }
> +// { dg-output {200(\n|\r\n|\r)} }
> +// { dg-output {copy-consed 3->300(\n|\r\n|\r)} }
> +// { dg-output {300(\n|\r\n|\r)} }
> +// { dg-output {0(\n|\r\n|\r)} }
> +// { dg-output {1(\n|\r\n|\r)} }
> +// { dg-output {2(\n|\r\n|\r)} }
> +// { dg-output {3(\n|\r\n|\r)} }
> +// { dg-output {0(\n|\r\n|\r)} }
> +// { dg-output {1(\n|\r\n|\r)} }
> +// { dg-output {2(\n|\r\n|\r)} }
> +// { dg-output {3(\n|\r\n|\r)} }
> +// { dg-output {---(\n|\r\n|\r)} }
> +// { dg-output {moved 0(\n|\r\n|\r)} }
> +// { dg-output {0(\n|\r\n|\r)} }
> +// { dg-output {copy-consed 1->100(\n|\r\n|\r)} }
> +// { dg-output {moved 100(\n|\r\n|\r)} }
> +// { dg-output {100(\n|\r\n|\r)} }
> +// { dg-output {copy-consed 2->200(\n|\r\n|\r)} }
> +// { dg-output {moved 200(\n|\r\n|\r)} }
> +// { dg-output {200(\n|\r\n|\r)} }
> +// { dg-output {moved 3(\n|\r\n|\r)} }
> +// { dg-output {3(\n|\r\n|\r)} }
> +// { dg-output {0(\n|\r\n|\r)} }
> +// { dg-output {copy-consed 1->100(\n|\r\n|\r)} }
> +// { dg-output {100(\n|\r\n|\r)} }
> +// { dg-output {copy-consed 2->200(\n|\r\n|\r)} }
> +// { dg-output {200(\n|\r\n|\r)} }
> +// { dg-output {3(\n|\r\n|\r)} }
> +// { dg-output {0(\n|\r\n|\r)} }
> +// { dg-output {copy-consed 1->100(\n|\r\n|\r)} }
> +// { dg-output {100(\n|\r\n|\r)} }
> +// { dg-output {copy-consed 2->200(\n|\r\n|\r)} }
> +// { dg-output {200(\n|\r\n|\r)} }
> +// { dg-output {3(\n|\r\n|\r)} }
> diff --git a/libstdc++-v3/testsuite/24_iterators/range_generators/copy.cc
> b/libstdc++-v3/testsuite/24_iterators/range_generators/copy.cc
> new file mode 100644
> index 000000000000..5e5474d0de53
> --- /dev/null
> +++ b/libstdc++-v3/testsuite/24_iterators/range_generators/copy.cc
> @@ -0,0 +1,97 @@
> +// { dg-do run { target c++23 } }
> +// Copyright (C) 2023 Free Software Foundation, Inc.
> +//
> +// This file is part of the GNU ISO C++ Library. This library is free
> +// software; you can redistribute it and/or modify it under the
> +// terms of the GNU General Public License as published by the
> +// Free Software Foundation; either version 3, or (at your option)
> +// any later version.
> +
> +// This library is distributed in the hope that it will be useful,
> +// but WITHOUT ANY WARRANTY; without even the implied warranty of
> +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> +// GNU General Public License for more details.
> +
> +// Under Section 7 of GPL version 3, you are granted additional
> +// permissions described in the GCC Runtime Library Exception, version
> +// 3.1, as published by the Free Software Foundation.
> +
> +// You should have received a copy of the GNU General Public License and
> +// a copy of the GCC Runtime Library Exception along with this program;
> +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
> +// <http://www.gnu.org/licenses/>.
> +
> +#include <testsuite_hooks.h>
> +#include <generator>
> +
> +template<unsigned MaxCopies>
> +struct copy_max
> +{
> + int copy = 0;
> +
> + copy_max()
> + {}
> +
> + copy_max(const copy_max& o)
> + : copy {o.copy + 1}
> + {
> + VERIFY(copy <= MaxCopies);
> + }
> +
> + copy_max&
> + operator=(const copy_max& o)
> + {
> + copy = o.copy + 1;
> + VERIFY(copy <= MaxCopies);
> + return *this;
> + }
> +
> + copy_max(copy_max&& o)
> + {
> + std::swap(o.copy, this->copy);
> + }
> +
> + copy_max&
> + operator=(copy_max&& o)
> + {
> + std::swap(o.copy, this->copy);
> + return *this;
> + }
> +};
> +
> +template<typename Ref>
> +std::generator<Ref>
> +foo()
> +{
> + co_yield {};
> +}
> +
> +int
> +main()
> +{
> + static_assert(!std::copy_constructible<std::generator<int>>);
> + {
> + auto gen = foo<const copy_max<1>&>();
> + auto i = gen.begin();
> + *i;
> + *i;
> + auto is = *i;
> + VERIFY(is.copy > 0);
> + }
> +
> + {
> + auto gen2 = foo<copy_max<0>&&>();
> + auto i = gen2.begin();
> + *i;
> + *i;
> + auto is = *i;
> + }
> +
> + {
> + auto gen = foo<copy_max<0>>(); // should be same as case 2
> + auto i = gen.begin();
> + *i;
> + *i;
> + auto is = *i;
> + }
> +}
> diff --git a/libstdc++-v3/testsuite/24_iterators/range_generators/except.cc
> b/libstdc++-v3/testsuite/24_iterators/range_generators/except.cc
> new file mode 100644
> index 000000000000..76f59b0aaed7
> --- /dev/null
> +++ b/libstdc++-v3/testsuite/24_iterators/range_generators/except.cc
> @@ -0,0 +1,97 @@
> +// { dg-do run { target c++23 } }
> +// Copyright (C) 2023 Free Software Foundation, Inc.
> +//
> +// This file is part of the GNU ISO C++ Library. This library is free
> +// software; you can redistribute it and/or modify it under the
> +// terms of the GNU General Public License as published by the
> +// Free Software Foundation; either version 3, or (at your option)
> +// any later version.
> +
> +// This library is distributed in the hope that it will be useful,
> +// but WITHOUT ANY WARRANTY; without even the implied warranty of
> +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> +// GNU General Public License for more details.
> +
> +// Under Section 7 of GPL version 3, you are granted additional
> +// permissions described in the GCC Runtime Library Exception, version
> +// 3.1, as published by the Free Software Foundation.
> +
> +// You should have received a copy of the GNU General Public License and
> +// a copy of the GCC Runtime Library Exception along with this program;
> +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
> +// <http://www.gnu.org/licenses/>.
> +
> +#include <testsuite_hooks.h>
> +#include <generator>
> +
> +std::generator<int>
> +foo()
> +{
> + co_yield 0;
> + throw 3; /* dice roll */
> +}
> +
> +std::generator<int>
> +foo_delegator()
> +{
> + co_yield 1;
> + co_yield std::ranges::elements_of { foo() };
> +}
> +
> +bool catchy_caught = false;
> +
> +std::generator<int>
> +foo_catchy_delegator()
> +{
> + try
> + {
> + co_yield std::ranges::elements_of { foo() };
> + VERIFY(false);
> + }
> + catch (int i)
> + {
> + catchy_caught = true;
> + VERIFY(i == 3);
> + }
> +}
> +
> +int
> +main()
> +{
> + {
> + auto gen = foo();
> + try
> + {
> + auto it = gen.begin();
> + VERIFY(*it == 0);
> + it++;
> + VERIFY(false);
> + }
> + catch (int x)
> + {
> + VERIFY(x == 3);
> + }
> + }
> +
> + {
> + auto gen = foo_delegator();
> + auto it = gen.begin();
> + VERIFY(*it == 1);
> + it++;
> +
> + try
> + {
> + VERIFY(*it == 0);
> + it++;
> + VERIFY(false);
> + }
> + catch (int x)
> + {
> + VERIFY(x == 3);
> + }
> + }
> +
> + for (auto x : foo_catchy_delegator())
> + VERIFY(x == 0);
> + VERIFY(catchy_caught);
> +}
> diff --git a/libstdc++-v3/testsuite/24_iterators/range_generators/subrange.cc
> b/libstdc++-v3/testsuite/24_iterators/range_generators/subrange.cc
> new file mode 100644
> index 000000000000..4bd0b2f9e078
> --- /dev/null
> +++ b/libstdc++-v3/testsuite/24_iterators/range_generators/subrange.cc
> @@ -0,0 +1,45 @@
> +// { dg-do run { target c++23 } }
> +// Copyright (C) 2023 Free Software Foundation, Inc.
> +//
> +// This file is part of the GNU ISO C++ Library. This library is free
> +// software; you can redistribute it and/or modify it under the
> +// terms of the GNU General Public License as published by the
> +// Free Software Foundation; either version 3, or (at your option)
> +// any later version.
> +
> +// This library is distributed in the hope that it will be useful,
> +// but WITHOUT ANY WARRANTY; without even the implied warranty of
> +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> +// GNU General Public License for more details.
> +
> +// Under Section 7 of GPL version 3, you are granted additional
> +// permissions described in the GCC Runtime Library Exception, version
> +// 3.1, as published by the Free Software Foundation.
> +
> +// You should have received a copy of the GNU General Public License and
> +// a copy of the GCC Runtime Library Exception along with this program;
> +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
> +// <http://www.gnu.org/licenses/>.
> +
> +#include <generator>
> +#include <ranges>
> +#include <vector>
> +#include <iostream>
> +
> +std::generator<int&>
> +yield_vector()
> +{
> + std::vector foo { 1, 2, 3 };
> + auto x = 123;
> + co_yield x;
> + co_yield std::ranges::elements_of { foo };
> + x = 456;
> + co_yield x;
> +}
> +
> +int
> +main()
> +{
> + for (auto x : yield_vector())
> + std::cout << x << '\n';
> +}
> diff --git a/libstdc++-v3/testsuite/24_iterators/range_generators/synopsis.cc
> b/libstdc++-v3/testsuite/24_iterators/range_generators/synopsis.cc
> new file mode 100644
> index 000000000000..6c037f2f3c05
> --- /dev/null
> +++ b/libstdc++-v3/testsuite/24_iterators/range_generators/synopsis.cc
> @@ -0,0 +1,38 @@
> +// { dg-do compile { target c++23 } }
> +// { dg-add-options no_pch }
> +// Copyright (C) 2023 Free Software Foundation, Inc.
> +//
> +// This file is part of the GNU ISO C++ Library. This library is free
> +// software; you can redistribute it and/or modify it under the
> +// terms of the GNU General Public License as published by the
> +// Free Software Foundation; either version 3, or (at your option)
> +// any later version.
> +
> +// This library is distributed in the hope that it will be useful,
> +// but WITHOUT ANY WARRANTY; without even the implied warranty of
> +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> +// GNU General Public License for more details.
> +
> +// Under Section 7 of GPL version 3, you are granted additional
> +// permissions described in the GCC Runtime Library Exception, version
> +// 3.1, as published by the Free Software Foundation.
> +
> +// You should have received a copy of the GNU General Public License and
> +// a copy of the GCC Runtime Library Exception along with this program;
> +// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
> +// <http://www.gnu.org/licenses/>.
> +
> +#include <generator>
> +
> +#if !defined(__cpp_lib_generator) || __cpp_lib_generator < 202207L
> +# error "__cpp_lib_generator undefined or has wrong value"
> +#endif
> +
> +namespace test {
> + using std::generator;
> +#if __STDC_HOSTED__
> + namespace pmr {
> + using std::pmr::generator;
> + }
> +#endif
> +}
> --
> 2.42.1
>
