diff --git a/xml/issue4251.xml b/xml/issue4251.xml index 57944547a5..0901c074a2 100644 --- a/xml/issue4251.xml +++ b/xml/issue4251.xml @@ -3,7 +3,10 @@ Move assignment for `indirect` unnecessarily requires copy construction -
+
+ + +
Jonathan Wakely 01 May 2025 1 @@ -46,15 +49,14 @@ Set priority to 1 after reflector poll. Similar change needed for `std::polymorphic`.

- - +

This wording is relative to .

    -

  1. Modify as indicated:

    +

  2. Modify as indicated:

    
 constexpr indirect& operator=(indirect&& other)
@@ -122,6 +124,153 @@ the allocator in `*this` is replaced with a copy of the allocator in `other`.
    3. +
+ + +2025-11-03; Tomasz provides wording. + + + +

+This wording is relative to . +

+
    + +

  1. Modify as indicated:

    +
    +
    
+constexpr indirect& operator=(indirect&& other)
+  noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
+           allocator_traits<Allocator>::is_always_equal::value);
+
    +
    +

    +-5- Mandates: + +If +allocator_traits<Allocator>::propagate_on_container_move_assignment::value +is `false` +and +allocator_traits<Allocator>::is_always_equal::value +is `false`, + +is_copymove_constructible_t<T> is `true`. +

    +

    +-6- Effects: +If `addressof(other) == this` is `true`, there are no effects. +Otherwise: +

      +
    1. (6.1) — +The allocator needs updating if +allocator_traits<Allocator>::propagate_on_container_move_assignment::value +is `true`. +
      2. +
    2. (6.2) — +If `other` is valueless, `*this` becomes valueless and the owned object +in `*this`, if any, is destroyed using +allocator_traits<Allocator>::destroy +and then the storage is deallocated. +
      3. +
    3. (6.3) — +Otherwise, +if the allocator needs updating or +if alloc == other.alloc is `true`, + +swaps the owned objects in `*this` and `other`; +the owned object in `other`, if any, is then destroyed using +allocator_traits<Allocator>::destroy +and then the storage is deallocated + +`*this` takes ownership of the owned object of `other`. +
      4. +
    4. (6.4) — +Otherwise, constructs a new owned object with the owned object of `other` +as the argument as an rvalue, using either the allocator in `*this` +or the allocator in `other` if the allocator needs updating. +
      5. +
    5. (6.5) — +The previously owned object in `*this`, if any, is destroyed using +allocator_traits<Allocator>::destroy +and then the storage is deallocated. +
      6. +
    6. (6.6) — +If the allocator needs updating, +the allocator in `*this` is replaced with a copy of the allocator in `other`. +
      7. +
    +

    +

    -7- Postcondition: `other` is valueless.

    +
    +
    +
    2. + +

  2. Modify as indicated:

    +
    +
    
+constexpr polymorphic& operator=(polymorphic&& other)
+  noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
+           allocator_traits<Allocator>::is_always_equal::value);
+
    +
    +

    +-5- Mandates: +If + +allocator_traits<Allocator>::propagate_on_container_move_assignment::value +is `false` +and + +allocator_traits<Allocator>::is_always_equal::value +is `false`, +`T` is complete type. +

    +

    +-6- Effects: +If `addressof(other) == this` is `true`, there are no effects. +Otherwise: +

      +
    1. (6.1) — +The allocator needs updating if +allocator_traits<Allocator>::propagate_on_container_move_assignment::value +is `true`. +
      2. +
    2. (6.?) — If `other` is valueless, `*this` becomes valueless.
      3. +
    3. (6.2) — +Otherwise, if the allocator needs updating orIf +alloc == other.alloc is `true`, + +swaps the owned objects in `*this` and `other`; +the owned object in `other`, if any, is then destroyed using +allocator_traits<Allocator>::destroy +and then the storage is deallocated + +`*this` takes ownership of the owned object of `other`. +
      4. +
    4. (6.3) — +Otherwise, if `alloc != other.alloc` is `true`; if `other` is not valueless, +a new owned object is constructed in `*this` using allocator_traits::construct +with the owned object from +Otherwise, constructs a new owned object with the owned object of +`other` as the argument as an rvalue, using either the allocator in `*this` +or the allocator in `other` if the allocator needs updating. +
      5. +
    5. (6.4) — +The previously owned object in `*this`, if any, is destroyed using +allocator_traits<Allocator>::destroy +and then the storage is deallocated. +
      6. +
    6. (6.5) — +If the allocator needs updating, +the allocator in `*this` is replaced with a copy of the allocator in `other`. +
      7. +
    +

    +[…] +
    +
    +
    3. +
diff --git a/xml/issue4316.xml b/xml/issue4316.xml index a08766fb5b..982fac7a74 100644 --- a/xml/issue4316.xml +++ b/xml/issue4316.xml @@ -43,9 +43,7 @@ Set priority to 1 after reflector poll.

2025-10-27; Tomasz provides wording. - - - +

This wording is relative to . @@ -126,6 +124,89 @@ context, the program is ill-formed. — end note] + + +2025-10-27; Reflector comments. +

+We lost definition of `Z`. Use TARG-SPLICE([:Args:]).... +

+ +2025-11-03; Tomasz provides wording. + + + + +

+This wording is relative to . +

+ +
    + +

  1. Modify as indicated:

    + +
    +
    +

    +-1- For value `x` of type `info`, and prvalue constant expression `X` that computes the +reflection held by `x`, let TARG-SPLICE(x) be: +

      +
    • -1.1- template [: X :] if `is_template(x)` is `true`, otherwise
      • +
    • -1.2- typename [: X :] if `is_type(x)` is `true`, otherwise
      • +
    • -1.3- ([: X :])
      • +
    +

    +
    + +
    +template<reflection_range R = initializer_list<info>>
+  consteval bool can_substitute(info templ, R&& arguments);
+
    +
    +

    +-1- Let `Z` be the template represented by `templ` and let `Args...` be a +sequence of prvalue constant expressions that compute the reflections held by +the elements of `arguments`, in order. +

    +

    +-2- Returns: `true` if Z<TARG-SPLICE([:Args:])...> is a valid template-id +() that does not name a function whose type contains an undeduced placeholder type. +Otherwise, `false`. +

    +

    +-3- Throws: `meta::exception` unless `templ` represents a template, and every reflection +in `arguments` represents a construct usable as a template argument (). +

    +

    +-4- [Note: If forming Z<TARG-SPLICE([:Args:])...> +leads to a failure outside of the immediate context, the program is ill-formed. — end note] +

    +
    + +
    +template<reflection_range R = initializer_list<info>>
+  consteval info substitute(info templ, R&& arguments);
+
    +
    +

    +-5- Let `Z` be the template represented by `templ` and let `Args...` be a +sequence of prvalue constant expressions that compute the reflections held by +the elements of `arguments`, in order. +

    +

    +-6- Returns: Z<TARG-SPLICE([:Args:])...>.

    +

    +-7- Throws: `meta::exception` unless `can_substitute(templ, arguments)` is `true`. +

    +

    +-8- [Note: If forming Z<TARG-SPLICE([:Args:])...> +leads to a failure outside of the immediate context, the program is ill-formed. — end note] +

    +
    + +
    +
    2. +
+ diff --git a/xml/issue4441.xml b/xml/issue4441.xml new file mode 100644 index 0000000000..9d19e8a089 --- /dev/null +++ b/xml/issue4441.xml @@ -0,0 +1,122 @@ + + + + +<tt>ranges::rotate</tt> do not handle sized-but-not-sized-sentinel ranges correctly +
+ + + + +
+Tomasz Kamiński +03 Nov 2025 +99 + + +Addresses US 161-258 +

These do not handle sized-but-not-sized-sentinel ranges correctly.

+ + + +

+This wording is relative to . +

+ +
    + +

  1. Modify as indicated:

    + +
    +template<execution-policy Ep, sized-random-access-range R>
+  requires permutable<iterator_t<R>>
+  borrowed_subrange_t<R> ranges::rotate(Ep&& exec, R&& r, iterator_t<R> middle);
+
+
    +
    +

    -6- Effects Equivalent to: +return ranges::rotate(std::forward<Ep>(exec), ranges::begin(r), middle, +ranges::end(r)ranges::begin(r) + ranges::distance(r)); +

    +
    + +[…] + +
    +template<execution-policy Ep, sized-random-access-range R, sized-random-access-range OutR>
+  requires indirectly_copyable<iterator_t<R>, iterator_t<OutR>>
+  ranges::rotate_copy_truncated_result<borrowed_iterator_t<R>, borrowed_iterator_t<OutR>>
+	  ranges::rotate_copy(Ep&& exec, R&& r, iterator_t<R> middle, OutR&& result_r);
+
    +
    +

    -18- Effects Equivalent to: +return ranges::rotate(std::forward<Ep>(exec), ranges::begin(r), middle, +ranges::end(r)ranges::begin(r)+ranges::distance(r) +ranges::begin(result_r), ranges::end(result_r)ranges::begin(result_r) + ranges::distance(result_r)); +

    +
    + +
    2. + +

  2. Modify as indicated:

    + +
    +template<execution-policy Ep, sized-random-access-range R,
+         class Comp = ranges::less, class Proj = identity>
+  requires sortable<iterator_t<R>, Comp, Proj>
+  borrowed_iterator_t<R>
+    ranges::partial_sort(Ep&& exec, R&& r, iterator_t<R> middle, Comp comp = {},
+                         Proj proj = {});
+
    +
    +

    -7- Effects Equivalent to: +return ranges::partial_sort(std::forward<Ep>(exec), ranges::begin(r), middle, +ranges::end(r)ranges::begin(r) + ranges::distance(r), comp, proj); +

    +
    + +
    3. + +

  3. Modify as indicated:

    + +
    +template<execution-policy Ep, sized-random-access-range R, class Comp = ranges::less,
+         class Proj = identity>
+  requires sortable<iterator_t<R>, Comp, Proj>
+  borrowed_iterator_t<R>
+    ranges::nth_element(Ep&& exec, R&& r, iterator_t<R> nth, Comp comp = {}, Proj proj = {});
+
    +
    +

    -7- Effects Equivalent to: +return ranges::nth_element(std::forward<Ep>(exec), ranges::begin(r), nth, +ranges::end(r)ranges::begin(r) + ranges::distance(r), comp, proj); +

    +
    + +
    4. + +

  4. Modify as indicated:

    + +
    +template<execution-policy Ep, sized-random-access-range R, class Comp = ranges::less,
+         class Proj = identity>
+  requires sortable<iterator_t<R>, Comp, Proj>
+  borrowed_iterator_t<R>
+    ranges::inplace_merge(Ep&& exec, R&& r, iterator_t<R> middle, Comp comp = {},
+                          Proj proj = {});
+
    +
    +

    -14- Effects Equivalent to: +return ranges::inplace_merge(std::forward<Ep>(exec), ranges::begin(r), middle, +ranges::end(r)ranges::begin(r) + ranges::distance(r), comp, proj); +

    +
    + +
    5. + + +
+ + + +