[libc++] Implement P1391 for string_view

[jloser]

Summary

Implement P1391 (https://wg21.link/p1391) which allows
std::string_view to be constructible from any contiguous range of
characters.

Note that a different paper (http://wg21.link/P1989) handles the generic
range constructor for std::string_view.

[jloser]

Adjust #ifdef to apply constructor for C++20 mode, not C++23

[jloser]

Mark tests as XFAIL: apple-clang-12.0 since AppleClang 12.0 doesn't support concepts.

[Mordante]

In general looks good, but the tests need some improvements.

libcxx/test/std/strings/string.view/string.view.cons/deduct.pass.cpp

11

Minor nit, XFAIL isn't required, since // UNSUPPORTED: libcpp-no-concepts achieves the same.

27

Since this test only tests the types, it could be a compile.pass.cpp. But I see the other deduction tests are a pass.cpp. They also test whether the result is the expected result. Can you also add the other character types in this test? For example have a look at libcxx/test/std/strings/basic.string/string.cons/string_view_deduction.pass.cpp

33

Why do you want to test with int?

35

There should be a return 0;. On some platforms this is even required for main.

libcxx/test/std/strings/string.view/string.view.cons/from_iterator_iterator.pass.cpp

20 ↗

(On Diff #375947)

Here it would be nice to add a test for all character types. This can be done using templates. You can use MAKE_CSTRING from libcxx/test/support/make_string.h to create the val based on a template argument.

[jloser]

Test other character types
Address other review feedback

[jloser]

libcxx/test/std/strings/string.view/string.view.cons/deduct.pass.cpp

11

Are you sure? Without the XFAIL, I was seeing CI failures only for AppleClang 12.0.0 as it couldn't resolve contiguous_iterator from what I could tell. The build failure link is https://buildkite.com/llvm-project/libcxx-ci/builds/5619.

BTW, we're about to drop support for AppleClang 12.0.0 as I talked with @ldionne the other day. AppleClang 13.0.0 just came out on 9/20 IIRC which has full support for concepts and then we can remove this XFAIL.

27

Added other character types and also test the result now. Good call!

33

Just as another character type. I decided to stick with char, wchar_t, and friends instead now.

libcxx/test/std/strings/string.view/string.view.cons/from_iterator_iterator.pass.cpp

20 ↗

(On Diff #375947)

Added a test for a variety of other character types. I added a MAKE_STRING_VIEW macro so our test function can be used in a constexpr context still (since we don't have fully constexpr string yet). This allows me to have static_assert(test())) work still.

[jloser]

Test the result in deduct.pass.cpp
Don't rely on deduction guide in from_iterator_iterator.pass.cpp

[ldionne]

libcxx/include/string_view

281

693

libcxx/test/std/strings/string.view/string.view.cons/deduct.pass.cpp

11

Actually, I believe @Mordante is correct here. We can remove the XFAIL: apple-clang-12 since libcpp-no-concepts handle it. What you were seeing in https://buildkite.com/llvm-project/libcxx-ci/builds/5619 is a failure to build the library, we were not even getting to this test.

[jloser]

Remove XFAIL: apple-clang-12.0.0
Adjust #ifdefs to require ranges support

[Mordante]

LGTM, except for some small details.

libcxx/test/std/strings/string.view/string.view.cons/deduct.pass.cpp

35

char8_t should be guarded by #ifndef _LIBCPP_HAS_NO_CHAR8_T.

libcxx/test/std/strings/string.view/string.view.cons/from_iterator_iterator.pass.cpp

22 ↗

(On Diff #376052)

This function can be a void.

libcxx/test/support/make_string.h

61

Please align the \ at the end of the line.

[jloser]

Guard use of char8_t
Align MAKE_STRING_VIEW \ macro

[jloser]

libcxx/test/std/strings/string.view/string.view.cons/deduct.pass.cpp

35

I just added the guard, but can you elaborate on why it's necessary? char8_t is a C++20 type and this is a C++20-or-later constructor we've added in string_view. Given that we support char8_t, I thought it could be used unconditionally without loss of generality. FWIW, CI passed without the guard.

[Mordante]

libcxx/test/std/strings/string.view/string.view.cons/deduct.pass.cpp

35

At the moment all usage of char8_t is guarded by this. Looking at cppreference it seems all our supported compilers implement this feature. So it's indeed no longer required. I'll create a patch to remove _LIBCPP_HAS_NO_CHAR8_T from __config instead.

[jloser]

libcxx/test/std/strings/string.view/string.view.cons/deduct.pass.cpp

35

Sounds good to me, thanks!. Are you happy with this PR as it stands then?

[jloser]

Remove _LIBCPP_HAS_NO_CHAR8_t guard as it's not needed

[jloser]

[NFC] Update commit message to reflect other paper for generic range constructor

[Mordante]

libcxx/test/std/strings/string.view/string.view.cons/deduct.pass.cpp

35

Yes I'm happy.

[jloser]

Try poking CI

[• Quuxplusone]

libcxx/include/string_view

88–89

@cor3ntin: The Tony Table at the beginning of http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1391r4.pdf claims that after this paper, foo(vec) will compile... but that's just plain false, correct? IIUC, the actual achievement of p1391 was to make foo(vec.begin(), vec.end()) compile; and then http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p1989r2.pdf is the one that would actually support foo(vec)?
Just checking, because if p1391 isn't wrong, then I'm super confused.

285

__size(__end - __begin), please. We know the expression is well-formed because we know _End is a sized sentinel for _It.

287

Vice versa, I see no reason for __begin <= __end to be valid. Please add a test case using a non-iterator sentinel type. (I think my SFINAE test below is not sufficient, because it won't instantiate the body of this template, and it's the body that explodes.)

libcxx/test/std/strings/string.view/string.view.cons/from_iterator_iterator.pass.cpp

43 ↗

(On Diff #376511)

This test file should probably be named from_iterator_sentinel.pass.cpp.
I'd also like to see some SFINAE tests, and some mixed-constness tests. Just these would be fine:

static_assert( std::is_constructible_v<std::string_view, const char*, char*>); // OK
static_assert( std::is_constructible_v<std::string_view, char*, const char*>); // OK
static_assert(!std::is_constructible_v<std::string_view, char*, void*>); // not a sentinel
static_assert(!std::is_constructible_v<std::string_view, signed char*, signed char*>); // wrong char type
static_assert(!std::is_constructible_v<std::string_view, random_access_iterator<char*>, random_access_iterator<char*>>); // not contiguous
static_assert( std::is_constructible_v<std::string_view, contiguous_iterator<char*>, contiguous_iterator<char*>>); // OK

[cor3ntin]

libcxx/include/string_view

88–89

Yes. LWG decided to adopt half the paper in 20, so the change was not reflected in the motivation and the other half was done in 23 in P1989

[jloser]

Address Arthur's feedback

[jloser]

libcxx/include/string_view

285

Oops, we definitely don't want to do the std::distance dance since we have a iterator/sentinel. Just fixed -- thanks!

287

Well, the standard states that [begin, end) is a valid range as a precondition. I noticed we have some inconsistencies with string and string_view when it comes to these precondition checking. For the most part, we don't seem to actually check valid ranges, but we do in std::string::erase (https://github.com/llvm/llvm-project/blob/fd9bc13803ee24bfa674311584126b83e059d756/libcxx/include/string#L3228)

What's the recommended advice here @ldionne? From my perspective, a friendly debug _LIBCPP_ASSERT leads to a higher quality implementation given that the standard states the precondition explicitly.

For consistency, I'll update the message to say (iterator, sentinel) instead of (iterator, iterator), but let's decide if we want to have it at all first.

[Mordante]

libcxx/docs/Status/Cxx20Papers.csv

174

This looks wrong. Is it a rebase error?

[jloser]

libcxx/docs/Status/Cxx20Papers.csv

174

Mind elaborating? This PR only touches one line in Cxx20Papers.csv which is to mark P1391 as complete.

diff --git a/libcxx/docs/Status/Cxx20Papers.csv b/libcxx/docs/Status/Cxx20Papers.csv
index ee59d657b9f2..c722b9676b4a 100644
--- a/libcxx/docs/Status/Cxx20Papers.csv
+++ b/libcxx/docs/Status/Cxx20Papers.csv
@@ -134,7 +134,7 @@
 "`P1754 <https://wg21.link/P1754>`__","LWG","Rename concepts to standard_case for C++20, while we still can","Cologne","|In Progress|",""
 "","","","","",""
 "`P0883 <https://wg21.link/P0883>`__","LWG","Fixing Atomic Initialization","Belfast","|Complete| [#note-P0883]_","13.0"
-"`P1391 <https://wg21.link/P1391>`__","LWG","Range constructor for std::string_view","Belfast","* *",""
+"`P1391 <https://wg21.link/P1391>`__","LWG","Range constructor for std::string_view","Belfast","|Complete|","14.0"
 "`P1394 <https://wg21.link/P1394>`__","LWG","Range constructor for std::span","Belfast","* *",""
 "`P1456 <https://wg21.link/P1456>`__","LWG","Move-only views","Belfast","* *",""
 "`P1622 <https://wg21.link/P1622>`__","LWG","Mandating the Standard Library: Clause 32 - Thread support library","Belfast","* *",""

[jloser]

Rebase to trigger CI

[Mordante]

libcxx/docs/Status/Cxx20Papers.csv

174

Very odd, have a look at this link https://reviews.llvm.org/D110718?vs=376511&id=376881#toc
This is the history between Diff 10 and Diff 11, this was the state when I wrote my comment.
In that view you see a change to P1868. I see the latest diff doesn't have this change.
I've no clue what happened, but it seems fine now.

[jloser]

libcxx/docs/Status/Cxx20Papers.csv

174

Hmm, that's weird. It was a clean rebase, so that's certainly odd.

[• Quuxplusone]

libcxx/include/string_view

287

I think either we shouldn't have the assert, or (if we do) we should hide it behind a new macro, something like _LIBCPP_ASSERT_VALID_RANGE(__begin, __end). Then all the magic can go inside that macro and be reused consistently — whether it's requires, or calling _VSTD::distance, or what. Plus (although Louis will hate this idea ;)) anyone who wants ordinary assertions without paying for valid-range assertions can just compile with -D_LIBCPP_ASSERT_VALID_RANGE(x,y)=(void)0.

libcxx/test/std/strings/string.view/string.view.cons/deduct.pass.cpp

26

Let's also add auto sv = std::basic_string_view((const CharT*)str.begin(), str.end()); (with different iterator types), which should also come out to std::basic_string_view<CharT>.

Also: Not a blocker necessarily, but I'd strongly prefer to use the auto sv = std::basic_string_view(str.begin(), str.end()); style for line 25 as well. Using the curly-brace sequence-initialization style makes it look as if we're initializing the string_view from a sequence of two elements, and that's not actually what's going on here.

Note that it is physically possible for auto x = foo{1,2} and auto x = foo(1,2) to wind up using different deduction guides (in fact, this happens with foo=std::vector), so if we really want exhaustive tests we should test both. But I think that's overkill. Then, assuming that we're only going to test one of the two syntaxes, I opine strongly that we should test the one people might ever use, which is the round-parens syntax, not the list-initialization syntax.

libcxx/test/std/strings/string.view/string.view.cons/from_iterator_sentinel.pass.cpp

25–31

I suggest

template<class CharT, class Sentinel>
constexpr void test() {
  auto val = MAKE_STRING_VIEW(CharT, "test");
  auto sv = std::basic_string_view(val.begin(), Sentinel(val.end()));
  ASSERT_SAME_TYPE(decltype(sv), std::basic_string_view<CharT>);
  assert(sv.size() == val.size());
  assert(sv.data() == val.data());
}

and then test with

test<char, char*>();
test<wchar_t, wchar_t*>();
test<char8_t, char8_t*>();
test<char16_t, char16_t*>();
test<char32_t, char32_t*>();
test<char, const char*>();
test<char, sized_sentinel_wrapper<char*>>();

On the last line, sized_sentinel_wrapper would go into test_iterators.h, right after sentinel_wrapper; it would just provide operator- in addition to the sentinel_wrapper stuff... ick, actually, I see several existing tests overloading operator- for sentinel_wrapper in incompatible ways. I'll clean that up in a new PR myself. Needn't block this on that, although, I won't complain if you do. ;)

[jloser]

libcxx/test/std/strings/string.view/string.view.cons/deduct.pass.cpp

26

Switched to round-parens syntax. Sorry, just a habit of using braces everywhere as you can tell.

As for the mixed iterator types, I'm not sure how to make that work with our debug iterators. For example, your proposed test won't work with __wrap_iter:

error: cannot cast from type 'std::basic_string<char>::iterator' (aka '__wrap_iter<char *>') to pointer type 'const char *'
    std::basic_string_view sv((const CharT*)str.begin(), str.end());

[jloser]

Prefer parens over braces
Add mixed iterator test in from_iterator_sentinel.pass.cpp

[jloser]

Use local sentinel in from_iterator_sentinel.pass.cpp

[jloser]

libcxx/include/string_view

287

I'd be in favor of the assert personally, but I don't feel like pushing for it in this PR. I like the idea of factoring it out into a macro as I can see valid range checks being used all over in libc++ preconditions.

I don't imagine many people actually (except @Quuxplusone of course :)) wanting all-but-range-check assertions.

We'll see what @ldionne says, but nothing to block this PR on I'd imagine.

libcxx/test/std/strings/string.view/string.view.cons/from_iterator_sentinel.pass.cpp

25–31

Added a test using a locally defined sentinel with appropriate operator== and operator-. I played for a bit in test_iterators.h with a sized_sentinel_wrapper. However, things didn't play so nicely due to constness and other things. Perhaps I overlooked something, but I'd say let's refactor this new use among others to use the new sized_sentinel_wrapper in a follow-up PR. I'm interested to see your PR for cleaning up the operator-- usage.

In the refactor, we can clean up the other uses in libcxx/test/std/ranges/range.adaptors/range.common.view/types.h and libcxx/test/std/ranges/range.adaptors/range.take/types.h from a quick look around.

[jloser]

[NFC] Clean up spacing in string_view constructor

[jloser]

ping @ldionne since CI is passing. Are you still happy with this?

[jloser]

Introduce sized_sentinel_wrapper and use it in from_iterator_sentinel.pass.cpp

[jloser]

libcxx/test/std/strings/string.view/string.view.cons/from_iterator_sentinel.pass.cpp

25–31

@Quuxplusone just reworked this to use sized_sentinel_wrapper and things worked out nicely this time around.

[ldionne]

LGTM with an assertion added. Also, bonus points for adding a test for the assertion, but that's non-blocking. Thanks a lot for working on this!

libcxx/include/string_view

284

Those are the same, but _LIBCPP_HIDE_FROM_ABI is the preferred name.

287

I think it's pretty important to add these assertions when we can. And it's a lot easier to do it when we write the function than come back later to add it.

I am working on a patch that will decouple assertions and the debug mode, with the mid/short term goal to allow people to ship libc++ with assertions enabled. So even though it's not super useful today, it will soon be.

I have no strong opinion on adding a _LIBCPP_ASSERT_VALID_RANGE macro or doing something like if constexpr (i-can-order-begin-and-end) { _LIBCPP_ASSERT(...); }, but an assertion in *some* form seems like a good idea.

[• Quuxplusone]

libcxx/include/string_view

287

I strongly prefer a macro over if constexpr-anything.
However, it occurs to me that even though _LIBCPP_ASSERT(__begin <= __end) would be ill-formed, we could still simply do _LIBCPP_ASSERT((__end - __begin) >= 0). I don't object if we want to add that, and I don't think it needs to be hidden behind a macro.

libcxx/test/support/test_iterators.h

919

If I weren't working on a PR for this, I would have some style comments here; but as I will eventually post a PR to clean this up, I don't object to this for now.
The one thing that would be helpful to do now, if it's easy enough for you, would be to rename sized_sentinel_wrapper<It> to just sized_sentinel<It>. Unfortunately we can't trivially rename sentinel_wrapper<It> to just sentinel<It> because the global name sentinel has already been land-grabbed by a few tests; but we can use the shorter and more consistent name sized_sentinel no problem. (Note that we use e.g. random_access_iterator<It>, not random_access_iterator_wrapper<It>.)

[jloser]

Add assert for valid range in string_view constructor
Rename sized_sentinel_wrapper to sized_sentinel

[jloser]

libcxx/include/string_view

284

Renamed. I used _LIBCPP_INLINE_VISIBILITY originally since it's what is used in the rest of this file. WDYT about a global s/_LIBCPP_INLINE_VISIBILITY/_LIBCPP_HIDE_FROM_ABI/g? And then we just adjust _LIBCPP_HIDE_FROM_ABI macro definition to not be defined in terms of _LIBCPP_INLINE_VISIBILITY but instead just be

#define _LIBCPP_HIDE_FROM_ABI __attribute__ ((__visibility__("hidden"), __always_inline__))

Then we avoid this issue in the future of having two identifiers to do the same thing.

287

Added an assert with _LIBCPP_ASSERT((__end - __begin) >= 0).

libcxx/test/support/test_iterators.h

919

Renamed to sized_sentinel. It's unfortunate that sentinel is such a common name used in the range tests so it's off the table without a bit of work for renaming sentinel_wrapper to sentinel.

[jloser]

s/_LIBCPP_INLINE_VISIBILITY/_LIBCPP_HIDE_FROM_ABI

If BuildKit is happy with this, I'll land it.

[• Quuxplusone]

libcxx/test/std/strings/string.view/string.view.cons/deduct.pass.cpp

26

your proposed test won't work with __wrap_iter

You could do

std::basic_string<CharT> str = MAKE_STRING(CharT, "test");
auto sv = std::basic_string_view(std::as_const(str).begin(), str.end());

(or even use .cbegin(); I'm not a fan of .cbegin() but I admit it'd be shorter than as_const(...).begin() in this case).
However, right now you're already testing the deduction guide in from_iterator_sentinel.pass.cpp, so maybe just copy-paste that test over into this file.

[jloser]

Add mixed-const iterator test in deduct.pass.cpp.
Test a sentinel while we're at it in deduct.pass.cpp
Don't rely on deduction guide in from_iterator_sentinel.pass.cpp

[jloser]

libcxx/test/std/strings/string.view/string.view.cons/deduct.pass.cpp

26

Added tests for mixed const iterators in the deduct.pass.cpp by just copying the test function template from from_iterator_sentinel_pass.cpp.

Also changed from_iterator_sentinel.pass.cpp to not rely on the deduction guide. Otherwise, deduct.pass is completely superfluous with the old from_iterator_sentinel.pass.cpp that used the deduction guide.

[• Quuxplusone]

@jloser if buildkite is happy, ship it!
FYI when/if you start working on [p1989] string_view's range ctor, note that https://cplusplus.github.io/LWG/issue3581 is relevant. (span's range ctor is already appropriately constrained, so D110503 is still good.)

libcxx/docs/Status/Cxx20Papers.csv

 "`P1644 <https://wg21.link/P1644>`__","LWG","Add wait/notify to atomic<shared_ptr>","Cologne","",""
 "`P1650 <https://wg21.link/P1650>`__","LWG","Output std::chrono::days with 'd' suffix","Cologne","",""
 "`P1651 <https://wg21.link/P1651>`__","LWG","bind_front should not unwrap reference_wrapper","Cologne","|Complete|","13.0"
 "`P1652 <https://wg21.link/P1652>`__","LWG","Printf corner cases in std::format","Cologne","",""
 "`P1661 <https://wg21.link/P1661>`__","LWG","Remove dedicated precalculated hash lookup interface","Cologne","|Nothing To Do|",""
 "`P1754 <https://wg21.link/P1754>`__","LWG","Rename concepts to standard_case for C++20, while we still can","Cologne","|In Progress|",""
 "","","","","",""
 "`P0883 <https://wg21.link/P0883>`__","LWG","Fixing Atomic Initialization","Belfast","|Complete| [#note-P0883]_","13.0"
-"`P1391 <https://wg21.link/P1391>`__","LWG","Range constructor for std::string_view","Belfast","* *",""
+"`P1391 <https://wg21.link/P1391>`__","LWG","Range constructor for std::string_view","Belfast","|Complete|","14.0"
 "`P1394 <https://wg21.link/P1394>`__","LWG","Range constructor for std::span","Belfast","* *",""
 "`P1456 <https://wg21.link/P1456>`__","LWG","Move-only views","Belfast","* *",""
 "`P1622 <https://wg21.link/P1622>`__","LWG","Mandating the Standard Library: Clause 32 - Thread support library","Belfast","* *",""
 "`P1645 <https://wg21.link/P1645>`__","LWG","constexpr for numeric algorithms","Belfast","|Complete|","12.0"
 "`P1664 <https://wg21.link/P1664>`__","LWG","reconstructible_range - a concept for putting ranges back together","Belfast","* *",""
 "`P1686 <https://wg21.link/P1686>`__","LWG","Mandating the Standard Library: Clause 27 - Time library","Belfast","* *",""
 "`P1690 <https://wg21.link/P1690>`__","LWG","Refinement Proposal for P0919 Heterogeneous lookup for unordered containers","Belfast","|Complete|","12.0"
 "`P1716 <https://wg21.link/P1716>`__","LWG","ranges compare algorithm are over-constrained","Belfast","* *",""

 "","","","","",""
 "`P0586 <https://wg21.link/P0586>`__","LWG","Safe integral comparisons","Prague","|Complete|","13.0"
 "`P0593 <https://wg21.link/P0593>`__","CWG","Implicit creation of objects for low-level object manipulation","Prague","* *",""
 "`P1115 <https://wg21.link/P1115>`__","LWG","Improving the Return Value of Erase-Like Algorithms II: Free erase/erase if","Prague","|Complete|","11.0"
 "`P1243 <https://wg21.link/P1243>`__","LWG","Rangify New Algorithms","Prague","* *",""
 "`P1460 <https://wg21.link/P1460>`__","LWG","Mandating the Standard Library: Clause 20 - Utilities library","Prague","* *",""
 "`P1739 <https://wg21.link/P1739>`__","LWG","Avoid template bloat for safe_ranges in combination with ""subrange-y"" view adaptors","Prague","* *",""
 "`P1831 <https://wg21.link/P1831>`__","LWG","Deprecating volatile: library","Prague","* *",""
 "`P1868 <https://wg21.link/P1868>`__","LWG","width: clarifying units of width and precision in std::format","Prague","|In Progress|",""
 "`P1908 <https://wg21.link/P1908>`__","CWG","Reserving Attribute Namespaces for Future Use","Prague","* *",""
 "`P1937 <https://wg21.link/P1937>`__","CWG","Fixing inconsistencies between constexpr and consteval functions","Prague","* *",""
 "`P1956 <https://wg21.link/P1956>`__","LWG","On the names of low-level bit manipulation functions","Prague","|Complete|","12.0"
 "`P1957 <https://wg21.link/P1957>`__","CWG","Converting from ``T*``\  to bool should be considered narrowing (re: US 212)","Prague","* *",""
 "`P1963 <https://wg21.link/P1963>`__","LWG","Fixing US 313","Prague","* *",""
 "`P1964 <https://wg21.link/P1964>`__","LWG","Wording for boolean-testable","Prague","|Complete|","13.0"
 "`P1970 <https://wg21.link/P1970>`__","LWG","Consistency for size() functions: Add ranges::ssize","Prague","* *",""
 "`P1973 <https://wg21.link/P1973>`__","LWG","Rename ""_default_init"" Functions, Rev1","Prague","* *",""

libcxx/include/string_view

class basic_string_view {
       // 7.3, basic_string_view constructors and assignment operators
       constexpr basic_string_view() noexcept;
       constexpr basic_string_view(const basic_string_view&) noexcept = default;
       basic_string_view& operator=(const basic_string_view&) noexcept = default;
       template<class Allocator>
       constexpr basic_string_view(const charT* str);
       basic_string_view(nullptr_t) = delete; // C++2b
       constexpr basic_string_view(const charT* str, size_type len);
+      template <class It, class End>
+      constexpr basic_string_view(It begin, End end); // C++20
 
       // 7.4, basic_string_view iterator support
       constexpr const_iterator begin() const noexcept;
       constexpr const_iterator end() const noexcept;
       constexpr const_iterator cbegin() const noexcept;
       constexpr const_iterator cend() const noexcept;
       const_reverse_iterator rbegin() const noexcept;
       const_reverse_iterator rend() const noexcept;
class basic_string_view {
       constexpr bool contains(charT c) const noexcept;             // C++2b
       constexpr bool contains(const charT* s) const;               // C++2b
 
      private:
       const_pointer data_;  // exposition only
       size_type     size_;  // exposition only
     };
 
+  // basic_string_view deduction guides
+  template<class It, class End>
+    basic_string_view(It, End) -> basic_string_view<iter_value_t<It>>; // C++20
+
   // 7.11, Hash support
   template <class T> struct hash;
   template <> struct hash<string_view>;
   template <> struct hash<u8string_view>; // C++20
   template <> struct hash<u16string_view>;
   template <> struct hash<u32string_view>;
   template <> struct hash<wstring_view>;
 
   constexpr basic_string_view<char>     operator "" sv( const char *str,     size_t len ) noexcept;
   constexpr basic_string_view<wchar_t>  operator "" sv( const wchar_t *str,  size_t len ) noexcept;
   constexpr basic_string_view<char8_t>  operator "" sv( const char8_t *str,  size_t len ) noexcept; // C++20
   constexpr basic_string_view<char16_t> operator "" sv( const char16_t *str, size_t len ) noexcept;
   constexpr basic_string_view<char32_t> operator "" sv( const char32_t *str, size_t len ) noexcept;
 
 }  // namespace std
 
 
 */
 
+#include <__concepts/convertible_to.h>
+#include <__concepts/same_as.h>
 #include <__config>
 #include <__debug>
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/enable_view.h>
 #include <__string>
 #include <algorithm>
 #include <compare>
 #include <iosfwd>
public:
     basic_string_view(const _CharT* __s, size_type __len) _NOEXCEPT
         : __data(__s), __size(__len)
     {
 #if _LIBCPP_STD_VER > 11
     _LIBCPP_ASSERT(__len == 0 || __s != nullptr, "string_view::string_view(_CharT *, size_t): received nullptr");
 #endif
     }
 
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_RANGES)
+    template <contiguous_iterator _It, sized_sentinel_for<_It> _End>
+      requires (same_as<iter_value_t<_It>, _CharT> && !convertible_to<_End, size_type>)
+    constexpr _LIBCPP_HIDE_FROM_ABI basic_string_view(_It __begin, _End __end)
+       : __data(_VSTD::to_address(__begin)), __size(__end - __begin)
+    {
+      _LIBCPP_ASSERT((__end - __begin) >= 0, "std::string_view::string_view(iterator, sentinel) received invalid range");
+    }
+#endif
+
     _LIBCPP_CONSTEXPR _LIBCPP_INLINE_VISIBILITY
     basic_string_view(const _CharT* __s)
         : __data(__s), __size(_VSTD::__char_traits_length_checked<_Traits>(__s)) {}
 
 #if _LIBCPP_STD_VER > 20
     basic_string_view(nullptr_t) = delete;
 #endif
 

 #if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_RANGES)
 template <class _CharT, class _Traits>
 inline constexpr bool ranges::enable_view<basic_string_view<_CharT, _Traits>> = true;
 
 template <class _CharT, class _Traits>
 inline constexpr bool ranges::enable_borrowed_range<basic_string_view<_CharT, _Traits> > = true;
 #endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_RANGES)
 
+// [string.view.deduct]
+
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_RANGES)
+template <contiguous_iterator _It, sized_sentinel_for<_It> _End>
+  basic_string_view(_It, _End) -> basic_string_view<iter_value_t<_It>>;
+#endif
+
 // [string.view.comparison]
 // operator ==
 template<class _CharT, class _Traits>
 _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 bool operator==(basic_string_view<_CharT, _Traits> __lhs,
                 basic_string_view<_CharT, _Traits> __rhs) _NOEXCEPT
 {
     if ( __lhs.size() != __rhs.size()) return false;

libcxx/test/std/strings/string.view/string.view.cons/deduct.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
+// UNSUPPORTED: libcpp-no-concepts
+
+// <string_view>
+
+//  template <contiguous_iterator _It, sized_sentinel_for<_It> _End>
+//    basic_string_view(_It, _End) -> basic_string_view<iter_value_t<_It>>;
+
+#include <string_view>
+#include <cassert>
+
+#include "make_string.h"
+#include "test_macros.h"
+
+template <class CharT>
+void test() {
+  auto str = MAKE_STRING(CharT, "test");
+  std::basic_string_view sv(str.begin(), str.end());
+  ASSERT_SAME_TYPE(decltype(sv), std::basic_string_view<CharT>);
+  assert(sv.size() == str.size());
+  assert(sv.data() == str.data());
+}
+
+int main(int, char**) {
+  test<char>();
+  test<wchar_t>();
+  test<char8_t>();
+  test<char16_t>();
+  test<char32_t>();
+
+  return 0;
+}
+

libcxx/test/std/strings/string.view/string.view.cons/from_iterator_sentinel.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
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// <string_view>
+
+//  template <class It, class End>
+//  constexpr basic_string_view(It begin, End end)
+
+#include <string_view>
+#include <cassert>
+#include <ranges>
+
+#include "make_string.h"
+#include "test_iterators.h"
+
+template<class CharT, class Sentinel>
+constexpr void test() {
+  auto val = MAKE_STRING_VIEW(CharT, "test");
+  auto sv = std::basic_string_view(val.begin(), Sentinel(val.end()));
+  ASSERT_SAME_TYPE(decltype(sv), std::basic_string_view<CharT>);
+  assert(sv.size() == val.size());
+  assert(sv.data() == val.data());
+}
+
+constexpr bool test() {
+  test<char, char*>();
+  test<wchar_t, wchar_t*>();
+  test<char8_t, char8_t*>();
+  test<char16_t, char16_t*>();
+  test<char32_t, char32_t*>();
+  test<char, const char*>();
+  test<char, sized_sentinel<const char*>>();
+  return true;
+}
+
+static_assert( std::is_constructible_v<std::string_view, const char*, char*>);
+static_assert( std::is_constructible_v<std::string_view, char*, const char*>);
+static_assert(!std::is_constructible_v<std::string_view, char*, void*>);               // not a sentinel
+static_assert(!std::is_constructible_v<std::string_view, signed char*, signed char*>); // wrong char type
+static_assert(!std::is_constructible_v<std::string_view, random_access_iterator<char*>, random_access_iterator<char*>>); // not contiguous
+static_assert( std::is_constructible_v<std::string_view, contiguous_iterator<char*>, contiguous_iterator<char*>>);
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}
+

libcxx/test/support/make_string.h

 
 #include "test_macros.h"
 
 #if TEST_STD_VER < 11
 #error This header requires C++11 or greater
 #endif
 
 #include <string>
+#include <string_view>
 
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t)
 #define CHAR8_ONLY(x) x,
 #else
 #define CHAR8_ONLY(x)
 #endif
 
 #define MKSTR(Str)                                                             \

 // Helper to convert a const char* string to a basic_string<CharT>.
 // This helper is used in unit tests to make them generic. The input should be
 // valid ASCII which means the input is also valid UTF-8.
 #define MAKE_STRING(CharT, Str)                                                \
   std::basic_string<CharT> {                                                   \
     static_cast<const CharT*>(MultiStringType MKSTR(Str))                      \
   }
 
+#define MAKE_STRING_VIEW(CharT, Str)                                           \
+  std::basic_string_view<CharT> {                                              \
+    static_cast<const CharT*>(MultiStringType MKSTR(Str))                      \
+  }
+
 // Like MAKE_STRING but converts to a const CharT*.
 #define MAKE_CSTRING(CharT, Str)                                               \
   static_cast<const CharT*>(MultiStringType MKSTR(Str))
 
 #endif

libcxx/test/support/test_iterators.h

public:
     constexpr bool operator==(const I2& other) const {
         return base_ == other.base();
     }
 
 private:
     I base_ = I();
 };
 
+template <std::input_or_output_iterator I>
+class sized_sentinel {
+public:
+    sized_sentinel() = default;
+    constexpr explicit sized_sentinel(I base) : base_(std::move(base)) {}
+
+    constexpr bool operator==(const I& other) const requires std::equality_comparable<I> {
+        return base_ == other;
+    }
+
+    constexpr const I& base() const& { return base_; }
+    constexpr I base() && { return std::move(base_); }
+
+    template<std::input_or_output_iterator I2>
+        requires sentinel_for_base<I, I2>
+    constexpr bool operator==(const I2& other) const {
+        return base_ == other.base();
+    }
+
+private:
+    I base_ = I();
+};
+
+template <std::input_or_output_iterator I>
+constexpr auto operator-(sized_sentinel<I> sent, std::input_or_output_iterator auto iter) {
+  return sent.base() - iter;
+}
+
+template <std::input_or_output_iterator I>
+constexpr auto operator-(std::input_or_output_iterator auto iter, sized_sentinel<I> sent) {
+  return iter - sent.base();
+}
+
 template <class It>
 class three_way_contiguous_iterator
 {
     static_assert(std::is_pointer_v<It>, "Things probably break in this case");
 
     It it_;
 
     template <class U> friend class three_way_contiguous_iterator;