[NO NOT COMMIT][libc++][modules] Updates tests.

[Mordante]

Summary

This patch is used to test the changes of D144994. For now only the
coroutines are done other parts of the test suite will follow at a
later stage.

The conversion is done by:
find libcxx/test/std/language.support/support.coroutines/ -name '*.cpp' -exec python3 libcxx/utils/use_modules_in_test.py \{} \;

Depends on D144994

[Mordante]

It seems this change is not wanted, when it would be the patch would need to be recreated due to the divergence with main.

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

 // template <class Promise = void>
 // struct coroutine_handle;
 
 // namespace std {
 //  template <class P> struct hash<coroutine_handle<P>>;
 // }
 
 #include <coroutine>
+#ifdef TEST_MODULES
+import std;
+#endif
+#ifndef TEST_MODULES
 #include <type_traits>
+#endif
 #include <memory>
+#ifndef TEST_MODULES
 #include <utility>
+#endif
 #include <cstdint>
 #include <cassert>
 #include <functional>
 
 #include "test_macros.h"
 
 template <class C>
 void do_test(int *LHSVal, int *RHSVal) {

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

 // <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // constexpr explicit operator bool() const noexcept
 
 #include <coroutine>
+#ifdef TEST_MODULES
+import std;
+#endif
+#ifndef TEST_MODULES
 #include <type_traits>
+#endif
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class C>
 constexpr bool do_test() {
   static_assert(std::is_nothrow_constructible<bool, C>::value, "");
   static_assert(!std::is_convertible<C, bool>::value, "");

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

 // <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // constexpr bool operator==(coroutine_handle<> x, coroutine_handle<> y) noexcept;
 
 #include <coroutine>
+#ifdef TEST_MODULES
+import std;
+#endif
+#ifndef TEST_MODULES
 #include <type_traits>
+#endif
+#ifndef TEST_MODULES
 #include <utility>
+#endif
 #include <cstdint>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class C>
 void do_test(int *LHSVal, int *RHSVal) {
   const C LHS = C::from_address(LHSVal);

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

 // <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // constexpr strong_ordering operator<=>(coroutine_handle<> x, coroutine_handle<> y) noexcept;
 
 #include <coroutine>
+#ifdef TEST_MODULES
+import std;
+#endif
+#ifndef TEST_MODULES
 #include <type_traits>
+#endif
+#ifndef TEST_MODULES
 #include <utility>
+#endif
 #include <cstdint>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class C>
 void do_test(int *LHSVal, int *RHSVal) {
   const C LHS = C::from_address(LHSVal);

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

 // <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // bool done() const
 
 #include <coroutine>
+#ifdef TEST_MODULES
+import std;
+#endif
+#ifndef TEST_MODULES
 #include <type_traits>
+#endif
 #include <memory>
+#ifndef TEST_MODULES
 #include <utility>
+#endif
 #include <cstdint>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class Promise>
 void do_test(std::coroutine_handle<Promise> const& H) {
   // FIXME Add a runtime test

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

 // <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // coroutine_handle& operator=(nullptr_t) noexcept
 
 #include <coroutine>
+#ifdef TEST_MODULES
+import std;
+#endif
+#ifndef TEST_MODULES
 #include <type_traits>
+#endif
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class C>
 void do_test() {
   int dummy = 42;
   void* dummy_h = &dummy;

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

 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // constexpr coroutine_handle() noexcept
 // constexpr coroutine_handle(nullptr_t) noexcept
 
 #include <coroutine>
+#ifdef TEST_MODULES
+import std;
+#endif
+#ifndef TEST_MODULES
 #include <type_traits>
+#endif
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class C>
 constexpr bool do_test() {
   static_assert(std::is_nothrow_constructible<C>::value, "");
   static_assert(std::is_nothrow_constructible<C, std::nullptr_t>::value, "");

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

 // <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // constexpr void* address() const noexcept
 
 #include <coroutine>
+#ifdef TEST_MODULES
+import std;
+#endif
+#ifndef TEST_MODULES
 #include <type_traits>
+#endif
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class C>
 constexpr bool do_test() {
   {
     constexpr C c; ((void)c);

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

 // <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // static coroutine_handle from_address(void*) noexcept
 
 #include <coroutine>
+#ifdef TEST_MODULES
+import std;
+#endif
+#ifndef TEST_MODULES
 #include <type_traits>
+#endif
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class C>
 void do_test() {
   {
     C c = C::from_address(nullptr);

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

 
 // <coroutine>
 // struct noop_coroutine_promise;
 // using noop_coroutine_handle = coroutine_handle<noop_coroutine_promise>;
 // noop_coroutine_handle noop_coroutine() noexcept;
 
 #include <coroutine>
 #include <cassert>
+#ifdef TEST_MODULES
+import std;
+#endif
+#ifndef TEST_MODULES
 #include <type_traits>
+#endif
 
 #include "test_macros.h"
 
 static_assert(std::is_same<std::coroutine_handle<std::noop_coroutine_promise>, std::noop_coroutine_handle>::value, "");
 static_assert(std::is_same<decltype(std::noop_coroutine()), std::noop_coroutine_handle>::value, "");
 
 // template <> struct coroutine_handle<noop_coroutine_promise> : coroutine_handle<>
 // {

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

 // <coroutine>
 
 // template <class Promise>
 // struct coroutine_handle<Promise>;
 
 // Promise& promise() const
 
 #include <coroutine>
+#ifdef TEST_MODULES
+import std;
+#endif
+#ifndef TEST_MODULES
 #include <type_traits>
+#endif
 #include <memory>
+#ifndef TEST_MODULES
 #include <utility>
+#endif
 #include <cstdint>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct MyCoro {
   struct promise_type {
     void unhandled_exception() {}

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

 // <coroutine>
 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // void destroy() const
 
 #include <coroutine>
+#ifdef TEST_MODULES
+import std;
+#endif
+#ifndef TEST_MODULES
 #include <type_traits>
+#endif
 #include <memory>
+#ifndef TEST_MODULES
 #include <utility>
+#endif
 #include <cstdint>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class H>
 auto has_destroy_imp(H&& h, int) -> decltype(h.destroy(), std::true_type{});
 template <class H>

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

 
 // template <class Promise = void>
 // struct coroutine_handle;
 
 // void operator()() const
 // void resume() const
 
 #include <coroutine>
+#ifdef TEST_MODULES
+import std;
+#endif
+#ifndef TEST_MODULES
 #include <type_traits>
+#endif
 #include <memory>
+#ifndef TEST_MODULES
 #include <utility>
+#endif
 #include <cstdint>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class H>
 auto has_resume_imp(H&& h, int) -> decltype(h.resume(), std::true_type{});
 template <class H>

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>
+#ifdef TEST_MODULES
+import std;
+#endif
+#ifndef TEST_MODULES
 #include <type_traits>
+#endif
 
 #include "test_macros.h"
 
 struct A {
   using promise_type = A*;
 };
 
 struct B {};

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>
+#ifdef TEST_MODULES
+import std;
+#endif
+#ifndef TEST_MODULES
 #include <type_traits>
+#endif
 
 #include "test_macros.h"
 
 template <class T, class = typename T::promise_type>
 constexpr bool has_promise_type(int) { return true; }
 template <class>
 constexpr bool has_promise_type(long) { return false; }
 template <class T>

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>
+#ifdef TEST_MODULES
+import std;
+#endif
+#ifndef TEST_MODULES
 #include <type_traits>
+#endif
 #include <cassert>
+#ifndef TEST_MODULES
 #include <utility>
+#endif
 
 #include "test_macros.h"
 
 constexpr bool check_suspend_constexpr() {
   std::suspend_always s{};
   const std::suspend_always scopy(s);
   std::suspend_always smove(std::move(s));
   s = scopy;

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>
+#ifdef TEST_MODULES
+import std;
+#endif
+#ifndef TEST_MODULES
 #include <type_traits>
+#endif
 #include <cassert>
+#ifndef TEST_MODULES
 #include <utility>
+#endif
 
 #include "test_macros.h"
 
 constexpr bool check_suspend_constexpr() {
   std::suspend_never s{};
   const std::suspend_never scopy(s); ((void)scopy);
   std::suspend_never smove(std::move(s)); ((void)smove);
   s = scopy;

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>
+#ifdef TEST_MODULES
+import std;
+#endif
+#ifndef TEST_MODULES
 #include <vector>
+#endif
 #include <cassert>
 
 #include "test_macros.h"
 
 template <typename Ty> struct generator {
   struct promise_type {
     Ty current_value;
     std::suspend_always yield_value(Ty value) {

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>
+#ifdef TEST_MODULES
+import std;
+#endif
+#ifndef TEST_MODULES
 #include <vector>
+#endif
 #include <cassert>
 
 #include "test_macros.h"
 
 // This file tests, one shot, movable std::function like thing using coroutine
 // for compile-time type erasure and unerasure.
 
 template <typename R> struct func {