[libc++][ranges] P2711R1 Making multi-param constructors of views explicit

[H-G-Hristov]

Summary

Implemented P2711R1 for existing views.
(join_with_view is not yet implemented)

[H-G-Hristov]

Updated papers

[H-G-Hristov]

Implemented P2711R1 for existing views

[H-G-Hristov]

• Fixed placement
• Unit tests

[philnik]

With added tests this should be good to go.

libcxx/docs/Status/Cxx2bPapers.csv

111

Please add a note that join_with_view isn't yet implemented, so we know what's missing to complete it.

libcxx/include/__ranges/drop_view.h

77

You are missing a test for this constructor.

libcxx/include/__ranges/iota_view.h

317

You are missing tests for these constructors.

libcxx/include/__ranges/lazy_split_view.h

85

You are missing tests for these constructors.

libcxx/include/__ranges/split_view.h

78

You are missing tests for these constructors.

libcxx/include/__ranges/take_view.h

70–71

You are missing a test for this constructor.

libcxx/test/std/ranges/range.adaptors/range.filter/ctor.view_pred.pass.cpp

45

We normally don't use aliases to make it easier to see what is tested. For a single instance it's also not really worth it.

101

We generally have SFINAE tests at the top of the file, so let's move them there.

[H-G-Hristov]

• Updated implementation and added tests

[H-G-Hristov]

@philnik Thank you very much for the review! I hope I addressed all comments as requested.

[philnik]

LGTM % nits.

libcxx/include/__config

880–884

Please move this up to the _LIBCPP_EXPLICIT_SINCE_CXX14.

libcxx/include/__ranges/filter_view.h

67–68

[H-G-Hristov]

• Addressed review comments and tried to fix CI

[H-G-Hristov]

libcxx/include/__ranges/filter_view.h

67–68

It looks like that the clang-format auto-fixer has it own oppinion.

[Mordante]

Note I just skimmed over the patch out of curiosity and I didn't do a real review. I noticed some issues.

libcxx/docs/Status/Cxx2b.rst

46

libcxx/test/std/ranges/range.adaptors/range.drop.while/ctor.view.pass.cpp

38

We shouldn't use _LIBCPP_foo macros in our test suite. Other vendors like MSVC STL and libstdc++ use our tests too. They don't define _LIBCPP_foo macros.

Note this change requires #include "test_macros.h" too.

The same applies to the other tests for explicit.

[H-G-Hristov]

In D144822#4210800, @Mordante wrote:

Note I just skimmed over the patch out of curiosity and I didn't do a real review. I noticed some issues.

Thanks for the remarks. I'll fix those.

[H-G-Hristov]

Addressed comments

[H-G-Hristov]

• Fix CI

[H-G-Hristov]

• Fix CI

[H-G-Hristov]

@philnik @Mordante

Thank you for the reviews!

I'd like to confirm what would be appropriate course of action on my side at this point in general:

1. I believe I addressed all remarks (IMO).
2. I fixed all related CI errors but there is still one unrelated (IMO).
3. I got LGTM but I still made changes after that.

In the context of the above at this point:

1. Shall I request a re-review explicitly.
2. Shall I wait for another review.
3. Shall I decide on my own if I am good to land the patch or wait for 1) or 2)

[philnik]

In D144822#4215605, @H-G-Hristov wrote:

@philnik @Mordante

Thank you for the reviews!

I'd like to confirm what would be appropriate course of action on my side at this point in general:

1. I believe I addressed all remarks (IMO).
2. I fixed all related CI errors but there is still one unrelated (IMO).
3. I got LGTM but I still made changes after that.

In the context of the above at this point:

1. Shall I request a re-review explicitly.
2. Shall I wait for another review.
3. Shall I decide on my own if I am good to land the patch or wait for 1) or 2)

It's generally a judgement call on your side. It depends on how much the patch changed. In this case IMO it would be OK for you to just land the patch, but it's also OK if you ask again.

[Mordante]

In D144822#4215789, @philnik wrote:

In D144822#4215605, @H-G-Hristov wrote:

@philnik @Mordante

Thank you for the reviews!

I'd like to confirm what would be appropriate course of action on my side at this point in general:

1. I believe I addressed all remarks (IMO).
2. I fixed all related CI errors but there is still one unrelated (IMO).
3. I got LGTM but I still made changes after that.

In the context of the above at this point:

1. Shall I request a re-review explicitly.
2. Shall I wait for another review.
3. Shall I decide on my own if I am good to land the patch or wait for 1) or 2)

It's generally a judgement call on your side. It depends on how much the patch changed. In this case IMO it would be OK for you to just land the patch, but it's also OK if you ask again.

+1 but in general you're free to commit, unless you make "large" changes to fix the CI. That's a judgement call.

Note if I (or a different reviewer) disagrees with the original approval they can request change (the red circle with a cross next to the review), which means a new approval is required. In this case I deemed the changes small enough that I trust you to address them correctly and it doesn't need another review.

I took a look at the changes you made and I was right to trust you :-)

libcxx/docs/Status/Cxx2b.rst

.. csv-table::
    :widths: auto
 
 .. note::
 
    .. [#note-P0533R9] P0533R9: ``isfinite``, ``isinf``, ``isnan`` and ``isnormal`` are implemented.
    .. [#note-P1413R3] P1413R3: ``std::aligned_storage_t`` and ``std::aligned_union_t`` are marked deprecated, but
       clang doesn't issue a diagnostic for deprecated using template declarations.
    .. [#note-P2520R0] P2520R0: Libc++ implemented this paper as a DR in C++20 as well.
+   .. [#note-P2711R1] P2711R1: ``join_with_view`` hasn't been done yet since this types isn't implemented yet.
 
 .. _issues-status-cxx2b:
 
 Library Working Group Issues Status
 ====================================
 
 .. csv-table::
    :file: Cxx2bIssues.csv
    :header-rows: 1
    :widths: auto
 
 .. note::
 
    .. [#note-LWG3798] LWG3798: ``join_with_view``, ``zip_transform_view``, and ``adjacent_transform_view`` haven't been done yet since these types aren't implemented yet.

libcxx/docs/Status/Cxx2bPapers.csv

 "`P2505R5 <https://wg21.link/P2505R5>`__","LWG", "Monadic Functions for ``std::expected``", "November 2022","","",""
 "`P2539R4 <https://wg21.link/P2539R4>`__","LWG", "Should the output of ``std::print`` to a terminal be synchronized with the underlying stream?", "November 2022","","","|format|"
 "`P2602R2 <https://wg21.link/P2602R2>`__","LWG", "Poison Pills are Too Toxic", "November 2022","","","|ranges|"
 "`P2708R1 <https://wg21.link/P2708R1>`__","LWG", "No Further Fundamentals TSes", "November 2022","|Nothing to do|","",""
 "","","","","","",""
 "`P0290R4 <https://wg21.link/P0290R4>`__","LWG", "``apply()`` for ``synchronized_value<T>``","February 2023","","","|concurrency TS|"
 "`P2770R0 <https://wg21.link/P2770R0>`__","LWG", "Stashing stashing ``iterators`` for proper flattening","February 2023","","","|ranges|"
 "`P2164R9 <https://wg21.link/P2164R9>`__","LWG", "``views::enumerate``","February 2023","","","|ranges|"
-"`P2711R1 <https://wg21.link/P2711R1>`__","LWG", "Making multi-param constructors of ``views`` ``explicit``","February 2023","","","|ranges|"
+"`P2711R1 <https://wg21.link/P2711R1>`__","LWG", "Making multi-param constructors of ``views`` ``explicit``","February 2023","|Partial| [#note-P2711R1]_","","|ranges|"
 "`P2609R3 <https://wg21.link/P2609R3>`__","LWG", "Relaxing Ranges Just A Smidge","February 2023","","","|ranges|"
 "`P2713R1 <https://wg21.link/P2713R1>`__","LWG", "Escaping improvements in ``std::format``","February 2023","","","|format|"
 "`P2675R1 <https://wg21.link/P2675R1>`__","LWG", "``format``'s width estimation is too approximate and not forward compatible","February 2023","","","|format|"
 "`P2572R1 <https://wg21.link/P2572R1>`__","LWG", "``std::format`` fill character allowances","February 2023","","","|format|"
 "`P2693R1 <https://wg21.link/P2693R1>`__","LWG", "Formatting ``thread::id`` and ``stacktrace``","February 2023","","","|format|"
 "`P2679R2 <https://wg21.link/P2679R2>`__","LWG", "Fixing ``std::start_lifetime_as`` for arrays","February 2023","","",""
 "`P2674R1 <https://wg21.link/P2674R1>`__","LWG", "A trait for implicit lifetime types","February 2023","","",""
 "`P2655R3 <https://wg21.link/P2655R3>`__","LWG", "``common_reference_t`` of ``reference_wrapper`` Should Be a Reference Type","February 2023","","",""
 "`P2652R2 <https://wg21.link/P2652R2>`__","LWG", "Disallow User Specialization of ``allocator_traits``","February 2023","","",""
 "`P2787R1 <https://wg21.link/P2787R1>`__","LWG", "``pmr::generator`` - Promise Types are not Values","February 2023","","",""
 "`P2614R2 <https://wg21.link/P2614R2>`__","LWG", "Deprecate ``numeric_limits::has_denorm``","February 2023","","",""
 "`P2588R3 <https://wg21.link/P2588R3>`__","LWG", "``barrier``’s phase completion guarantees","February 2023","","",""
 "`P2763R1 <https://wg21.link/P2763R1>`__","LWG", "``layout_stride`` static extents default constructor fix","February 2023","","",""
 "`P2736R2 <https://wg21.link/P2736R2>`__","CWG","Referencing The Unicode Standard","February 2023","","","|format|"

libcxx/include/__config

 #  endif
 
 #  if _LIBCPP_STD_VER <= 11
 #    define _LIBCPP_EXPLICIT_SINCE_CXX14
 #  else
 #    define _LIBCPP_EXPLICIT_SINCE_CXX14 explicit
 #  endif
 
+#  if _LIBCPP_STD_VER >= 23
+#    define _LIBCPP_EXPLICIT_SINCE_CXX23 explicit
+#  else
+#    define _LIBCPP_EXPLICIT_SINCE_CXX23
+#  endif
+
 #  if _LIBCPP_STD_VER >= 14
 #    define _LIBCPP_CONSTEXPR_SINCE_CXX14 constexpr
 #  else
 #    define _LIBCPP_CONSTEXPR_SINCE_CXX14
 #  endif
 
 #  if _LIBCPP_STD_VER >= 17
 #    define _LIBCPP_CONSTEXPR_SINCE_CXX17 constexpr
 #  else
 #    define _LIBCPP_CONSTEXPR_SINCE_CXX17
 #  endif
 
 #  if _LIBCPP_STD_VER >= 20
 #    define _LIBCPP_CONSTEXPR_SINCE_CXX20 constexpr
 #  else
 #    define _LIBCPP_CONSTEXPR_SINCE_CXX20
 #  endif
 
 #  if _LIBCPP_STD_VER >= 23
 #    define _LIBCPP_CONSTEXPR_SINCE_CXX23 constexpr
 #  else
 #    define _LIBCPP_CONSTEXPR_SINCE_CXX23
 #  endif
 
 #  if __has_cpp_attribute(nodiscard)
 #    define _LIBCPP_NODISCARD [[nodiscard]]
 #  else
 // We can't use GCC's [[gnu::warn_unused_result]] and
 // __attribute__((warn_unused_result)), because GCC does not silence them via
 // (void) cast.
 #    define _LIBCPP_NODISCARD
 #  endif
 
 // _LIBCPP_NODISCARD_EXT may be used to apply [[nodiscard]] to entities not
 // specified as such as an extension.
 #  if !defined(_LIBCPP_DISABLE_NODISCARD_EXT)
 #    define _LIBCPP_NODISCARD_EXT _LIBCPP_NODISCARD

libcxx/include/__ranges/drop_view.h

class drop_view
     _LIBCPP_NO_UNIQUE_ADDRESS _Cache __cached_begin_ = _Cache();
     range_difference_t<_View> __count_ = 0;
     _View __base_ = _View();
 
 public:
     drop_view() requires default_initializable<_View> = default;
 
     _LIBCPP_HIDE_FROM_ABI
-    constexpr drop_view(_View __base, range_difference_t<_View> __count)
+    constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 drop_view(_View __base, range_difference_t<_View> __count)
       : __count_(__count)
       , __base_(std::move(__base))
     {
       _LIBCPP_ASSERT(__count_ >= 0, "count must be greater than or equal to zero.");
     }
 
     _LIBCPP_HIDE_FROM_ABI constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
     _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }

libcxx/include/__ranges/drop_while_view.h

 template <view _View, class _Pred>
   requires input_range<_View> && is_object_v<_Pred> && indirect_unary_predicate<const _Pred, iterator_t<_View>>
 class drop_while_view : public view_interface<drop_while_view<_View, _Pred>> {
 public:
   _LIBCPP_HIDE_FROM_ABI drop_while_view()
     requires default_initializable<_View> && default_initializable<_Pred>
   = default;
 
-  _LIBCPP_HIDE_FROM_ABI constexpr drop_while_view(_View __base, _Pred __pred)
+  _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 drop_while_view(_View __base, _Pred __pred)
       : __base_(std::move(__base)), __pred_(std::in_place, std::move(__pred)) {}
 
   _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
     requires copy_constructible<_View>
   {
     return __base_;
   }
 

libcxx/include/__ranges/filter_view.h

class filter_view : public view_interface<filter_view<_View, _Pred>> {
 
     class __iterator;
     class __sentinel;
 
   public:
     _LIBCPP_HIDE_FROM_ABI
     filter_view() requires default_initializable<_View> && default_initializable<_Pred> = default;
 
-    _LIBCPP_HIDE_FROM_ABI
-    constexpr filter_view(_View __base, _Pred __pred)
-      : __base_(std::move(__base)), __pred_(in_place, std::move(__pred))
-    { }
+    _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 filter_view(_View __base, _Pred __pred)
+        : __base_(std::move(__base)), __pred_(in_place, std::move(__pred)) {}
 
     template<class _Vp = _View>
     _LIBCPP_HIDE_FROM_ABI
     constexpr _View base() const& requires copy_constructible<_Vp> { return __base_; }
     _LIBCPP_HIDE_FROM_ABI
     constexpr _View base() && { return std::move(__base_); }
 
     _LIBCPP_HIDE_FROM_ABI

libcxx/include/__ranges/iota_view.h

namespace ranges {
   public:
     _LIBCPP_HIDE_FROM_ABI
     iota_view() requires default_initializable<_Start> = default;
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr explicit iota_view(_Start __value) : __value_(std::move(__value)) { }
 
     _LIBCPP_HIDE_FROM_ABI
-    constexpr iota_view(type_identity_t<_Start> __value, type_identity_t<_BoundSentinel> __bound_sentinel)
+    constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 iota_view(type_identity_t<_Start> __value, type_identity_t<_BoundSentinel> __bound_sentinel)
         : __value_(std::move(__value)), __bound_sentinel_(std::move(__bound_sentinel)) {
       // Validate the precondition if possible.
       if constexpr (totally_ordered_with<_Start, _BoundSentinel>) {
         _LIBCPP_ASSERT(ranges::less_equal()(__value_, __bound_sentinel_),
                        "Precondition violated: value is greater than bound.");
       }
     }
 
     _LIBCPP_HIDE_FROM_ABI
-    constexpr iota_view(__iterator __first, __iterator __last)
+    constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 iota_view(__iterator __first, __iterator __last)
       requires same_as<_Start, _BoundSentinel>
     : iota_view(std::move(__first.__value_), std::move(__last.__value_)) {}
 
     _LIBCPP_HIDE_FROM_ABI
-    constexpr iota_view(__iterator __first, _BoundSentinel __last)
+    constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 iota_view(__iterator __first, _BoundSentinel __last)
       requires same_as<_BoundSentinel, unreachable_sentinel_t>
     : iota_view(std::move(__first.__value_), std::move(__last)) {}
 
     _LIBCPP_HIDE_FROM_ABI
-    constexpr iota_view(__iterator __first, __sentinel __last)
+    constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 iota_view(__iterator __first, __sentinel __last)
       requires(!same_as<_Start, _BoundSentinel> && !same_as<_Start, unreachable_sentinel_t>)
     : iota_view(std::move(__first.__value_), std::move(__last.__bound_sentinel_)) {}
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr __iterator begin() const { return __iterator{__value_}; }
 
     _LIBCPP_HIDE_FROM_ABI
     constexpr auto end() const {

libcxx/include/__ranges/lazy_split_view.h

class lazy_split_view : public view_interface<lazy_split_view<_View, _Pattern>> {
   template <bool> struct __inner_iterator;
 
 public:
   _LIBCPP_HIDE_FROM_ABI
   lazy_split_view()
     requires default_initializable<_View> && default_initializable<_Pattern> = default;
 
   _LIBCPP_HIDE_FROM_ABI
-  constexpr lazy_split_view(_View __base, _Pattern __pattern)
+  constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 lazy_split_view(_View __base, _Pattern __pattern)
     : __base_(std::move(__base)), __pattern_(std::move(__pattern)) {}
 
   template <input_range _Range>
     requires constructible_from<_View, views::all_t<_Range>> &&
              constructible_from<_Pattern, single_view<range_value_t<_Range>>>
   _LIBCPP_HIDE_FROM_ABI
-  constexpr lazy_split_view(_Range&& __r, range_value_t<_Range> __e)
+  constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 lazy_split_view(_Range&& __r, range_value_t<_Range> __e)
     : __base_(views::all(std::forward<_Range>(__r)))
     , __pattern_(views::single(std::move(__e))) {}
 
   _LIBCPP_HIDE_FROM_ABI
   constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
   _LIBCPP_HIDE_FROM_ABI
   constexpr _View base() && { return std::move(__base_); }
 

libcxx/include/__ranges/split_view.h

_LIBCPP_HIDE_FROM_ABI constexpr subrange<iterator_t<_View>> __find_next(iterator_t<_View> __it) {
     return {__begin, __end};
   }
 
 public:
   _LIBCPP_HIDE_FROM_ABI split_view()
     requires default_initializable<_View> && default_initializable<_Pattern>
   = default;
 
-  _LIBCPP_HIDE_FROM_ABI constexpr split_view(_View __base, _Pattern __pattern)
+  _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 split_view(_View __base, _Pattern __pattern)
       : __base_(std::move(__base)), __pattern_(std::move((__pattern))) {}
 
   template <forward_range _Range>
     requires constructible_from<_View, views::all_t<_Range>> &&
                  constructible_from<_Pattern, single_view<range_value_t<_Range>>>
-  _LIBCPP_HIDE_FROM_ABI constexpr split_view(_Range&& __range, range_value_t<_Range> __elem)
+  _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23
+  split_view(_Range&& __range, range_value_t<_Range> __elem)
       : __base_(views::all(std::forward<_Range>(__range))), __pattern_(views::single(std::move(__elem))) {}
 
   _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
     requires copy_constructible<_View>
   {
     return __base_;
   }
 

libcxx/include/__ranges/take_view.h

class take_view : public view_interface<take_view<_View>> {
   range_difference_t<_View> __count_ = 0;
 
   template<bool> class __sentinel;
 
 public:
   _LIBCPP_HIDE_FROM_ABI
   take_view() requires default_initializable<_View> = default;
 
-  _LIBCPP_HIDE_FROM_ABI constexpr take_view(_View __base, range_difference_t<_View> __count)
+  _LIBCPP_HIDE_FROM_ABI 
+  constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 take_view(_View __base, range_difference_t<_View> __count)
       : __base_(std::move(__base)), __count_(__count) {
     _LIBCPP_ASSERT(__count >= 0, "count has to be greater than or equal to zero");
   }
 
   _LIBCPP_HIDE_FROM_ABI
   constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
 
   _LIBCPP_HIDE_FROM_ABI

libcxx/include/__ranges/take_while_view.h

class take_while_view : public view_interface<take_while_view<_View, _Pred>> {
   _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
   _LIBCPP_NO_UNIQUE_ADDRESS __copyable_box<_Pred> __pred_;
 
 public:
   _LIBCPP_HIDE_FROM_ABI take_while_view()
     requires default_initializable<_View> && default_initializable<_Pred>
   = default;
 
-  _LIBCPP_HIDE_FROM_ABI constexpr take_while_view(_View __base, _Pred __pred)
+  _LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 take_while_view(_View __base, _Pred __pred)
       : __base_(std::move(__base)), __pred_(std::in_place, std::move(__pred)) {}
 
   _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
     requires copy_constructible<_View>
   {
     return __base_;
   }
 

libcxx/include/__ranges/transform_view.h

class transform_view : public view_interface<transform_view<_View, _Fn>> {
   _LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
 
 public:
   _LIBCPP_HIDE_FROM_ABI
   transform_view()
     requires default_initializable<_View> && default_initializable<_Fn> = default;
 
   _LIBCPP_HIDE_FROM_ABI
-  constexpr transform_view(_View __base, _Fn __func)
+  constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 transform_view(_View __base, _Fn __func)
     : __func_(std::in_place, std::move(__func)), __base_(std::move(__base)) {}
 
   _LIBCPP_HIDE_FROM_ABI
   constexpr _View base() const& requires copy_constructible<_View> { return __base_; }
   _LIBCPP_HIDE_FROM_ABI
   constexpr _View base() && { return std::move(__base_); }
 
   _LIBCPP_HIDE_FROM_ABI

libcxx/test/std/ranges/range.adaptors/range.drop.while/ctor.view.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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: c++03, c++11, c++14, c++17
 
-// constexpr drop_while_view(V base, Pred pred);
+// constexpr drop_while_view(V base, Pred pred); // explicit since C++23
 
 #include <cassert>
 #include <ranges>
 #include <type_traits>
 #include <utility>
 
 #include "MoveOnly.h"
+#include "test_convertible.h"
 
 struct View : std::ranges::view_base {
   MoveOnly mo;
   int* begin() const;
   int* end() const;
 };
 
 struct Pred {
   bool copied      = false;
   bool moved       = false;
   constexpr Pred() = default;
   constexpr Pred(Pred&&) : moved(true) {}
   constexpr Pred(const Pred&) : copied(true) {}
   bool operator()(int) const;
 };
 
+// SFINAE tests.
+
+#if _LIBCPP_STD_VER >= 23
+
+static_assert(!test_convertible<std::ranges::drop_while_view<View, Pred>, View, Pred>(),
+              "This constructor must be explicit");
+
+#else
+
+static_assert( test_convertible<std::ranges::drop_while_view<View, Pred>, View, Pred>(),
+              "This constructor must not be explicit");
+
+#endif // _LIBCPP_STD_VER >= 23
+
 constexpr bool test() {
   {
-    std::ranges::drop_while_view<View, Pred> dwv = {View{{}, MoveOnly{5}}, Pred{}};
+    std::ranges::drop_while_view<View, Pred> dwv{View{{}, MoveOnly{5}}, Pred{}};
     assert(dwv.pred().moved);
     assert(!dwv.pred().copied);
     assert(std::move(dwv).base().mo.get() == 5);
   }
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
+
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.drop/ctor.view.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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: c++03, c++11, c++14, c++17
 
-// constexpr drop_view(V base, range_difference_t<V> count);
+// constexpr drop_view(V base, range_difference_t<V> count);  // explicit since C++23
 
 #include <ranges>
 
+#include "test_convertible.h"
 #include "test_macros.h"
 #include "types.h"
 
+// SFINAE tests.
+
+#if _LIBCPP_STD_VER >= 23
+
+static_assert(!test_convertible<std::ranges::drop_view<View>, 
+                                View, 
+                                std::ranges::range_difference_t<View>>(),
+              "This constructor must be explicit");
+
+#else
+
+static_assert( test_convertible<std::ranges::drop_view<View>, 
+                                View, 
+                                std::ranges::range_difference_t<View>>(),
+              "This constructor must not be explicit");
+
+#endif // _LIBCPP_STD_VER >= 23
+
 constexpr bool test() {
   std::ranges::drop_view dropView1(MoveOnlyView(), 4);
   assert(dropView1.size() == 4);
   assert(dropView1.begin() == globalBuff + 4);
 
   std::ranges::drop_view dropView2(ForwardView(), 4);
   assert(base(dropView2.begin()) == globalBuff + 4);
 

libcxx/test/std/ranges/range.adaptors/range.drop/types.h

 };
 
 using CountedIter = stride_counting_iterator<forward_iterator<int*>>;
 struct CountedView : std::ranges::view_base {
   constexpr CountedIter begin() const { return CountedIter(ForwardIter(globalBuff)); }
   constexpr CountedIter end() const { return CountedIter(ForwardIter(globalBuff + 8)); }
 };
 
+struct View : std::ranges::view_base {
+  constexpr explicit View(int* b, int* e) : begin_(b), end_(e) { }
+
+  constexpr int* begin() const { return begin_; }
+  constexpr int* end() const { return end_; }
+
+private:
+  int* begin_;
+  int* end_;
+};
+
 #endif // TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_DROP_TYPES_H

libcxx/test/std/ranges/range.adaptors/range.filter/ctor.view_pred.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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: c++03, c++11, c++14, c++17
 
-// constexpr filter_view(View, Pred);
-
-#include <ranges>
+// constexpr filter_view(View, Pred); // explicit since C++23
 
 #include <cassert>
+#include <ranges>
 #include <utility>
+
+#include "test_convertible.h"
 #include "types.h"
 
 struct Range : std::ranges::view_base {
   constexpr explicit Range(int* b, int* e) : begin_(b), end_(e) { }
   constexpr int* begin() const { return begin_; }
   constexpr int* end() const { return end_; }
 
 private:

 };
 
 struct TrackingRange : TrackInitialization, std::ranges::view_base {
   using TrackInitialization::TrackInitialization;
   int* begin() const;
   int* end() const;
 };
 
+// SFINAE tests.
+
+#if _LIBCPP_STD_VER >= 23
+
+static_assert(!test_convertible<std::ranges::filter_view<Range, Pred>, Range, Pred>(),
+              "This constructor must be explicit");
+
+#else
+
+static_assert( test_convertible<std::ranges::filter_view<Range, Pred>, Range, Pred>(),
+              "This constructor must not be explicit");
+
+#endif // _LIBCPP_STD_VER >= 23
+
 constexpr bool test() {
   int buff[] = {1, 2, 3, 4, 5, 6, 7, 8};
 
   // Test explicit syntax
   {
     Range range(buff, buff + 8);
     Pred pred;
     std::ranges::filter_view<Range, Pred> view(range, pred);
     auto it = view.begin(), end = view.end();
     assert(*it++ == 1);
     assert(*it++ == 3);
     assert(*it++ == 5);
     assert(*it++ == 7);
     assert(it == end);
   }
 
-  // Test implicit syntax
-  {
-    Range range(buff, buff + 8);
-    Pred pred;
-    std::ranges::filter_view<Range, Pred> view = {range, pred};
-    auto it = view.begin(), end = view.end();
-    assert(*it++ == 1);
-    assert(*it++ == 3);
-    assert(*it++ == 5);
-    assert(*it++ == 7);
-    assert(it == end);
-  }
-
   // Make sure we move the view
   {
     bool moved = false, copied = false;
     TrackingRange range(&moved, &copied);
     Pred pred;
     [[maybe_unused]] std::ranges::filter_view<TrackingRange, Pred> view(std::move(range), pred);
     assert(moved);
     assert(!copied);
constexpr bool test() {
   }
 
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.lazy.split/ctor.range.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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: c++03, c++11, c++14, c++17
 
 // template <input_range Range>
 //   requires constructible_from<View, views::all_t<Range>> &&
 //             constructible_from<Pattern, single_view<range_value_t<Range>>>
-// constexpr lazy_split_view(Range&& r, range_value_t<Range> e);
+// constexpr lazy_split_view(Range&& r, range_value_t<Range> e); // explicit since C++23
 
 #include <ranges>
 
 #include <cassert>
 #include <string>
 #include <string_view>
 #include <type_traits>
 #include <utility>
+
+#include "test_convertible.h"
 #include "types.h"
 
 struct ElementWithCounting {
   int* times_copied = nullptr;
   int* times_moved = nullptr;
 
   constexpr ElementWithCounting(int& copies_ctr, int& moves_ctr) : times_copied(&copies_ctr), times_moved(&moves_ctr) {}
 
struct StrView : std::ranges::view_base {
   constexpr std::string_view::const_iterator begin() const { return buffer_.begin(); }
   constexpr std::string_view::const_iterator end() const { return buffer_.end(); }
   constexpr bool operator==(const StrView& rhs) const { return buffer_ == rhs.buffer_; }
 };
 static_assert( std::ranges::random_access_range<StrView>);
 static_assert( std::ranges::view<StrView>);
 static_assert( std::is_copy_constructible_v<StrView>);
 
+// SFINAE tests.
+
+#if _LIBCPP_STD_VER >= 23
+
+static_assert(!test_convertible<std::ranges::lazy_split_view<StrView, StrView>, 
+                                StrView, 
+                                std::ranges::range_value_t<StrView>>(),
+              "This constructor must be explicit");
+
+#else
+
+static_assert( test_convertible<std::ranges::lazy_split_view<StrView, StrView>, 
+                                StrView, 
+                                std::ranges::range_value_t<StrView>>(),
+              "This constructor must not be explicit");
+
+#endif // _LIBCPP_STD_VER >= 23
+
 constexpr bool test() {
   {
     using V = std::ranges::lazy_split_view<StrView, StrView>;
 
     // Calling the constructor with `(std::string, range_value_t)`.
     {
       std::string input;
       V v(input, ' ');

libcxx/test/std/ranges/range.adaptors/range.lazy.split/ctor.view.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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: c++03, c++11, c++14, c++17
 
-// constexpr lazy_split_view(View base, Pattern pattern);
-
-#include <ranges>
+// constexpr lazy_split_view(View base, Pattern pattern); // explicit since C++23
 
 #include <cassert>
+#include <ranges>
 #include <string_view>
 #include <utility>
+
+#include "test_convertible.h"
 #include "types.h"
 
 struct ViewWithCounting : std::ranges::view_base {
   int* times_copied = nullptr;
   int* times_moved = nullptr;
 
   constexpr ViewWithCounting(int& copies_ctr, int& moves_ctr) : times_copied(&copies_ctr), times_moved(&moves_ctr) {}
 
struct ViewWithCounting : std::ranges::view_base {
 
   constexpr const char* begin() const { return nullptr; }
   constexpr const char* end() const { return nullptr; }
 
   constexpr ViewWithCounting& operator=(const ViewWithCounting&) = default;
   constexpr ViewWithCounting& operator=(ViewWithCounting&&) = default;
   constexpr bool operator==(const ViewWithCounting&) const { return true; }
 };
+
 static_assert(std::ranges::forward_range<ViewWithCounting>);
 static_assert(std::ranges::view<ViewWithCounting>);
 
+using View = ViewWithCounting;
+using Pattern = ViewWithCounting;
+
+// SFINAE tests.
+
+#if _LIBCPP_STD_VER >= 23
+
+static_assert(!test_convertible<std::ranges::lazy_split_view<View, Pattern>, View, Pattern>(),
+              "This constructor must be explicit");
+
+#else
+
+static_assert( test_convertible<std::ranges::lazy_split_view<View, Pattern>, View, Pattern>(),
+              "This constructor must not be explicit");
+
+#endif // _LIBCPP_STD_VER >= 23
+
 constexpr bool test() {
   // Calling the constructor with `(ForwardView, ForwardView)`.
   {
     CopyableView input = "abc def";
     std::ranges::lazy_split_view<CopyableView, CopyableView> v(input, " ");
     assert(v.base() == input);
   }
 
   // Calling the constructor with `(InputView, TinyView)`.
   {
     InputView input = "abc def";
     std::ranges::lazy_split_view<InputView, ForwardTinyView> v(input, ' ');
     // Note: `InputView` isn't equality comparable.
     (void)v;
   }
 
   // Make sure the arguments are moved, not copied.
   {
-    using View = ViewWithCounting;
-    using Pattern = ViewWithCounting;
-
     // Arguments are lvalues.
     {
       int view_copied = 0, view_moved = 0, pattern_copied = 0, pattern_moved = 0;
       View view(view_copied, view_moved);
       Pattern pattern(pattern_copied, pattern_moved);
 
       std::ranges::lazy_split_view<View, Pattern> v(view, pattern);
       assert(view_copied == 1); // The local variable is copied into the argument.

libcxx/test/std/ranges/range.adaptors/range.split/ctor.range.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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: c++03, c++11, c++14, c++17
 
 // template <input_range Range>
 //   requires constructible_from<View, views::all_t<Range>> &&
 //             constructible_from<Pattern, single_view<range_value_t<Range>>>
-// constexpr split_view(Range&& r, range_value_t<Range> e);
+// constexpr split_view(Range&& r, range_value_t<Range> e); // explicit since C++23
 
 #include <algorithm>
 #include <cassert>
 #include <ranges>
 #include <string>
 #include <string_view>
 #include <type_traits>
 #include <utility>
 
+#include "test_convertible.h"
+
 struct Counting {
   int* times_copied = nullptr;
   int* times_moved  = nullptr;
 
   constexpr Counting(int& copies_ctr, int& moves_ctr) : times_copied(&copies_ctr), times_moved(&moves_ctr) {}
 
   constexpr Counting(const Counting& rhs) : times_copied(rhs.times_copied), times_moved(rhs.times_moved) {
     ++(*times_copied);
struct StrView : std::ranges::view_base {
   constexpr const char* begin() const { return buffer_.data(); }
   constexpr const char* end() const { return buffer_.data() + buffer_.size(); }
   constexpr bool operator==(const StrView& rhs) const { return buffer_ == rhs.buffer_; }
 };
 static_assert(std::ranges::random_access_range<StrView>);
 static_assert(std::ranges::view<StrView>);
 static_assert(std::is_copy_constructible_v<StrView>);
 
+// SFINAE tests.
+
+#if _LIBCPP_STD_VER >= 23
+
+static_assert(!test_convertible<std::ranges::split_view<StrView, StrView>, 
+                                StrView, 
+                                std::ranges::range_value_t<StrView>>(),
+              "This constructor must be explicit");
+
+# else
+
+static_assert( test_convertible<std::ranges::split_view<StrView, StrView>, 
+                                StrView, 
+                                std::ranges::range_value_t<StrView>>(),
+              "This constructor must not be explicit");
+
+#endif // _LIBCPP_STD_VER >= 23
+
 constexpr bool test() {
   {
     using V = std::ranges::split_view<StrView, StrView>;
 
     // Calling the constructor with `(std::string, range_value_t)`.
     {
       std::string input("abc def");
       V v(input, ' ');

libcxx/test/std/ranges/range.adaptors/range.split/ctor.view.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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: c++03, c++11, c++14, c++17
 
-// constexpr split_view(View base, Pattern pattern);
+// constexpr split_view(View base, Pattern pattern); // explicit since C++23
 
 #include <algorithm>
 #include <cassert>
 #include <ranges>
 #include <string_view>
 #include <utility>
 
+#include "test_convertible.h"
+
 struct ViewWithCounting : std::ranges::view_base {
   int* times_copied = nullptr;
   int* times_moved  = nullptr;
 
   constexpr ViewWithCounting(int& copies_ctr, int& moves_ctr) : times_copied(&copies_ctr), times_moved(&moves_ctr) {}
 
   constexpr ViewWithCounting(const ViewWithCounting& rhs)
       : times_copied(rhs.times_copied), times_moved(rhs.times_moved) {
     ++(*times_copied);
   }
   constexpr ViewWithCounting(ViewWithCounting&& rhs) : times_copied(rhs.times_copied), times_moved(rhs.times_moved) {
     ++(*times_moved);
   }
 
   constexpr const char* begin() const { return nullptr; }
   constexpr const char* end() const { return nullptr; }
 
   constexpr ViewWithCounting& operator=(const ViewWithCounting&) = default;
   constexpr ViewWithCounting& operator=(ViewWithCounting&&)      = default;
   constexpr bool operator==(const ViewWithCounting&) const { return true; }
 };
 
+using View    = ViewWithCounting;
+using Pattern = ViewWithCounting;
+
+// SFINAE tests.
+
+#if _LIBCPP_STD_VER >= 23
+
+static_assert(!test_convertible<std::ranges::split_view<View, Pattern>, View, Pattern>(),
+              "This constructor must be explicit");
+
+#else
+
+static_assert( test_convertible<std::ranges::split_view<View, Pattern>, View, Pattern>(),
+              "This constructor must not be explicit");
+
+#endif // _LIBCPP_STD_VER >= 23
+
 constexpr bool test() {
   {
     std::string_view input = "abc def";
     std::ranges::lazy_split_view<std::string_view, std::string_view> v(input, " ");
     assert(v.base() == input);
     assert(std::ranges::equal(*v.begin(), std::string_view{"abc"}));
   }
 
   // Make sure the arguments are moved, not copied.
   {
-    using View    = ViewWithCounting;
-    using Pattern = ViewWithCounting;
-
     // Arguments are lvalues.
     {
       int view_copied = 0, view_moved = 0, pattern_copied = 0, pattern_moved = 0;
       View view(view_copied, view_moved);
       Pattern pattern(pattern_copied, pattern_moved);
 
       std::ranges::split_view<View, Pattern> v(view, pattern);
       assert(view_copied == 1); // The local variable is copied into the argument.

libcxx/test/std/ranges/range.adaptors/range.take.while/ctor.view.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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: c++03, c++11, c++14, c++17
 
-// constexpr take_while_view(V base, Pred pred);
+// constexpr take_while_view(V base, Pred pred); // explicit since C++23
 
 #include <cassert>
 #include <ranges>
 #include <type_traits>
 #include <utility>
 
 #include "MoveOnly.h"
+#include "test_convertible.h"
 
 struct View : std::ranges::view_base {
   MoveOnly mo;
   int* begin() const;
   int* end() const;
 };
 
 struct Pred {
   bool copied      = false;
   bool moved       = false;
   constexpr Pred() = default;
   constexpr Pred(Pred&&) : moved(true) {}
   constexpr Pred(const Pred&) : copied(true) {}
   bool operator()(int) const;
 };
 
+// SFINAE tests.
+
+#if _LIBCPP_STD_VER >= 23
+
+static_assert(!test_convertible<std::ranges::take_while_view<View, Pred>, View, Pred>(), 
+              "This constructor must be explicit");
+
+#else
+
+static_assert( test_convertible<std::ranges::take_while_view<View, Pred>, View, Pred>(), 
+              "This constructor must not be explicit");
+
+#endif // _LIBCPP_STD_VER >= 23
+
 constexpr bool test() {
   {
-    std::ranges::take_while_view<View, Pred> twv = {View{{}, MoveOnly{5}}, Pred{}};
+    std::ranges::take_while_view<View, Pred> twv{View{{}, MoveOnly{5}}, Pred{}};
     assert(twv.pred().moved);
     assert(!twv.pred().copied);
     assert(std::move(twv).base().mo.get() == 5);
   }
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
+
   return 0;
 }

libcxx/test/std/ranges/range.adaptors/range.take/ctor.view_count.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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: c++03, c++11, c++14, c++17
 
-// constexpr take_view(V base, range_difference_t<V> count);
+// constexpr take_view(V base, range_difference_t<V> count); // explicit since C++23
 
-#include <ranges>
 #include <cassert>
+#include <ranges>
 
-#include "test_macros.h"
+#include "test_convertible.h"
 #include "test_iterators.h"
+#include "test_macros.h"
 #include "test_range.h"
 #include "types.h"
 
+// SFINAE tests.
+
+#if _LIBCPP_STD_VER >= 23
+
+static_assert(!test_convertible<std::ranges::take_view<View>, 
+                                View, 
+                                std::ranges::range_difference_t<View>>(),
+              "This constructor must be explicit");
+
+#else
+
+static_assert( test_convertible<std::ranges::take_view<View>, 
+                                View, 
+                                std::ranges::range_difference_t<View>>(),
+              "This constructor must be explicit");
+
+#endif // _LIBCPP_STD_VER >= 23
+
 constexpr bool test() {
   int buffer[8] = {1, 2, 3, 4, 5, 6, 7, 8};
 
   {
     std::ranges::take_view<CopyableView> tv(CopyableView{buffer}, 0);
     assert(tv.base().ptr_ == buffer);
     assert(tv.begin() == tv.end()); // Checking we have correct size.
   }

libcxx/test/std/ranges/range.adaptors/range.take/types.h

struct SizedRandomAccessView : std::ranges::view_base {
   constexpr explicit SizedRandomAccessView(int* ptr) : ptr_(ptr) {}
   constexpr auto begin() const { return RandomAccessIter(ptr_); }
   constexpr auto end() const { return sized_sentinel<RandomAccessIter>(RandomAccessIter(ptr_ + 8)); }
 };
 static_assert(std::ranges::view<SizedRandomAccessView>);
 static_assert(std::ranges::random_access_range<SizedRandomAccessView>);
 static_assert(std::ranges::sized_range<SizedRandomAccessView>);
 
+struct View : std::ranges::view_base {
+  constexpr explicit View(int* b, int* e) : begin_(b), end_(e) { }
+
+  constexpr int* begin() const { return begin_; }
+  constexpr int* end() const { return end_; }
+
+private:
+  int* begin_;
+  int* end_;
+};
+
 #endif // TEST_STD_RANGES_RANGE_ADAPTORS_RANGE_TAKE_TYPES_H

libcxx/test/std/ranges/range.adaptors/range.transform/ctor.view_function.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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: c++03, c++11, c++14, c++17
 
-// constexpr transform_view(View, F);
+// constexpr transform_view(View, F); // explicit since C++23
 
+#include <cassert>
 #include <ranges>
 
-#include <cassert>
+#include "test_convertible.h"
 
 struct Range : std::ranges::view_base {
-  constexpr explicit Range(int* b, int* e) : begin_(b), end_(e) { }
+  constexpr explicit Range(int* b, int* e) : begin_(b), end_(e) {}
   constexpr int* begin() const { return begin_; }
   constexpr int* end() const { return end_; }
 
 private:
   int* begin_;
   int* end_;
 };
 
 struct F {
   constexpr int operator()(int i) const { return i + 100; }
 };
 
+// SFINAE tests.
+
+#if _LIBCPP_STD_VER >= 23
+
+static_assert(!test_convertible<std::ranges::transform_view<Range, F>, Range, F>(),
+              "This constructor must be explicit");
+
+#else
+
+static_assert( test_convertible<std::ranges::transform_view<Range, F>, Range, F>(),
+              "This constructor must not be explicit");
+
+#endif // _LIBCPP_STD_VER >= 23
+
 constexpr bool test() {
   int buff[] = {1, 2, 3, 4, 5, 6, 7, 8};
 
   {
     Range range(buff, buff + 8);
     F f;
     std::ranges::transform_view<Range, F> view(range, f);
     assert(view[0] == 101);
     assert(view[1] == 102);
     // ...
     assert(view[7] == 108);
   }
 
-  {
-    Range range(buff, buff + 8);
-    F f;
-    std::ranges::transform_view<Range, F> view = {range, f};
-    assert(view[0] == 101);
-    assert(view[1] == 102);
-    // ...
-    assert(view[7] == 108);
-  }
-
   return true;
 }
 
 int main(int, char**) {
   test();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/ranges/range.factories/range.iota.view/ctor.first.last.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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: c++03, c++11, c++14, c++17
 
-// constexpr iota_view(iterator first, see below last);
+// constexpr iota_view(iterator first, see below last); // explicit since C++23
 
 #include <ranges>
 #include <cassert>
 
+#include "test_convertible.h"
 #include "test_macros.h"
 #include "types.h"
 
+// SFINAE tests.
+
+#if _LIBCPP_STD_VER >= 23
+
+std::ranges::iota_view<SomeInt, SomeInt> view;
+
+static_assert(!test_convertible<std::ranges::iota_view<SomeInt, SomeInt>, 
+                                decltype(std::ranges::iota_view<SomeInt, SomeInt>{}.begin()),
+                                decltype(std::ranges::iota_view<SomeInt, SomeInt>{}.end())>(),
+              "This constructor must be explicit");
+
+static_assert(!test_convertible<std::ranges::iota_view<SomeInt>, 
+                                decltype(std::ranges::iota_view{SomeInt{0}}.begin()),
+                                decltype(std::unreachable_sentinel)>(),
+              "This constructor must be explicit");
+
+static_assert(!test_convertible<std::ranges::iota_view<SomeInt, IntComparableWith<SomeInt>>, 
+                                decltype(std::ranges::iota_view{SomeInt(0), IntComparableWith(SomeInt(10))}.begin()),
+                                decltype(std::ranges::iota_view{SomeInt(0), IntComparableWith(SomeInt(10))}.end())>(),
+              "This constructor must be explicit");
+
+#else
+
+static_assert( test_convertible<std::ranges::iota_view<SomeInt, SomeInt>, 
+                                decltype(std::ranges::iota_view<SomeInt, SomeInt>{}.begin()),
+                                decltype(std::ranges::iota_view<SomeInt, SomeInt>{}.end())>(),
+              "This constructor must not be explicit");
+
+static_assert( test_convertible<std::ranges::iota_view<SomeInt>, 
+                                decltype(std::ranges::iota_view{SomeInt{0}}.begin()),
+                                decltype(std::unreachable_sentinel)>(),
+              "This constructor must not be explicit");
+
+static_assert( test_convertible<std::ranges::iota_view<SomeInt, IntComparableWith<SomeInt>>, 
+                                decltype(std::ranges::iota_view{SomeInt(0), IntComparableWith(SomeInt(10))}.begin()),
+                                decltype(std::ranges::iota_view{SomeInt(0), IntComparableWith(SomeInt(10))}.end())>(),
+              "This constructor must not be explicit");
+
+#endif // _LIBCPP_STD_VER >= 23
+
 constexpr bool test() {
   {
     std::ranges::iota_view commonView(SomeInt(0), SomeInt(10));
     std::ranges::iota_view<SomeInt, SomeInt> io(commonView.begin(), commonView.end());
     assert(std::ranges::next(io.begin(), 10) == io.end());
   }
 
   {

libcxx/test/std/ranges/range.factories/range.iota.view/ctor.value.bound.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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: c++03, c++11, c++14, c++17
 
 #include "test_macros.h"
 
 TEST_CLANG_DIAGNOSTIC_IGNORED("-Wsign-compare")
 TEST_GCC_DIAGNOSTIC_IGNORED("-Wsign-compare")
 TEST_MSVC_DIAGNOSTIC_IGNORED(4018 4389) // various "signed/unsigned mismatch"
 
-// constexpr iota_view(type_identity_t<W> value, type_identity_t<Bound> bound);
+// constexpr iota_view(type_identity_t<W> value, type_identity_t<Bound> bound); // explicit since C++23
 
 #include <ranges>
 #include <cassert>
 
+#include "test_convertible.h"
 #include "types.h"
 
+// SFINAE tests.
+
+#if _LIBCPP_STD_VER >= 23
+
+static_assert(!test_convertible<std::ranges::iota_view<SomeInt, SomeInt>,
+                                decltype(std::ranges::iota_view<SomeInt, SomeInt>{}.begin()),
+                                decltype(std::ranges::iota_view<SomeInt, SomeInt>{}.end())>(),
+              "This constructor must be explicit");
+
+static_assert(!test_convertible<std::ranges::iota_view<SomeInt>,
+                                decltype(std::ranges::iota_view<SomeInt>{}.begin()),
+                                decltype(std::unreachable_sentinel)>(),
+              "This constructor must be explicit");
+
+static_assert(!test_convertible<std::ranges::iota_view<SomeInt, IntComparableWith<SomeInt>>,
+                                decltype(std::ranges::iota_view{SomeInt(0), IntComparableWith(SomeInt(10))}.begin()),
+                                decltype(std::ranges::iota_view{SomeInt(0), IntComparableWith(SomeInt(10))}.end())>(),
+              "This constructor must be explicit");
+
+#else
+
+static_assert( test_convertible<std::ranges::iota_view<SomeInt, SomeInt>,
+                                decltype(std::ranges::iota_view<SomeInt, SomeInt>{}.begin()),
+                                decltype(std::ranges::iota_view<SomeInt, SomeInt>{}.end())>(),
+              "This constructor must not be explicit");
+
+static_assert( test_convertible<std::ranges::iota_view<SomeInt>,
+                                decltype(std::ranges::iota_view<SomeInt>{}.begin()),
+                                decltype(std::unreachable_sentinel)>(),
+              "This constructor must not be explicit");
+
+static_assert( test_convertible<std::ranges::iota_view<SomeInt, IntComparableWith<SomeInt>>,
+                                decltype(std::ranges::iota_view{SomeInt(0), IntComparableWith(SomeInt(10))}.begin()),
+                                decltype(std::ranges::iota_view{SomeInt(0), IntComparableWith(SomeInt(10))}.end())>(),
+              "This constructor must not be explicit");
+
+#endif // _LIBCPP_STD_VER >= 23
+
 constexpr bool test() {
   {
     std::ranges::iota_view<SomeInt, SomeInt> io(SomeInt(0), SomeInt(10));
     assert(std::ranges::next(io.begin(), 10) == io.end());
   }
 
   {
     std::ranges::iota_view<SomeInt> io(SomeInt(0), std::unreachable_sentinel);