[libc++] Implement `stop_token`

[huixie90]

Summary

Implement stop_token
http://eel.is/c++draft/thread.stoptoken

[huixie90]

address feedback

[huixie90]

formatting

[ldionne]

Could you extract atomic_unique_lock.h, intrusive_list.h and intrusive_shared_ptr.h into a separate review? I think we can check those in soon and that will greatly simplify this review. I don't know where to put them. It's not great, but I'd suggest leaving them in __stop_token and we can think about reorganization later.

libcxx/include/__stop_token/atomic_unique_lock.h

1 ↗

(On Diff #512113)

Since this is general purpose, it makes little sense to keep this under __stop_token/, but we also don't have any good place for these general-purpose utilities. No action item, but let's keep this at the back of our mind that we might need to reorganize things a bit in the future.

4 ↗

(On Diff #512113)

Can you add just a few simple tests for this class under libcxx/test/libcxx?

40 ↗

(On Diff #512113)

Would it make sense to use std::try_to_lock_t here to convey that we're taking the lock? Otherwise, this can be confusing with std::unique_lock.

66 ↗

(On Diff #512113)

Maybe we could call this __owns_lock() to mirror unique_lock?

87 ↗

(On Diff #512113)

I think a short comment explaining what __fail_to_lock and __state_after_lock are used for, it's not obvious from the names alone.

Actually, maybe __fail_to_lock should be called __give_up_locking? __fail_to_lock can sound like something that is called in case you've failed to take the lock, which is not quite correct.

117 ↗

(On Diff #512113)

libcxx/include/__stop_token/intrusive_list.h

1 ↗

(On Diff #512113)

Can you add just a few simple tests for this class under libcxx/test/libcxx?

31 ↗

(On Diff #512113)

__empty()? Or __is_empty()?

42–47 ↗

(On Diff #512113)

I think this is fine, but you should add a comment explaining that it's fine not to set __front->__next_ = nullptr, since it's not part of the linked list anymore.

57–59 ↗

(On Diff #512113)

If we don't have a prev, then we are necessarily the head. I would instead change this to:

if (...) { ... } else {
  _LIBCPP_ASSERT(__node == __head_, "message");
  __pop_front();
}

IOW, I think this function needs the precondition that __node is in the list, similarly to how std::list requires the iterator to be from this list when you call erase(). I think that's a really useful and important model to have.

libcxx/include/__stop_token/intrusive_shared_ptr.h

28–29 ↗

(On Diff #512113)

Can you please add a comment documenting what this type is and what its contents should be for anyone specializing it?

31–32 ↗

(On Diff #512113)

Let's also add a short comment documenting this class, since it's general purpose in nature and we might reuse it in the future.

35 ↗

(On Diff #512113)

I'd make this explicit, like the one for std::shared_ptr.

libcxx/include/__stop_token/stop_callback.h

85

Isn't this always nullptr since you default initialize it above?

libcxx/include/__stop_token/stop_state.h

151

154

I think we shouldn't call this __remove if we know that __cb is not in the list anymore, which can be checked via __cb->__prev_ == nullptr && !__callback_list_.__is_head(__cb). Oh and that's exactly the check you make above with __potentially_executing_now!

And now I think we have the precondition we want for __remove.

[ldionne]

libcxx/include/__stop_token/stop_source.h

49

I would add a comment like:

// increment `other` first so that we don't hit 0 in case of self-assignment

73–75

A default constructed stop_token has no associated stop-state, and thus has not had stop requested.

I assume this is tested in stop_requested.pass.cpp?

libcxx/include/__stop_token/stop_state.h

43–51

54–56

83

89–90

124

Or something!

151

libcxx/test/std/thread/thread.stoptoken/stopcallback/cons.const.token.pass.cpp

12–13

You can replace this by // XFAIL: availability-synchronization_library-missing now. Here and everywhere else.

libcxx/test/std/thread/thread.stoptoken/stopcallback/dtor.pass.cpp

156

Maybe a bit more explicit?

158

Is there any reason why you don't initialize sc_ directly with std::make_unique<>? That would make it clear that ptr is not actually meaningful other than a temporary variable.

[ldionne]

libcxx/include/__stop_token/stop_state.h

35

Here I think we do need to store a pointer to a bool saying whether we've been destroyed to handle https://eel.is/c++draft/thread.stoptoken#stopcallback.cons-6 like we've discussed.

[huixie90]

rebase

[huixie90]

libcxx/include/__stop_token/atomic_unique_lock.h

40 ↗

(On Diff #512113)

std::try_to_lock_t is non-blocking. here we are still blocking so might not be appropriate

libcxx/include/__stop_token/stop_callback.h

85

__state is a function parameter which is not always nullptr
__state_ is the member which is nullptr

[huixie90]

CI

[huixie90]

CI

[huixie90]

CI

[ldionne]

I am extremely happy with the state of this patch! Thanks so much for all the iterations, I feel like we really have something good with great test coverage now. I'm especially happy about how things ended up after intrusive shared ptr and other generic bits were extracted, I think the code is really neat now.

Once the remaining comments have been addressed and the CI is passing, feel free to ship this. Thank you!

libcxx/include/__stop_token/stop_callback.h

43

Do you have a test for this typedef?

85

Do you have a test for the fact that the stop_callback won't get shared ownership of the __stop_state if the constructor runs the callback immediately (aka if a stop has been requested at the moment of calling this constructor).

Edit: I don't think there's a way to test that without poking into the library internals -- IOW I'm not sure this is user-observable.

85–86

I might combine these two ifs into if (__state && __state->__add_callback(this)).

libcxx/include/__stop_token/stop_source.h

29

Do you have a test for this? We need to make sure that:

1. It exists
2. The constructor is explicit
3. Maybe that it's empty and trivially default constructible?
4. That std::nostopstate (the variable, not the class) exists and is constexpr.

libcxx/include/__stop_token/stop_state.h

2

Recording the discussion: We considered whether we should move some of these classes to the dylib, and I think the answer should be no. There isn't *that much* code, it's not platform-specific (e.g. no including windows.h), and it would add backdeployment requirements. All in all, I don't think there's enough bang for the buck.

57

71

Could we add a _LIBCPP_ASSERT here to make sure that we don't overflow? Same below for the decrement: if we decrement when we are already at 0, I guess it means that there's a lifetime bug in the program somewhere and someone's using a stop_source that has already been destroyed. Since that's easy to catch, I think we should add those assertions.

110

Taking note of what you explained just now:

Since there's only one thread looping through the list and executing callbacks, it should be possible to store a single pointer to the currently-executing callback in the stop state. That would avoid requiring a __completed_ and a __destroyed_ member in the callback. Then in __remove_callback, we would atomic-wait on the currently-executing callback not being this.

I would suggest that we ship this patch with the current approach, and we investigate this improvement in a separate patch.

176

libcxx/include/__stop_token/stop_token.h

53

This private is redundant with the one above.

libcxx/test/std/thread/thread.stoptoken/stopcallback/cons.const.token.pass.cpp

96

Don't change anything, but we generally use snake_case for variable names. Just in the future.

libcxx/test/std/thread/thread.stoptoken/stopsource/cons.copy.pass.cpp

10

This is duplicated with the line below (please double-check throughout all your tests).

13

Here you're missing // XFAIL: availability-synchronization_library-missing, that would fix some of your CI.

libcxx/utils/generate_header_tests.py

1 ↗

(On Diff #523770)

To fix your CI issue, I think you need to add "stop_token": ["UNSUPPORTED: no-threads, availability-synchronization_library-missing"], to libcxx/utils/generate_feature_test_macro_components.py.

[huixie90]

address review comments

[huixie90]

add tests

[huixie90]

CI

[huixie90]

CI

[huixie90]

CI

[huixie90]

rebase

[huixie90]

• [libc++] Implement stop_token

[clementval]

Something seems wrong with this patch. It contains multiple unrelated changes.

[huixie90]

rebase

[Mordante]

Thanks for working on this. I've a few nits, otherwise LGTM!

libcxx/include/__stop_token/stop_callback.h

79

libcxx/include/__stop_token/stop_state.h

35

53

please search for other places too.

65

libcxx/test/std/thread/thread.stoptoken/nostopstate/cons.default.pass.cpp

38

How about testing the type?

libcxx/test/std/thread/thread.stoptoken/stopcallback/cons.const.token.pass.cpp

62

I really dislike using auto here. Either use a real type or the same_as.
In general I'm not a fan of auto, but here we should make sure we get the expected types. Or is the token an unspecified type?

[huixie90]

address comments

[ldionne]

libcxx/include/__stop_token/stop_token.h

26

I think my comment about fixing the backdeployment CI using availability-synchronization_library-missing was misguided. I'm not sure, but it seems like adding _LIBCPP_AVAILABILITY_SYNC here should tell the compiler that the class is only available when the synchronization library is available, and it should avoid getting an error when you merely #include <stop_token>. If you try to use std::stop_token, then it would fail with an error message but that's intended and it wouldn't impact the generated tests like modules_include.sh.cpp.

[huixie90]

CI

[huixie90]

indentation

[huixie90]

CI

[huixie90]

try again

[huixie90]

try again

[huixie90]

fix apple platform

[huixie90]

rebase

[ldionne]

You should rebase onto main, that'll fix CI. LGTM once CI is green.

[huixie90]

rebase

[huixie90]

fix stop_token lit_header_restrictions

[huixie90]

rebase

[ldionne]

Can you confirm whether this landed as b77e50e6aef5650d1ce0ce7ad1a41049395b9426? If so, let's close this.

[lewissbaker]

Sorry for the belated feedback - I only just noticed that the stop_token implementation had been published.

The implementation looks like it's doing all the right things from a correctness point of view, which is good!

I have a few suggestions for some changes that might help reduce the number of atomic ops needed for some operations which you could consider if performance was problematic.

libcxx/include/__stop_token/stop_source.h

65

The way that you have separated the ref-count from the stop_source_counter in the state_t means that destroying a stop_source object now needs to update two separate atomic variables, resulting in two atomic operations instead of one.
If you instead combine both fields into a single 64-bit atomic value, then you can combine this into a single atomic decrement on destruction.

libcxx/include/__stop_token/stop_state.h

59

Initialising the ref-count to zero means that you need to do an atomic increment when the object is first constructed.

Since you know that a state is only ever allocated by a stop_source, which will immediately take a reference, you could just initialise the reference to 1 here and have the stop_source constructor's intrusive_shared_ptr "adopt" the reference.
You could also initialise the ref-count to 1 on construction as well.
This would save two atomic op on every stop source construction.

Further, if you merged the ref-count and state_t atomics into a single 64-bit atomic then you could reduce the destruction of a stop_source to a single atomic subtraction.

Making both of these changes would allow reducing the number of atomics executed when constructing a stop_source and immediately destructing it from 4 atomic ops in the current implementation, to just 1 atomic operation.

133

Note that you don't need to lock again here if you know that this callback was the last callback in the list, since once you have set the "stop-requested" flag, then no more callback items should be enqueued. This should save you an additional atomic lock/unlock at the cost of a branch here.

160

If you were to combine the state_t and the ref-count you could potentially merge the ref-count increment with the unlock into a single atomic operation by adding (__ref_count_increment - _lock_bit) atomically (in the case where the stop_callback is being constructed with a const stop_token&). This would save an extra atomic op.

Ideally the compiler would be able to merge consecutive atomic ops like this, but I don't think I've seen clang do such a thing before.

[ldionne]

Since we want to investigate some improvements, I would start by making stop_token experimental. Then we can add some benchmarks that faithfully represent the intended use cases for stop_token, not just some random benchmarks that test the performance of some arbitrary operations. @lewissbaker are you aware of any benchmarks that would be representative of the way stop_token intends to be used?

Then we can try a few things (in no order):

1. Try to remove some atomic operations as laid out by @lewissbaker above
2. Try implementing the lock with try { mutex.lock(); } catch (...) { ... }; instead and see if it's faster. We need try-catch cause the methods on stop_token are noexcept.
3. Try to see if there's something obviously wrong with our atomic_unique_lock implementation. Maybe we're using compare_exchange_weak when we should be using strong, or maybe there's some other perf issue with our implementation.

I would also not eliminate the possibility that the current implementation actually performs quite well for the intended use cases of stop_token. But the benchmarks will give us more insight into that.

[lewissbaker]

In D145183#4456591, @ldionne wrote:

@lewissbaker are you aware of any benchmarks that would be representative of the way stop_token intends to be used?

I wrote up a few basic tests/benchmarks for an older implementation of the design in cppcoro here:
https://github.com/lewissbaker/cppcoro/blob/master/test/cancellation_token_tests.cpp

Although I don't think these tests are necessarily representative of real-world usage.

There are a few use-cases that are going to be common for stop_tokens which could be good candidates for benchmarks:

1. The std::jthread use-case.

In this case, you will have a single thread created by std::jthread consuming the stop_token:

• registering/deregistering callbacks, usually just one at a time (e.g. in implementation of condition_variable::wait functions that take a stop-token), but sometimes might register one or more long-lived callbacks combined with single ephemeral callbacks.
• polling for a stop_request / stop_possible
• copying the stop_token (e.g. when passing by-value to nested function calls)

And then a main thread will eventually call request_stop() from the destructor of the std::jthread.

A rough sketch:

int main() {
  std::uint64_t count = 0;
  {
    std::jthread t([&](std::stop_token st) {
      std::uint64_t local_count = 0;
      while (!st.stop_requested()) {
        std::stop_callback cb{st, [&]() noexcept  {}};
        ++local_count;
      }
      count = local_count;
    });
    std::this_thread::sleep_for(30s);
  }
  std::cout << "Thread did " << count << " callback registration/deregistration in 30s\n";
}

If you also have an implementation of the condition_variable::wait() functions then you could also try calling the stop_token-taking versions of those instead.

2. Async use-case #1 - Shutdown stop_token

At app startup, the app creates a single stop_source which it will then pass an associated stop_token to every request.

Assume a thread-pool handles these requests and for each request it polls for stop_requested(), then attaches a stop-callback, does some work, then detaches the stop-callback some time later.
The lifetime of requests/callbacks would overlap with other requests/callback from the same thread.

Say something like each thread keeping a circular buffer of N stop-callbacks and destroying the stop-callbacks in FIFO order

Rough sketch:

constexpr size_t thread_count = 20;
constexpr size_t concurrent_request_count = 1000;
std::atomic<bool> ready{false};

struct dummy_stop_callback { void operator()() const noexcept {} };

void thread_func(uint64_t& count, std::stop_token st) {
  std::vector<std::optional<std::stop_callback<dummy_stop_callback>>> cbs(concurrent_request_count);

  ready.wait(false);

  std::uint32_t index = 0;
  std::uint64_t local_count = 0;
  while (!st.stop_requested()) {
    cbs[index].emplace(st, dummy_stop_callback{});
    index = (index + 1) % concurrent_request_count;
    ++local_count;
  }
  count = local_count;
} 

int main() {
  std::vector<std::uint64_t> counts(thread_count, 0);
  std::stop_source ss;
  {
    std::vector<std::jthread> threads;

    {
      auto release_on_exit = on_scope_exit([&]() { ready = true; ready.notify_all(); });
      for (size_t i = 0; i < thread_count; ++i) {
        threads.emplace_back(thread_func, counts[i], ss.get_token());
      }
    }
  
    std::this_thread::sleep_for(std::chrono::seconds(10));

    ss.request_stop();
  }

  std::uint64_t total_count = std::reduce(counts.begin(), counts.end());

  std::cout << "Total iterations of " << thread_count << " threads for 10s was " << total_count << "\n";
}

Variations on this might involve deregistering stop-callbacks on different threads than the threads they were registered on.
But this is more involved to setup.

3. Async use-case #2 - Per-request stop_source

This is a variation on the previous use-case, but where each task ends up creating a bunch of different chained stop_sources to simulate the concurrent sub-task nature of some operations.
e.g. for each request, we create a new stop_source, A, and then attach a stop_callback to the global shutdown stop-token which then calls request_stop() on the new stop_source if called.
Then we simulate passing the a stop_token to two child operations, each of which then creates its own stop_source (B and C) and subscribes a stop_callback to A which calls request_stop() on B or C respectively.

This can be done to an arbitrary number of ops per request, with varying tree widths/depths.

This should help to evaluate the performance of creation/destruction of stop_source and non-contended registration of stop-callbacks with less of a focus on lots of threads hitting the same stop-state.

You could also try a variation on this without the top-level shutdown stop_callback.

It is worth noting, however, that with P2300 there is also a proposed std::in_place_stop_source, which provides an alternative that does not heap-allocate/ref-count but for which the caller is required to keep the stop-source alive until all child ops that use the stop-tokens are done with it, and so I'd expect a lot of the structured async use-cases to eventually use that where possible instead of std::stop_source. This in-place version was not appropriate for jthread since that needs to be movable.

[ldionne]

Thanks a lot, this is great! @huixie90 I think this is something we can work with -- let's make this experimental, add a few benchmarks like laid out above and then iterate on that!

[ldionne]

I created https://github.com/llvm/llvm-project/issues/63738 to track these optimizations. Let's close this patch since it has been shipped in b77e50e6aef5650d1ce0ce7ad1a41049395b9426

libcxx/docs/Status/Cxx20.rst

.. note::
    .. [#note-P0645] P0645: The paper is implemented but still marked as an incomplete feature
       (the feature-test macro is not set and the libary is only available when built with ``-fexperimental-library``).
       Not yet implemented LWG-issues will cause API and ABI breakage.
    .. [#note-P0966] P0966: It was previously erroneously marked as complete in version 8.0. See `bug 45368 <https://llvm.org/PR45368>`__.
    .. [#note-P0619] P0619: Only sections D.8, D.9, D.10 and D.13 are implemented. Sections D.4, D.7, D.11, D.12, and D.14 remain undone.
    .. [#note-P0883.1] P0883: shared_ptr and floating-point changes weren't applied as they themselves aren't implemented yet.
    .. [#note-P0883.2] P0883: ``ATOMIC_FLAG_INIT`` was marked deprecated in version 14.0, but was undeprecated with the implementation of LWG3659 in version 15.0.
    .. [#note-P2231] P2231: Optional is complete. The changes to variant haven't been implemented yet.
    .. [#note-P0408] P0408: Only `view()` members implemented.
+   .. [#note-P0660] P0660: Section 32.3 Stop Tokens is complete. ``jthread`` hasn't been implemented yet.
 
 .. _issues-status-cxx20:
 
 Library Working Group Issues Status
 ====================================
 
 .. csv-table::
    :file: Cxx20Issues.csv
    :header-rows: 1
    :widths: auto

libcxx/docs/Status/Cxx20Issues.csv

 "`3238 <https://wg21.link/LWG3238>`__","Insufficiently-defined behavior of ``std::function``\  deduction guides","Prague","",""
 "`3242 <https://wg21.link/LWG3242>`__","``std::format``\ : missing rules for ``arg-id``\  in ``width``\  and ``precision``\ ","Prague","|Complete|","Clang 14","|format|"
 "`3243 <https://wg21.link/LWG3243>`__","``std::format``\  and negative zeroes","Prague","|Complete|","14.0","|format|"
 "`3247 <https://wg21.link/LWG3247>`__","``ranges::iter_move``\  should perform ADL-only lookup of ``iter_move``\ ","Prague","|Complete|","15.0","|ranges|"
 "`3248 <https://wg21.link/LWG3248>`__","``std::format``\  ``#b``\ , ``#B``\ , ``#o``\ , ``#x``\ , and ``#X``\   presentation types misformat negative numbers","Prague","|Complete|","14.0","|format|"
 "`3250 <https://wg21.link/LWG3250>`__","``std::format``\ : ``#``\  (alternate form) for NaN and inf","Prague","|Complete|","14.0","|format|"
 "`3251 <https://wg21.link/LWG3251>`__","Are ``std::format``\  alignment specifiers applied to string arguments?","Prague","|Complete|","14.0","|format|"
 "`3252 <https://wg21.link/LWG3252>`__","Parse locale's aware modifiers for commands are not consistent with POSIX spec","Prague","","","|chrono|"
-"`3254 <https://wg21.link/LWG3254>`__","Strike ``stop_token``\ 's ``operator!=``\ ","Prague","",""
+"`3254 <https://wg21.link/LWG3254>`__","Strike ``stop_token``\ 's ``operator!=``\ ","Prague","|Complete|","17.0"
 "`3255 <https://wg21.link/LWG3255>`__","``span``\ 's ``array``\  constructor is too strict","Prague","|Complete|",""
 "`3260 <https://wg21.link/LWG3260>`__","``year_month*``\  arithmetic rejects durations convertible to years","Prague","","","|chrono|"
 "`3262 <https://wg21.link/LWG3262>`__","Formatting of negative durations is not specified","Prague","|Complete|","16.0","|chrono| |format|"
 "`3264 <https://wg21.link/LWG3264>`__","``sized_range``\  and ``ranges::size``\  redundantly use ``disable_sized_range``\ ","Prague","|Complete|","15.0","|ranges|"
 "`3269 <https://wg21.link/LWG3269>`__","Parse manipulators do not specify the result of the extraction from stream","Prague","","","|chrono|"
 "`3270 <https://wg21.link/LWG3270>`__","Parsing and formatting ``%j``\  with ``duration``\ s","Prague","|Partial|","","|chrono| |format|"
 "`3280 <https://wg21.link/LWG3280>`__","View converting constructors can cause constraint recursion and are unneeded","Prague","|Complete|","15.0","|ranges|"
 "`3281 <https://wg21.link/LWG3281>`__","Conversion from ``*pair-like*``\  types to ``subrange``\  is a silent semantic promotion","Prague","|Complete|","15.0","|ranges|"

libcxx/docs/Status/Cxx20Papers.csv

 "`P1464R1 <https://wg21.link/P1464R1>`__","LWG","Mandating the Standard Library: Clause 22 - Iterators library","Kona","|Complete|","9.0"
 "","","","","","",""
 "`P0325R4 <https://wg21.link/P0325R4>`__","LWG","to_array from LFTS with updates","Cologne","|Complete|","10.0"
 "`P0408R7 <https://wg21.link/P0408R7>`__","LWG","Efficient Access to basic_stringbuf's Buffer","Cologne","|In Progress| [#note-P0408]_",""
 "`P0466R5 <https://wg21.link/P0466R5>`__","LWG","Layout-compatibility and Pointer-interconvertibility Traits","Cologne","",""
 "`P0553R4 <https://wg21.link/P0553R4>`__","LWG","Bit operations","Cologne","|Complete|","9.0"
 "`P0631R8 <https://wg21.link/P0631R8>`__","LWG","Math Constants","Cologne","|Complete|","11.0"
 "`P0645R10 <https://wg21.link/P0645R10>`__","LWG","Text Formatting","Cologne","|Complete| [#note-P0645]_","14.0"
-"`P0660R10 <https://wg21.link/P0660R10>`__","LWG","Stop Token and Joining Thread, Rev 10","Cologne","",""
+"`P0660R10 <https://wg21.link/P0660R10>`__","LWG","Stop Token and Joining Thread, Rev 10.","Cologne","|In Progress| [#note-P0660]_",""
 "`P0784R7 <https://wg21.link/P0784R7>`__","CWG","More constexpr containers","Cologne","|Complete|","12.0"
 "`P0980R1 <https://wg21.link/P0980R1>`__","LWG","Making std::string constexpr","Cologne","|Complete|","15.0"
 "`P1004R2 <https://wg21.link/P1004R2>`__","LWG","Making std::vector constexpr","Cologne","|Complete|","15.0"
 "`P1035R7 <https://wg21.link/P1035R7>`__","LWG","Input Range Adaptors","Cologne","|Complete|","16.0","|ranges|"
 "`P1065R2 <https://wg21.link/P1065R2>`__","LWG","Constexpr INVOKE","Cologne","|Complete|","12.0"
 "`P1135R6 <https://wg21.link/P1135R6>`__","LWG","The C++20 Synchronization Library","Cologne","|Complete|","11.0"
 "`P1207R4 <https://wg21.link/P1207R4>`__","LWG","Movability of Single-pass Iterators","Cologne","|Complete|","15.0","|ranges|"
 "`P1208R6 <https://wg21.link/P1208R6>`__","LWG","Adopt source_location for C++20","Cologne","|Complete|","16.0"

libcxx/include/CMakeLists.txt

set(files
   __ranges/view_interface.h
   __ranges/views.h
   __ranges/zip_view.h
   __split_buffer
   __std_mbstate_t.h
   __stop_token/atomic_unique_lock.h
   __stop_token/intrusive_list_view.h
   __stop_token/intrusive_shared_ptr.h
+  __stop_token/stop_callback.h
+  __stop_token/stop_source.h
+  __stop_token/stop_state.h
+  __stop_token/stop_token.h
   __string/char_traits.h
   __string/constexpr_c_functions.h
   __string/extern_template_lists.h
   __support/android/locale_bionic.h
   __support/fuchsia/xlocale.h
   __support/ibm/gettod_zos.h
   __support/ibm/locale_mgmt_zos.h
   __support/ibm/nanosleep.h
set(files
   stack
   stdatomic.h
   stdbool.h
   stddef.h
   stdexcept
   stdint.h
   stdio.h
   stdlib.h
+  stop_token
   streambuf
   string
   string.h
   string_view
   strstream
   system_error
   tgmath.h
   thread

libcxx/include/__stop_token/stop_callback.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___STOP_TOKEN_STOP_CALLBACK_H
+#define _LIBCPP___STOP_TOKEN_STOP_CALLBACK_H
+
+#include <__availability>
+#include <__concepts/constructible.h>
+#include <__concepts/destructible.h>
+#include <__concepts/invocable.h>
+#include <__config>
+#include <__stop_token/intrusive_shared_ptr.h>
+#include <__stop_token/stop_state.h>
+#include <__stop_token/stop_token.h>
+#include <__type_traits/is_nothrow_constructible.h>
+#include <__utility/forward.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 20
+
+template <class _Callback>
+class _LIBCPP_AVAILABILITY_SYNC stop_callback : private __stop_callback_base {
+  static_assert(invocable<_Callback>,
+                "Mandates: stop_callback is instantiated with an argument for the template parameter Callback that "
+                "satisfies invocable.");
+  static_assert(destructible<_Callback>,
+                "Mandates: stop_callback is instantiated with an argument for the template parameter Callback that "
+                "satisfies destructible.");
+
+public:
+  using callback_type = _Callback;
+
+  template <class _Cb>
+    requires constructible_from<_Callback, _Cb>
+  _LIBCPP_HIDE_FROM_ABI explicit stop_callback(const stop_token& __st,
+                                               _Cb&& __cb) noexcept(is_nothrow_constructible_v<_Callback, _Cb>)
+      : stop_callback(__private_tag{}, __st.__state_, std::forward<_Cb>(__cb)) {}
+
+  template <class _Cb>
+    requires constructible_from<_Callback, _Cb>
+  _LIBCPP_HIDE_FROM_ABI explicit stop_callback(stop_token&& __st,
+                                               _Cb&& __cb) noexcept(is_nothrow_constructible_v<_Callback, _Cb>)
+      : stop_callback(__private_tag{}, std::move(__st.__state_), std::forward<_Cb>(__cb)) {}
+
+  _LIBCPP_HIDE_FROM_ABI ~stop_callback() {
+    if (__state_) {
+      __state_->__remove_callback(this);
+    }
+  }
+
+  stop_callback(const stop_callback&)            = delete;
+  stop_callback(stop_callback&&)                 = delete;
+  stop_callback& operator=(const stop_callback&) = delete;
+  stop_callback& operator=(stop_callback&&)      = delete;
+
+private:
+  _LIBCPP_NO_UNIQUE_ADDRESS _Callback __callback_;
+  __intrusive_shared_ptr<__stop_state> __state_;
+
+  friend __stop_callback_base;
+
+  struct __private_tag {};
+
+  template <class _StatePtr, class _Cb>
+  _LIBCPP_HIDE_FROM_ABI explicit stop_callback(__private_tag, _StatePtr&& __state, _Cb&& __cb) noexcept(
+      is_nothrow_constructible_v<_Callback, _Cb>)
+      : __stop_callback_base([](__stop_callback_base* __cb_base) noexcept {
+          // stop callback is supposed to only be called once
+          std::forward<_Callback>(static_cast<stop_callback*>(__cb_base)->__callback_)();
+        }),
+        __callback_(std::forward<_Cb>(__cb)),
+        __state_() {
+    if (__state && __state->__add_callback(this)) {
+      // st.stop_requested() was false and this is successfully added to the linked list
+      __state_ = std::forward<_StatePtr>(__state);
+    }
+  }
+};
+
+template <class Callback>
+stop_callback(stop_token, Callback) -> stop_callback<Callback>;
+
+#endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___STOP_TOKEN_STOP_TOKEN_H

libcxx/include/__stop_token/stop_source.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___STOP_TOKEN_STOP_SOURCE_H
+#define _LIBCPP___STOP_TOKEN_STOP_SOURCE_H
+
+#include <__availability>
+#include <__config>
+#include <__stop_token/intrusive_shared_ptr.h>
+#include <__stop_token/stop_state.h>
+#include <__stop_token/stop_token.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 20
+
+struct nostopstate_t {
+  explicit nostopstate_t() = default;
+};
+
+inline constexpr nostopstate_t nostopstate{};
+
+class _LIBCPP_AVAILABILITY_SYNC stop_source {
+public:
+  _LIBCPP_HIDE_FROM_ABI stop_source() : __state_(new __stop_state()) { __state_->__increment_stop_source_counter(); }
+
+  _LIBCPP_HIDE_FROM_ABI explicit stop_source(nostopstate_t) noexcept : __state_(nullptr) {}
+
+  _LIBCPP_HIDE_FROM_ABI stop_source(const stop_source& __other) noexcept : __state_(__other.__state_) {
+    if (__state_) {
+      __state_->__increment_stop_source_counter();
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI stop_source(stop_source&& __other) noexcept = default;
+
+  _LIBCPP_HIDE_FROM_ABI stop_source& operator=(const stop_source& __other) noexcept {
+    // increment `__other` first so that we don't hit 0 in case of self-assignment
+    if (__other.__state_) {
+      __other.__state_->__increment_stop_source_counter();
+    }
+    if (__state_) {
+      __state_->__decrement_stop_source_counter();
+    }
+    __state_ = __other.__state_;
+    return *this;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI stop_source& operator=(stop_source&&) noexcept = default;
+
+  _LIBCPP_HIDE_FROM_ABI ~stop_source() {
+    if (__state_) {
+      __state_->__decrement_stop_source_counter();
+    }
+  }
+
+  _LIBCPP_HIDE_FROM_ABI void swap(stop_source& __other) noexcept { __state_.swap(__other.__state_); }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI stop_token get_token() const noexcept { return stop_token(__state_); }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool stop_possible() const noexcept { return __state_ != nullptr; }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool stop_requested() const noexcept {
+    return __state_ != nullptr && __state_->__stop_requested();
+  }
+
+  _LIBCPP_HIDE_FROM_ABI bool request_stop() noexcept { return __state_ && __state_->__request_stop(); }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI friend bool operator==(const stop_source&, const stop_source&) noexcept = default;
+
+  _LIBCPP_HIDE_FROM_ABI friend void swap(stop_source& __lhs, stop_source& __rhs) noexcept { __lhs.swap(__rhs); }
+
+private:
+  __intrusive_shared_ptr<__stop_state> __state_;
+};
+
+#endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___STOP_TOKEN_STOP_SOURCE_H

libcxx/include/__stop_token/stop_state.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___STOP_TOKEN_STOP_STATE_H
+#define _LIBCPP___STOP_TOKEN_STOP_STATE_H
+
+#include <__availability>
+#include <__config>
+#include <__stop_token/atomic_unique_lock.h>
+#include <__stop_token/intrusive_list_view.h>
+#include <atomic>
+#include <thread>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 20
+
+struct __stop_callback_base : __intrusive_node_base<__stop_callback_base> {
+  using __callback_fn_t = void(__stop_callback_base*) noexcept;
+  _LIBCPP_HIDE_FROM_ABI explicit __stop_callback_base(__callback_fn_t* __callback_fn) : __callback_fn_(__callback_fn) {}
+
+  _LIBCPP_HIDE_FROM_ABI void __invoke() noexcept { __callback_fn_(this); }
+
+  __callback_fn_t* __callback_fn_;
+  atomic<bool> __completed_ = false;
+  bool* __destroyed_        = nullptr;
+};
+
+class _LIBCPP_AVAILABILITY_SYNC __stop_state {
+  static constexpr uint32_t __stop_requested_bit        = 1;
+  static constexpr uint32_t __callback_list_locked_bit  = 1 << 1;
+  static constexpr uint32_t __stop_source_counter_shift = 2;
+
+  // The "stop_source counter" is not used for lifetime reference counting.
+  // When the number of stop_source reaches 0, the remaining stop_tokens's
+  // stop_possible will return false. We need this counter to track this.
+  //
+  // The "callback list locked" bit implements the atomic_unique_lock to
+  // guard the operations on the callback list
+  //
+  //       31 - 2          |  1                   |    0           |
+  //  stop_source counter  | callback list locked | stop_requested |
+  atomic<uint32_t> __state_ = 0;
+
+  // Reference count for stop_token + stop_callback + stop_source
+  // When the counter reaches zero, the state is destroyed
+  // It is used by __intrusive_shared_ptr, but it is stored here for better layout
+  atomic<uint32_t> __ref_count_ = 0;
+
+  using __state_t            = uint32_t;
+  using __callback_list_lock = __atomic_unique_lock<__state_t, __callback_list_locked_bit>;
+  using __callback_list      = __intrusive_list_view<__stop_callback_base>;
+
+  __callback_list __callback_list_;
+  thread::id __requesting_thread_;
+
+public:
+  _LIBCPP_HIDE_FROM_ABI __stop_state() noexcept = default;
+
+  _LIBCPP_HIDE_FROM_ABI void __increment_stop_source_counter() noexcept {
+    _LIBCPP_ASSERT(
+        __state_.load(std::memory_order_relaxed) <= static_cast<__state_t>(~(1 << __stop_source_counter_shift)),
+        "stop_source's counter reaches the maximum. Incrementing the counter will overflow");
+    __state_.fetch_add(1 << __stop_source_counter_shift, std::memory_order_relaxed);
+  }
+
+  // We are not destroying the object after counter decrements to zero, nor do we have
+  // operations depend on the ordering of decrementing the counter. relaxed is enough.
+  _LIBCPP_HIDE_FROM_ABI void __decrement_stop_source_counter() noexcept {
+    _LIBCPP_ASSERT(__state_.load(std::memory_order_relaxed) >= static_cast<__state_t>(1 << __stop_source_counter_shift),
+                   "stop_source's counter is 0. Decrementing the counter will underflow");
+    __state_.fetch_sub(1 << __stop_source_counter_shift, std::memory_order_relaxed);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI bool __stop_requested() const noexcept {
+    // acquire because [thread.stoptoken.intro] A call to request_stop that returns true
+    // synchronizes with a call to stop_requested on an associated stop_token or stop_source
+    // object that returns true.
+    // request_stop's compare_exchange_weak has release which syncs with this acquire
+    return (__state_.load(std::memory_order_acquire) & __stop_requested_bit) != 0;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI bool __stop_possible_for_stop_token() const noexcept {
+    // [stoptoken.mem] false if "a stop request was not made and there are no associated stop_source objects"
+    // Todo: Can this be std::memory_order_relaxed as the standard does not say anything except not to introduce data
+    // race?
+    __state_t __curent_state = __state_.load(std::memory_order_acquire);
+    return ((__curent_state & __stop_requested_bit) != 0) || ((__curent_state >> __stop_source_counter_shift) != 0);
+  }
+
+  _LIBCPP_HIDE_FROM_ABI bool __request_stop() noexcept {
+    auto __cb_list_lock = __try_lock_for_request_stop();
+    if (!__cb_list_lock.__owns_lock()) {
+      return false;
+    }
+    __requesting_thread_ = this_thread::get_id();
+
+    while (!__callback_list_.__empty()) {
+      auto __cb = __callback_list_.__pop_front();
+
+      // allow other callbacks to be removed while invoking the current callback
+      __cb_list_lock.__unlock();
+
+      bool __destroyed   = false;
+      __cb->__destroyed_ = &__destroyed;
+
+      __cb->__invoke();
+
+      // __cb's invoke function could potentially delete itself. We need to check before accessing __cb's member
+      if (!__destroyed) {
+        // needs to set __destroyed_ pointer to nullptr, otherwise it points to a local variable
+        // which is to be destroyed at the end of the loop
+        __cb->__destroyed_ = nullptr;
+
+        // [stopcallback.cons] If callback is concurrently executing on another thread, then the return
+        // from the invocation of callback strongly happens before ([intro.races]) callback is destroyed.
+        // this release syncs with the acquire in the remove_callback
+        __cb->__completed_.store(true, std::memory_order_release);
+        __cb->__completed_.notify_all();
+      }
+
+      __cb_list_lock.__lock();
+    }
+
+    return true;
+  }
+
+  _LIBCPP_HIDE_FROM_ABI bool __add_callback(__stop_callback_base* __cb) noexcept {
+    // If it is already stop_requested. Do not try to request it again.
+    const auto __give_up_trying_to_lock_condition = [__cb](__state_t __state) {
+      if ((__state & __stop_requested_bit) != 0) {
+        // already stop requested, synchronously run the callback and no need to lock the list again
+        __cb->__invoke();
+        return true;
+      }
+      // no stop source. no need to lock the list to add the callback as it can never be invoked
+      return (__state >> __stop_source_counter_shift) == 0;
+    };
+
+    __callback_list_lock __cb_list_lock(__state_, __give_up_trying_to_lock_condition);
+
+    if (!__cb_list_lock.__owns_lock()) {
+      return false;
+    }
+
+    __callback_list_.__push_front(__cb);
+
+    return true;
+    // unlock here: [thread.stoptoken.intro] Registration of a callback synchronizes with the invocation of
+    // that callback.
+    // Note: this release sync with the acquire in the request_stop' __try_lock_for_request_stop
+  }
+
+  // called by the destructor of stop_callback
+  _LIBCPP_HIDE_FROM_ABI void __remove_callback(__stop_callback_base* __cb) noexcept {
+    __callback_list_lock __cb_list_lock(__state_);
+
+    // under below condition, the request_stop call just popped __cb from the list and could execute it now
+    bool __potentially_executing_now = __cb->__prev_ == nullptr && !__callback_list_.__is_head(__cb);
+
+    if (__potentially_executing_now) {
+      auto __requested_thread = __requesting_thread_;
+      __cb_list_lock.__unlock();
+
+      if (std::this_thread::get_id() != __requested_thread) {
+        // [stopcallback.cons] If callback is concurrently executing on another thread, then the return
+        // from the invocation of callback strongly happens before ([intro.races]) callback is destroyed.
+        __cb->__completed_.wait(false, std::memory_order_acquire);
+      } else {
+        // The destructor of stop_callback runs on the same thread of the thread that invokes the callback.
+        // The callback is potentially invoking its own destuctor. Set the flag to avoid accessing destroyed
+        // members on the invoking side
+        if (__cb->__destroyed_) {
+          *__cb->__destroyed_ = true;
+        }
+      }
+    } else {
+      __callback_list_.__remove(__cb);
+    }
+  }
+
+private:
+  _LIBCPP_HIDE_FROM_ABI __callback_list_lock __try_lock_for_request_stop() noexcept {
+    // If it is already stop_requested, do not try to request stop or lock the list again.
+    const auto __lock_fail_condition = [](__state_t __state) { return (__state & __stop_requested_bit) != 0; };
+
+    // set locked and requested bit at the same time
+    const auto __after_lock_state = [](__state_t __state) {
+      return __state | __callback_list_locked_bit | __stop_requested_bit;
+    };
+
+    // acq because [thread.stoptoken.intro] Registration of a callback synchronizes with the invocation of that
+    //     callback. We are going to invoke the callback after getting the lock, acquire so that we can see the
+    //     registration of a callback (and other writes that happens-before the add_callback)
+    //     Note: the rel (unlock) in the add_callback syncs with this acq
+    // rel because [thread.stoptoken.intro] A call to request_stop that returns true synchronizes with a call
+    //     to stop_requested on an associated stop_token or stop_source object that returns true.
+    //     We need to make sure that all writes (including user code) before request_stop will be made visible
+    //     to the threads that waiting for `stop_requested == true`
+    //     Note: this rel syncs with the acq in `stop_requested`
+    const auto __locked_ordering = std::memory_order_acq_rel;
+
+    return __callback_list_lock(__state_, __lock_fail_condition, __after_lock_state, __locked_ordering);
+  }
+
+  template <class _Tp>
+  friend struct __intrusive_shared_ptr_traits;
+};
+
+template <class _Tp>
+struct __intrusive_shared_ptr_traits;
+
+template <>
+struct __intrusive_shared_ptr_traits<__stop_state> {
+  _LIBCPP_HIDE_FROM_ABI static atomic<uint32_t>& __get_atomic_ref_count(__stop_state& __state) {
+    return __state.__ref_count_;
+  }
+};
+
+#endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___STOP_TOKEN_STOP_STATE_H

libcxx/include/__stop_token/stop_token.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP___STOP_TOKEN_STOP_TOKEN_H
+#define _LIBCPP___STOP_TOKEN_STOP_TOKEN_H
+
+#include <__availability>
+#include <__config>
+#include <__stop_token/intrusive_shared_ptr.h>
+#include <__stop_token/stop_state.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 20
+
+class _LIBCPP_AVAILABILITY_SYNC stop_token {
+public:
+  _LIBCPP_HIDE_FROM_ABI stop_token() noexcept = default;
+
+  _LIBCPP_HIDE_FROM_ABI stop_token(const stop_token&) noexcept            = default;
+  _LIBCPP_HIDE_FROM_ABI stop_token(stop_token&&) noexcept                 = default;
+  _LIBCPP_HIDE_FROM_ABI stop_token& operator=(const stop_token&) noexcept = default;
+  _LIBCPP_HIDE_FROM_ABI stop_token& operator=(stop_token&&) noexcept      = default;
+  _LIBCPP_HIDE_FROM_ABI ~stop_token()                                     = default;
+
+  _LIBCPP_HIDE_FROM_ABI void swap(stop_token& __other) noexcept { __state_.swap(__other.__state_); }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool stop_requested() const noexcept {
+    return __state_ != nullptr && __state_->__stop_requested();
+  }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool stop_possible() const noexcept {
+    return __state_ != nullptr && __state_->__stop_possible_for_stop_token();
+  }
+
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI friend bool operator==(const stop_token&, const stop_token&) noexcept = default;
+
+  _LIBCPP_HIDE_FROM_ABI friend void swap(stop_token& __lhs, stop_token& __rhs) noexcept { __lhs.swap(__rhs); }
+
+private:
+  __intrusive_shared_ptr<__stop_state> __state_;
+
+  friend class stop_source;
+  template <class _Tp>
+  friend class stop_callback;
+
+  _LIBCPP_HIDE_FROM_ABI explicit stop_token(const __intrusive_shared_ptr<__stop_state>& __state) : __state_(__state) {}
+};
+
+#endif // _LIBCPP_STD_VER >= 20
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP___STOP_TOKEN_STOP_TOKEN_H

libcxx/include/module.modulemap.in

module stack {
     export initializer_list
     export *
   }
   module stdexcept {
     header "stdexcept"
     export *
   }
   module stop_token {
+    @requires_LIBCXX_ENABLE_THREADS@
+    header "stop_token"
     export *
     module __stop_token {
       module atomic_unique_lock   { private header "__stop_token/atomic_unique_lock.h" }
       module intrusive_list_view  { private header "__stop_token/intrusive_list_view.h" }
       module intrusive_shared_ptr { private header "__stop_token/intrusive_shared_ptr.h" }
+      module stop_callback        { private header "__stop_token/stop_callback.h" }
+      module stop_source          { private header "__stop_token/stop_source.h" }
+      module stop_state           { private header "__stop_token/stop_state.h" }
+      module stop_token           { private header "__stop_token/stop_token.h" }
     }
   }
   module streambuf {
     @requires_LIBCXX_ENABLE_LOCALIZATION@
     header "streambuf"
     export *
   }
   module string {

libcxx/include/stop_token

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_STOP_TOKEN
+#define _LIBCPP_STOP_TOKEN
+
+/*
+
+namespace std {
+  // [stoptoken], class stop_token
+  class stop_token;
+
+  // [stopsource], class stop_source
+  class stop_source;
+
+  // no-shared-stop-state indicator
+  struct nostopstate_t {
+    explicit nostopstate_t() = default;
+  };
+  inline constexpr nostopstate_t nostopstate{};
+
+  // [stopcallback], class template stop_callback
+  template<class Callback>
+    class stop_callback;
+
+*/
+
+#include <__assert> // all public C++ headers provide the assertion handler
+#include <__config>
+#include <__stop_token/stop_callback.h>
+#include <__stop_token/stop_source.h>
+#include <__stop_token/stop_token.h>
+#include <version>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#ifdef _LIBCPP_HAS_NO_THREADS
+#  error "<stop_token> is not supported since libc++ has been configured without support for threads."
+#endif
+
+#endif // _LIBCPP_STOP_TOKEN

libcxx/test/libcxx/clang_tidy.sh.cpp

 #   include <stdatomic.h>
 #endif
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdexcept>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
+#if !defined(_LIBCPP_HAS_NO_THREADS)
+#   include <stop_token>
+#endif
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   include <streambuf>
 #endif
 #include <string>
 #include <string.h>
 #include <string_view>
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   include <strstream>

libcxx/test/libcxx/double_include.sh.cpp

 #   include <stdatomic.h>
 #endif
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdexcept>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
+#if !defined(_LIBCPP_HAS_NO_THREADS)
+#   include <stop_token>
+#endif
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   include <streambuf>
 #endif
 #include <string>
 #include <string.h>
 #include <string_view>
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   include <strstream>

libcxx/test/libcxx/min_max_macros.compile.pass.cpp

 #include <stdexcept>
 TEST_MACROS();
 #include <stdint.h>
 TEST_MACROS();
 #include <stdio.h>
 TEST_MACROS();
 #include <stdlib.h>
 TEST_MACROS();
+#if !defined(_LIBCPP_HAS_NO_THREADS)
+#   include <stop_token>
+TEST_MACROS();
+#endif
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   include <streambuf>
 TEST_MACROS();
 #endif
 #include <string>
 TEST_MACROS();
 #include <string.h>
 TEST_MACROS();

libcxx/test/libcxx/modules_include.sh.cpp

 // RUN: echo 'TEST_100=$!' >> %t.sh
 // RUN: echo "wait $TEST_84" >> %t.sh
 #if defined(TEST_100)
 #include <stdlib.h>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_101 &' >> %t.sh
 // RUN: echo 'TEST_101=$!' >> %t.sh
 // RUN: echo "wait $TEST_85" >> %t.sh
-#if defined(TEST_101) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-#include <streambuf>
+#if defined(TEST_101) && !defined(_LIBCPP_HAS_NO_THREADS)
+#include <stop_token>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_102 &' >> %t.sh
 // RUN: echo 'TEST_102=$!' >> %t.sh
 // RUN: echo "wait $TEST_86" >> %t.sh
-#if defined(TEST_102)
-#include <string>
+#if defined(TEST_102) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#include <streambuf>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_103 &' >> %t.sh
 // RUN: echo 'TEST_103=$!' >> %t.sh
 // RUN: echo "wait $TEST_87" >> %t.sh
 #if defined(TEST_103)
-#include <string.h>
+#include <string>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_104 &' >> %t.sh
 // RUN: echo 'TEST_104=$!' >> %t.sh
 // RUN: echo "wait $TEST_88" >> %t.sh
 #if defined(TEST_104)
-#include <string_view>
+#include <string.h>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_105 &' >> %t.sh
 // RUN: echo 'TEST_105=$!' >> %t.sh
 // RUN: echo "wait $TEST_89" >> %t.sh
-#if defined(TEST_105) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-#include <strstream>
+#if defined(TEST_105)
+#include <string_view>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_106 &' >> %t.sh
 // RUN: echo 'TEST_106=$!' >> %t.sh
 // RUN: echo "wait $TEST_90" >> %t.sh
-#if defined(TEST_106)
-#include <system_error>
+#if defined(TEST_106) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#include <strstream>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_107 &' >> %t.sh
 // RUN: echo 'TEST_107=$!' >> %t.sh
 // RUN: echo "wait $TEST_91" >> %t.sh
 #if defined(TEST_107)
-#include <tgmath.h>
+#include <system_error>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_108 &' >> %t.sh
 // RUN: echo 'TEST_108=$!' >> %t.sh
 // RUN: echo "wait $TEST_92" >> %t.sh
-#if defined(TEST_108) && !defined(_LIBCPP_HAS_NO_THREADS)
-#include <thread>
+#if defined(TEST_108)
+#include <tgmath.h>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_109 &' >> %t.sh
 // RUN: echo 'TEST_109=$!' >> %t.sh
 // RUN: echo "wait $TEST_93" >> %t.sh
-#if defined(TEST_109)
-#include <tuple>
+#if defined(TEST_109) && !defined(_LIBCPP_HAS_NO_THREADS)
+#include <thread>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_110 &' >> %t.sh
 // RUN: echo 'TEST_110=$!' >> %t.sh
 // RUN: echo "wait $TEST_94" >> %t.sh
 #if defined(TEST_110)
-#include <type_traits>
+#include <tuple>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_111 &' >> %t.sh
 // RUN: echo 'TEST_111=$!' >> %t.sh
 // RUN: echo "wait $TEST_95" >> %t.sh
 #if defined(TEST_111)
-#include <typeindex>
+#include <type_traits>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_112 &' >> %t.sh
 // RUN: echo 'TEST_112=$!' >> %t.sh
 // RUN: echo "wait $TEST_96" >> %t.sh
 #if defined(TEST_112)
-#include <typeinfo>
+#include <typeindex>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_113 &' >> %t.sh
 // RUN: echo 'TEST_113=$!' >> %t.sh
 // RUN: echo "wait $TEST_97" >> %t.sh
 #if defined(TEST_113)
-#include <uchar.h>
+#include <typeinfo>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_114 &' >> %t.sh
 // RUN: echo 'TEST_114=$!' >> %t.sh
 // RUN: echo "wait $TEST_98" >> %t.sh
 #if defined(TEST_114)
-#include <unordered_map>
+#include <uchar.h>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_115 &' >> %t.sh
 // RUN: echo 'TEST_115=$!' >> %t.sh
 // RUN: echo "wait $TEST_99" >> %t.sh
 #if defined(TEST_115)
-#include <unordered_set>
+#include <unordered_map>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_116 &' >> %t.sh
 // RUN: echo 'TEST_116=$!' >> %t.sh
 // RUN: echo "wait $TEST_100" >> %t.sh
 #if defined(TEST_116)
-#include <utility>
+#include <unordered_set>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_117 &' >> %t.sh
 // RUN: echo 'TEST_117=$!' >> %t.sh
 // RUN: echo "wait $TEST_101" >> %t.sh
 #if defined(TEST_117)
-#include <valarray>
+#include <utility>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_118 &' >> %t.sh
 // RUN: echo 'TEST_118=$!' >> %t.sh
 // RUN: echo "wait $TEST_102" >> %t.sh
 #if defined(TEST_118)
-#include <variant>
+#include <valarray>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_119 &' >> %t.sh
 // RUN: echo 'TEST_119=$!' >> %t.sh
 // RUN: echo "wait $TEST_103" >> %t.sh
 #if defined(TEST_119)
-#include <vector>
+#include <variant>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_120 &' >> %t.sh
 // RUN: echo 'TEST_120=$!' >> %t.sh
 // RUN: echo "wait $TEST_104" >> %t.sh
 #if defined(TEST_120)
-#include <version>
+#include <vector>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_121 &' >> %t.sh
 // RUN: echo 'TEST_121=$!' >> %t.sh
 // RUN: echo "wait $TEST_105" >> %t.sh
-#if defined(TEST_121) && !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
-#include <wchar.h>
+#if defined(TEST_121)
+#include <version>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_122 &' >> %t.sh
 // RUN: echo 'TEST_122=$!' >> %t.sh
 // RUN: echo "wait $TEST_106" >> %t.sh
 #if defined(TEST_122) && !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
-#include <wctype.h>
+#include <wchar.h>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_123 &' >> %t.sh
 // RUN: echo 'TEST_123=$!' >> %t.sh
 // RUN: echo "wait $TEST_107" >> %t.sh
-#if defined(TEST_123) && __cplusplus >= 201103L
-#include <experimental/deque>
+#if defined(TEST_123) && !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
+#include <wctype.h>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_124 &' >> %t.sh
 // RUN: echo 'TEST_124=$!' >> %t.sh
 // RUN: echo "wait $TEST_108" >> %t.sh
 #if defined(TEST_124) && __cplusplus >= 201103L
-#include <experimental/forward_list>
+#include <experimental/deque>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_125 &' >> %t.sh
 // RUN: echo 'TEST_125=$!' >> %t.sh
 // RUN: echo "wait $TEST_109" >> %t.sh
 #if defined(TEST_125) && __cplusplus >= 201103L
-#include <experimental/iterator>
+#include <experimental/forward_list>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_126 &' >> %t.sh
 // RUN: echo 'TEST_126=$!' >> %t.sh
 // RUN: echo "wait $TEST_110" >> %t.sh
 #if defined(TEST_126) && __cplusplus >= 201103L
-#include <experimental/list>
+#include <experimental/iterator>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_127 &' >> %t.sh
 // RUN: echo 'TEST_127=$!' >> %t.sh
 // RUN: echo "wait $TEST_111" >> %t.sh
 #if defined(TEST_127) && __cplusplus >= 201103L
-#include <experimental/map>
+#include <experimental/list>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_128 &' >> %t.sh
 // RUN: echo 'TEST_128=$!' >> %t.sh
 // RUN: echo "wait $TEST_112" >> %t.sh
 #if defined(TEST_128) && __cplusplus >= 201103L
-#include <experimental/memory_resource>
+#include <experimental/map>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_129 &' >> %t.sh
 // RUN: echo 'TEST_129=$!' >> %t.sh
 // RUN: echo "wait $TEST_113" >> %t.sh
 #if defined(TEST_129) && __cplusplus >= 201103L
-#include <experimental/propagate_const>
+#include <experimental/memory_resource>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_130 &' >> %t.sh
 // RUN: echo 'TEST_130=$!' >> %t.sh
 // RUN: echo "wait $TEST_114" >> %t.sh
-#if defined(TEST_130) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) && __cplusplus >= 201103L
-#include <experimental/regex>
+#if defined(TEST_130) && __cplusplus >= 201103L
+#include <experimental/propagate_const>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_131 &' >> %t.sh
 // RUN: echo 'TEST_131=$!' >> %t.sh
 // RUN: echo "wait $TEST_115" >> %t.sh
-#if defined(TEST_131) && __cplusplus >= 201103L
-#include <experimental/set>
+#if defined(TEST_131) && !defined(_LIBCPP_HAS_NO_LOCALIZATION) && __cplusplus >= 201103L
+#include <experimental/regex>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_132 &' >> %t.sh
 // RUN: echo 'TEST_132=$!' >> %t.sh
 // RUN: echo "wait $TEST_116" >> %t.sh
 #if defined(TEST_132) && __cplusplus >= 201103L
-#include <experimental/simd>
+#include <experimental/set>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_133 &' >> %t.sh
 // RUN: echo 'TEST_133=$!' >> %t.sh
 // RUN: echo "wait $TEST_117" >> %t.sh
 #if defined(TEST_133) && __cplusplus >= 201103L
-#include <experimental/string>
+#include <experimental/simd>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_134 &' >> %t.sh
 // RUN: echo 'TEST_134=$!' >> %t.sh
 // RUN: echo "wait $TEST_118" >> %t.sh
 #if defined(TEST_134) && __cplusplus >= 201103L
-#include <experimental/type_traits>
+#include <experimental/string>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_135 &' >> %t.sh
 // RUN: echo 'TEST_135=$!' >> %t.sh
 // RUN: echo "wait $TEST_119" >> %t.sh
 #if defined(TEST_135) && __cplusplus >= 201103L
-#include <experimental/unordered_map>
+#include <experimental/type_traits>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_136 &' >> %t.sh
 // RUN: echo 'TEST_136=$!' >> %t.sh
 // RUN: echo "wait $TEST_120" >> %t.sh
 #if defined(TEST_136) && __cplusplus >= 201103L
-#include <experimental/unordered_set>
+#include <experimental/unordered_map>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_137 &' >> %t.sh
 // RUN: echo 'TEST_137=$!' >> %t.sh
 // RUN: echo "wait $TEST_121" >> %t.sh
 #if defined(TEST_137) && __cplusplus >= 201103L
-#include <experimental/utility>
+#include <experimental/unordered_set>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_138 &' >> %t.sh
 // RUN: echo 'TEST_138=$!' >> %t.sh
 // RUN: echo "wait $TEST_122" >> %t.sh
 #if defined(TEST_138) && __cplusplus >= 201103L
-#include <experimental/vector>
+#include <experimental/utility>
 #endif
+// RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_139 &' >> %t.sh
+// RUN: echo 'TEST_139=$!' >> %t.sh
 // RUN: echo "wait $TEST_123" >> %t.sh
+#if defined(TEST_139) && __cplusplus >= 201103L
+#include <experimental/vector>
+#endif
 // RUN: echo "wait $TEST_124" >> %t.sh
 // RUN: echo "wait $TEST_125" >> %t.sh
 // RUN: echo "wait $TEST_126" >> %t.sh
 // RUN: echo "wait $TEST_127" >> %t.sh
 // RUN: echo "wait $TEST_128" >> %t.sh
 // RUN: echo "wait $TEST_129" >> %t.sh
 // RUN: echo "wait $TEST_130" >> %t.sh
 // RUN: echo "wait $TEST_131" >> %t.sh
 // RUN: echo "wait $TEST_132" >> %t.sh
 // RUN: echo "wait $TEST_133" >> %t.sh
 // RUN: echo "wait $TEST_134" >> %t.sh
 // RUN: echo "wait $TEST_135" >> %t.sh
 // RUN: echo "wait $TEST_136" >> %t.sh
 // RUN: echo "wait $TEST_137" >> %t.sh
 // RUN: echo "wait $TEST_138" >> %t.sh
+// RUN: echo "wait $TEST_139" >> %t.sh
 // RUN: bash %t.sh
 // GENERATED-MARKER

libcxx/test/libcxx/nasty_macros.compile.pass.cpp

 #   include <stdatomic.h>
 #endif
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdexcept>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
+#if !defined(_LIBCPP_HAS_NO_THREADS)
+#   include <stop_token>
+#endif
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   include <streambuf>
 #endif
 #include <string>
 #include <string.h>
 #include <string_view>
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   include <strstream>

libcxx/test/libcxx/no_assert_include.compile.pass.cpp

 #   include <stdatomic.h>
 #endif
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdexcept>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
+#if !defined(_LIBCPP_HAS_NO_THREADS)
+#   include <stop_token>
+#endif
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   include <streambuf>
 #endif
 #include <string>
 #include <string.h>
 #include <string_view>
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   include <strstream>

libcxx/test/libcxx/private_headers.verify.cpp

 #include <__ranges/view_interface.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/view_interface.h'}}
 #include <__ranges/views.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/views.h'}}
 #include <__ranges/zip_view.h> // expected-error@*:* {{use of private header from outside its module: '__ranges/zip_view.h'}}
 #include <__split_buffer> // expected-error@*:* {{use of private header from outside its module: '__split_buffer'}}
 #include <__std_mbstate_t.h> // expected-error@*:* {{use of private header from outside its module: '__std_mbstate_t.h'}}
 #include <__stop_token/atomic_unique_lock.h> // expected-error@*:* {{use of private header from outside its module: '__stop_token/atomic_unique_lock.h'}}
 #include <__stop_token/intrusive_list_view.h> // expected-error@*:* {{use of private header from outside its module: '__stop_token/intrusive_list_view.h'}}
 #include <__stop_token/intrusive_shared_ptr.h> // expected-error@*:* {{use of private header from outside its module: '__stop_token/intrusive_shared_ptr.h'}}
+#include <__stop_token/stop_callback.h> // expected-error@*:* {{use of private header from outside its module: '__stop_token/stop_callback.h'}}
+#include <__stop_token/stop_source.h> // expected-error@*:* {{use of private header from outside its module: '__stop_token/stop_source.h'}}
+#include <__stop_token/stop_state.h> // expected-error@*:* {{use of private header from outside its module: '__stop_token/stop_state.h'}}
+#include <__stop_token/stop_token.h> // expected-error@*:* {{use of private header from outside its module: '__stop_token/stop_token.h'}}
 #include <__string/char_traits.h> // expected-error@*:* {{use of private header from outside its module: '__string/char_traits.h'}}
 #include <__string/constexpr_c_functions.h> // expected-error@*:* {{use of private header from outside its module: '__string/constexpr_c_functions.h'}}
 #include <__string/extern_template_lists.h> // expected-error@*:* {{use of private header from outside its module: '__string/extern_template_lists.h'}}
 #include <__system_error/errc.h> // expected-error@*:* {{use of private header from outside its module: '__system_error/errc.h'}}
 #include <__system_error/error_category.h> // expected-error@*:* {{use of private header from outside its module: '__system_error/error_category.h'}}
 #include <__system_error/error_code.h> // expected-error@*:* {{use of private header from outside its module: '__system_error/error_code.h'}}
 #include <__system_error/error_condition.h> // expected-error@*:* {{use of private header from outside its module: '__system_error/error_condition.h'}}
 #include <__system_error/system_error.h> // expected-error@*:* {{use of private header from outside its module: '__system_error/system_error.h'}}

libcxx/test/libcxx/transitive_includes.sh.cpp

 // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_93 > /dev/null 2> %t/header.stack
 #if defined(TEST_93)
 #include <stack>
 #endif
 // RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_97 > /dev/null 2> %t/header.stdexcept
 #if defined(TEST_97)
 #include <stdexcept>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_101 > /dev/null 2> %t/header.streambuf
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_101 > /dev/null 2> %t/header.stop_token
 #if defined(TEST_101)
-#include <streambuf>
+#include <stop_token>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_102 > /dev/null 2> %t/header.string
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_102 > /dev/null 2> %t/header.streambuf
 #if defined(TEST_102)
+#include <streambuf>
+#endif
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_103 > /dev/null 2> %t/header.string
+#if defined(TEST_103)
 #include <string>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_104 > /dev/null 2> %t/header.string_view
-#if defined(TEST_104)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_105 > /dev/null 2> %t/header.string_view
+#if defined(TEST_105)
 #include <string_view>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_105 > /dev/null 2> %t/header.strstream
-#if defined(TEST_105)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_106 > /dev/null 2> %t/header.strstream
+#if defined(TEST_106)
 #include <strstream>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_106 > /dev/null 2> %t/header.system_error
-#if defined(TEST_106)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_107 > /dev/null 2> %t/header.system_error
+#if defined(TEST_107)
 #include <system_error>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_108 > /dev/null 2> %t/header.thread
-#if defined(TEST_108)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_109 > /dev/null 2> %t/header.thread
+#if defined(TEST_109)
 #include <thread>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_109 > /dev/null 2> %t/header.tuple
-#if defined(TEST_109)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_110 > /dev/null 2> %t/header.tuple
+#if defined(TEST_110)
 #include <tuple>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_110 > /dev/null 2> %t/header.type_traits
-#if defined(TEST_110)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_111 > /dev/null 2> %t/header.type_traits
+#if defined(TEST_111)
 #include <type_traits>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_111 > /dev/null 2> %t/header.typeindex
-#if defined(TEST_111)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_112 > /dev/null 2> %t/header.typeindex
+#if defined(TEST_112)
 #include <typeindex>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_112 > /dev/null 2> %t/header.typeinfo
-#if defined(TEST_112)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_113 > /dev/null 2> %t/header.typeinfo
+#if defined(TEST_113)
 #include <typeinfo>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_114 > /dev/null 2> %t/header.unordered_map
-#if defined(TEST_114)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_115 > /dev/null 2> %t/header.unordered_map
+#if defined(TEST_115)
 #include <unordered_map>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_115 > /dev/null 2> %t/header.unordered_set
-#if defined(TEST_115)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_116 > /dev/null 2> %t/header.unordered_set
+#if defined(TEST_116)
 #include <unordered_set>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_116 > /dev/null 2> %t/header.utility
-#if defined(TEST_116)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_117 > /dev/null 2> %t/header.utility
+#if defined(TEST_117)
 #include <utility>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_117 > /dev/null 2> %t/header.valarray
-#if defined(TEST_117)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_118 > /dev/null 2> %t/header.valarray
+#if defined(TEST_118)
 #include <valarray>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_118 > /dev/null 2> %t/header.variant
-#if defined(TEST_118)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_119 > /dev/null 2> %t/header.variant
+#if defined(TEST_119)
 #include <variant>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_119 > /dev/null 2> %t/header.vector
-#if defined(TEST_119)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_120 > /dev/null 2> %t/header.vector
+#if defined(TEST_120)
 #include <vector>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_120 > /dev/null 2> %t/header.version
-#if defined(TEST_120)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_121 > /dev/null 2> %t/header.version
+#if defined(TEST_121)
 #include <version>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_123 > /dev/null 2> %t/header.experimental_deque
-#if defined(TEST_123)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_124 > /dev/null 2> %t/header.experimental_deque
+#if defined(TEST_124)
 #include <experimental/deque>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_124 > /dev/null 2> %t/header.experimental_forward_list
-#if defined(TEST_124)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_125 > /dev/null 2> %t/header.experimental_forward_list
+#if defined(TEST_125)
 #include <experimental/forward_list>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_125 > /dev/null 2> %t/header.experimental_iterator
-#if defined(TEST_125)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_126 > /dev/null 2> %t/header.experimental_iterator
+#if defined(TEST_126)
 #include <experimental/iterator>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_126 > /dev/null 2> %t/header.experimental_list
-#if defined(TEST_126)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_127 > /dev/null 2> %t/header.experimental_list
+#if defined(TEST_127)
 #include <experimental/list>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_127 > /dev/null 2> %t/header.experimental_map
-#if defined(TEST_127)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_128 > /dev/null 2> %t/header.experimental_map
+#if defined(TEST_128)
 #include <experimental/map>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_128 > /dev/null 2> %t/header.experimental_memory_resource
-#if defined(TEST_128)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_129 > /dev/null 2> %t/header.experimental_memory_resource
+#if defined(TEST_129)
 #include <experimental/memory_resource>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_129 > /dev/null 2> %t/header.experimental_propagate_const
-#if defined(TEST_129)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_130 > /dev/null 2> %t/header.experimental_propagate_const
+#if defined(TEST_130)
 #include <experimental/propagate_const>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_130 > /dev/null 2> %t/header.experimental_regex
-#if defined(TEST_130)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_131 > /dev/null 2> %t/header.experimental_regex
+#if defined(TEST_131)
 #include <experimental/regex>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_131 > /dev/null 2> %t/header.experimental_set
-#if defined(TEST_131)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_132 > /dev/null 2> %t/header.experimental_set
+#if defined(TEST_132)
 #include <experimental/set>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_132 > /dev/null 2> %t/header.experimental_simd
-#if defined(TEST_132)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_133 > /dev/null 2> %t/header.experimental_simd
+#if defined(TEST_133)
 #include <experimental/simd>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_133 > /dev/null 2> %t/header.experimental_string
-#if defined(TEST_133)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_134 > /dev/null 2> %t/header.experimental_string
+#if defined(TEST_134)
 #include <experimental/string>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_134 > /dev/null 2> %t/header.experimental_type_traits
-#if defined(TEST_134)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_135 > /dev/null 2> %t/header.experimental_type_traits
+#if defined(TEST_135)
 #include <experimental/type_traits>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_135 > /dev/null 2> %t/header.experimental_unordered_map
-#if defined(TEST_135)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_136 > /dev/null 2> %t/header.experimental_unordered_map
+#if defined(TEST_136)
 #include <experimental/unordered_map>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_136 > /dev/null 2> %t/header.experimental_unordered_set
-#if defined(TEST_136)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_137 > /dev/null 2> %t/header.experimental_unordered_set
+#if defined(TEST_137)
 #include <experimental/unordered_set>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_137 > /dev/null 2> %t/header.experimental_utility
-#if defined(TEST_137)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_138 > /dev/null 2> %t/header.experimental_utility
+#if defined(TEST_138)
 #include <experimental/utility>
 #endif
-// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_138 > /dev/null 2> %t/header.experimental_vector
-#if defined(TEST_138)
+// RUN: %{cxx} %s %{flags} %{compile_flags} --trace-includes -fshow-skipped-includes --preprocess -DTEST_139 > /dev/null 2> %t/header.experimental_vector
+#if defined(TEST_139)
 #include <experimental/vector>
 #endif
 // RUN: %{python} %S/transitive_includes_to_csv.py %t > %t/transitive_includes.csv
 // RUN: diff -w %S/transitive_includes/%{cxx_std}.csv %t/transitive_includes.csv
 // GENERATED-MARKER

libcxx/test/libcxx/transitive_includes/cxx03.csv

 stack deque
 stack functional
 stack initializer_list
 stack type_traits
 stack version
 stdexcept cstdlib
 stdexcept exception
 stdexcept iosfwd
+stop_token atomic
+stop_token cstddef
+stop_token limits
+stop_token thread
+stop_token version
 streambuf cstdint
 streambuf ios
 streambuf iosfwd
 streambuf version
 string algorithm
 string climits
 string compare
 string concepts

libcxx/test/libcxx/transitive_includes/cxx11.csv

 stack deque
 stack functional
 stack initializer_list
 stack type_traits
 stack version
 stdexcept cstdlib
 stdexcept exception
 stdexcept iosfwd
+stop_token atomic
+stop_token cstddef
+stop_token limits
+stop_token thread
+stop_token version
 streambuf cstdint
 streambuf ios
 streambuf iosfwd
 streambuf version
 string algorithm
 string climits
 string compare
 string concepts

libcxx/test/libcxx/transitive_includes/cxx14.csv

 stack deque
 stack functional
 stack initializer_list
 stack type_traits
 stack version
 stdexcept cstdlib
 stdexcept exception
 stdexcept iosfwd
+stop_token atomic
+stop_token cstddef
+stop_token limits
+stop_token thread
+stop_token version
 streambuf cstdint
 streambuf ios
 streambuf iosfwd
 streambuf version
 string algorithm
 string climits
 string compare
 string concepts

libcxx/test/libcxx/transitive_includes/cxx17.csv

 stack deque
 stack functional
 stack initializer_list
 stack type_traits
 stack version
 stdexcept cstdlib
 stdexcept exception
 stdexcept iosfwd
+stop_token atomic
+stop_token cstddef
+stop_token limits
+stop_token thread
+stop_token version
 streambuf cstdint
 streambuf ios
 streambuf iosfwd
 streambuf version
 string algorithm
 string climits
 string compare
 string concepts

libcxx/test/libcxx/transitive_includes/cxx20.csv

 stack deque
 stack functional
 stack initializer_list
 stack type_traits
 stack version
 stdexcept cstdlib
 stdexcept exception
 stdexcept iosfwd
+stop_token atomic
+stop_token cstddef
+stop_token limits
+stop_token thread
+stop_token version
 streambuf cstdint
 streambuf ios
 streambuf iosfwd
 streambuf version
 string algorithm
 string climits
 string compare
 string concepts

libcxx/test/libcxx/transitive_includes/cxx23.csv

 sstream string
 sstream version
 stack compare
 stack cstddef
 stack deque
 stack initializer_list
 stack version
 stdexcept iosfwd
+stop_token atomic
+stop_token cstddef
+stop_token limits
+stop_token thread
+stop_token version
 streambuf cstdint
 streambuf ios
 streambuf iosfwd
 streambuf version
 string climits
 string compare
 string cstddef
 string cstdint

libcxx/test/std/language.support/support.limits/support.limits.general/stop_token.version.compile.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
+//
+//===----------------------------------------------------------------------===//
+//
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
+//
+// clang-format off
+
+// UNSUPPORTED: no-threads
+
+// <stop_token>
+
+// Test the feature test macros defined by <stop_token>
+
+/*  Constant             Value
+    __cpp_lib_jthread    201911L [C++20]
+*/
+
+#include <stop_token>
+#include "test_macros.h"
+
+#if TEST_STD_VER < 14
+
+# ifdef __cpp_lib_jthread
+#   error "__cpp_lib_jthread should not be defined before c++20"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_jthread
+#   error "__cpp_lib_jthread should not be defined before c++20"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifdef __cpp_lib_jthread
+#   error "__cpp_lib_jthread should not be defined before c++20"
+# endif
+
+#elif TEST_STD_VER == 20
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_jthread
+#     error "__cpp_lib_jthread should be defined in c++20"
+#   endif
+#   if __cpp_lib_jthread != 201911L
+#     error "__cpp_lib_jthread should have the value 201911L in c++20"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_jthread
+#     error "__cpp_lib_jthread should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+#elif TEST_STD_VER == 23
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_jthread
+#     error "__cpp_lib_jthread should be defined in c++23"
+#   endif
+#   if __cpp_lib_jthread != 201911L
+#     error "__cpp_lib_jthread should have the value 201911L in c++23"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_jthread
+#     error "__cpp_lib_jthread should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+#elif TEST_STD_VER > 23
+
+# if !defined(_LIBCPP_VERSION)
+#   ifndef __cpp_lib_jthread
+#     error "__cpp_lib_jthread should be defined in c++26"
+#   endif
+#   if __cpp_lib_jthread != 201911L
+#     error "__cpp_lib_jthread should have the value 201911L in c++26"
+#   endif
+# else // _LIBCPP_VERSION
+#   ifdef __cpp_lib_jthread
+#     error "__cpp_lib_jthread should not be defined because it is unimplemented in libc++!"
+#   endif
+# endif
+
+#endif // TEST_STD_VER > 23
+

libcxx/test/std/thread/thread.stoptoken/nostopstate/cons.default.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: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// struct nostopstate_t {
+//   explicit nostopstate_t() = default;
+// };
+//
+// inline constexpr nostopstate_t nostopstate{};
+
+#include <concepts>
+#include <stop_token>
+#include <type_traits>
+
+#include "test_macros.h"
+
+static_assert(std::is_trivially_default_constructible_v<std::nostopstate_t>);
+
+struct Empty {};
+static_assert(sizeof(Empty) == sizeof(std::nostopstate_t));
+
+template <class T>
+void conversionTest(T);
+
+template <class T>
+concept ImplicitlyDefaultConstructible = requires { conversionTest<T>({}); };
+static_assert(!ImplicitlyDefaultConstructible<std::nostopstate_t>);
+
+int main(int, char**) {
+  [[maybe_unused]] std::same_as<std::nostopstate_t> auto x = std::nostopstate;
+  [[maybe_unused]] auto y                                  = std::nostopstate_t{};
+
+  return 0;
+}

libcxx/test/std/thread/thread.stoptoken/stopcallback/cons.const.token.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: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// template<class C>
+// explicit stop_callback(const stop_token& st, C&& cb)
+//   noexcept(is_nothrow_constructible_v<Callback, C>);
+
+#include <atomic>
+#include <cassert>
+#include <chrono>
+#include <stop_token>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "make_test_thread.h"
+#include "test_macros.h"
+
+struct Cb {
+  void operator()() const;
+};
+
+// Constraints: Callback and C satisfy constructible_from<Callback, C>.
+static_assert(std::is_constructible_v<std::stop_callback<void (*)()>, const std::stop_token&, void (*)()>);
+static_assert(!std::is_constructible_v<std::stop_callback<void (*)()>, const std::stop_token&, void (*)(int)>);
+static_assert(std::is_constructible_v<std::stop_callback<Cb>, const std::stop_token&, Cb&>);
+static_assert(std::is_constructible_v<std::stop_callback<Cb&>, const std::stop_token&, Cb&>);
+static_assert(!std::is_constructible_v<std::stop_callback<Cb>, const std::stop_token&, int>);
+
+// explicit
+template <class T>
+void conversion_test(T);
+
+template <class T, class... Args>
+concept ImplicitlyConstructible = requires(Args&&... args) { conversion_test<T>({std::forward<Args>(args)...}); };
+static_assert(ImplicitlyConstructible<int, int>);
+static_assert(!ImplicitlyConstructible<std::stop_callback<Cb>, const std::stop_token&, Cb>);
+
+// noexcept
+template <bool NoExceptCtor>
+struct CbNoExcept {
+  CbNoExcept(int) noexcept(NoExceptCtor);
+  void operator()() const;
+};
+static_assert(std::is_nothrow_constructible_v<std::stop_callback<CbNoExcept<true>>, const std::stop_token&, int>);
+static_assert(!std::is_nothrow_constructible_v<std::stop_callback<CbNoExcept<false>>, const std::stop_token&, int>);
+
+int main(int, char**) {
+  // was requested
+  {
+    std::stop_source ss;
+    const std::stop_token st = ss.get_token();
+    ss.request_stop();
+
+    bool called = false;
+    std::stop_callback sc(st, [&] { called = true; });
+    assert(called);
+  }
+
+  // was not requested
+  {
+    std::stop_source ss;
+    const std::stop_token st = ss.get_token();
+
+    bool called = false;
+    std::stop_callback sc(st, [&] { called = true; });
+    assert(!called);
+
+    ss.request_stop();
+    assert(called);
+  }
+
+  // token has no state
+  {
+    std::stop_token st;
+    bool called = false;
+    std::stop_callback sc(st, [&] { called = true; });
+    assert(!called);
+  }
+
+  // should not be called multiple times
+  {
+    std::stop_source ss;
+    const std::stop_token st = ss.get_token();
+
+    int calledTimes = 0;
+    std::stop_callback sc(st, [&] { ++calledTimes; });
+
+    std::vector<std::thread> threads;
+    for (auto i = 0; i < 10; ++i) {
+      threads.emplace_back(support::make_test_thread([&] { ss.request_stop(); }));
+    }
+
+    for (auto& thread : threads) {
+      thread.join();
+    }
+    assert(calledTimes == 1);
+  }
+
+  // adding more callbacks during invoking other callbacks
+  {
+    std::stop_source ss;
+    const std::stop_token st = ss.get_token();
+
+    std::atomic<bool> startedFlag = false;
+    std::atomic<bool> finishFlag  = false;
+    std::stop_callback sc(st, [&] {
+      startedFlag = true;
+      startedFlag.notify_all();
+      finishFlag.wait(false);
+    });
+
+    auto thread = support::make_test_thread([&] { ss.request_stop(); });
+
+    startedFlag.wait(false);
+
+    // first callback is still running, adding another one;
+    bool secondCallbackCalled = false;
+    std::stop_callback sc2(st, [&] { secondCallbackCalled = true; });
+
+    finishFlag = true;
+    finishFlag.notify_all();
+
+    thread.join();
+    assert(secondCallbackCalled);
+  }
+
+  // adding callbacks on different threads
+  {
+    std::stop_source ss;
+    const std::stop_token st = ss.get_token();
+
+    std::vector<std::thread> threads;
+    std::atomic<int> callbackCalledTimes = 0;
+    std::atomic<bool> done               = false;
+    for (auto i = 0; i < 10; ++i) {
+      threads.emplace_back(support::make_test_thread([&] {
+        std::stop_callback sc{st, [&] { callbackCalledTimes.fetch_add(1, std::memory_order_relaxed); }};
+        done.wait(false);
+      }));
+    }
+    using namespace std::chrono_literals;
+    std::this_thread::sleep_for(1ms);
+    ss.request_stop();
+    done = true;
+    done.notify_all();
+    for (auto& thread : threads) {
+      thread.join();
+    }
+    assert(callbackCalledTimes.load(std::memory_order_relaxed) == 10);
+  }
+
+  // correct overload
+  {
+    struct CBWithTracking {
+      bool& lvalueCalled;
+      bool& lvalueConstCalled;
+      bool& rvalueCalled;
+      bool& rvalueConstCalled;
+
+      void operator()() & { lvalueCalled = true; }
+      void operator()() const& { lvalueConstCalled = true; }
+      void operator()() && { rvalueCalled = true; }
+      void operator()() const&& { rvalueConstCalled = true; }
+    };
+
+    // RValue
+    {
+      bool lvalueCalled      = false;
+      bool lvalueConstCalled = false;
+      bool rvalueCalled      = false;
+      bool rvalueConstCalled = false;
+      std::stop_source ss;
+      const std::stop_token st = ss.get_token();
+      ss.request_stop();
+
+      std::stop_callback<CBWithTracking> sc(
+          st, CBWithTracking{lvalueCalled, lvalueConstCalled, rvalueCalled, rvalueConstCalled});
+      assert(rvalueCalled);
+    }
+
+    // RValue
+    {
+      bool lvalueCalled      = false;
+      bool lvalueConstCalled = false;
+      bool rvalueCalled      = false;
+      bool rvalueConstCalled = false;
+      std::stop_source ss;
+      const std::stop_token st = ss.get_token();
+      ss.request_stop();
+
+      std::stop_callback<const CBWithTracking> sc(
+          st, CBWithTracking{lvalueCalled, lvalueConstCalled, rvalueCalled, rvalueConstCalled});
+      assert(rvalueConstCalled);
+    }
+
+    // LValue
+    {
+      bool lvalueCalled      = false;
+      bool lvalueConstCalled = false;
+      bool rvalueCalled      = false;
+      bool rvalueConstCalled = false;
+      std::stop_source ss;
+      const std::stop_token st = ss.get_token();
+      ss.request_stop();
+      CBWithTracking cb{lvalueCalled, lvalueConstCalled, rvalueCalled, rvalueConstCalled};
+      std::stop_callback<CBWithTracking&> sc(st, cb);
+      assert(lvalueCalled);
+    }
+
+    // const LValue
+    {
+      bool lvalueCalled      = false;
+      bool lvalueConstCalled = false;
+      bool rvalueCalled      = false;
+      bool rvalueConstCalled = false;
+      std::stop_source ss;
+      const std::stop_token st = ss.get_token();
+      ss.request_stop();
+      CBWithTracking cb{lvalueCalled, lvalueConstCalled, rvalueCalled, rvalueConstCalled};
+      std::stop_callback<const CBWithTracking&> sc(st, cb);
+      assert(lvalueConstCalled);
+    }
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.stoptoken/stopcallback/cons.rvalue.token.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: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// template<class C>
+// explicit stop_callback(stop_token&& st, C&& cb)
+//   noexcept(is_nothrow_constructible_v<Callback, C>);
+
+#include <atomic>
+#include <cassert>
+#include <chrono>
+#include <stop_token>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "make_test_thread.h"
+#include "test_macros.h"
+
+struct Cb {
+  void operator()() const;
+};
+
+// Constraints: Callback and C satisfy constructible_from<Callback, C>.
+static_assert(std::is_constructible_v<std::stop_callback<void (*)()>, std::stop_token&&, void (*)()>);
+static_assert(!std::is_constructible_v<std::stop_callback<void (*)()>, std::stop_token&&, void (*)(int)>);
+static_assert(std::is_constructible_v<std::stop_callback<Cb>, std::stop_token&&, Cb&>);
+static_assert(std::is_constructible_v<std::stop_callback<Cb&>, std::stop_token&&, Cb&>);
+static_assert(!std::is_constructible_v<std::stop_callback<Cb>, std::stop_token&&, int>);
+
+// explicit
+template <class T>
+void conversion_test(T);
+
+template <class T, class... Args>
+concept ImplicitlyConstructible = requires(Args&&... args) { conversion_test<T>({std::forward<Args>(args)...}); };
+static_assert(ImplicitlyConstructible<int, int>);
+static_assert(!ImplicitlyConstructible<std::stop_callback<Cb>, std::stop_token&&, Cb>);
+
+// noexcept
+template <bool NoExceptCtor>
+struct CbNoExcept {
+  CbNoExcept(int) noexcept(NoExceptCtor);
+  void operator()() const;
+};
+static_assert(std::is_nothrow_constructible_v<std::stop_callback<CbNoExcept<true>>, std::stop_token&&, int>);
+static_assert(!std::is_nothrow_constructible_v<std::stop_callback<CbNoExcept<false>>, std::stop_token&&, int>);
+
+int main(int, char**) {
+  // was requested
+  {
+    std::stop_source ss;
+    ss.request_stop();
+
+    bool called = false;
+    std::stop_callback sc(ss.get_token(), [&] { called = true; });
+    assert(called);
+  }
+
+  // was not requested
+  {
+    std::stop_source ss;
+
+    bool called = false;
+    std::stop_callback sc(ss.get_token(), [&] { called = true; });
+    assert(!called);
+
+    ss.request_stop();
+    assert(called);
+  }
+
+  // token has no state
+  {
+    std::stop_token st;
+    bool called = false;
+    std::stop_callback sc(std::move(st), [&] { called = true; });
+    assert(!called);
+  }
+
+  // should not be called multiple times
+  {
+    std::stop_source ss;
+
+    int calledTimes = 0;
+    std::stop_callback sc(ss.get_token(), [&] { ++calledTimes; });
+
+    std::vector<std::thread> threads;
+    for (auto i = 0; i < 10; ++i) {
+      threads.emplace_back(support::make_test_thread([&] { ss.request_stop(); }));
+    }
+
+    for (auto& thread : threads) {
+      thread.join();
+    }
+    assert(calledTimes == 1);
+  }
+
+  // adding more callbacks during invoking other callbacks
+  {
+    std::stop_source ss;
+
+    std::atomic<bool> startedFlag = false;
+    std::atomic<bool> finishFlag  = false;
+    std::stop_callback sc(ss.get_token(), [&] {
+      startedFlag = true;
+      startedFlag.notify_all();
+      finishFlag.wait(false);
+    });
+
+    auto thread = support::make_test_thread([&] { ss.request_stop(); });
+
+    startedFlag.wait(false);
+
+    // first callback is still running, adding another one;
+    bool secondCallbackCalled = false;
+    std::stop_callback sc2(ss.get_token(), [&] { secondCallbackCalled = true; });
+
+    finishFlag = true;
+    finishFlag.notify_all();
+
+    thread.join();
+    assert(secondCallbackCalled);
+  }
+
+  // adding callbacks on different threads
+  {
+    std::stop_source ss;
+
+    std::vector<std::thread> threads;
+    std::atomic<int> callbackCalledTimes = 0;
+    std::atomic<bool> done               = false;
+    for (auto i = 0; i < 10; ++i) {
+      threads.emplace_back(support::make_test_thread([&] {
+        std::stop_callback sc{ss.get_token(), [&] { callbackCalledTimes.fetch_add(1, std::memory_order_relaxed); }};
+        done.wait(false);
+      }));
+    }
+    using namespace std::chrono_literals;
+    std::this_thread::sleep_for(1ms);
+    ss.request_stop();
+    done = true;
+    done.notify_all();
+    for (auto& thread : threads) {
+      thread.join();
+    }
+    assert(callbackCalledTimes.load(std::memory_order_relaxed) == 10);
+  }
+
+  // correct overload
+  {
+    struct CBWithTracking {
+      bool& lvalueCalled;
+      bool& lvalueConstCalled;
+      bool& rvalueCalled;
+      bool& rvalueConstCalled;
+
+      void operator()() & { lvalueCalled = true; }
+      void operator()() const& { lvalueConstCalled = true; }
+      void operator()() && { rvalueCalled = true; }
+      void operator()() const&& { rvalueConstCalled = true; }
+    };
+
+    // RValue
+    {
+      bool lvalueCalled      = false;
+      bool lvalueConstCalled = false;
+      bool rvalueCalled      = false;
+      bool rvalueConstCalled = false;
+      std::stop_source ss;
+      ss.request_stop();
+
+      std::stop_callback<CBWithTracking> sc(
+          ss.get_token(), CBWithTracking{lvalueCalled, lvalueConstCalled, rvalueCalled, rvalueConstCalled});
+      assert(rvalueCalled);
+    }
+
+    // RValue
+    {
+      bool lvalueCalled      = false;
+      bool lvalueConstCalled = false;
+      bool rvalueCalled      = false;
+      bool rvalueConstCalled = false;
+      std::stop_source ss;
+      ss.request_stop();
+
+      std::stop_callback<const CBWithTracking> sc(
+          ss.get_token(), CBWithTracking{lvalueCalled, lvalueConstCalled, rvalueCalled, rvalueConstCalled});
+      assert(rvalueConstCalled);
+    }
+
+    // LValue
+    {
+      bool lvalueCalled      = false;
+      bool lvalueConstCalled = false;
+      bool rvalueCalled      = false;
+      bool rvalueConstCalled = false;
+      std::stop_source ss;
+      ss.request_stop();
+      CBWithTracking cb{lvalueCalled, lvalueConstCalled, rvalueCalled, rvalueConstCalled};
+      std::stop_callback<CBWithTracking&> sc(ss.get_token(), cb);
+      assert(lvalueCalled);
+    }
+
+    // const LValue
+    {
+      bool lvalueCalled      = false;
+      bool lvalueConstCalled = false;
+      bool rvalueCalled      = false;
+      bool rvalueConstCalled = false;
+      std::stop_source ss;
+      ss.request_stop();
+      CBWithTracking cb{lvalueCalled, lvalueConstCalled, rvalueCalled, rvalueConstCalled};
+      std::stop_callback<const CBWithTracking&> sc(ss.get_token(), cb);
+      assert(lvalueConstCalled);
+    }
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.stoptoken/stopcallback/copy.move.compile.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: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+//  stop_callback(const stop_callback&) = delete;
+//  stop_callback(stop_callback&&) = delete;
+//  stop_callback& operator=(const stop_callback&) = delete;
+//  stop_callback& operator=(stop_callback&&) = delete;
+
+#include <stop_token>
+#include <type_traits>
+
+struct Callback {
+  void operator()() const;
+};
+
+static_assert(!std::is_copy_constructible_v<std::stop_callback<Callback>>);
+static_assert(!std::is_move_constructible_v<std::stop_callback<Callback>>);
+static_assert(!std::is_copy_assignable_v<std::stop_callback<Callback>>);
+static_assert(!std::is_move_assignable_v<std::stop_callback<Callback>>);

libcxx/test/std/thread/thread.stoptoken/stopcallback/ctad.compile.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: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+//   template<class Callback>
+//   stop_callback(stop_token, Callback) -> stop_callback<Callback>;
+
+#include <stop_token>
+#include <type_traits>
+#include <utility>
+
+void test() {
+  std::stop_token st;
+  auto a = [] {};
+  static_assert(std::is_same_v<decltype(std::stop_callback(st, a)), std::stop_callback<decltype(a)>>);
+  static_assert(std::is_same_v<decltype(std::stop_callback(st, std::as_const(a))), std::stop_callback<decltype(a)>>);
+  static_assert(std::is_same_v<decltype(std::stop_callback(st, std::move(a))), std::stop_callback<decltype(a)>>);
+  static_assert(
+      std::is_same_v<decltype(std::stop_callback(st, std::move(std::as_const(a)))), std::stop_callback<decltype(a)>>);
+}

libcxx/test/std/thread/thread.stoptoken/stopcallback/dtor.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: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// ~stop_callback();
+
+#include <atomic>
+#include <cassert>
+#include <chrono>
+#include <functional>
+#include <optional>
+#include <stop_token>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "make_test_thread.h"
+#include "test_macros.h"
+
+struct CallbackHolder;
+
+struct DeleteHolder {
+  CallbackHolder& holder_;
+  void operator()() const;
+};
+
+struct CallbackHolder {
+  std::unique_ptr<std::stop_callback<DeleteHolder>> callback_;
+};
+
+void DeleteHolder::operator()() const { holder_.callback_.reset(); }
+
+int main(int, char**) {
+  // Unregisters the callback from the owned stop state, if any
+  {
+    std::stop_source ss;
+    bool called = false;
+
+    {
+      std::stop_callback sc(ss.get_token(), [&] { called = true; });
+    }
+    ss.request_stop();
+    assert(!called);
+  }
+
+  // The destructor does not block waiting for the execution of another
+  // callback registered by an associated stop_callback.
+  {
+    std::stop_source ss;
+
+    std::atomic<int> startedIndex    = 0;
+    std::atomic<bool> callbackFinish = false;
+
+    std::optional<std::stop_callback<std::function<void()>>> sc1(std::in_place, ss.get_token(), [&] {
+      startedIndex = 1;
+      startedIndex.notify_all();
+      callbackFinish.wait(false);
+    });
+
+    std::optional<std::stop_callback<std::function<void()>>> sc2(std::in_place, ss.get_token(), [&] {
+      startedIndex = 2;
+      startedIndex.notify_all();
+      callbackFinish.wait(false);
+    });
+
+    auto thread = support::make_test_thread([&] { ss.request_stop(); });
+
+    startedIndex.wait(0);
+
+    // now one of the callback has started but not finished.
+    if (startedIndex == 1) {
+      sc2.reset();   // destructor should not block
+    } else if (startedIndex == 2) {
+      sc1.reset();   // destructor should not block
+    } else {
+      assert(false); // something is wrong
+    }
+
+    callbackFinish = true;
+    callbackFinish.notify_all();
+    thread.join();
+  }
+
+  // If callback is concurrently executing on another thread, then the
+  // return from the invocation of callback strongly happens before ([intro.races])
+  // callback is destroyed.
+  {
+    struct Callback {
+      std::atomic<bool>& started_;
+      std::atomic<bool>& waitDone_;
+      std::atomic<bool>& finished_;
+      bool moved = false;
+
+      Callback(std::atomic<bool>& started, std::atomic<bool>& waitDone, std::atomic<bool>& finished)
+          : started_(started), waitDone_(waitDone), finished_(finished) {}
+      Callback(Callback&& other) : started_(other.started_), waitDone_(other.waitDone_), finished_(other.finished_) {
+        other.moved = true;
+      }
+
+      void operator()() const {
+        struct ScopedGuard {
+          std::atomic<bool>& g_finished_;
+          ~ScopedGuard() { g_finished_.store(true, std::memory_order_relaxed); }
+        };
+
+        started_ = true;
+        started_.notify_all();
+        waitDone_.wait(false);
+        ScopedGuard g{finished_};
+      }
+
+      ~Callback() {
+        if (!moved) {
+          // destructor has to be called after operator() returns
+          assert(finished_.load(std::memory_order_relaxed));
+        }
+      }
+    };
+
+    std::stop_source ss;
+
+    std::atomic<bool> started  = false;
+    std::atomic<bool> waitDone = false;
+    std::atomic<bool> finished = false;
+
+    std::optional<std::stop_callback<Callback>> sc{
+        std::in_place, ss.get_token(), Callback{started, waitDone, finished}};
+
+    auto thread1 = support::make_test_thread([&] { ss.request_stop(); });
+    started.wait(false);
+
+    auto thread2 = support::make_test_thread([&] {
+      using namespace std::chrono_literals;
+      std::this_thread::sleep_for(1ms);
+      waitDone = true;
+      waitDone.notify_all();
+    });
+
+    sc.reset(); // destructor should block until operator() returns, i.e. waitDone to be true
+
+    thread1.join();
+    thread2.join();
+  }
+
+  // If callback is executing on the current thread, then the destructor does not block ([defns.block])
+  // waiting for the return from the invocation of callback.
+  {
+    std::stop_source ss;
+
+    CallbackHolder holder;
+    holder.callback_ = std::make_unique<std::stop_callback<DeleteHolder>>(ss.get_token(), DeleteHolder{holder});
+
+    assert(holder.callback_ != nullptr);
+
+    ss.request_stop(); // the callbacks deletes itself. if the destructor blocks, it would be deadlock
+    assert(holder.callback_ == nullptr);
+  }
+}

libcxx/test/std/thread/thread.stoptoken/stopcallback/typedef.compile.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: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// using callback_type = _Callback;
+
+#include <stop_token>
+#include <type_traits>
+
+struct Callback {
+  void operator()() const;
+};
+
+static_assert(std::is_same_v<std::stop_callback<Callback>::callback_type, Callback>);
+static_assert(std::is_same_v<std::stop_callback<const Callback>::callback_type, const Callback>);
+static_assert(std::is_same_v<std::stop_callback<Callback&>::callback_type, Callback&>);
+static_assert(std::is_same_v<std::stop_callback<const Callback&>::callback_type, const Callback&>);
+static_assert(std::is_same_v<std::stop_callback<Callback&&>::callback_type, Callback&&>);
+static_assert(std::is_same_v<std::stop_callback<const Callback&&>::callback_type, const Callback&&>);

libcxx/test/std/thread/thread.stoptoken/stopsource/assign.copy.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: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// stop_source& operator=(const stop_source& rhs) noexcept;
+
+#include <cassert>
+#include <concepts>
+#include <stop_token>
+#include <type_traits>
+
+#include "test_macros.h"
+
+static_assert(std::is_nothrow_copy_assignable_v<std::stop_source>);
+
+int main(int, char**) {
+  // have two different states
+  {
+    std::stop_source ss1;
+    std::stop_source ss2;
+
+    assert(ss1 != ss2);
+
+    ss2.request_stop();
+
+    assert(!ss1.stop_requested());
+    assert(ss2.stop_requested());
+
+    std::same_as<std::stop_source&> decltype(auto) ref = ss1 = ss2;
+    assert(&ref == &ss1);
+
+    assert(ss1 == ss2);
+    assert(ss1.stop_requested());
+    assert(ss2.stop_requested());
+  }
+
+  // this has no state
+  {
+    std::stop_source ss1{std::nostopstate};
+    std::stop_source ss2;
+
+    assert(ss1 != ss2);
+
+    ss2.request_stop();
+
+    assert(!ss1.stop_requested());
+    assert(!ss1.stop_possible());
+    assert(ss2.stop_requested());
+    assert(ss2.stop_possible());
+
+    std::same_as<std::stop_source&> decltype(auto) ref = ss1 = ss2;
+    assert(&ref == &ss1);
+
+    assert(ss1 == ss2);
+    assert(ss1.stop_requested());
+    assert(ss1.stop_possible());
+    assert(ss2.stop_requested());
+    assert(ss2.stop_possible());
+  }
+
+  // other has no state
+  {
+    std::stop_source ss1;
+    std::stop_source ss2{std::nostopstate};
+
+    assert(ss1 != ss2);
+
+    ss1.request_stop();
+
+    assert(ss1.stop_requested());
+    assert(ss1.stop_possible());
+    assert(!ss2.stop_requested());
+    assert(!ss2.stop_possible());
+
+    std::same_as<std::stop_source&> decltype(auto) ref = ss1 = ss2;
+    assert(&ref == &ss1);
+
+    assert(ss1 == ss2);
+    assert(!ss1.stop_requested());
+    assert(!ss1.stop_possible());
+    assert(!ss2.stop_requested());
+    assert(!ss2.stop_possible());
+  }
+
+  // both no state
+  {
+    std::stop_source ss1{std::nostopstate};
+    std::stop_source ss2{std::nostopstate};
+
+    assert(ss1 == ss2);
+
+    assert(!ss1.stop_requested());
+    assert(!ss1.stop_possible());
+    assert(!ss2.stop_requested());
+    assert(!ss2.stop_possible());
+
+    std::same_as<std::stop_source&> decltype(auto) ref = ss1 = ss2;
+    assert(&ref == &ss1);
+
+    assert(ss1 == ss2);
+    assert(!ss1.stop_requested());
+    assert(!ss1.stop_possible());
+    assert(!ss2.stop_requested());
+    assert(!ss2.stop_possible());
+  }
+
+  // self assignment
+  {
+    std::stop_source ss;
+    auto& self = ss;
+
+    assert(!ss.stop_requested());
+
+    std::same_as<std::stop_source&> decltype(auto) ref = ss = self;
+    assert(&ref == &ss);
+
+    assert(!ss.stop_requested());
+
+    ss.request_stop();
+    assert(ss.stop_requested());
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.stoptoken/stopsource/cons.copy.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: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// stop_source(const stop_source&) noexcept;
+
+#include <cassert>
+#include <optional>
+#include <stop_token>
+#include <type_traits>
+
+#include "test_macros.h"
+
+static_assert(std::is_nothrow_copy_constructible_v<std::stop_source>);
+
+int main(int, char**) {
+  {
+    std::stop_source source;
+    std::stop_source copy{source};
+
+    assert(source == copy);
+
+    assert(source.stop_possible());
+    assert(!source.stop_requested());
+
+    assert(copy.stop_possible());
+    assert(!copy.stop_requested());
+
+    source.request_stop();
+    assert(source.stop_possible());
+    assert(source.stop_requested());
+
+    assert(copy.stop_possible());
+    assert(copy.stop_requested());
+  }
+
+  // source counter incremented
+  {
+    std::optional<std::stop_source> source(std::in_place);
+    auto st = source->get_token();
+    assert(st.stop_possible());
+
+    std::optional<std::stop_source> copy{source};
+    source.reset();
+
+    assert(st.stop_possible());
+
+    copy.reset();
+    assert(!st.stop_possible());
+  }
+
+  // copy from empty
+  {
+    std::stop_source ss1{std::nostopstate};
+    std::stop_source copy{ss1};
+    assert(!copy.stop_possible());
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.stoptoken/stopsource/cons.default.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: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// stop_source();
+
+#include <cassert>
+#include <stop_token>
+#include <type_traits>
+
+#include "test_macros.h"
+
+static_assert(std::is_default_constructible_v<std::stop_source>);
+
+int main(int, char**) {
+  {
+    std::stop_source ss = {}; // implicit
+    assert(ss.stop_possible());
+    assert(!ss.stop_requested());
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.stoptoken/stopsource/cons.move.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: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// stop_source(stop_source&&) noexcept;
+
+#include <cassert>
+#include <stop_token>
+#include <type_traits>
+#include <utility>
+
+#include "test_macros.h"
+
+static_assert(std::is_nothrow_move_constructible_v<std::stop_source>);
+
+int main(int, char**) {
+  {
+    std::stop_source source;
+
+    assert(source.stop_possible());
+    assert(!source.stop_requested());
+
+    std::stop_source source2{std::move(source)};
+
+    assert(!source.stop_possible());
+    assert(!source.stop_requested());
+
+    assert(source2.stop_possible());
+    assert(!source2.stop_requested());
+
+    source2.request_stop();
+
+    assert(!source.stop_possible());
+    assert(!source.stop_requested());
+
+    assert(source2.stop_possible());
+    assert(source2.stop_requested());
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.stoptoken/stopsource/cons.nostopstate.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: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// explicit stop_source(nostopstate_t) noexcept;
+
+#include <cassert>
+#include <stop_token>
+#include <type_traits>
+
+#include "test_macros.h"
+
+static_assert(std::is_nothrow_constructible_v<std::stop_source, std::nostopstate_t>);
+// explicit
+static_assert(!std::is_convertible_v<std::nostopstate_t, std::stop_source>);
+
+int main(int, char**) {
+  {
+    std::stop_source ss(std::nostopstate);
+    assert(!ss.stop_possible());
+    assert(!ss.stop_requested());
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.stoptoken/stopsource/equals.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: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// [[nodiscard]] bool operator==(const stop_source& lhs, const stop_source& rhs) noexcept;
+// Returns: true if lhs and rhs have ownership of the same stop state or if both lhs and rhs do not have ownership of a stop state; otherwise false.
+
+#include <cassert>
+#include <concepts>
+#include <stop_token>
+#include <type_traits>
+
+#include "test_macros.h"
+
+template <class T>
+concept IsNoThrowEqualityComparable = requires(const T& t1, const T& t2) {
+  { t1 == t2 } noexcept;
+};
+
+static_assert(IsNoThrowEqualityComparable<std::stop_source>);
+
+int main(int, char**) {
+  // both no state
+  {
+    const std::stop_source ss1(std::nostopstate);
+    const std::stop_source ss2(std::nostopstate);
+    assert(ss1 == ss2);
+    assert(!(ss1 != ss2));
+  }
+
+  // only one has no state
+  {
+    const std::stop_source ss1(std::nostopstate);
+    const std::stop_source ss2;
+    assert(!(ss1 == ss2));
+    assert(ss1 != ss2);
+  }
+
+  // both has states. same state
+  {
+    const std::stop_source ss1;
+    const std::stop_source ss2(ss1);
+    assert(ss1 == ss2);
+    assert(!(ss1 != ss2));
+  }
+
+  // both has states. different states
+  {
+    const std::stop_source ss1;
+    const std::stop_source ss2;
+    assert(!(ss1 == ss2));
+    assert(ss1 != ss2);
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.stoptoken/stopsource/get_token.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: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// [[nodiscard]] stop_token get_token() const noexcept;
+
+#include <cassert>
+#include <concepts>
+#include <stop_token>
+#include <type_traits>
+
+#include "test_macros.h"
+
+template <class T>
+concept IsGetTokenNoexcept = requires(const T& t) {
+  { t.get_token() } noexcept;
+};
+
+static_assert(IsGetTokenNoexcept<std::stop_source>);
+
+int main(int, char**) {
+  // no state
+  {
+    std::stop_source ss{std::nostopstate};
+    std::same_as<std::stop_token> decltype(auto) st = ss.get_token();
+    assert(!st.stop_possible());
+    assert(!st.stop_requested());
+  }
+
+  // with state
+  {
+    std::stop_source ss;
+    std::same_as<std::stop_token> decltype(auto) st = ss.get_token();
+    assert(st.stop_possible());
+    assert(!st.stop_requested());
+
+    ss.request_stop();
+    assert(st.stop_requested());
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.stoptoken/stopsource/move.copy.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: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// stop_source& operator=(stop_source&& rhs) noexcept;
+
+#include <cassert>
+#include <concepts>
+#include <stop_token>
+#include <type_traits>
+#include <utility>
+
+#include "test_macros.h"
+
+static_assert(std::is_nothrow_move_assignable_v<std::stop_source>);
+
+int main(int, char**) {
+  // have two different states
+  {
+    std::stop_source ss1;
+    std::stop_source ss2;
+
+    assert(ss1 != ss2);
+
+    ss2.request_stop();
+
+    assert(!ss1.stop_requested());
+    assert(ss2.stop_requested());
+
+    std::same_as<std::stop_source&> decltype(auto) ref = ss1 = std::move(ss2);
+    assert(&ref == &ss1);
+
+    assert(ss1.stop_requested());
+    assert(!ss2.stop_possible());
+    assert(!ss2.stop_requested());
+  }
+
+  // this has no state
+  {
+    std::stop_source ss1{std::nostopstate};
+    std::stop_source ss2;
+
+    assert(ss1 != ss2);
+
+    ss2.request_stop();
+
+    assert(!ss1.stop_requested());
+    assert(!ss1.stop_possible());
+    assert(ss2.stop_requested());
+    assert(ss2.stop_possible());
+
+    std::same_as<std::stop_source&> decltype(auto) ref = ss1 = std::move(ss2);
+    assert(&ref == &ss1);
+
+    assert(ss1.stop_requested());
+    assert(ss1.stop_possible());
+    assert(!ss2.stop_requested());
+    assert(!ss2.stop_possible());
+  }
+
+  // other has no state
+  {
+    std::stop_source ss1;
+    std::stop_source ss2{std::nostopstate};
+
+    assert(ss1 != ss2);
+
+    ss1.request_stop();
+
+    assert(ss1.stop_requested());
+    assert(ss1.stop_possible());
+    assert(!ss2.stop_requested());
+    assert(!ss2.stop_possible());
+
+    std::same_as<std::stop_source&> decltype(auto) ref = ss1 = std::move(ss2);
+    assert(&ref == &ss1);
+
+    assert(ss1 == ss2);
+    assert(!ss1.stop_requested());
+    assert(!ss1.stop_possible());
+    assert(!ss2.stop_requested());
+    assert(!ss2.stop_possible());
+  }
+
+  // both no state
+  {
+    std::stop_source ss1{std::nostopstate};
+    std::stop_source ss2{std::nostopstate};
+
+    assert(ss1 == ss2);
+
+    assert(!ss1.stop_requested());
+    assert(!ss1.stop_possible());
+    assert(!ss2.stop_requested());
+    assert(!ss2.stop_possible());
+
+    std::same_as<std::stop_source&> decltype(auto) ref = ss1 = std::move(ss2);
+    assert(&ref == &ss1);
+
+    assert(ss1 == ss2);
+    assert(!ss1.stop_requested());
+    assert(!ss1.stop_possible());
+    assert(!ss2.stop_requested());
+    assert(!ss2.stop_possible());
+  }
+
+  // self assignment
+  {
+    std::stop_source ss;
+    auto& self = ss;
+
+    assert(!ss.stop_requested());
+
+    std::same_as<std::stop_source&> decltype(auto) ref = ss = std::move(self);
+    assert(&ref == &ss);
+
+    assert(!ss.stop_requested());
+
+    ss.request_stop();
+    assert(ss.stop_requested());
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.stoptoken/stopsource/nodiscard.verify.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: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// [[nodiscard]] stop_token get_token() const noexcept;
+// [[nodiscard]] bool stop_possible() const noexcept;
+// [[nodiscard]] bool stop_requested() const noexcept;
+// [[nodiscard]] friend bool operator==(const stop_source& lhs, const stop_source& rhs) noexcept;
+
+#include <stop_token>
+
+void test() {
+  std::stop_source ss;
+  ss.get_token();      // expected-warning {{ignoring return value of function}}
+  ss.stop_requested(); // expected-warning {{ignoring return value of function}}
+  ss.stop_possible();  // expected-warning {{ignoring return value of function}}
+  operator==(ss, ss);  // expected-warning {{ignoring return value of function}}
+}

libcxx/test/std/thread/thread.stoptoken/stopsource/request_stop.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: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// bool request_stop() noexcept;
+
+#include <cassert>
+#include <chrono>
+#include <concepts>
+#include <optional>
+#include <stop_token>
+#include <type_traits>
+
+#include "make_test_thread.h"
+#include "test_macros.h"
+
+template <class T>
+concept IsRequestStopNoexcept = requires(T& t) {
+  { t.request_stop() } noexcept;
+};
+
+static_assert(IsRequestStopNoexcept<std::stop_source>);
+
+int main(int, char**) {
+  // If *this does not have ownership of a stop state, returns false
+  {
+    std::stop_source ss{std::nostopstate};
+    auto ret = ss.request_stop();
+    assert(!ret);
+    assert(!ss.stop_requested());
+  }
+
+  // Otherwise, atomically determines whether the owned stop state has received
+  // a stop request, and if not, makes a stop request
+  {
+    std::stop_source ss;
+
+    auto ret = ss.request_stop();
+    assert(ret);
+    assert(ss.stop_requested());
+  }
+
+  // already requested
+  {
+    std::stop_source ss;
+    ss.request_stop();
+    assert(ss.stop_requested());
+
+    auto ret = ss.request_stop();
+    assert(!ret);
+    assert(ss.stop_requested());
+  }
+
+  // If the request was made, the callbacks registered by
+  // associated stop_callback objects are synchronously called.
+  {
+    std::stop_source ss;
+    auto st = ss.get_token();
+
+    bool cb1Called = false;
+    bool cb2Called = false;
+    std::stop_callback sc1(st, [&] { cb1Called = true; });
+    std::stop_callback sc2(st, [&] { cb2Called = true; });
+
+    ss.request_stop();
+    assert(cb1Called);
+    assert(cb2Called);
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.stoptoken/stopsource/stop_possible.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: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// [[nodiscard]] bool stop_possible() const noexcept;
+// Returns: true if *this has ownership of a stop state; otherwise, false.
+
+#include <cassert>
+#include <stop_token>
+#include <type_traits>
+
+#include "test_macros.h"
+
+template <class T>
+concept IsStopPossibleNoexcept = requires(const T& t) {
+  { t.stop_possible() } noexcept;
+};
+
+static_assert(IsStopPossibleNoexcept<std::stop_source>);
+
+int main(int, char**) {
+  // no state
+  {
+    const std::stop_source st{std::nostopstate};
+    assert(!st.stop_possible());
+  }
+
+  // with state
+  {
+    const std::stop_source st;
+    assert(st.stop_possible());
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.stoptoken/stopsource/stop_requested.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: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// [[nodiscard]] bool stop_requested() const noexcept;
+// true if *this has ownership of a stop state that has received a stop request; otherwise, false.
+
+#include <cassert>
+#include <chrono>
+#include <concepts>
+#include <optional>
+#include <stop_token>
+#include <type_traits>
+
+#include "make_test_thread.h"
+#include "test_macros.h"
+
+template <class T>
+concept IsStopRequestedNoexcept = requires(const T& t) {
+  { t.stop_requested() } noexcept;
+};
+
+static_assert(IsStopRequestedNoexcept<std::stop_source>);
+
+int main(int, char**) {
+  // no state
+  {
+    const std::stop_source ss{std::nostopstate};
+    assert(!ss.stop_requested());
+  }
+
+  // has state
+  {
+    std::stop_source ss;
+    assert(!ss.stop_requested());
+
+    ss.request_stop();
+    assert(ss.stop_requested());
+  }
+
+  // request from another instance with same state
+  {
+    std::stop_source ss1;
+    auto ss2 = ss1;
+    ss2.request_stop();
+    assert(ss1.stop_requested());
+  }
+
+  // request from another instance with different state
+  {
+    std::stop_source ss1;
+    std::stop_source ss2;
+
+    ss2.request_stop();
+    assert(!ss1.stop_requested());
+  }
+
+  // multiple threads
+  {
+    std::stop_source ss;
+
+    std::thread t = support::make_test_thread([&]() { ss.request_stop(); });
+
+    t.join();
+    assert(ss.stop_requested());
+  }
+
+  // [thread.stopsource.intro] A call to request_stop that returns true
+  // synchronizes with a call to stop_requested on an associated stop_source
+  // or stop_source object that returns true.
+  {
+    std::stop_source ss;
+
+    bool flag = false;
+
+    std::thread t = support::make_test_thread([&]() {
+      using namespace std::chrono_literals;
+      std::this_thread::sleep_for(1ms);
+
+      // happens-before request_stop
+      flag   = true;
+      auto b = ss.request_stop();
+      assert(b);
+    });
+
+    while (!ss.stop_requested()) {
+      std::this_thread::yield();
+    }
+
+    // write should be visible to the current thread
+    assert(flag == true);
+
+    t.join();
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.stoptoken/stopsource/swap.free.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: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// void swap(stop_source& rhs) noexcept;
+
+#include <cassert>
+#include <concepts>
+#include <stop_token>
+#include <type_traits>
+
+#include "test_macros.h"
+
+template <class T>
+concept IsNoThrowFreeSwappable = requires(T& t) {
+  { swap(t, t) } noexcept;
+};
+
+static_assert(IsNoThrowFreeSwappable<std::stop_source>);
+
+int main(int, char**) {
+  {
+    std::stop_source ss1;
+    std::stop_source ss2;
+
+    assert(ss1 != ss2);
+
+    ss2.request_stop();
+
+    assert(!ss1.stop_requested());
+    assert(ss2.stop_requested());
+
+    swap(ss1, ss2);
+
+    assert(ss1 != ss2);
+    assert(ss1.stop_requested());
+    assert(!ss2.stop_requested());
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.stoptoken/stopsource/swap.member.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: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// void swap(stop_source& rhs) noexcept;
+
+#include <cassert>
+#include <concepts>
+#include <stop_token>
+#include <type_traits>
+
+#include "test_macros.h"
+
+template <class T>
+concept IsNoThrowMemberSwappable = requires(T& t) {
+  { t.swap(t) } noexcept;
+};
+
+static_assert(IsNoThrowMemberSwappable<std::stop_source>);
+
+int main(int, char**) {
+  {
+    std::stop_source ss1;
+    std::stop_source ss2;
+
+    assert(ss1 != ss2);
+
+    ss2.request_stop();
+
+    assert(!ss1.stop_requested());
+    assert(ss2.stop_requested());
+
+    ss1.swap(ss2);
+
+    assert(ss1 != ss2);
+    assert(ss1.stop_requested());
+    assert(!ss2.stop_requested());
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.stoptoken/stoptoken/assign.copy.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: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+#include <cassert>
+#include <concepts>
+#include <stop_token>
+#include <type_traits>
+
+#include "test_macros.h"
+
+static_assert(std::is_nothrow_copy_assignable_v<std::stop_token>);
+
+int main(int, char**) {
+  {
+    std::stop_token st1;
+
+    std::stop_source source;
+    auto st2 = source.get_token();
+
+    assert(st1 != st2);
+
+    source.request_stop();
+
+    assert(!st1.stop_requested());
+    assert(st2.stop_requested());
+
+    std::same_as<std::stop_token&> decltype(auto) ref = st1 = st2;
+    assert(&ref == &st1);
+
+    assert(st1 == st2);
+    assert(st1.stop_requested());
+    assert(st2.stop_requested());
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.stoptoken/stoptoken/assign.move.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: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// stop_token& operator=(stop_token&& rhs) noexcept;
+
+#include <cassert>
+#include <concepts>
+#include <stop_token>
+#include <type_traits>
+#include <utility>
+
+#include "test_macros.h"
+
+static_assert(std::is_nothrow_move_assignable_v<std::stop_token>);
+
+int main(int, char**) {
+  {
+    std::stop_token st1;
+
+    std::stop_source source;
+    auto st2 = source.get_token();
+
+    assert(st1 != st2);
+
+    source.request_stop();
+
+    assert(!st1.stop_requested());
+    assert(st2.stop_requested());
+
+    std::same_as<std::stop_token&> decltype(auto) ref = st1 = std::move(st2);
+    assert(&ref == &st1);
+
+    assert(st1 != st2);
+    assert(st1.stop_requested());
+    assert(!st2.stop_requested());
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.stoptoken/stoptoken/cons.copy.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: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// stop_token(const stop_token&) noexcept;
+
+#include <cassert>
+#include <stop_token>
+#include <type_traits>
+
+#include "test_macros.h"
+
+static_assert(std::is_nothrow_copy_constructible_v<std::stop_token>);
+
+int main(int, char**) {
+  {
+    std::stop_source source;
+    auto st = source.get_token();
+    std::stop_token copy{st};
+
+    assert(st == copy);
+
+    assert(st.stop_possible());
+    assert(!st.stop_requested());
+
+    assert(copy.stop_possible());
+    assert(!copy.stop_requested());
+
+    source.request_stop();
+    assert(st.stop_possible());
+    assert(st.stop_requested());
+
+    assert(copy.stop_possible());
+    assert(copy.stop_requested());
+
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.stoptoken/stoptoken/cons.default.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: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// stop_token() noexcept;
+
+#include <cassert>
+#include <stop_token>
+#include <type_traits>
+
+#include "test_macros.h"
+
+static_assert(std::is_nothrow_default_constructible_v<std::stop_token>);
+
+int main(int, char**) {
+  {
+    std::stop_token st = {}; // implicit
+    assert(!st.stop_possible());
+    assert(!st.stop_requested());
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.stoptoken/stoptoken/cons.move.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: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// stop_token(stop_token&&) noexcept;
+
+#include <cassert>
+#include <stop_token>
+#include <type_traits>
+#include <utility>
+
+#include "test_macros.h"
+
+static_assert(std::is_nothrow_move_constructible_v<std::stop_token>);
+
+int main(int, char**) {
+  {
+    std::stop_source source;
+    auto st = source.get_token();
+
+    assert(st.stop_possible());
+    assert(!st.stop_requested());
+
+    std::stop_token st2{std::move(st)};
+
+    assert(!st.stop_possible());
+    assert(!st.stop_requested());
+
+    assert(st2.stop_possible());
+    assert(!st2.stop_requested());
+
+    source.request_stop();
+
+    assert(!st.stop_possible());
+    assert(!st.stop_requested());
+
+    assert(st2.stop_possible());
+    assert(st2.stop_requested());
+
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.stoptoken/stoptoken/equals.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: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// [[nodiscard]] bool operator==(const stop_token& lhs, const stop_token& rhs) noexcept;
+// Returns: true if lhs and rhs have ownership of the same stop state or if both lhs and rhs do not have ownership of a stop state; otherwise false.
+
+// synthesized operator != also tested.
+
+#include <cassert>
+#include <concepts>
+#include <stop_token>
+#include <type_traits>
+
+#include "test_macros.h"
+
+// LWG 3254 is related.
+template <class T>
+concept IsNoThrowEqualityComparable = requires(const T& t1, const T& t2) {
+  { t1 == t2 } noexcept;
+};
+
+template <class T>
+concept IsNoThrowInequalityComparable = requires(const T& t1, const T& t2) {
+  { t1 != t2 } noexcept;
+};
+
+static_assert(IsNoThrowEqualityComparable<std::stop_token>);
+static_assert(IsNoThrowInequalityComparable<std::stop_token>);
+
+int main(int, char**) {
+  // both no state
+  {
+    const std::stop_token st1;
+    const std::stop_token st2;
+    assert(st1 == st2);
+    assert(!(st1 != st2));
+  }
+
+  // only one has no state
+  {
+    std::stop_source ss;
+    const std::stop_token st1;
+    const auto st2 = ss.get_token();
+    assert(!(st1 == st2));
+    assert(st1 != st2);
+  }
+
+  // both has states. same source
+  {
+    std::stop_source ss;
+    const auto st1 = ss.get_token();
+    const auto st2 = ss.get_token();
+    assert(st1 == st2);
+    assert(!(st1 != st2));
+  }
+
+  // both has states. different sources with same states
+  {
+    std::stop_source ss1;
+    auto ss2 = ss1;
+    const auto st1 = ss1.get_token();
+    const auto st2 = ss2.get_token();
+    assert(st1 == st2);
+    assert(!(st1 != st2));
+  }
+
+  // both has states. different sources with different states
+  {
+    std::stop_source ss1;
+    std::stop_source ss2;
+    const auto st1 = ss1.get_token();
+    const auto st2 = ss2.get_token();
+    assert(!(st1 == st2));
+    assert(st1 != st2);
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.stoptoken/stoptoken/nodiscard.verify.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: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+//  [[nodiscard]] bool stop_requested() const noexcept;
+//  [[nodiscard]] bool stop_possible() const noexcept;
+//  [[nodiscard]] friend bool operator==(const stop_token& lhs, const stop_token& rhs) noexcept;
+
+#include <stop_token>
+
+void test() {
+  std::stop_token st;
+  st.stop_requested(); // expected-warning {{ignoring return value of function}}
+  st.stop_possible();  // expected-warning {{ignoring return value of function}}
+  operator==(st, st);  // expected-warning {{ignoring return value of function}}
+}

libcxx/test/std/thread/thread.stoptoken/stoptoken/stop_possible.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: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// [[nodiscard]] bool stop_possible() const noexcept;
+// Returns: false if:
+//    - *this does not have ownership of a stop state, or
+//    - a stop request was not made and there are no associated stop_source objects;
+// otherwise, true.
+
+#include <cassert>
+#include <concepts>
+#include <optional>
+#include <stop_token>
+#include <type_traits>
+
+#include "make_test_thread.h"
+#include "test_macros.h"
+
+template <class T>
+concept IsStopPossibleNoexcept = requires(const T& t) {
+  { t.stop_possible() } noexcept;
+};
+
+static_assert(IsStopPossibleNoexcept<std::stop_token>);
+
+int main(int, char**) {
+  // no state
+  {
+    const std::stop_token st;
+    assert(!st.stop_possible());
+  }
+
+  // a stop request was not made and there are no associated stop_source objects
+  {
+    std::optional<std::stop_source> ss{std::in_place};
+    const auto st = ss->get_token();
+    ss.reset();
+
+    assert(!st.stop_possible());
+  }
+
+  // a stop request was not made, but there is an associated stop_source objects
+  {
+    std::stop_source ss;
+    const auto st = ss.get_token();
+    assert(st.stop_possible());
+  }
+
+  // a stop request was made and there are no associated stop_source objects
+  {
+    std::optional<std::stop_source> ss{std::in_place};
+    const auto st = ss->get_token();
+    ss->request_stop();
+    ss.reset();
+
+    assert(st.stop_possible());
+  }
+
+  // a stop request was made and there is an associated stop_source objects
+  {
+    std::stop_source ss;
+    const auto st = ss.get_token();
+    ss.request_stop();
+    assert(st.stop_possible());
+  }
+
+  // a stop request was made on a different thread and
+  // there are no associated stop_source objects
+  {
+    std::optional<std::stop_source> ss{std::in_place};
+    const auto st = ss->get_token();
+
+    std::thread t = support::make_test_thread([&]() {
+      ss->request_stop();
+      ss.reset();
+    });
+
+    assert(st.stop_possible());
+    t.join();
+    assert(st.stop_possible());
+
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.stoptoken/stoptoken/stop_requested.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: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// [[nodiscard]] bool stop_requested() const noexcept;
+// Returns: true if *this has ownership of a stop state that has received a stop request; otherwise, false.
+
+#include <cassert>
+#include <chrono>
+#include <concepts>
+#include <optional>
+#include <stop_token>
+#include <type_traits>
+
+#include "make_test_thread.h"
+#include "test_macros.h"
+
+template <class T>
+concept IsStopRequestedNoexcept = requires(const T& t) {
+  { t.stop_requested() } noexcept;
+};
+
+static_assert(IsStopRequestedNoexcept<std::stop_token>);
+
+int main(int, char**) {
+  // no state
+  {
+    const std::stop_token st;
+    assert(!st.stop_requested());
+  }
+
+  // has state
+  {
+    std::stop_source ss;
+    const auto st = ss.get_token();
+    assert(!st.stop_requested());
+
+    ss.request_stop();
+    assert(st.stop_requested());
+  }
+
+  // already requested before constructor
+  {
+    std::stop_source ss;
+    ss.request_stop();
+    const auto st = ss.get_token();
+    assert(st.stop_requested());
+  }
+
+  // stop_token should share the state
+  {
+    std::optional<std::stop_source> ss{std::in_place};
+    ss->request_stop();
+    const auto st = ss->get_token();
+
+    ss.reset();
+    assert(st.stop_requested());
+  }
+
+  // single stop_source, multiple stop_token
+  {
+    std::stop_source ss;
+    const auto st1 = ss.get_token();
+    const auto st2 = ss.get_token();
+    assert(!st1.stop_requested());
+    assert(!st2.stop_requested());
+
+    ss.request_stop();
+    assert(st1.stop_requested());
+    assert(st2.stop_requested());
+  }
+
+  // multiple stop_source, multiple stop_token
+  {
+    std::stop_source ss1;
+    std::stop_source ss2;
+
+    const auto st1 = ss1.get_token();
+    const auto st2 = ss2.get_token();
+    assert(!st1.stop_requested());
+    assert(!st2.stop_requested());
+
+    ss1.request_stop();
+    assert(st1.stop_requested());
+    assert(!st2.stop_requested());
+  }
+
+  // multiple threads
+  {
+    std::stop_source ss;
+    const auto st = ss.get_token();
+    assert(!st.stop_requested());
+
+    std::thread t = support::make_test_thread([&]() { ss.request_stop(); });
+
+    t.join();
+    assert(st.stop_requested());
+  }
+
+  // maybe concurrent calls
+  {
+    std::stop_source ss;
+    const auto st = ss.get_token();
+    assert(!st.stop_requested());
+
+    std::thread t = support::make_test_thread([&]() { ss.request_stop(); });
+
+    while (!st.stop_requested()) {
+      // should eventually exit the loop
+      std::this_thread::yield();
+    }
+
+    t.join();
+  }
+
+  // [thread.stoptoken.intro] A call to request_stop that returns true
+  // synchronizes with a call to stop_requested on an associated stop_token
+  // or stop_source object that returns true.
+  {
+    std::stop_source ss;
+    const auto st = ss.get_token();
+    assert(!st.stop_requested());
+
+    bool flag = false;
+
+    std::thread t = support::make_test_thread([&]() {
+      using namespace std::chrono_literals;
+      std::this_thread::sleep_for(1ms);
+
+      // happens-before request_stop
+      flag   = true;
+      auto b = ss.request_stop();
+      assert(b);
+    });
+
+    while (!st.stop_requested()) {
+      std::this_thread::yield();
+    }
+
+    // write should be visible to the current thread
+    assert(flag == true);
+
+    t.join();
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.stoptoken/stoptoken/swap.free.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: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// friend void swap(stop_token& x, stop_token& y) noexcept;
+
+#include <cassert>
+#include <concepts>
+#include <stop_token>
+#include <type_traits>
+
+#include "test_macros.h"
+
+template <class T>
+concept IsNoThrowFreeSwappable = requires(T& t) {
+  { swap(t, t) } noexcept;
+};
+
+static_assert(IsNoThrowFreeSwappable<std::stop_token>);
+
+int main(int, char**) {
+  {
+    std::stop_token st1;
+
+    std::stop_source source;
+    auto st2 = source.get_token();
+
+    assert(st1 != st2);
+
+    source.request_stop();
+
+    assert(!st1.stop_requested());
+    assert(st2.stop_requested());
+
+    swap(st1, st2);
+
+    assert(st1 != st2);
+    assert(st1.stop_requested());
+    assert(!st2.stop_requested());
+  }
+
+  return 0;
+}

libcxx/test/std/thread/thread.stoptoken/stoptoken/swap.member.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: no-threads
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: availability-synchronization_library-missing
+
+// void swap(stop_token& rhs) noexcept;
+
+#include <cassert>
+#include <concepts>
+#include <stop_token>
+#include <type_traits>
+
+#include "test_macros.h"
+
+template <class T>
+concept IsNoThrowMemberSwappable = requires(T& t) {
+  { t.swap(t) } noexcept;
+};
+
+static_assert(IsNoThrowMemberSwappable<std::stop_token>);
+
+int main(int, char**) {
+  {
+    std::stop_token st1;
+
+    std::stop_source source;
+    auto st2 = source.get_token();
+
+    assert(st1 != st2);
+
+    source.request_stop();
+
+    assert(!st1.stop_requested());
+    assert(st2.stop_requested());
+
+    st1.swap(st2);
+
+    assert(st1 != st2);
+    assert(st1.stop_requested());
+    assert(!st2.stop_requested());
+  }
+
+  return 0;
+}

libcxx/utils/generate_feature_test_macro_components.py

 
 # Map from each header to the Lit annotations that should be used for
 # tests that include that header.
 #
 # For example, when threads are not supported, any test that includes
 # <thread> should be marked as UNSUPPORTED, because including <thread>
 # is a hard error in that case.
 lit_markup = {
-    "barrier": ["UNSUPPORTED: no-threads"],
-    "filesystem": ["UNSUPPORTED: no-filesystem"],
-    "iomanip": ["UNSUPPORTED: no-localization"],
-    "ios": ["UNSUPPORTED: no-localization"],
-    "iostream": ["UNSUPPORTED: no-localization"],
-    "istream": ["UNSUPPORTED: no-localization"],
-    "latch": ["UNSUPPORTED: no-threads"],
-    "locale": ["UNSUPPORTED: no-localization"],
-    "mutex": ["UNSUPPORTED: no-threads"],
-    "ostream": ["UNSUPPORTED: no-localization"],
-    "regex": ["UNSUPPORTED: no-localization"],
-    "semaphore": ["UNSUPPORTED: no-threads"],
-    "shared_mutex": ["UNSUPPORTED: no-threads"],
-    "stdatomic.h": ["UNSUPPORTED: no-threads"],
-    "thread": ["UNSUPPORTED: no-threads"],
+  "stop_token": ["UNSUPPORTED: no-threads"],
 }
 
 
 def get_std_dialects():
     std_dialects = ["c++14", "c++17", "c++20", "c++23", "c++26"]
     return list(std_dialects)
 
 

libcxx/utils/generate_header_inclusion_tests.py

new_in_version = {
     "concepts": "20",
     "coroutine": "20",
     "cuchar": "11",
     "expected": "23",
     "filesystem": "17",
     "initializer_list": "11",
     "optional": "17",
     "ranges": "20",
+    "stop_token": "20",
     "string_view": "17",
     "syncstream": "20",
     "system_error": "11",
     "thread": "11",
     "tuple": "11",
     "uchar.h": "11",
     "unordered_map": "11",
     "unordered_set": "11",

libcxx/utils/libcxx/test/header_information.py

 header_restrictions = {
     "barrier": "!defined(_LIBCPP_HAS_NO_THREADS)",
     "future": "!defined(_LIBCPP_HAS_NO_THREADS)",
     "latch": "!defined(_LIBCPP_HAS_NO_THREADS)",
     "mutex": "!defined(_LIBCPP_HAS_NO_THREADS)",
     "semaphore": "!defined(_LIBCPP_HAS_NO_THREADS)",
     "shared_mutex": "!defined(_LIBCPP_HAS_NO_THREADS)",
     "stdatomic.h": "__cplusplus > 202002L && !defined(_LIBCPP_HAS_NO_THREADS)",
+    "stop_token": "!defined(_LIBCPP_HAS_NO_THREADS)",
     "thread": "!defined(_LIBCPP_HAS_NO_THREADS)",
     "filesystem": "!defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)",
     # TODO(LLVM-17): simplify this to __cplusplus >= 202002L
     "coroutine": "(defined(__cpp_impl_coroutine) && __cpp_impl_coroutine >= 201902L) || (defined(__cpp_coroutines) && __cpp_coroutines >= 201703L)",
     "clocale": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
     "codecvt": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
     "fstream": "!defined(_LIBCPP_HAS_NO_LOCALIZATION) && !defined(_LIBCPP_HAS_NO_FSTREAM)",
     "iomanip": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",