[libc++] P3168R2 Give std::optional Range Support

libcxx/docs/FeatureTestMacroTable.rst

@@ -476,7 +476,7 @@ Status
     ---------------------------------------------------------- -----------------
     ``__cpp_lib_not_fn``                                       ``202306L``
     ---------------------------------------------------------- -----------------
-    ``__cpp_lib_optional_range_support``                       *unimplemented*
+    ``__cpp_lib_optional_range_support``                       ``202406L``
     ---------------------------------------------------------- -----------------
     ``__cpp_lib_out_ptr``                                      ``202311L``
     ---------------------------------------------------------- -----------------

libcxx/include/__iterator/wrap_iter.h

@@ -117,6 +117,10 @@ class __wrap_iter {
   friend class span;
   template <class _Tp, size_t _Size>
   friend struct array;
+#if _LIBCPP_STD_VER >= 26
+  template <typename _Tp>
+  friend class optional;
+#endif
 };
 
 template <class _Iter1>

libcxx/include/optional

@@ -102,6 +102,8 @@ namespace std {
   class optional {
   public:
     using value_type = T;
+    using iterator               = implementation-defined; // see [optional.iterators] // since C++26
+    using const_iterator         = implementation-defined; // see [optional.iterators] // since C++26
 
     // [optional.ctor], constructors
     constexpr optional() noexcept;
@@ -135,6 +137,12 @@ namespace std {
     // [optional.swap], swap
     void swap(optional &) noexcept(see below ); // constexpr in C++20
 
+    // [optional.iterators], iterator support
+    constexpr iterator begin() noexcept; // since C++26
+    constexpr const_iterator begin() const noexcept; // since C++26
+    constexpr iterator end() noexcept; // since C++26
+    constexpr const_iterator end() const noexcept; // since C++26
+
     // [optional.observe], observers
     constexpr T const *operator->() const noexcept;
     constexpr T *operator->() noexcept;
@@ -173,6 +181,11 @@ namespace std {
   template<class T>
     optional(T) -> optional<T>;
 
+  template<class T>
+   constexpr bool ranges::enable_view<optional<T>> = true; // since C++26
+  template<class T>
+   constexpr auto format_kind<optional<T>> = range_format::disabled;  // since C++26
+
 } // namespace std
 
 */
@@ -187,10 +200,12 @@ namespace std {
 #  include <__concepts/invocable.h>
 #  include <__config>
 #  include <__exception/exception.h>
+#  include <__format/range_default_formatter.h>
 #  include <__functional/hash.h>
 #  include <__functional/invoke.h>
 #  include <__functional/unary_function.h>
 #  include <__fwd/functional.h>
+#  include <__iterator/wrap_iter.h>
 #  include <__memory/addressof.h>
 #  include <__memory/construct_at.h>
 #  include <__tuple/sfinae_helpers.h>
@@ -578,6 +593,16 @@ struct __is_std_optional : false_type {};
 template <class _Tp>
 struct __is_std_optional<optional<_Tp>> : true_type {};
 
+#    if _LIBCPP_STD_VER >= 26
+
+template <class _T>
+constexpr bool ranges::enable_view<optional<_T>> = true;
+
+template <class _T>
+constexpr auto format_kind<optional<_T>> = range_format::disabled;
+
+#    endif
+
 template <class _Tp>
 class _LIBCPP_DECLSPEC_EMPTY_BASES optional
     : private __optional_move_assign_base<_Tp>,
@@ -588,6 +613,11 @@ class _LIBCPP_DECLSPEC_EMPTY_BASES optional
 public:
   using value_type = _Tp;
 
+#    if _LIBCPP_STD_VER >= 26
+  using iterator       = __wrap_iter<_Tp*>;
+  using const_iterator = __wrap_iter<const _Tp*>;
+#    endif // _LIBCPP_STD_VER >= 26
+
   using __trivially_relocatable _LIBCPP_NODEBUG =
       conditional_t<__libcpp_is_trivially_relocatable<_Tp>::value, optional, void>;
   using __replaceable _LIBCPP_NODEBUG = conditional_t<__is_replaceable_v<_Tp>, optional, void>;
@@ -976,6 +1006,27 @@ public:
   }
 #    endif // _LIBCPP_STD_VER >= 23
 
+// P3168R2
+#    if _LIBCPP_STD_VER >= 26
+
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator begin() {
+    if (!this->has_value())
+      return end();
+    return iterator(static_cast<_Tp*>(this->__get()));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr const_iterator begin() const {
+    if (!this->has_value())
+      return end();
+    return const_iterator(static_cast<const _Tp*>(this->__get()));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator end() { return iterator(static_cast<_Tp*>(nullptr)); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr const_iterator end() const { return const_iterator(static_cast<const _Tp*>(nullptr)); }
+
+#    endif // _LIBCPP_STD_VER >= 26
+
   using __base::reset;
 };
 

libcxx/include/version

@@ -581,7 +581,7 @@ __cpp_lib_void_t                                        201411L <type_traits>
 # define __cpp_lib_mdspan                               202406L
 # undef  __cpp_lib_not_fn
 # define __cpp_lib_not_fn                               202306L
-// # define __cpp_lib_optional_range_support               202406L
+# define __cpp_lib_optional_range_support               202406L
 # undef  __cpp_lib_out_ptr
 # define __cpp_lib_out_ptr                              202311L
 // # define __cpp_lib_philox_engine                        202406L

libcxx/test/std/language.support/support.limits/support.limits.general/optional.version.compile.pass.cpp

@@ -152,17 +152,11 @@
 #    error "__cpp_lib_optional should have the value 202110L in c++26"
 #  endif
 
-#  if !defined(_LIBCPP_VERSION)
-#    ifndef __cpp_lib_optional_range_support
-#      error "__cpp_lib_optional_range_support should be defined in c++26"
-#    endif
-#    if __cpp_lib_optional_range_support != 202406L
-#      error "__cpp_lib_optional_range_support should have the value 202406L in c++26"
-#    endif
-#  else
-#    ifdef __cpp_lib_optional_range_support
-#      error "__cpp_lib_optional_range_support should not be defined because it is unimplemented in libc++!"
-#    endif
+#  ifndef __cpp_lib_optional_range_support
+#    error "__cpp_lib_optional_range_support should be defined in c++26"
+#  endif
+#  if __cpp_lib_optional_range_support != 202406L
+#    error "__cpp_lib_optional_range_support should have the value 202406L in c++26"
 #  endif
 
 #endif // TEST_STD_VER > 23

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp

@@ -7377,17 +7377,11 @@
 #    error "__cpp_lib_optional should have the value 202110L in c++26"
 #  endif
 
-#  if !defined(_LIBCPP_VERSION)
-#    ifndef __cpp_lib_optional_range_support
-#      error "__cpp_lib_optional_range_support should be defined in c++26"
-#    endif
-#    if __cpp_lib_optional_range_support != 202406L
-#      error "__cpp_lib_optional_range_support should have the value 202406L in c++26"
-#    endif
-#  else
-#    ifdef __cpp_lib_optional_range_support
-#      error "__cpp_lib_optional_range_support should not be defined because it is unimplemented in libc++!"
-#    endif
+#  ifndef __cpp_lib_optional_range_support
+#    error "__cpp_lib_optional_range_support should be defined in c++26"
+#  endif
+#  if __cpp_lib_optional_range_support != 202406L
+#    error "__cpp_lib_optional_range_support should have the value 202406L in c++26"
 #  endif
 
 #  ifndef __cpp_lib_out_ptr

libcxx/test/std/utilities/optional/optional.range/enable_ranges_view.compile.pass.cpp

@@ -0,0 +1,17 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: std-at-least-c++26
+
+#include <optional>
+#include <ranges>
+
+int main() {
+  static_assert(std::ranges::enable_view<std::optional<int>>);
+  return 0;
+}

libcxx/test/std/utilities/optional/optional.range/format_kind.compile.pass.cpp

@@ -0,0 +1,14 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: std-at-least-c++26
+
+#include <format>
+#include <optional>
+
+static_assert(std::format_kind<std::optional<int>>);

libcxx/test/std/utilities/optional/optional.range/iteration.pass.cpp

@@ -0,0 +1,26 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: std-at-least-c++26
+
+#include <cassert>
+#include <optional>
+
+constexpr bool test() {
+  constexpr std::optional<int> val = 2;
+  for (const auto& elem : val)
+    if (elem != 2)
+      return false;
+  return true;
+}
+
+int main() {
+  test();
+  static_assert(test());
+  return 0;
+}

libcxx/test/std/utilities/optional/optional.range/iterator_types.compile.pass.cpp

@@ -0,0 +1,37 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: std-at-least-c++26
+
+#include <iterator>
+#include <type_traits>
+#include <cstddef>
+#include <optional>
+
+using iterator = std::optional<int>::iterator;
+using const_iterator = std::optional<int>::const_iterator;
+
+// iterator
+
+static_assert(std::random_access_iterator<iterator>);
+static_assert(std::contiguous_iterator<iterator>);
+static_assert(std::is_same_v<typename std::iterator_traits<iterator>::value_type, int>);
+static_assert(std::is_same_v<typename std::iterator_traits<iterator>::difference_type, std::ptrdiff_t>);
+static_assert(std::is_same_v<typename std::iterator_traits<iterator>::pointer, int*>);
+static_assert(std::is_same_v<typename std::iterator_traits<iterator>::reference, int&>);
+static_assert(std::is_same_v<typename std::iterator_traits<iterator>::iterator_category, std::random_access_iterator_tag>);
+
+// const iterator
+
+static_assert(std::random_access_iterator<const_iterator>);
+static_assert(std::contiguous_iterator<const_iterator>);
+static_assert(std::is_same_v<typename std::iterator_traits<const_iterator>::value_type, int>);
+static_assert(std::is_same_v<typename std::iterator_traits<const_iterator>::difference_type, std::ptrdiff_t>);
+static_assert(std::is_same_v<typename std::iterator_traits<const_iterator>::pointer, int*>);
+static_assert(std::is_same_v<typename std::iterator_traits<const_iterator>::reference, int&>);
+static_assert(std::is_same_v<typename std::iterator_traits<const_iterator>::iterator_category, std::random_access_iterator_tag>);

libcxx/test/std/utilities/optional/optional.range/runtime_error.verify.cpp

@@ -0,0 +1,19 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: std-at-least-c++26
+
+#include "assert_macros.h"
+#include <optional>
+
+int main() {
+  std::optional<int> val = 2;
+  auto end               = val.end();
+  TEST_DOES_NOT_THROW(*end);
+  return 0;
+}

libcxx/test/std/utilities/optional/optional.range/satisfies_range_concept.compile.pass.cpp

@@ -0,0 +1,16 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: std-at-least-c++26
+
+#include <optional>
+#include <ranges>
+
+static_assert(std::ranges::sized_range<std::optional<int>>);
+static_assert(std::ranges::common_range<std::optional<int>>);
+static_assert(std::ranges::contiguous_range<std::optional<int>>);

libcxx/utils/generate_feature_test_macro_components.py

@@ -1004,7 +1004,6 @@ def add_version_header(tc):
             "name": "__cpp_lib_optional_range_support",
             "values": {"c++26": 202406},  # P3168R2 Give std::optional Range Support
             "headers": ["optional"],
-            "unimplemented": True,
         },
         {
             "name": "__cpp_lib_out_ptr",