[libc++] Assume that coroutines are available in C++20

[ldionne]

Summary

All supported compilers have support for coroutines in C++20 now.

[Mordante]

Are you sure all CIs have this available? I tried about a month ago and ran into CI issues, see D143485.

[ldionne]

Rebase

[ldionne]

In D145086#4162218, @Mordante wrote:

Are you sure all CIs have this available? I tried about a month ago and ran into CI issues, see D143485.

Interesting, let's see what the CI thinks this time around.

[ldionne]

In D145086#4162687, @ldionne wrote:

In D145086#4162218, @Mordante wrote:

Are you sure all CIs have this available? I tried about a month ago and ran into CI issues, see D143485.

Interesting, let's see what the CI thinks this time around.

Yeah, it does look like the latest supported AppleClang doesn't work out of the box. Let's wait a bit before landing this.

[Mordante]

In D145086#4164994, @ldionne wrote:

In D145086#4162687, @ldionne wrote:

In D145086#4162218, @Mordante wrote:

Are you sure all CIs have this available? I tried about a month ago and ran into CI issues, see D143485.

Interesting, let's see what the CI thinks this time around.

Yeah, it does look like the latest supported AppleClang doesn't work out of the box. Let's wait a bit before landing this.

That indeed matches my experience. I just abandoned my patch in favour of this one.

[ldionne]

Rebase

[ldionne]

Rebase on top of modular build fixes (hopefully).

[ldionne]

This works now, only the AIX build failed so I'll ship this.

(Edit: I think this must have started working when I updated the last AppleClang builders recently)

libcxx/docs/DesignDocs/ExperimentalFeatures.rst

 Some (most) of the Parallelism TS was accepted for C++17.
 We have not yet shipped an implementation of the Parallelism TS.
 
 `Coroutines TS <https://wg21.link/N4680>`__
 -------------------------------------------
 The Coroutines TS was accepted for C++20.
 An implementation of the Coroutines TS was shipped in LLVM 5.0 in namespace ``std::experimental``,
 and C++20 Coroutines shipped in LLVM 14.0. The implementation of the Coroutines TS in ``std::experimental``
-will be removed in LLVM 16.0.
+has been removed in LLVM 17.0.
 
 `Networking TS <https://wg21.link/N4656>`__
 -------------------------------------------
 The Networking TS is not yet part of a shipping standard.
 We have not yet shipped an implementation of the Networking TS.
 
 `Ranges TS <https://wg21.link/N4685>`__
 ---------------------------------------

libcxx/test/libcxx/assertions/headers_declare_verbose_abort.sh.cpp

 
 // RUN: %{build} -DTEST_25
 #if defined(TEST_25)
 #   include <condition_variable>
     using HandlerType = decltype(std::__libcpp_verbose_abort);
 #endif
 
 // RUN: %{build} -DTEST_26
-#if defined(TEST_26) && (defined(__cpp_impl_coroutine) && __cpp_impl_coroutine >= 201902L) || (defined(__cpp_coroutines) && __cpp_coroutines >= 201703L)
+#if defined(TEST_26) && __cplusplus >= 202002L
 #   include <coroutine>
     using HandlerType = decltype(std::__libcpp_verbose_abort);
 #endif
 
 // RUN: %{build} -DTEST_27
 #if defined(TEST_27)
 #   include <csetjmp>
     using HandlerType = decltype(std::__libcpp_verbose_abort);

libcxx/test/libcxx/clang_tidy.sh.cpp

 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   include <codecvt>
 #endif
 #include <compare>
 #include <complex>
 #include <complex.h>
 #include <concepts>
 #include <condition_variable>
-#if (defined(__cpp_impl_coroutine) && __cpp_impl_coroutine >= 201902L) || (defined(__cpp_coroutines) && __cpp_coroutines >= 201703L)
+#if __cplusplus >= 202002L
 #   include <coroutine>
 #endif
 #include <csetjmp>
 #include <csignal>
 #include <cstdarg>
 #include <cstdbool>
 #include <cstddef>
 #include <cstdint>

libcxx/test/libcxx/double_include.sh.cpp

 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   include <codecvt>
 #endif
 #include <compare>
 #include <complex>
 #include <complex.h>
 #include <concepts>
 #include <condition_variable>
-#if (defined(__cpp_impl_coroutine) && __cpp_impl_coroutine >= 201902L) || (defined(__cpp_coroutines) && __cpp_coroutines >= 201703L)
+#if __cplusplus >= 202002L
 #   include <coroutine>
 #endif
 #include <csetjmp>
 #include <csignal>
 #include <cstdarg>
 #include <cstdbool>
 #include <cstddef>
 #include <cstdint>

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

 #include <complex>
 TEST_MACROS();
 #include <complex.h>
 TEST_MACROS();
 #include <concepts>
 TEST_MACROS();
 #include <condition_variable>
 TEST_MACROS();
-#if (defined(__cpp_impl_coroutine) && __cpp_impl_coroutine >= 201902L) || (defined(__cpp_coroutines) && __cpp_coroutines >= 201703L)
+#if __cplusplus >= 202002L
 #   include <coroutine>
 TEST_MACROS();
 #endif
 #include <csetjmp>
 TEST_MACROS();
 #include <csignal>
 TEST_MACROS();
 #include <cstdarg>

libcxx/test/libcxx/modules_include.sh.cpp

 // RUN: echo 'TEST_25=$!' >> %t.sh
 // RUN: echo "wait $TEST_9" >> %t.sh
 #if defined(TEST_25)
 #include <condition_variable>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_26 &' >> %t.sh
 // RUN: echo 'TEST_26=$!' >> %t.sh
 // RUN: echo "wait $TEST_10" >> %t.sh
-#if defined(TEST_26) && (defined(__cpp_impl_coroutine) && __cpp_impl_coroutine >= 201902L) || (defined(__cpp_coroutines) && __cpp_coroutines >= 201703L)
+#if defined(TEST_26) && __cplusplus >= 202002L
 #include <coroutine>
 #endif
 // RUN: echo '%{cxx} %s %{flags} %{compile_flags} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only -DTEST_27 &' >> %t.sh
 // RUN: echo 'TEST_27=$!' >> %t.sh
 // RUN: echo "wait $TEST_11" >> %t.sh
 #if defined(TEST_27)
 #include <csetjmp>
 #endif

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

 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   include <codecvt>
 #endif
 #include <compare>
 #include <complex>
 #include <complex.h>
 #include <concepts>
 #include <condition_variable>
-#if (defined(__cpp_impl_coroutine) && __cpp_impl_coroutine >= 201902L) || (defined(__cpp_coroutines) && __cpp_coroutines >= 201703L)
+#if __cplusplus >= 202002L
 #   include <coroutine>
 #endif
 #include <csetjmp>
 #include <csignal>
 #include <cstdarg>
 #include <cstdbool>
 #include <cstddef>
 #include <cstdint>

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

 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
 #   include <codecvt>
 #endif
 #include <compare>
 #include <complex>
 #include <complex.h>
 #include <concepts>
 #include <condition_variable>
-#if (defined(__cpp_impl_coroutine) && __cpp_impl_coroutine >= 201902L) || (defined(__cpp_coroutines) && __cpp_coroutines >= 201703L)
+#if __cplusplus >= 202002L
 #   include <coroutine>
 #endif
 #include <csetjmp>
 #include <csignal>
 #include <cstdarg>
 #include <cstdbool>
 #include <cstddef>
 #include <cstdint>

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.hash/hash.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-no-coroutines
 
 // <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // namespace std {
 //  template <class P> struct hash<coroutine_handle<P>>;

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.capacity/operator_bool.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-no-coroutines
 
 // <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // constexpr explicit operator bool() const noexcept
 

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.compare/equal_comp.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-no-coroutines
 
 // <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // constexpr bool operator==(coroutine_handle<> x, coroutine_handle<> y) noexcept;
 

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.compare/less_comp.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-no-coroutines
 
 // <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // constexpr strong_ordering operator<=>(coroutine_handle<> x, coroutine_handle<> y) noexcept;
 

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.completion/done.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-no-coroutines
 
 // <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // bool done() const
 

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.con/assign.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-no-coroutines
 
 // <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // coroutine_handle& operator=(nullptr_t) noexcept
 

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.con/construct.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-no-coroutines
 
 // <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // constexpr coroutine_handle() noexcept
 // constexpr coroutine_handle(nullptr_t) noexcept

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/address.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-no-coroutines
 
 // <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // constexpr void* address() const noexcept
 

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-no-coroutines
 
 // <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // static coroutine_handle from_address(void*) noexcept
 

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.noop/noop_coroutine.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 // UNSUPPORTED: ubsan
-// UNSUPPORTED: libcpp-no-coroutines
 
 // <coroutine>
 // struct noop_coroutine_promise;
 // using noop_coroutine_handle = coroutine_handle<noop_coroutine_promise>;
 // noop_coroutine_handle noop_coroutine() noexcept;
 
 #include <coroutine>
 #include <cassert>

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.prom/promise.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-no-coroutines
 
 // <coroutine>
 
 // template <class Promise>
 // struct coroutine_handle<Promise>;
 
 // Promise& promise() const
 

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.resumption/destroy.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-no-coroutines
 
 // <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // void destroy() const
 

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.resumption/resume.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-no-coroutines
 
 // <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // void operator()() const
 // void resume() const

libcxx/test/std/language.support/support.coroutines/coroutine.handle/void_handle.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-no-coroutines
 
 #include <coroutine>
 #include <type_traits>
 
 #include "test_macros.h"
 
 struct A {
   using promise_type = A*;

libcxx/test/std/language.support/support.coroutines/coroutine.traits/promise_type.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-no-coroutines
 
 #include <coroutine>
 #include <type_traits>
 
 #include "test_macros.h"
 
 template <class T, class = typename T::promise_type>
 constexpr bool has_promise_type(int) { return true; }

libcxx/test/std/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_always.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-no-coroutines
 
 #include <coroutine>
 #include <type_traits>
 #include <cassert>
 #include <utility>
 
 #include "test_macros.h"
 

libcxx/test/std/language.support/support.coroutines/coroutine.trivial.awaitables/suspend_never.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-no-coroutines
 
 #include <coroutine>
 #include <type_traits>
 #include <cassert>
 #include <utility>
 
 #include "test_macros.h"
 

libcxx/test/std/language.support/support.coroutines/end.to.end/await_result.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-no-coroutines
 
 #include <coroutine>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct coro_t {
   struct promise_type {

libcxx/test/std/language.support/support.coroutines/end.to.end/bool_await_suspend.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-no-coroutines
 
 // See https://llvm.org/PR33271
 // UNSUPPORTED: ubsan
 
 #include <coroutine>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/language.support/support.coroutines/end.to.end/expected.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-no-coroutines
 
 #include <coroutine>
 #include <cassert>
 #include <memory>
 
 #include "test_macros.h"
 
 struct error_tag { };

libcxx/test/std/language.support/support.coroutines/end.to.end/fullexpr-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: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-no-coroutines
 
 #include <coroutine>
 #include <cassert>
 
 #include "test_macros.h"
 
 int alive = 0;
 int ctor_called = 0;

libcxx/test/std/language.support/support.coroutines/end.to.end/generator.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-no-coroutines
 
 // See https://llvm.org/PR33271
 // UNSUPPORTED: ubsan
 
 #include <coroutine>
 #include <vector>
 #include <cassert>
 

libcxx/test/std/language.support/support.coroutines/end.to.end/go.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-no-coroutines
 
 #include <cassert>
 #include <coroutine>
 #include <memory>
 
 #include "test_macros.h"
 
 bool cancel = false;

libcxx/test/std/language.support/support.coroutines/end.to.end/multishot_func.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-no-coroutines
 
 #include <coroutine>
 #include <cassert>
 
 #include "test_macros.h"
 
 // This file tests, multishot, movable std::function like thing using coroutine
 // for compile-time type erasure and unerasure.

libcxx/test/std/language.support/support.coroutines/end.to.end/oneshot_func.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
-// UNSUPPORTED: libcpp-no-coroutines
 
 #include <coroutine>
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 
 // This file tests, one shot, movable std::function like thing using coroutine

libcxx/utils/generate_header_tests.py

header_restrictions = {
     "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)",
     "thread": "!defined(_LIBCPP_HAS_NO_THREADS)",
 
     "filesystem": "!defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)",
 
-    # TODO LLVM17: simplify this to __cplusplus >= 202002L
-    "coroutine": "(defined(__cpp_impl_coroutine) && __cpp_impl_coroutine >= 201902L) || (defined(__cpp_coroutines) && __cpp_coroutines >= 201703L)",
+    "coroutine": "__cplusplus >= 202002L",
 
     "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)",
     "ios": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
     "iostream": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
     "istream": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",

libcxx/utils/libcxx/test/features.py

DEFAULT_FEATURES = [
 
   Feature(name='has-fconstexpr-ops-limit',
           when=lambda cfg: hasCompileFlag(cfg, '-fconstexpr-ops-limit=1')),
 
   Feature(name='has-fblocks',                   when=lambda cfg: hasCompileFlag(cfg, '-fblocks')),
   Feature(name='-fsized-deallocation',          when=lambda cfg: hasCompileFlag(cfg, '-fsized-deallocation')),
   Feature(name='-faligned-allocation',          when=lambda cfg: hasCompileFlag(cfg, '-faligned-allocation')),
   Feature(name='fdelayed-template-parsing',     when=lambda cfg: hasCompileFlag(cfg, '-fdelayed-template-parsing')),
-  Feature(name='libcpp-no-coroutines',          when=lambda cfg: featureTestMacros(cfg).get('__cpp_impl_coroutine', 0) < 201902),
   Feature(name='has-fobjc-arc',                 when=lambda cfg: hasCompileFlag(cfg, '-xobjective-c++ -fobjc-arc') and
                                                                  sys.platform.lower().strip() == 'darwin'), # TODO: this doesn't handle cross-compiling to Apple platforms.
   Feature(name='objective-c++',                 when=lambda cfg: hasCompileFlag(cfg, '-xobjective-c++ -fobjc-arc')),
   Feature(name='verify-support',                when=lambda cfg: hasCompileFlag(cfg, '-Xclang -verify-ignore-unexpected')),
 
   Feature(name='non-lockfree-atomics',
           when=lambda cfg: sourceBuilds(cfg, """
             #include <atomic>