[libc++][P1679] add string contains

[WimLeflere]

Summary

C++23 string contains implementation and tests

Paper: https://wg21.link/P1679R3
Standard (string): https://eel.is/c++draft/string.contains
Standard (string_view): https://eel.is/c++draft/string.view.ops#lib:contains,basic_string_view

[• Quuxplusone]

libcxx/include/string

330

Before libc++ starts adding C++23 stuff, I think it needs someone (notme) to do a "C++20 exists now" audit. References to "2a" should be changed to "20" — especially in the test suite, where I keep tripping up by typing --param std=c++20 instead of --param std=c++2a — and then a "2b" mode needs to be added.

I weakly recommend using "2b" instead of "23" here, for pedantic accuracy. I admit that it is very likely that C++2b will be C++23, and that by recommending "2b" I'm just making work for somebody three years from now. :P

1437

Incidentally, I wonder why this existing code isn't return __self_view(data(), size()).ends_with(__s). I like the symmetrical way you did contains below, and wish starts_with and ends_with would match it... unless there's a good reason they were done this way originally.

libcxx/test/std/strings/basic.string/string.contains/contains.ptr.pass.cpp

23

Could use using S = std::string; here, since this is a non-03 test.

31

Why commented out?

libcxx/test/std/strings/string.view/string.view.template/contains.char.pass.cpp

38

This is always true; you don't need the #if.
You don't need constexpr_char_traits in '20 and later (which includes this test).

Also, please do

constexpr bool test() {
    std::string_view sv1;
    std::string_view sv2 = "abcde";
    ASSERT_NOEXCEPT(sv1.contains('e'));
    assert(!sv1.contains('c'));
    [...]
    return true;
}

int main(int, char **)
{
    test();
    static_assert(test());
}

to get constexpr coverage without repeating the code.

[curdeius]

You might want to wait for D93383 to land, so that it updates C++2a to C++20.
Then, we need to have a way to test C++2b. I have a patch D93520 that adds Tip of the Trunk clang supporting -std=c++2b.
When this is done and the builders are updated, we need to add C++2b to the tested configurations.

In other words, please be patient.

[WimLeflere]

Where are the feature test macros defined?
__cpp_lib_string_contains should be added

[WimLeflere]

libcxx/test/std/strings/basic.string/string.contains/contains.ptr.pass.cpp

31

The code is based on the ends_with test code, in which it's also commented out.
I'll remove it as it's not necessary.

[WimLeflere]

Applied review comments

• replaced C++23 with C++2b and typedef with using
• added constexpr test function to re-use for runtime and compile time testing
• removed commented code and unnecessary constexpr_char_traits

[Mordante]

In D93912#2474869, @WimLeflere wrote:

Where are the feature test macros defined?
__cpp_lib_string_contains should be added

The macro should be added to libcxx/utils/generate_feature_test_macro_components.py, then run the script to generate the proper macros and tests.

libcxx/include/string

1442

Wouldn't it be better to use constexpr and noexcept since the code is never compiled using C++98.

[WimLeflere]

In D93912#2479707, @Mordante wrote:

In D93912#2474869, @WimLeflere wrote:

Where are the feature test macros defined?
__cpp_lib_string_contains should be added

The macro should be added to libcxx/utils/generate_feature_test_macro_components.py, then run the script to generate the proper macros and tests.

Thanks!
Should I check in the (changed) generated files?

[Mordante]

In D93912#2479938, @WimLeflere wrote:

The macro should be added to libcxx/utils/generate_feature_test_macro_components.py, then run the script to generate the proper macros and tests.

Thanks!
Should I check in the (changed) generated files?

Yes please.

[WimLeflere]

Added feature test macro to script and updated generated files.

[mclow.lists]

This looks like WAY too much code for "add string contains".

[ldionne]

In D93912#2485543, @WimLeflere wrote:

Added feature test macro to script and updated generated files.

Thanks for your contribution! I think you should try rebasing against main, as most of the changes @curdeius was discussing have been checked in now (thanks Marek!).

I believe that should remove the need for most of the boilerplate/generated stuff in this patch, which should end up being much simpler. I see you added tests and updated the synopsis, that's great.

[WimLeflere]

In D93912#2485571, @mclow.lists wrote:

This looks like WAY too much code for "add string contains".

The bulk of the changes are coming from introducing C++2b in the generate_feature_test_macro script.
This generates a lot of C++2b feature macro tests which are not directly related to string contains.

Should introducing C++2b in the generate_feature_test_macro script be done in a separate review?

In D93912#2485579, @ldionne wrote:

In D93912#2485543, @WimLeflere wrote:

Added feature test macro to script and updated generated files.

Thanks for your contribution! I think you should try rebasing against main, as most of the changes @curdeius was discussing have been checked in now (thanks Marek!).

I believe that should remove the need for most of the boilerplate/generated stuff in this patch, which should end up being much simpler. I see you added tests and updated the synopsis, that's great.

The patch was created after rebasing on 1a2eaeb.
Should I wait for other changes?

[curdeius]

There is already D94227. You might want to wait for it and rebase when it's merged.

[WimLeflere]

Merged main with changes from D94227 and D93830.

@Mordante 's question is still open

Wouldn't it be better to use constexpr and noexcept since the code is never compiled using C++98.

[curdeius]

libcxx/test/std/strings/basic.string/string.contains/contains.ptr.pass.cpp

49

I think you lack some test cases like:
assert(!s3.contains("ce"));
That is all characters exist in the string but not in this order.
Also, "ced" - permutation.

[WimLeflere]

Added extra testcases

[curdeius]

Please reupload the diff setting the repo to rG LLVM Monorepo so that the CI gets triggered. You might need to do it twice to make it work. Otherwise use arcanist and it should do the job.
Otherwise looks good!

[WimLeflere]

Setting correct repo

[curdeius]

Great.
LGTM if CI passes. But please wait for an approval from somebody from libc++ group, e.g. @ldionne.

[curdeius]

libcxx/include/string

1442

@WimLeflere, please use constexpr and noexcept directly as suggested above.

libcxx/test/std/strings/basic.string/string.contains/contains.char.pass.cpp

22

You cannot just use std::string as it's not constexpr-friendly (yet), but need to use a constexpr-loving allocator or do some other hacks.

libcxx/test/std/strings/string.view/string.view.template/contains.string_view.pass.cpp

9

You should still use "c++2a" and not "c++20" as it's derived from the flag name (and we still use c++2a).
The same applies to all other tests.

[curdeius]

libcxx/test/std/strings/basic.string/string.contains/contains.char.pass.cpp

22

Actually, I think we just need to comment out constexpr test and add a FIXME note.

[WimLeflere]

• replaced constexpr/noexcept macros with keywords
• made const char* overload not noexcept
• disabled constexpr std::string tests
• used c++2a label for test support

[WimLeflere]

libcxx/test/std/strings/basic.string/string.contains/contains.char.pass.cpp

22

I could add a #ifdef __cpp_lib_constexpr_string error message

[• Quuxplusone]

libcxx/test/std/strings/basic.string/string.contains/contains.char.pass.cpp

22

Just add a FIXME comment that contains the exact string P0980. That way, anybody implementing P0980 "Making std::string constexpr" will be able to find this FIXME comment, and fix it, as part of their grepping for P0980.

[WimLeflere]

added paper nr to FIXME

[WimLeflere]

• removed constexpr from string test functions
• removed noexcept assert for const char* overload

[zoecarver]

A few small comments. This is looking really good :)

libcxx/include/string

1450

Thoughts on making this one noexcept as well? (I know it's not noexcept in the standard, does anyone know the reason for that?)

libcxx/test/std/strings/basic.string/string.contains/contains.char.pass.cpp

35

See my comment below... that means we don't need this either.

42

I think we should leave this out. Whoever implements that can add tests as part of their patch.

libcxx/test/std/strings/basic.string/string.contains/contains.ptr.pass.cpp

23

We can also use using in C++03 now, just FYI.

[• Quuxplusone]

libcxx/test/std/strings/basic.string/string.contains/contains.char.pass.cpp

42

On further consideration, I think @zoecarver is right. Whoever implements [P0980] is going to have to adjust the tests for all string member functions (not just contains) — we'll need to constexprize the tests for append and substr and operator[] and so on and so forth. No specially greppable reminder ought to be needed in this one test, because it lives right alongside all the other tests that will need just as much auditing.

[• Quuxplusone]

libcxx/include/string

1450

Lakos Rule. If __s is null, or points to a non-null-terminated array, then this overload has UB; whereas the other two overloads never have UB.

No useful opinion from me on making this one noexcept. Personally I can never remember whether vendors are allowed to add noexcept, or constexpr, or neither. I also don't know if libc++ thinks it's OK to add either keyword if it's not mandated by the standard, because that might be a portability trap for users (they rely on its being noexcept and then their code breaks when they switch to libstdc++ or something).

[WimLeflere]

libcxx/include/string

1450

The implementation is based on find(const char*) which is not noexcept (string_view::find).
So I think it's best to keep it not noexcept.

I think a vendor can be more 'strict' than the standard and still be conformant.
In the MS STL they are more strict for example: https://github.com/microsoft/STL/pull/1478#issuecomment-730789583

[WimLeflere]

removed constexpr string test FIXME

[curdeius]

LGTM.

[WimLeflere]

Any action required from my side?

[zoecarver]

libcxx/include/string

1450

Libc++ adds noexcept to some things that aren't required to have it in the standard. But I don't think we add constexpr. Maybe @mclow.lists or @ldionne can confirm this, though.

The implementation is based on find(const char*) which is not noexcept (string_view::find).
So I think it's best to keep it not noexcept.

Well... they're all implemented with __str_find which is unconditionally noexcept so, I think it might make sense. (Given that, it probably also makes sense to mark that find function as noexcept, but that's out of scope.) But, we should definitely also make the corresponding string_view overload noexpect if we make this one noexecept.

Separate note: I know the paper suggests using __self_view::find, but why not just use basic_string::find (which is noexecpt, against the standard specification, btw)?

[ldionne]

libcxx/include/string

1450

Indeed, we've historically added noexcept to some things as "extensions", and my understanding is that we're allowed by the Standard to do so: http://eel.is/c++draft/res.on.exception.handling#5. My personal preference would be to avoid adding these unless they add tremendous value, as they make us diverge from the Standard, and could potentially work against the goal of having a "safe" standard library mode (e.g. when you do something bad, we do something customizeable instead of having UB or necessarily terminating).

We haven't been adding constexpr to things not marked as such in the Standard, and the Standard explicitly forbids us from doing it: http://eel.is/c++draft/constexpr.functions. It would be a bad idea anyway due to portability and future-proofness of our implementation anyway.

[ldionne]

@Quuxplusone Arthur, did you still have objections? If not, please accept and I'll commit this.

[zoecarver]

libcxx/include/string

1450

My personal preference would be to avoid adding these unless they add tremendous value, as they make us diverge from the Standard, and could potentially work against the goal of having a "safe" standard library mode (e.g. when you do something bad, we do something customizeable instead of having UB or necessarily terminating).

That's fair, but in this case, we're going to necessarily terminate either way. This function is a simple wrapper for string_view::find which is a simple wrapper for __str_find which is always noexcept. Hopefully, the compiler will inline this all away, but there's a fair possibility that we're making the codegen a bit worse, and there is absolutely no benefit afaict. I like the idea of a "safe" standard library mode, and while marking this as noexcept isn't moving towards that, I'd argue it's also not really moving away from it.

[• Quuxplusone]

@ldionne: LGTM except that the non-constexpr tests no longer need to return true; from bool test() — they could do void test() for now.
Also, I don't think this will rebase as-is on generate_feature_test_macro_components.py, will it? You'll have to add the entry for __cpp_lib_string_contains, which will be easy — but I notice that it will be a divergence from what's literally in https://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations as of this writing. I would bet that's fine; I'm just bringing it up for awareness.

The current direction on constexpr/noexcept sounds great to me.

libcxx/test/std/strings/basic.string/string.contains/contains.char.pass.cpp

36

Nit: you can remove the bool and return true for now.

[ldionne]

Thanks Arthur. Indeed, this doesn't apply cleanly on top of main. Please rebase and address Arthur's comments. Requesting changes just so it shows up in the review queue, but this LGTM except for what I just said.

[mclow.lists]

libcxx/include/string

1450

My personal preference would be to add NOEXCEPT here. All this does is call a noexcept constructor, and then calls a noexcept member fn, and returns a bool (which is a noexcept operation as well.

libc++ has traditionally been quite liberal in marking things NOEXCEPT; it can help codegen tremendously in a few very specific circumstances.

[ldionne]

libcxx/include/string

1450

Yeah, okay, I'm swayed. I think I agree. Feel free to add noexcept here.

[mclow.lists]

Ok, I take it back. __str_find calls Traits::find, which is NOT always noexcept. (It *is* for all the specializations of std::char_traits, but that's not enough). So we can't slap NOEXCEPT here; in fact, we should revisit __str_find, and remove some of the NOEXCEPTs that are already there.

[WimLeflere]

In D93912#2505421, @Quuxplusone wrote:

@ldionne: LGTM except that the non-constexpr tests no longer need to return true; from bool test() — they could do void test() for now.
Also, I don't think this will rebase as-is on generate_feature_test_macro_components.py, will it? You'll have to add the entry for __cpp_lib_string_contains, which will be easy — but I notice that it will be a divergence from what's literally in https://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations as of this writing. I would bet that's fine; I'm just bringing it up for awareness.

The current direction on constexpr/noexcept sounds great to me.

The entry for __cpp_lib_string_contains in generate_feature_test_macro_components.py was already added in D94227, but I can rebase anyway.

https://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations seems out of date anyway, the draft standard is maybe a better source?
https://eel.is/c++draft/version.syn

[• Quuxplusone]

https://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations seems out of date anyway, the draft standard is maybe a better source? https://eel.is/c++draft/version.syn

Good call. I had not thought to check https://eel.is/c++draft/version.syn when I did D93830. On the one hand version.syn is more authoritative; on the downside version.syn fails to mention what P-numbered papers each macro refers to, and also thus fails to include a "history" of how each macro should be set in each different language mode. I continue to think that at some point we'll need to rejigger generate_feature_test_macro_components.py to include P-numbered papers (e.g. "p1679") in the big data table, as well as language modes (e.g. "c++14").

I wonder if WG21 considers https://isocpp.org/std/standing-documents/sd-6-sg10-feature-test-recommendations to be unmaintained/obsolete, now that version.syn is part of the formal standard.

[WimLeflere]

Rebased and removed unused bool return from basic_string tests.

It's unclear to me if I should add noexcept to the const char* overloads.

[zoecarver]

It's unclear to me if I should add noexcept to the const char* overloads.

I think @mclow.lists is right. We shouldn't have noexcept here, and we also need to remove it from some of the __str_find overloads (as a separate patch, which I'm happy to make).

[ldionne]

In D93912#2507132, @zoecarver wrote:

It's unclear to me if I should add noexcept to the const char* overloads.

I think @mclow.lists is right. We shouldn't have noexcept here, and we also need to remove it from some of the __str_find overloads (as a separate patch, which I'm happy to make).

@WimLeflere Don't add noexcept. Your patch is fine as-is -- we'll tackle the noexcept story separately.

In D93912#2505552, @mclow.lists wrote:

Ok, I take it back. __str_find calls Traits::find, which is NOT always noexcept. (It *is* for all the specializations of std::char_traits, but that's not enough). So we can't slap NOEXCEPT here; in fact, we should revisit __str_find, and remove some of the NOEXCEPTs that are already there.

Hmm, indeed. std::char_traits::find is marked as constexpr since C++17, but technically it could still throw at runtime. @zoecarver Feel free to submit a patch to remove it if you want. You could also audit the other helper functions (like __str_rfind - I see there's a bunch) for the same problem.

[ldionne]

Thanks for your contribution!

[Mordante]

@WimLeflere I just noticed that during review we didn't mention the https://libcxx.llvm.org/docs/Cxx2bStatus.html should be updated. Does this commit fully implement the paper?

Once you confirm whether it's completed or partly done I'll update the status page.

[WimLeflere]

The paper is fully implemented.

With the caveat that std::string::contains is not constexpr yet.
std::string_view::contains is constexpr

[Mordante]

In D93912#2515767, @WimLeflere wrote:

The paper is fully implemented.

With the caveat that std::string::contains is not constexpr yet.
std::string_view::contains is constexpr

Looking at the code that's only because std::string itself can't be used as constexpr yet. The patch has the proper constexpr.

I'll update the status page. Thanks for the information.

[curdeius]

That's funny because https://en.cppreference.com/w/cpp/compiler_support is already updated!

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     **C++ 2b**
     -------------------------------------------------------------------
     ``__cpp_lib_is_scoped_enum``                      *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_stacktrace``                          *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_stdatomic_h``                         *unimplemented*
     ------------------------------------------------- -----------------
-    ``__cpp_lib_string_contains``                     *unimplemented*
+    ``__cpp_lib_string_contains``                     ``202011L``
     ================================================= =================
 

libcxx/include/string

// types:
 
     bool starts_with(basic_string_view<charT, traits> sv) const noexcept; // C++20
     bool starts_with(charT c) const noexcept;                             // C++20
     bool starts_with(const charT* s) const;                               // C++20
     bool ends_with(basic_string_view<charT, traits> sv) const noexcept;   // C++20
     bool ends_with(charT c) const noexcept;                               // C++20
     bool ends_with(const charT* s) const;                                 // C++20
 
+    constexpr bool contains(basic_string_view<charT, traits> sv) const noexcept; // C++2b
+    constexpr bool contains(charT c) const noexcept;                             // C++2b
+    constexpr bool contains(const charT* s) const;                               // C++2b
+
     bool __invariants() const;
 };
 
 template<class InputIterator,
          class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>>
 basic_string(InputIterator, InputIterator, Allocator = Allocator())
    -> basic_string<typename iterator_traits<InputIterator>::value_type,
                   char_traits<typename iterator_traits<InputIterator>::value_type>,
#if _LIBCPP_STD_VER > 17
     { return __self_view(data(), size()).ends_with( __sv); }
 
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     bool ends_with(value_type __c) const _NOEXCEPT
     { return !empty() && _Traits::eq(back(), __c); }
 
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     bool ends_with(const value_type* __s) const _NOEXCEPT
     { return ends_with(__self_view(__s)); }
 #endif
 
+#if _LIBCPP_STD_VER > 20
+    constexpr _LIBCPP_INLINE_VISIBILITY
+    bool contains(__self_view __sv) const noexcept
+    { return __self_view(data(), size()).contains(__sv); }
+
+    constexpr _LIBCPP_INLINE_VISIBILITY
+    bool contains(value_type __c) const noexcept
+    { return __self_view(data(), size()).contains(__c); }
+
+    constexpr _LIBCPP_INLINE_VISIBILITY
+    bool contains(const value_type* __s) const
+    { return __self_view(data(), size()).contains(__s); }
+#endif
+
     _LIBCPP_INLINE_VISIBILITY bool __invariants() const;
 
     _LIBCPP_INLINE_VISIBILITY void __clear_and_shrink() _NOEXCEPT;
 
     _LIBCPP_INLINE_VISIBILITY void __shrink_or_extend(size_type __target_capacity);
 
     _LIBCPP_INLINE_VISIBILITY
     bool __is_long() const _NOEXCEPT

libcxx/include/string_view

class basic_string_view {
 
       constexpr bool starts_with(basic_string_view s) const noexcept; // C++20
       constexpr bool starts_with(charT c) const noexcept;             // C++20
       constexpr bool starts_with(const charT* s) const;               // C++20
       constexpr bool ends_with(basic_string_view s) const noexcept;   // C++20
       constexpr bool ends_with(charT c) const noexcept;               // C++20
       constexpr bool ends_with(const charT* s) const;                 // C++20
 
+      constexpr bool contains(basic_string_view s) const noexcept; // C++2b
+      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
     };
 
   // 7.11, Hash support
   template <class T> struct hash;
   template <> struct hash<string_view>;
#if _LIBCPP_STD_VER > 17
     bool ends_with(value_type __c) const _NOEXCEPT
     { return !empty() && _Traits::eq(back(), __c); }
 
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     bool ends_with(const value_type* __s) const _NOEXCEPT
     { return ends_with(basic_string_view(__s)); }
 #endif
 
+#if _LIBCPP_STD_VER > 20
+    constexpr _LIBCPP_INLINE_VISIBILITY
+    bool contains(basic_string_view __sv) const noexcept
+    { return find(__sv) != npos; }
+
+    constexpr _LIBCPP_INLINE_VISIBILITY
+    bool contains(value_type __c) const noexcept
+    { return find(__c) != npos; }
+
+    constexpr _LIBCPP_INLINE_VISIBILITY
+    bool contains(const value_type* __s) const
+    { return find(__s) != npos; }
+#endif
+
 private:
     const   value_type* __data;
     size_type           __size;
 };
 
 
 // [string.view.comparison]
 // operator ==

libcxx/include/version

 # define __cpp_lib_to_array                             201907L
 # define __cpp_lib_unwrap_ref                           201811L
 #endif
 
 #if _LIBCPP_STD_VER > 20
 // # define __cpp_lib_is_scoped_enum                       202011L
 // # define __cpp_lib_stacktrace                           202011L
 // # define __cpp_lib_stdatomic_h                          202011L
-// # define __cpp_lib_string_contains                      202011L
+# define __cpp_lib_string_contains                      202011L
 #endif
 
 #endif // _LIBCPP_VERSIONH

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

 
 # ifndef __cpp_lib_starts_ends_with
 #   error "__cpp_lib_starts_ends_with should be defined in c++2b"
 # endif
 # if __cpp_lib_starts_ends_with != 201711L
 #   error "__cpp_lib_starts_ends_with should have the value 201711L in c++2b"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_string_contains
-#     error "__cpp_lib_string_contains should be defined in c++2b"
-#   endif
-#   if __cpp_lib_string_contains != 202011L
-#     error "__cpp_lib_string_contains should have the value 202011L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_string_contains
-#     error "__cpp_lib_string_contains should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_string_contains
+#   error "__cpp_lib_string_contains should be defined in c++2b"
+# endif
+# if __cpp_lib_string_contains != 202011L
+#   error "__cpp_lib_string_contains should have the value 202011L in c++2b"
+# endif
 
 # ifndef __cpp_lib_string_udls
 #   error "__cpp_lib_string_udls should be defined in c++2b"
 # endif
 # if __cpp_lib_string_udls != 201304L
 #   error "__cpp_lib_string_udls should have the value 201304L in c++2b"
 # endif
 

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

 
 # ifndef __cpp_lib_starts_ends_with
 #   error "__cpp_lib_starts_ends_with should be defined in c++2b"
 # endif
 # if __cpp_lib_starts_ends_with != 201711L
 #   error "__cpp_lib_starts_ends_with should have the value 201711L in c++2b"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_string_contains
-#     error "__cpp_lib_string_contains should be defined in c++2b"
-#   endif
-#   if __cpp_lib_string_contains != 202011L
-#     error "__cpp_lib_string_contains should have the value 202011L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_string_contains
-#     error "__cpp_lib_string_contains should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_string_contains
+#   error "__cpp_lib_string_contains should be defined in c++2b"
+# endif
+# if __cpp_lib_string_contains != 202011L
+#   error "__cpp_lib_string_contains should have the value 202011L in c++2b"
+# endif
 
 # ifndef __cpp_lib_string_view
 #   error "__cpp_lib_string_view should be defined in c++2b"
 # endif
 # if __cpp_lib_string_view != 201803L
 #   error "__cpp_lib_string_view should have the value 201803L in c++2b"
 # endif
 
 #endif // TEST_STD_VER > 20
 
 int main(int, char**) { return 0; }

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

 #     error "__cpp_lib_stdatomic_h should have the value 202011L in c++2b"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_stdatomic_h
 #     error "__cpp_lib_stdatomic_h should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_string_contains
-#     error "__cpp_lib_string_contains should be defined in c++2b"
-#   endif
-#   if __cpp_lib_string_contains != 202011L
-#     error "__cpp_lib_string_contains should have the value 202011L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_string_contains
-#     error "__cpp_lib_string_contains should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_string_contains
+#   error "__cpp_lib_string_contains should be defined in c++2b"
+# endif
+# if __cpp_lib_string_contains != 202011L
+#   error "__cpp_lib_string_contains should have the value 202011L in c++2b"
+# endif
 
 # ifndef __cpp_lib_string_udls
 #   error "__cpp_lib_string_udls should be defined in c++2b"
 # endif
 # if __cpp_lib_string_udls != 201304L
 #   error "__cpp_lib_string_udls should have the value 201304L in c++2b"
 # endif
 

libcxx/test/std/strings/basic.string/string.contains/contains.char.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, c++2a
+
+// <string>
+
+//   constexpr bool contains(charT x) const noexcept;
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+
+bool test()
+{
+    using S = std::string;
+
+    S s1 {};
+    S s2 {"abcde", 5};
+
+    ASSERT_NOEXCEPT(s1.contains('e'));
+
+    assert(!s1.contains('c'));
+    assert(!s1.contains('e'));
+    assert(!s1.contains('x'));
+    assert( s2.contains('c'));
+    assert( s2.contains('e'));
+    assert(!s2.contains('x'));
+
+    return true;
+}
+
+int main(int, char**)
+{
+    test();
+    // FIXME: wait for constexpr std::string P0980
+    // static_assert(test());
+
+    return 0;
+}

libcxx/test/std/strings/basic.string/string.contains/contains.ptr.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, c++2a
+
+// <string>
+
+//   constexpr bool contains(const CharT *x) const;
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+
+bool test()
+{
+    using S = std::string;
+
+    const char* s = "abcde";
+    S s0;
+    S s1 {s + 4, 1};
+    S s3 {s + 2, 3};
+    S sNot {"xyz", 3};
+
+    assert(s0.contains(""));
+    assert(!s0.contains("e"));
+
+    assert( s1.contains(""));
+    assert(!s1.contains("d"));
+    assert( s1.contains("e"));
+    assert(!s1.contains("de"));
+    assert(!s1.contains("cd"));
+    assert(!s1.contains("cde"));
+    assert(!s1.contains("bcde"));
+    assert(!s1.contains("abcde"));
+    assert(!s1.contains("xyz"));
+
+    assert( s3.contains(""));
+    assert( s3.contains("d"));
+    assert( s3.contains("e"));
+    assert( s3.contains("de"));
+    assert( s3.contains("cd"));
+    assert(!s3.contains("ce"));
+    assert( s3.contains("cde"));
+    assert(!s3.contains("edc"));
+    assert(!s3.contains("bcde"));
+    assert(!s3.contains("abcde"));
+    assert(!s3.contains("xyz"));
+
+    assert( sNot.contains(""));
+    assert(!sNot.contains("d"));
+    assert(!sNot.contains("e"));
+    assert(!sNot.contains("de"));
+    assert(!sNot.contains("cd"));
+    assert(!sNot.contains("cde"));
+    assert(!sNot.contains("bcde"));
+    assert(!sNot.contains("abcde"));
+    assert( sNot.contains("xyz"));
+    assert(!sNot.contains("zyx"));
+
+    return true;
+}
+
+int main(int, char**)
+{
+    test();
+    // FIXME: wait for constexpr std::string P0980
+    // static_assert(test());
+
+    return 0;
+}

libcxx/test/std/strings/basic.string/string.contains/contains.string_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, c++2a
+
+// <string>
+
+//   constexpr bool contains(basic_string_view x) const noexcept;
+
+#include <string>
+#include <cassert>
+
+#include "test_macros.h"
+
+bool test()
+{
+    using S = std::string;
+    using SV = std::string_view;
+
+    const char* s = "abcde";
+    S s0;
+    S s1 {s + 1, 1};
+    S s3 {s + 1, 3};
+    S s5 {s    , 5};
+    S sNot {"xyz", 3};
+
+    SV sv0;
+    SV sv1 {s + 1, 1};
+    SV sv2 {s + 1, 2};
+    SV sv3 {s + 1, 3};
+    SV sv4 {s + 1, 4};
+    SV sv5 {s    , 5};
+    SV svNot  {"xyz", 3};
+    SV svNot2 {"bd" , 2};
+    SV svNot3 {"dcb", 3};
+
+    ASSERT_NOEXCEPT(s0.contains(sv0));
+
+    assert( s0.contains(sv0));
+    assert(!s0.contains(sv1));
+
+    assert( s1.contains(sv0));
+    assert( s1.contains(sv1));
+    assert(!s1.contains(sv2));
+    assert(!s1.contains(sv3));
+    assert(!s1.contains(sv4));
+    assert(!s1.contains(sv5));
+    assert(!s1.contains(svNot));
+    assert(!s1.contains(svNot2));
+    assert(!s1.contains(svNot3));
+
+    assert( s3.contains(sv0));
+    assert( s3.contains(sv1));
+    assert( s3.contains(sv2));
+    assert( s3.contains(sv3));
+    assert(!s3.contains(sv4));
+    assert(!s3.contains(sv5));
+    assert(!s3.contains(svNot));
+    assert(!s3.contains(svNot2));
+    assert(!s3.contains(svNot3));
+
+    assert( s5.contains(sv0));
+    assert( s5.contains(sv1));
+    assert( s5.contains(sv2));
+    assert( s5.contains(sv3));
+    assert( s5.contains(sv4));
+    assert( s5.contains(sv5));
+    assert(!s5.contains(svNot));
+    assert(!s5.contains(svNot2));
+    assert(!s5.contains(svNot3));
+
+    assert( sNot.contains(sv0));
+    assert(!sNot.contains(sv1));
+    assert(!sNot.contains(sv2));
+    assert(!sNot.contains(sv3));
+    assert(!sNot.contains(sv4));
+    assert(!sNot.contains(sv5));
+    assert( sNot.contains(svNot));
+    assert(!sNot.contains(svNot2));
+    assert(!sNot.contains(svNot3));
+
+    return true;
+}
+
+int main(int, char**)
+{
+    test();
+    // FIXME: wait for constexpr std::string P0980
+    // static_assert(test());
+
+    return 0;
+}

libcxx/test/std/strings/string.view/string.view.template/contains.char.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, c++2a
+
+// <string_view>
+
+//   constexpr bool contains(charT x) const noexcept;
+
+#include <string_view>
+#include <cassert>
+
+#include "test_macros.h"
+
+constexpr bool test()
+{
+    using SV = std::string_view;
+
+    SV sv1 {};
+    SV sv2 {"abcde", 5};
+
+    ASSERT_NOEXCEPT(sv1.contains('e'));
+
+    assert(!sv1.contains('c'));
+    assert(!sv1.contains('e'));
+    assert(!sv1.contains('x'));
+    assert( sv2.contains('c'));
+    assert( sv2.contains('e'));
+    assert(!sv2.contains('x'));
+
+    return true;
+}
+
+int main(int, char**)
+{
+    test();
+    static_assert(test());
+
+    return 0;
+}

libcxx/test/std/strings/string.view/string.view.template/contains.ptr.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, c++2a
+
+// <string_view>
+
+//   constexpr bool contains(const CharT *x) const;
+
+#include <string_view>
+#include <cassert>
+
+#include "test_macros.h"
+
+constexpr bool test()
+{
+    using SV = std::string_view;
+
+    const char* s = "abcde";
+    SV sv0;
+    SV sv1 {s + 4, 1};
+    SV sv3 {s + 2, 3};
+    SV svNot {"xyz", 3};
+
+    assert( sv0.contains(""));
+    assert(!sv0.contains("e"));
+
+    assert( sv1.contains(""));
+    assert(!sv1.contains("d"));
+    assert( sv1.contains("e"));
+    assert(!sv1.contains("de"));
+    assert(!sv1.contains("cd"));
+    assert(!sv1.contains("cde"));
+    assert(!sv1.contains("bcde"));
+    assert(!sv1.contains("abcde"));
+    assert(!sv1.contains("xyz"));
+
+    assert( sv3.contains(""));
+    assert( sv3.contains("d"));
+    assert( sv3.contains("e"));
+    assert( sv3.contains("de"));
+    assert( sv3.contains("cd"));
+    assert(!sv3.contains("ce"));
+    assert( sv3.contains("cde"));
+    assert(!sv3.contains("edc"));
+    assert(!sv3.contains("bcde"));
+    assert(!sv3.contains("abcde"));
+    assert(!sv3.contains("xyz"));
+
+    assert( svNot.contains(""));
+    assert(!svNot.contains("d"));
+    assert(!svNot.contains("e"));
+    assert(!svNot.contains("de"));
+    assert(!svNot.contains("cd"));
+    assert(!svNot.contains("cde"));
+    assert(!svNot.contains("bcde"));
+    assert(!svNot.contains("abcde"));
+    assert( svNot.contains("xyz"));
+    assert(!svNot.contains("zyx"));
+
+    return true;
+}
+
+int main(int, char**)
+{
+    test();
+    static_assert(test());
+
+    return 0;
+}

libcxx/test/std/strings/string.view/string.view.template/contains.string_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, c++2a
+
+// <string_view>
+
+//   constexpr bool contains(string_view x) const noexcept;
+
+#include <string_view>
+#include <cassert>
+
+#include "test_macros.h"
+
+constexpr bool test()
+{
+    using SV = std::string_view;
+
+    const char* s = "abcde";
+    SV sv0;
+    SV sv1 {s + 1, 1};
+    SV sv2 {s + 1, 2};
+    SV sv3 {s + 1, 3};
+    SV sv4 {s + 1, 4};
+    SV sv5 {s    , 5};
+    SV svNot  {"xyz", 3};
+    SV svNot2 {"bd" , 2};
+    SV svNot3 {"dcb", 3};
+
+    ASSERT_NOEXCEPT(sv0.contains(sv0));
+
+    assert( sv0.contains(sv0));
+    assert(!sv0.contains(sv1));
+
+    assert( sv1.contains(sv0));
+    assert( sv1.contains(sv1));
+    assert(!sv1.contains(sv2));
+    assert(!sv1.contains(sv3));
+    assert(!sv1.contains(sv4));
+    assert(!sv1.contains(sv5));
+    assert(!sv1.contains(svNot));
+    assert(!sv1.contains(svNot2));
+    assert(!sv1.contains(svNot3));
+
+    assert( sv3.contains(sv0));
+    assert( sv3.contains(sv1));
+    assert( sv3.contains(sv2));
+    assert( sv3.contains(sv3));
+    assert(!sv3.contains(sv4));
+    assert(!sv3.contains(sv5));
+    assert(!sv3.contains(svNot));
+    assert(!sv3.contains(svNot2));
+    assert(!sv3.contains(svNot3));
+
+    assert( sv5.contains(sv0));
+    assert( sv5.contains(sv1));
+    assert( sv5.contains(sv2));
+    assert( sv5.contains(sv3));
+    assert( sv5.contains(sv4));
+    assert( sv5.contains(sv5));
+    assert(!sv5.contains(svNot));
+    assert(!sv5.contains(svNot2));
+    assert(!sv5.contains(svNot3));
+
+    assert( svNot.contains(sv0));
+    assert(!svNot.contains(sv1));
+    assert(!svNot.contains(sv2));
+    assert(!svNot.contains(sv3));
+    assert(!svNot.contains(sv4));
+    assert(!svNot.contains(sv5));
+    assert( svNot.contains(svNot));
+    assert(!svNot.contains(svNot2));
+    assert(!svNot.contains(svNot3));
+
+    return true;
+}
+
+int main(int, char**)
+{
+    test();
+    static_assert(test());
+
+    return 0;
+}

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = [ add_version_header(x) for x in [
     "name": "__cpp_lib_stdatomic_h",
     "values": { "c++2b": 202011 },
     "headers": ["stdatomic.h"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_string_contains",
     "values": { "c++2b": 202011 },
     "headers": ["string", "string_view"],
-    "unimplemented": True,
   }, {
     "name": "__cpp_lib_string_udls",
     "values": { "c++14": 201304 },
     "headers": ["string"],
   }, {
     "name": "__cpp_lib_string_view",
     "values": { "c++17": 201606, "c++20": 201803 },
     "headers": ["string", "string_view"],