[libc++] Make `stop_token` experimental

[ldionne]

Summary

There are discussions about different ways of implementing stop_token to make it more performant
mark stop_token as experimental to allow us to change the design before it is shipped

[ldionne]

libcxx/include/__stop_token/stop_callback.h

23

Let's instead add something like this to __config:

#  if !defined(_LIBCPP_ENABLE_EXPERIMENTAL) && !defined(_LIBCPP_BUILDING_LIBRARY)
#    define _LIBCPP_HAS_NO_INCOMPLETE_STOP_TOKEN
#  endif

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

10

Here let's introduce a specific Lit feature for it.

[ldionne]

Commandeering as discussed with Hui!

[Mordante]

I mainly glossed over the the patch.

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

10

Please also update libcxx/test/libcxx/experimental/fexperimental-library.compile.pass.cpp

[ldionne]

libcxx/include/__stop_token/stop_callback.h

15

Also let's tweak the release note.

[ldionne]

Address comments and rebase.

[Mordante]

libcxx/include/__stop_token/stop_callback.h

15

I already made changes in my draft update for the release notes ;-)
I still want to look whether we missed other changes, so I probably upload it later today.

[ldionne]

libcxx/include/__stop_token/stop_callback.h

15

Oh, nice, thanks for having a review with updates to the release notes. This comment was actually saying that we should update the release notes to account for the fact that this is now experimental, however I realized that we didn't add stop_token to the release notes at all, so that's moot. But if you mention stop_token in your release notes update, let's mention it as being experimental.

[ldionne]

Fix inverted conditions and missing Lit feature.

[Mordante]

libcxx/include/__stop_token/stop_callback.h

15

That's what I already did ;-)

[ldionne]

Address a comment I had missed.

[ldionne]

CI failure is a fluke, merging.

libcxx/include/__stop_token/stop_callback.h

15

Great, thanks!

libcxx/include/__config

 #  endif
 
 // Incomplete features get their own specific disabling flags. This makes it
 // easier to grep for target specific flags once the feature is complete.
 #  if !defined(_LIBCPP_ENABLE_EXPERIMENTAL) && !defined(_LIBCPP_BUILDING_LIBRARY)
 #    define _LIBCPP_HAS_NO_INCOMPLETE_PSTL
 #  endif
 
+#  if !defined(_LIBCPP_ENABLE_EXPERIMENTAL) && !defined(_LIBCPP_BUILDING_LIBRARY)
+#    define _LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN
+#  endif
+
 // Need to detect which libc we're using if we're on Linux.
 #  if defined(__linux__)
 #    include <features.h>
 #    if defined(__GLIBC_PREREQ)
 #      define _LIBCPP_GLIBC_PREREQ(a, b) __GLIBC_PREREQ(a, b)
 #    else
 #      define _LIBCPP_GLIBC_PREREQ(a, b) 0
 #    endif // defined(__GLIBC_PREREQ)

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
+#if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN)
 
 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 "

 
 template <class Callback>
 _LIBCPP_AVAILABILITY_SYNC stop_callback(stop_token, Callback) -> stop_callback<Callback>;
 
 #endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
-#endif // _LIBCPP___STOP_TOKEN_STOP_TOKEN_H
+#endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN)

libcxx/include/__stop_token/stop_source.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
+#if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN)
 
 struct nostopstate_t {
   explicit nostopstate_t() = default;
 };
 
 inline constexpr nostopstate_t nostopstate{};
 
 class _LIBCPP_AVAILABILITY_SYNC stop_source {

 private:
   __intrusive_shared_ptr<__stop_state> __state_;
 };
 
 #endif // _LIBCPP_STD_VER >= 20
 
 _LIBCPP_END_NAMESPACE_STD
 
-#endif // _LIBCPP___STOP_TOKEN_STOP_SOURCE_H
+#endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN)

libcxx/include/__stop_token/stop_token.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
+#if _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN)
 
 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;
private:
 
   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
+#endif // _LIBCPP_STD_VER >= 20 && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN)
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___STOP_TOKEN_STOP_TOKEN_H

libcxx/test/libcxx/experimental/fexperimental-library.compile.pass.cpp

 
 // ADDITIONAL_COMPILE_FLAGS: -fexperimental-library
 
 #include <version>
 
 #ifdef _LIBCPP_HAS_NO_INCOMPLETE_PSTL
 #  error "-fexperimental-library should enable the PSTL"
 #endif
+
+#ifdef _LIBCPP_HAS_NO_EXPERIMENTAL_STOP_TOKEN
+#  error "-fexperimental-library should enable the PSTL"
+#endif

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: libcpp-has-no-experimental-stop_token
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // struct nostopstate_t {
 //   explicit nostopstate_t() = default;
 // };
 //
 // inline constexpr nostopstate_t nostopstate{};
 

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: libcpp-has-no-experimental-stop_token
 // 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>

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: libcpp-has-no-experimental-stop_token
 // 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>

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: libcpp-has-no-experimental-stop_token
 // 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;
 

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: libcpp-has-no-experimental-stop_token
 // 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>

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: libcpp-has-no-experimental-stop_token
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // XFAIL: availability-synchronization_library-missing
 
 // ~stop_callback();
 
 #include <atomic>
 #include <cassert>
 #include <chrono>

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: libcpp-has-no-experimental-stop_token
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 // using callback_type = _Callback;
 
 #include <stop_token>
 #include <type_traits>
 
 struct 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: libcpp-has-no-experimental-stop_token
 // 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>

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: libcpp-has-no-experimental-stop_token
 // 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>

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: libcpp-has-no-experimental-stop_token
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // XFAIL: availability-synchronization_library-missing
 
 // stop_source();
 
 #include <cassert>
 #include <stop_token>
 #include <type_traits>

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: libcpp-has-no-experimental-stop_token
 // 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>

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: libcpp-has-no-experimental-stop_token
 // 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>

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: libcpp-has-no-experimental-stop_token
 // 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>

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: libcpp-has-no-experimental-stop_token
 // 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>

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: libcpp-has-no-experimental-stop_token
 // 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>

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: libcpp-has-no-experimental-stop_token
 // 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;
 

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: libcpp-has-no-experimental-stop_token
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // XFAIL: availability-synchronization_library-missing
 
 // bool request_stop() noexcept;
 
 #include <cassert>
 #include <chrono>
 #include <concepts>

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: libcpp-has-no-experimental-stop_token
 // 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>

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: libcpp-has-no-experimental-stop_token
 // 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>

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: libcpp-has-no-experimental-stop_token
 // 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>

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: libcpp-has-no-experimental-stop_token
 // 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>

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: libcpp-has-no-experimental-stop_token
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // XFAIL: availability-synchronization_library-missing
 
 #include <cassert>
 #include <concepts>
 #include <stop_token>
 #include <type_traits>
 

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: libcpp-has-no-experimental-stop_token
 // 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>

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: libcpp-has-no-experimental-stop_token
 // 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>

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: libcpp-has-no-experimental-stop_token
 // 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>

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: libcpp-has-no-experimental-stop_token
 // 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>

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: libcpp-has-no-experimental-stop_token
 // 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.
 

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: libcpp-has-no-experimental-stop_token
 // 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: libcpp-has-no-experimental-stop_token
 // 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.

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: libcpp-has-no-experimental-stop_token
 // 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>

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: libcpp-has-no-experimental-stop_token
 // 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>

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: libcpp-has-no-experimental-stop_token
 // 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>

libcxx/utils/libcxx/test/params.py

Parameter(
             # as those features are added after processing parameters.
             AddFeature("c++experimental"),
             PrependLinkFlag(lambda cfg: "-llibc++experimental" if _isMSVC(cfg) else "-lc++experimental"),
             AddCompileFlag("-D_LIBCPP_ENABLE_EXPERIMENTAL"),
         ]
         if experimental
         else [
             AddFeature("libcpp-has-no-incomplete-pstl"),
+            AddFeature("libcpp-has-no-experimental-stop_token"),
         ],
     ),
     Parameter(
         name="long_tests",
         choices=[True, False],
         type=bool,
         default=True,
         help="Whether to enable tests that take longer to run. This can be useful when running on a very slow device.",