Implement P3016R6 Resolve Inconsistencies In begin/end For valarray And Braced Initializer Lists

stl/inc/initializer_list

@@ -51,20 +51,19 @@ public:
         return static_cast<size_t>(_Last - _First);
     }
 
+    _NODISCARD constexpr bool empty() const noexcept {
+        return size() == 0;
+    }
+
+    _NODISCARD constexpr const _Elem* data() const noexcept {
+        return begin();
+    }
+
 private:
     const _Elem* _First;
     const _Elem* _Last;
 };
 
-_EXPORT_STD template <class _Elem>
-_NODISCARD constexpr const _Elem* begin(initializer_list<_Elem> _Ilist) noexcept {
-    return _Ilist.begin();
-}
-
-_EXPORT_STD template <class _Elem>
-_NODISCARD constexpr const _Elem* end(initializer_list<_Elem> _Ilist) noexcept {
-    return _Ilist.end();
-}
 _STD_END
 
 // TRANSITION, non-_Ugly attribute tokens

stl/inc/valarray

@@ -59,19 +59,9 @@ class valarray { // store array with various indexing options
 public:
     friend _Tidy_deallocate_guard<valarray>;
 
-    template <class _Ty2>
-    friend _Ty2* begin(valarray<_Ty2>& _Array) noexcept /* strengthened */;
-
-    template <class _Ty2>
-    friend const _Ty2* begin(const valarray<_Ty2>& _Array) noexcept /* strengthened */;
-
-    template <class _Ty2>
-    friend _Ty2* end(valarray<_Ty2>& _Array) noexcept /* strengthened */;
-
-    template <class _Ty2>
-    friend const _Ty2* end(const valarray<_Ty2>& _Array) noexcept /* strengthened */;
-
-    using value_type = _Ty;
+    using value_type     = _Ty;
+    using iterator       = _Ty*;
+    using const_iterator = const _Ty*;
 
     valarray() = default; // construct empty valarray
 
@@ -411,6 +401,22 @@ public:
         return _Mysize;
     }
 
+    _NODISCARD iterator begin() noexcept /* strengthened */ {
+        return _Myptr;
+    }
+
+    _NODISCARD const_iterator begin() const noexcept /* strengthened */ {
+        return _Myptr;
+    }
+
+    _NODISCARD iterator end() noexcept /* strengthened */ {
+        return _Myptr + _Mysize;
+    }
+
+    _NODISCARD const_iterator end() const noexcept /* strengthened */ {
+        return _Myptr + _Mysize;
+    }
+
     _NODISCARD const _Ty& operator[](size_t _Off) const noexcept /* strengthened */ {
 #if _MSVC_STL_HARDENING_VALARRAY || _ITERATOR_DEBUG_LEVEL != 0
         _STL_VERIFY(_Off < _Mysize, "valarray subscript out of range");
@@ -612,26 +618,6 @@ void swap(valarray<_Ty>& _Left, valarray<_Ty>& _Right) noexcept {
     _Left.swap(_Right);
 }
 
-_EXPORT_STD template <class _Ty>
-_NODISCARD _Ty* begin(valarray<_Ty>& _Array) noexcept /* strengthened */ {
-    return _Array._Myptr;
-}
-
-_EXPORT_STD template <class _Ty>
-_NODISCARD const _Ty* begin(const valarray<_Ty>& _Array) noexcept /* strengthened */ {
-    return _Array._Myptr;
-}
-
-_EXPORT_STD template <class _Ty>
-_NODISCARD _Ty* end(valarray<_Ty>& _Array) noexcept /* strengthened */ {
-    return _Array._Myptr + _Array.size();
-}
-
-_EXPORT_STD template <class _Ty>
-_NODISCARD const _Ty* end(const valarray<_Ty>& _Array) noexcept /* strengthened */ {
-    return _Array._Myptr + _Array.size();
-}
-
 _EXPORT_STD template <class _Ty>
 _NODISCARD valarray<_Ty> operator*(const valarray<_Ty>& _Left, const typename valarray<_Ty>::value_type& _Right) {
     const size_t _Size = _Left.size();

stl/inc/xutility

@@ -2283,11 +2283,6 @@ _NODISCARD_EMPTY_NON_MEMBER constexpr bool empty(const _Ty (&)[_Size]) noexcept
     return false;
 }
 
-_EXPORT_STD template <class _Elem>
-_NODISCARD_EMPTY_NON_MEMBER constexpr bool empty(initializer_list<_Elem> _Ilist) noexcept {
-    return _Ilist.size() == 0;
-}
-
 _EXPORT_STD template <class _Container>
 _NODISCARD constexpr auto data(_Container& _Cont) noexcept(noexcept(_Cont.data())) /* strengthened */
     -> decltype(_Cont.data()) {
@@ -2305,11 +2300,6 @@ _NODISCARD constexpr _Ty* data(_Ty (&_Array)[_Size]) noexcept {
     return _Array;
 }
 
-_EXPORT_STD template <class _Elem>
-_NODISCARD constexpr const _Elem* data(initializer_list<_Elem> _Ilist) noexcept {
-    return _Ilist.begin();
-}
-
 #if _HAS_CXX20
 #if _HAS_CXX23
 _EXPORT_STD template <indirectly_readable _Ty>

stl/inc/yvals_core.h

@@ -80,6 +80,7 @@
 //     (__cpp_lib_freestanding_algorithm and __cpp_lib_freestanding_array only)
 // P2937R0 Freestanding Library: Remove strtok
 // P2968R2 Make std::ignore A First-Class Object
+// P3016R6 Resolve Inconsistencies In begin/end For valarray And Braced Initializer Lists
 // P3223R2 Making istream::ignore() Less Surprising
 // P3323R1 Forbid atomic<cv T>, Specify atomic_ref<cv T>
 //     (for atomic<cv T>)
@@ -1833,6 +1834,10 @@ _EMIT_STL_ERROR(STL1004, "C++98 unexpected() is incompatible with C++23 unexpect
 #define __cpp_lib_unreachable                 202202L
 #endif // _HAS_CXX23
 
+// C++26
+#define __cpp_lib_initializer_list 202511L
+#define __cpp_lib_valarray         202511L
+
 // macros with language mode sensitivity
 #if _HAS_CXX20
 #define __cpp_lib_array_constexpr 201811L // P1032R1 Miscellaneous constexpr

tests/libcxx/expected_results.txt

@@ -142,6 +142,9 @@ std/language.support/support.limits/support.limits.general/mdspan.version.compil
 # libc++ has not implemented P2937R0: "Freestanding Library: Remove strtok"
 std/language.support/support.limits/support.limits.general/cstring.version.compile.pass.cpp FAIL
 
+# libc++ has not implemented P3016R6: "Resolve Inconsistencies In begin/end For valarray And Braced Initializer Lists"
+std/language.support/support.initlist/support.initlist.range/begin_end.pass.cpp FAIL
+
 # libc++ has not implemented P3323R1: "Forbid atomic<cv T>, Specify atomic_ref<cv T>"
 std/atomics/atomics.ref/member_types.compile.pass.cpp FAIL
 

tests/std/test.lst

@@ -720,6 +720,7 @@ tests\P2693R1_text_formatting_header_stacktrace
 tests\P2693R1_text_formatting_header_thread
 tests\P2693R1_text_formatting_stacktrace
 tests\P2693R1_text_formatting_thread_id
+tests\P3016R6_inconsistent_begin_end
 tests\P3107R5_enabled_specializations
 tests\P3349R1_contiguous_iterators_to_pointers
 tests\P3503R3_packaged_task_promise_with_allocator

tests/std/tests/Dev11_1074023_constexpr/test.cpp

@@ -53,7 +53,9 @@ constexpr auto int64_max = numeric_limits<int64_t>::max();
 constexpr initializer_list<int> il;
 STATIC_ASSERT(il.size() == 0);
 STATIC_ASSERT(il.begin() == il.end());
+#if _HAS_CXX17
 STATIC_ASSERT(begin(il) == end(il));
+#endif // _HAS_CXX17
 
 // TRANSITION,
 // constexpr error_category() noexcept;

tests/std/tests/P3016R6_inconsistent_begin_end/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

tests/std/tests/P3016R6_inconsistent_begin_end/test.cpp

@@ -0,0 +1,65 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <initializer_list>
+#include <iterator>
+#include <type_traits>
+#include <valarray>
+
+namespace my {
+
+    template <typename T>
+    void begin(std::initializer_list<T>);
+
+    template <typename T>
+    void end(std::initializer_list<T>);
+
+    template <typename T>
+    void empty(std::initializer_list<T>);
+
+    template <typename T>
+    void data(std::initializer_list<T>);
+} // namespace my
+
+
+int main() {
+    {
+        // Check that free functions in std can't be invoked with braced-initializer-list.
+        // If they could be invoked, the following expressions would be ambiguous between std:: and my::
+        using namespace std;
+        using namespace my;
+        static_assert(std::is_same_v<decltype(begin({1, 2, 3})), void>);
+        static_assert(std::is_same_v<decltype(end({1, 2, 3})), void>);
+        static_assert(std::is_same_v<decltype(empty({1, 2, 3})), void>);
+        static_assert(std::is_same_v<decltype(data({1, 2, 3})), void>);
+    }
+
+    {
+        // Check that free functions in std still can be invoked on std::initializer_list
+        std::initializer_list<int> il = {1, 2, 3};
+
+        using namespace std;
+        (void) begin(il);
+        (void) cbegin(il);
+        (void) end(il);
+        (void) cend(il);
+        (void) size(il);
+        (void) empty(il);
+        (void) data(il);
+    }
+
+    {
+        // Check that free functions in std can be invoked on std::valarray
+        std::valarray<int> v{1};
+
+        using namespace std;
+        (void) begin(v);
+        (void) cbegin(v); // Did not compile before P3016R6
+        (void) end(v);
+        (void) cend(v); // Did not compile before P3016R6
+        (void) size(v);
+        // There are no members 'empty' and 'data' of valarray
+        // (void) empty(il);
+        // (void) data(il);
+    }
+}