[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/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,6 +200,8 @@ namespace std {
 #  include <__concepts/invocable.h>
 #  include <__config>
 #  include <__exception/exception.h>
+#  include <__format/format_context.h>
+#  include <__format/range_default_formatter.h>
 #  include <__functional/hash.h>
 #  include <__functional/invoke.h>
 #  include <__functional/unary_function.h>
@@ -566,6 +581,13 @@ using __optional_sfinae_assign_base_t _LIBCPP_NODEBUG =
 template <class _Tp>
 class optional;
 
+#    if _LIBCPP_STD_VER >= 26
+
+template <typename _Tp>
+class __optional_iterator;
+
+#    endif // _LIBCPP_STD_VER >= 26
+
 #    if _LIBCPP_STD_VER >= 20
 
 template <class _Tp>
@@ -578,6 +600,120 @@ 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;
+
+template <typename _Tp>
+class __optional_iterator {
+public:
+  using value_type        = _Tp;
+  using difference_type   = std::ptrdiff_t;
+  using pointer           = _Tp*;
+  using reference         = _Tp&;
+  using iterator_category = random_access_iterator_tag;
+  using iterator_concept  = contiguous_iterator_tag;
+
+private:
+  pointer __ptr_;
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __optional_iterator(pointer __ptr) : __ptr_(__ptr) {}
+  _LIBCPP_HIDE_FROM_ABI friend class optional<std::remove_const_t<_Tp>>;
+  _LIBCPP_HIDE_FROM_ABI friend class optional<const _Tp>;
+
+public:
+  _LIBCPP_HIDE_FROM_ABI constexpr __optional_iterator() : __ptr_(nullptr) {}
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __optional_iterator(const __optional_iterator&)            = default;
+  _LIBCPP_HIDE_FROM_ABI constexpr __optional_iterator& operator=(const __optional_iterator&) = default;
+
+  _LIBCPP_HIDE_FROM_ABI constexpr reference operator*() const { return *__ptr_; }
+  _LIBCPP_HIDE_FROM_ABI constexpr pointer operator->() const { return *__ptr_; }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __optional_iterator& operator++() noexcept {
+    __ptr_ = nullptr;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr __optional_iterator operator++(int) noexcept {
+    auto __t = *this;
+    __ptr_   = nullptr;
+    return __t;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __optional_iterator& operator--() noexcept {
+    __ptr_ = nullptr;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr __optional_iterator operator--(int) noexcept {
+    auto __t = *this;
+    __ptr_   = nullptr;
+    return __t;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr __optional_iterator& operator+=(difference_type __n) noexcept {
+    if (__n != 0)
+      __ptr_ = nullptr;
+    return *this;
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr __optional_iterator& operator-=(difference_type __n) noexcept {
+    if (__n != 0)
+      __ptr_ = nullptr;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __optional_iterator
+  operator+(__optional_iterator __i, difference_type __n) noexcept {
+    return (__n == 0 ? __i : __optional_iterator{});
+  }
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __optional_iterator
+  operator+(difference_type __n, __optional_iterator __i) noexcept {
+    return __i + __n;
+  }
+  _LIBCPP_HIDE_FROM_ABI friend constexpr __optional_iterator
+  operator-(__optional_iterator __i, difference_type __n) noexcept {
+    return (__n == 0 ? __i : __optional_iterator{});
+  }
+  _LIBCPP_HIDE_FROM_ABI friend constexpr difference_type
+  operator-(__optional_iterator __a, __optional_iterator __b) noexcept {
+    return (__a.__ptr_ == __b.__ptr_ ? 0 : (__a.__ptr_ ? 1 : -1));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr reference operator[](difference_type __n) const noexcept { return *(*this + __n); }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const __optional_iterator& __other) const {
+    return __ptr_ == __other.__ptr_;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool
+  operator<(const __optional_iterator& __a, const __optional_iterator& __b) noexcept {
+    return __a.__ptr_ < __b.__ptr_;
+  }
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool
+  operator>(const __optional_iterator& __a, const __optional_iterator& __b) noexcept {
+    return __a.__ptr_ > __b.__ptr_;
+  }
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool
+  operator<=(const __optional_iterator& __a, const __optional_iterator& __b) noexcept {
+    return __a.__ptr_ <= __b.__ptr_;
+  }
+  _LIBCPP_HIDE_FROM_ABI friend constexpr bool
+  operator>=(const __optional_iterator& __a, const __optional_iterator& __b) noexcept {
+    return __a.__ptr_ >= __b.__ptr_;
+  }
+
+  template <typename _Ut = _Tp>
+  _LIBCPP_HIDE_FROM_ABI constexpr operator __optional_iterator<const _Tp>() const
+    requires(!std::is_const_v<_Ut>)
+  {
+    return __optional_iterator<const _Tp>(static_cast<const _Tp*>(__ptr_));
+  }
+};
+
+#    endif // _LIBCPP_STD_VER >= 26
+
 template <class _Tp>
 class _LIBCPP_DECLSPEC_EMPTY_BASES optional
     : private __optional_move_assign_base<_Tp>,
@@ -588,6 +724,13 @@ class _LIBCPP_DECLSPEC_EMPTY_BASES optional
 public:
   using value_type = _Tp;
 
+#    if _LIBCPP_STD_VER >= 26
+
+  using iterator       = __optional_iterator<_Tp>;
+  using const_iterator = __optional_iterator<_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 +1119,25 @@ public:
   }
 #    endif // _LIBCPP_STD_VER >= 23
 
+// P3168R2
+#    if _LIBCPP_STD_VER >= 26
+
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator begin() {
+    if (!this->has_value())
+      return this->end();
+    return iterator(static_cast<_Tp*>(this->__get()));
+  }
+  _LIBCPP_HIDE_FROM_ABI constexpr const_iterator begin() const {
+    if (!this->has_value())
+      return this->end();
+    return const_iterator(static_cast<_Tp*>(this->value()));
+  }
+
+  _LIBCPP_HIDE_FROM_ABI constexpr iterator end() { return iterator(nullptr); }
+  _LIBCPP_HIDE_FROM_ABI constexpr const_iterator end() const { return const_iterator(nullptr); }
+
+#    endif
+
   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/iteration.pass.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 <cassert>
+#include <optional>
+
+int main() {
+  std::optional<int> val = 2;
+  for (const auto& elem : val)
+    assert(elem == 2);
+  return 0;
+}

libcxx/test/std/utilities/optional/optional.range/runtime_error.fail.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.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::range<std::optional<int>>, "std::ranges::range<std::optional<int>> is false");
+  return 0;
+}

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",