P2502R2 <generator>: Synchronous Coroutine Generator For Ranges

stl/CMakeLists.txt

@@ -81,6 +81,7 @@ set(HEADERS
     ${CMAKE_CURRENT_LIST_DIR}/inc/fstream
     ${CMAKE_CURRENT_LIST_DIR}/inc/functional
     ${CMAKE_CURRENT_LIST_DIR}/inc/future
+    ${CMAKE_CURRENT_LIST_DIR}/inc/generator
     ${CMAKE_CURRENT_LIST_DIR}/inc/hash_map
     ${CMAKE_CURRENT_LIST_DIR}/inc/hash_set
     ${CMAKE_CURRENT_LIST_DIR}/inc/header-units.json

stl/inc/__msvc_all_public_headers.hpp

@@ -86,6 +86,7 @@
 #include <forward_list>
 #include <fstream>
 #include <functional>
+#include <generator>
 #include <hash_map>
 #include <hash_set>
 #include <iomanip>

stl/inc/coroutine

@@ -92,12 +92,12 @@ private:
     void* _Ptr = nullptr;
 };
 
-_EXPORT_STD template <class _Promise>
+_EXPORT_STD template <class _CoroPromise>
 struct coroutine_handle {
     constexpr coroutine_handle() noexcept = default;
     constexpr coroutine_handle(nullptr_t) noexcept {}
 
-    _NODISCARD static coroutine_handle from_promise(_Promise& _Prom) noexcept { // strengthened
+    _NODISCARD static coroutine_handle from_promise(_CoroPromise& _Prom) noexcept { // strengthened
         const auto _Prom_ptr  = const_cast<void*>(static_cast<const volatile void*>(_STD addressof(_Prom)));
         const auto _Frame_ptr = __builtin_coro_promise(_Prom_ptr, 0, true);
         coroutine_handle _Result;
@@ -144,8 +144,8 @@ struct coroutine_handle {
         __builtin_coro_destroy(_Ptr);
     }
 
-    _NODISCARD _Promise& promise() const noexcept { // strengthened
-        return *reinterpret_cast<_Promise*>(__builtin_coro_promise(_Ptr, 0, false));
+    _NODISCARD _CoroPromise& promise() const noexcept { // strengthened
+        return *reinterpret_cast<_CoroPromise*>(__builtin_coro_promise(_Ptr, 0, false));
     }
 
 private:
@@ -184,10 +184,10 @@ _NODISCARD constexpr bool operator>=(const coroutine_handle<> _Left, const corou
 }
 #endif // ^^^ !_HAS_CXX20 ^^^
 
-template <class _Promise>
-struct hash<coroutine_handle<_Promise>> {
+template <class _CoroPromise>
+struct hash<coroutine_handle<_CoroPromise>> {
     _NODISCARD _STATIC_CALL_OPERATOR size_t operator()(
-        const coroutine_handle<_Promise>& _Coro) _CONST_CALL_OPERATOR noexcept {
+        const coroutine_handle<_CoroPromise>& _Coro) _CONST_CALL_OPERATOR noexcept {
         return _Hash_representation(_Coro.address());
     }
 };

stl/inc/header-units.json

@@ -75,6 +75,7 @@
         "fstream",
         "functional",
         "future",
+        "generator",
         // "hash_map", // non-Standard, will be removed soon
         // "hash_set", // non-Standard, will be removed soon
         "initializer_list",

stl/inc/xmemory

@@ -2588,6 +2588,28 @@ template <class _Ty>
 concept _Transparent = _Is_transparent_v<_Ty>;
 #endif // _HAS_CXX20
 
+#if _HAS_CXX23
+namespace ranges {
+#if defined(__cpp_lib_byte)
+    _EXPORT_STD template <range _Rng, class _Alloc = allocator<byte>>
+#else // ^^^ defined(__cpp_lib_byte) / !defined(__cpp_lib_byte) vvv
+    _EXPORT_STD template <range _Rng, class _Alloc>
+#endif // ^^^ !defined(__cpp_lib_byte) ^^^
+    struct elements_of {
+        /* [[no_unique_address]] */ _Rng range;
+        /* [[no_unique_address]] */ _Alloc allocator{};
+    };
+
+#if defined(__cpp_lib_byte)
+    template <class _Rng, class _Alloc = allocator<byte>>
+    elements_of(_Rng&&, _Alloc = _Alloc()) -> elements_of<_Rng&&, _Alloc>;
+#else // ^^^ defined(__cpp_lib_byte) / !defined(__cpp_lib_byte) vvv
+    template <class _Rng, class _Alloc>
+    elements_of(_Rng&&, _Alloc) -> elements_of<_Rng&&, _Alloc>;
+#endif // ^^^ !defined(__cpp_lib_byte) ^^^
+} // namespace ranges
+#endif // _HAS_CXX23
+
 template <class _Elem, class _UTy>
 _NODISCARD _Elem* _UIntegral_to_buff(_Elem* _RNext, _UTy _UVal) { // used by both to_string and thread::id output
     // format _UVal into buffer *ending at* _RNext

stl/inc/yvals_core.h

@@ -379,6 +379,7 @@
 // P2474R2 views::repeat
 // P2494R2 Relaxing Range Adaptors To Allow Move-Only Types
 // P2499R0 string_view Range Constructor Should Be explicit
+// P2502R2 <generator>: Synchronous Coroutine Generator For Ranges
 // P2505R5 Monadic Functions For expected
 // P2539R4 Synchronizing print() With The Underlying Stream
 // P2540R1 Empty Product For Certain Views
@@ -391,6 +392,7 @@
 // P2693R1 Formatting thread::id And stacktrace
 // P2713R1 Escaping Improvements In std::format
 // P2763R1 Fixing layout_stride's Default Constructor For Fully Static Extents
+// P2787R1 pmr::generator
 // P2833R2 Freestanding Library: inout expected span
 //     (except for __cpp_lib_span which also covers C++26 span::at)
 // P2836R1 basic_const_iterator Should Follow Its Underlying Type's Convertibility
@@ -1764,6 +1766,7 @@ _EMIT_STL_ERROR(STL1004, "C++98 unexpected() is incompatible with C++23 unexpect
 #define __cpp_lib_forward_like                      202207L
 #define __cpp_lib_freestanding_expected             202311L
 #define __cpp_lib_freestanding_mdspan               202311L
+#define __cpp_lib_generator                         202207L
 #define __cpp_lib_invoke_r                          202106L
 #define __cpp_lib_ios_noreplace                     202207L
 #define __cpp_lib_is_scoped_enum                    202011L

stl/modules/std.ixx

@@ -69,6 +69,9 @@ export module std;
 #include <fstream>
 #include <functional>
 #include <future>
+#if _HAS_CXX23
+#include <generator>
+#endif // _HAS_CXX23
 #include <initializer_list>
 #include <iomanip>
 #include <ios>

tests/std/include/test_generator_support.hpp

@@ -0,0 +1,148 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#pragma once
+
+#include <concepts>
+#include <cstddef>
+#include <generator>
+#include <memory>
+#include <type_traits>
+
+template <class R, class V = void, class A = void>
+struct gen_traits;
+
+template <class R>
+struct gen_traits<R> {
+    using generator = std::generator<R>;
+    using value     = std::remove_cvref_t<R>;
+    using reference = R&&;
+    using yielded   = reference;
+
+    // Verify the default template arguments
+    static_assert(std::same_as<std::generator<R>, std::generator<R, void>>);
+    static_assert(std::same_as<std::generator<R, void>, std::generator<R, void, void>>);
+};
+template <class R, class V>
+struct gen_traits<R, V> {
+    using generator = std::generator<R, V>;
+    using value     = V;
+    using reference = R;
+    using yielded   = std::conditional_t<std::is_reference_v<R>, R, const R&>;
+
+    // Ditto verify default template arguments
+    static_assert(std::same_as<std::generator<R, V>, std::generator<R, V, void>>);
+};
+template <class R, class V, class A>
+struct gen_traits : gen_traits<R, V> {
+    using generator = std::generator<R, V, A>;
+};
+
+template <class Ref, class V>
+using gen_value_t = gen_traits<Ref, V>::value;
+
+template <class Ref, class V>
+using gen_reference_t = gen_traits<Ref, V>::reference;
+
+template <class T, class AlwaysEqual = std::true_type, std::signed_integral DifferenceType = std::ptrdiff_t>
+class StatelessAlloc {
+public:
+    using value_type      = T;
+    using is_always_equal = AlwaysEqual;
+    using difference_type = DifferenceType;
+    using size_type       = std::make_unsigned_t<difference_type>;
+
+    StatelessAlloc() = default;
+
+    template <class U>
+    StatelessAlloc(const StatelessAlloc<U, AlwaysEqual, DifferenceType>&) {}
+
+    T* allocate(const size_type s) {
+        return std::allocator<T>{}.allocate(s);
+    }
+
+    void deallocate(T* const p, const size_type n) noexcept {
+        std::allocator<T>{}.deallocate(p, n);
+    }
+
+    template <class U>
+    bool operator==(const StatelessAlloc<U, AlwaysEqual, DifferenceType>&) const noexcept {
+        return true;
+    }
+};
+
+static_assert(std::default_initializable<StatelessAlloc<int>>);
+
+template <class T>
+class StatefulAlloc {
+public:
+    using value_type = T;
+
+    explicit StatefulAlloc(int dom) noexcept : domain{dom} {}
+
+    template <class U>
+    StatefulAlloc(const StatefulAlloc<U>& that) noexcept : domain{that.domain} {}
+
+    T* allocate(const size_t n) {
+        return std::allocator<T>{}.allocate(n);
+    }
+
+    void deallocate(T* const p, const size_t n) noexcept {
+        return std::allocator<T>{}.deallocate(p, n);
+    }
+
+    template <class U>
+    bool operator==(const StatefulAlloc<U>& that) noexcept {
+        return domain == that.domain;
+    }
+
+private:
+    int domain;
+
+    template <class U>
+    friend class StatefulAlloc;
+};
+
+static_assert(!std::default_initializable<StatefulAlloc<int>>);
+
+struct MoveOnly {
+    MoveOnly()                           = default;
+    MoveOnly(const MoveOnly&)            = delete;
+    MoveOnly& operator=(const MoveOnly&) = delete;
+    MoveOnly(MoveOnly&&)                 = default;
+    MoveOnly& operator=(MoveOnly&&)      = default;
+};
+
+static_assert(std::movable<MoveOnly>);
+static_assert(!std::copyable<MoveOnly>);
+
+struct Immovable {
+    Immovable()                       = default;
+    Immovable(Immovable&&)            = delete;
+    Immovable& operator=(Immovable&&) = delete;
+};
+
+static_assert(!std::movable<Immovable>);
+
+template <class T>
+class Proxy {
+public:
+    Proxy(const T&) {}
+};
+
+template <std::equality_comparable T>
+class Proxy<T> {
+public:
+    Proxy(const T& _value_) : value(_value_) {}
+
+    bool operator==(const Proxy& other) const {
+        return value == other.value;
+    }
+
+    bool operator==(const T& x) const {
+        return value == x;
+    }
+
+private:
+    const T& value;
+};

tests/std/include/test_header_units_and_modules.hpp

@@ -284,6 +284,20 @@ void test_future() {
     assert(f.get() == 1729);
 }
 
+#if TEST_STANDARD >= 23
+void test_generator() {
+    using namespace std;
+    puts("Testing <generator>.");
+    auto some_ints = [](int hi) -> generator<int> {
+        for (int i = 0; i < hi; ++i) {
+            co_yield i;
+        }
+    };
+    constexpr int bound = 42;
+    assert(ranges::equal(some_ints(bound), views::iota(0, bound)));
+}
+#endif // TEST_STANDARD >= 23
+
 void test_initializer_list() {
     using namespace std;
     puts("Testing <initializer_list>.");
@@ -1182,6 +1196,9 @@ void all_cpp_header_tests() {
     test_fstream();
     test_functional();
     test_future();
+#if TEST_STANDARD >= 23
+    test_generator();
+#endif // TEST_STANDARD >= 23
     test_initializer_list();
     test_iomanip();
     test_ios();

tests/std/test.lst

@@ -670,6 +670,10 @@ tests\P2467R1_exclusive_mode_fstreams
 tests\P2474R2_views_repeat
 tests\P2474R2_views_repeat_death
 tests\P2494R2_move_only_range_adaptors
+tests\P2502R2_generator
+tests\P2502R2_generator_death
+tests\P2502R2_generator_iterator
+tests\P2502R2_generator_promise
 tests\P2505R5_monadic_functions_for_std_expected
 tests\P2510R3_text_formatting_pointers
 tests\P2517R1_apply_conditional_noexcept

tests/std/tests/P1502R1_standard_library_header_units/importable_cxx_library_headers.jsonc

@@ -28,6 +28,7 @@
     "fstream",
     "functional",
     "future",
+    "generator",
     "initializer_list",
     "iomanip",
     "ios",

tests/std/tests/P1502R1_standard_library_header_units/test.cpp

@@ -36,6 +36,9 @@ import <forward_list>;
 import <fstream>;
 import <functional>;
 import <future>;
+#if TEST_STANDARD >= 23
+import <generator>;
+#endif // TEST_STANDARD >= 23
 import <initializer_list>;
 import <iomanip>;
 import <ios>;

tests/std/tests/P2502R2_generator/env.lst

@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\usual_latest_matrix.lst