[Draft] [libcxx] introducing std modules

[ChuanqiXu]

Summary

This is only a draft for asking questions due to I am not familiar with testing infrastructure. No reviewing is required. We need some higher level discussion now.

The main problem I meet now is how can I add another test mode with new macro definitions (or new compiler options).

See test/std_modules/language.support/support.coroutines/end.to.end/generator.pass.cpp and https://github.com/llvm/llvm-project/blob/main/libcxx/test/std/language.support/support.coroutines/end.to.end/generator.pass.cpp, there two differences only:

• the modules version add another unsupported testing mode: c++20
• the modules version uses import std; while the original one includes <vector> and <coroutine>.

What I want to achieve is the following one:

// UNSUPPORTED: c++03, c++11, c++14, c++17
// UNSUPPORTED: libcpp-no-coroutines

// See https://llvm.org/PR33271
// UNSUPPORTED: ubsan

#include <cassert>
#include "test_macros.h"

#ifdef USE_STD_MODULES
import std;
#else
#include <coroutine>
#include <vector>
#endif

Then for every testing mode with std version higher than C++20, it will test the file twice. One with the macro USE_STD_MODULES and one without it. But I failed to make it so I am wondering if it is better to ask questions here.

(I updated the discussion in https://discourse.llvm.org/t/maybe-we-could-start-to-play-with-std-modules/64093/15. And the question here should be independent with the concrete implementation methods.)

[philnik]

I think it would be a lot easier to generate dummy headers, which just import std;. These can be used instead of the actual headers in the tests, so we don't have to add an #ifdef for every single test.

libcxx/modules/CMakeLists.txt

18

libcxx/modules/std-coroutine.cppm

1–14

I think it would be nice if we add the sections like this:

module;

#include <coroutine>

export module std:coroutine;

export namespace std {
  // [coroutine.traits]
  using std::coroutine_traits;

  // [coroutine.handle]
  using std::coroutine_handle;

  // [coroutine.handle.compare]
  using std::operator==;
  using std::operator<=>;

  // [coroutine.handle.hash]
  using std::hash;

  // [coroutine.noop]
  using std::noop_coroutine_promise;
  using std::noop_coroutine_handle;
  using std::noop_coroutine;

  // [coroutine.trivial.awaitables]
  using std::suspend_always;
  using std::suspend_never;
}

This makes it a lot easier to compare to the standard, since we already know in which section to look. This will be especially useful for large headers like <algorithm> or <type_traits>.

[ChuanqiXu]

In D135507#3844778, @philnik wrote:

I think it would be a lot easier to generate dummy headers, which just import std;. These can be used instead of the actual headers in the tests, so we don't have to add an #ifdef for every single test.

I don't get your point.. May you elaborate more? The reason why I stopped at the current state is that I feel it is bad to copy the test files. So I can move on if I avoid the copyings.

libcxx/modules/std-coroutine.cppm

1–14

Yeah, I'll follow when this one is not draft.

[philnik]

In D135507#3844785, @ChuanqiXu wrote:

In D135507#3844778, @philnik wrote:

I think it would be a lot easier to generate dummy headers, which just import std;. These can be used instead of the actual headers in the tests, so we don't have to add an #ifdef for every single test.

I don't get your point.. May you elaborate more? The reason why I stopped at the current state is that I feel it is bad to copy the test files. So I can move on if I avoid the copyings.

The idea is that you generate the public headers, which just import std; instead of the actual headers. i.e. you build the modules with the normal headers. Then you generate all the public headers, which just contain import std;. These get used by the tests. That way as soon as a test #include <public-header> the std module gets imported.

For example, you have an <algorithm> header which contains all the actual stuff and you generate an <algorithm> header which is just:

algorithm

import std;

Then you have a test:

test.pass.cpp

#include <algorithm>

...

That test uses the generated header, so it just imports std instead of including the implementation header. Does that explanation make sense?

[ChuanqiXu]

In D135507#3844834, @philnik wrote:

In D135507#3844785, @ChuanqiXu wrote:

In D135507#3844778, @philnik wrote:

I think it would be a lot easier to generate dummy headers, which just import std;. These can be used instead of the actual headers in the tests, so we don't have to add an #ifdef for every single test.

I don't get your point.. May you elaborate more? The reason why I stopped at the current state is that I feel it is bad to copy the test files. So I can move on if I avoid the copyings.

The idea is that you generate the public headers, which just import std; instead of the actual headers. i.e. you build the modules with the normal headers. Then you generate all the public headers, which just contain import std;. These get used by the tests. That way as soon as a test #include <public-header> the std module gets imported.

For example, you have an <algorithm> header which contains all the actual stuff and you generate an <algorithm> header which is just:

algorithm

import std;

Then you have a test:

test.pass.cpp

#include <algorithm>

...

That test uses the generated header, so it just imports std instead of including the implementation header. Does that explanation make sense?

I got your point. It makes sense. The only problem I have now is how to make it.. do you have any ideas?

[Mordante]

In D135507#3845196, @ChuanqiXu wrote:

I got your point. It makes sense. The only problem I have now is how to make it.. do you have any ideas?

I also don't have an immediate solution. But maybe post on our Discord channel @ldionne is more active there and he often has some suggestions.

[ChuanqiXu]

In D135507#3853191, @Mordante wrote:

In D135507#3845196, @ChuanqiXu wrote:

I got your point. It makes sense. The only problem I have now is how to make it.. do you have any ideas?

I also don't have an immediate solution. But maybe post on our Discord channel @ldionne is more active there and he often has some suggestions.

Oh, I got it. Thanks.

In D135507#3844834, @philnik wrote:

In D135507#3844785, @ChuanqiXu wrote:

In D135507#3844778, @philnik wrote:

I think it would be a lot easier to generate dummy headers, which just import std;. These can be used instead of the actual headers in the tests, so we don't have to add an #ifdef for every single test.

I don't get your point.. May you elaborate more? The reason why I stopped at the current state is that I feel it is bad to copy the test files. So I can move on if I avoid the copyings.

The idea is that you generate the public headers, which just import std; instead of the actual headers. i.e. you build the modules with the normal headers. Then you generate all the public headers, which just contain import std;. These get used by the tests. That way as soon as a test #include <public-header> the std module gets imported.

For example, you have an <algorithm> header which contains all the actual stuff and you generate an <algorithm> header which is just:

algorithm

import std;

Then you have a test:

test.pass.cpp

#include <algorithm>

...

That test uses the generated header, so it just imports std instead of including the implementation header. Does that explanation make sense?

@philnik Now I have a different idea. I think my proposed solution is better. Since it has higher readability and consistently. The codes behaves the same with its look. And in your suggestion, it may be confusing. Although it saves a little bit typing, I feel the readability may be more important.

[ChuanqiXu]

Deprecated since we prefer D144994

libcxx/CMakeLists.txt

 endfunction()
 
 #===============================================================================
 # Setup Source Code And Tests
 #===============================================================================
 add_subdirectory(include)
 add_subdirectory(src)
 add_subdirectory(utils)
+add_subdirectory(modules)
 
 set(LIBCXX_TEST_DEPS "cxx_experimental")
 
 if (LIBCXX_BUILD_EXTERNAL_THREAD_LIBRARY)
   list(APPEND LIBCXX_TEST_DEPS cxx_external_threads)
 endif()
 
 if (LIBCXX_INCLUDE_BENCHMARKS)

libcxx/modules/CMakeLists.txt

+set(LIBCXX_MODULES_CMAKEFILES_DIR "${CMAKE_CURRENT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/pcm.cache")
+
+set(STD_PARTITIONS_SOURCES
+    std-coroutine.cppm
+    std-type_traits.cppm
+    std-utility.cppm
+    std-vector.cppm
+    std-exception.cppm)
+
+file(GLOB STD_SOURCES "*.cppm")
+
+set_property(SOURCE ${STD_SOURCES} PROPERTY LANGUAGE CXX)
+
+add_target_flags_if_supported("-fmodules-cache-path=${LIBCXX_MODULES_CMAKEFILES_DIR}")
+
+add_library(std_partitions_objects OBJECT ${STD_PARTITIONS_SOURCES})
+
+set(MODULES_COMPILE_FLAGS "${LIBCXX_COMPILE_FLAGS} -std=c++2b -pthread")
+
+set_target_properties(std_partitions_objects
+                      PROPERTIES
+                         LINKER_LANGUAGE CXX
+                         COMPILE_FLAGS "${MODULES_COMPILE_FLAGS}"
+                         LINK_FLAGS    "${LIBCXX_LINK_FLAGS}")
+file(GLOB_RECURSE LIBCXX_HEADERS ${CMAKE_CURRENT_SOURCE_DIR}/../include/*)
+target_include_directories(std_partitions_objects PRIVATE ${LIBCXX_GENERATED_INCLUDE_DIR})
+target_add_compile_flags_if_supported(std_partitions_objects PUBLIC -nostdinc++)
+
+add_library(std_modules STATIC $<TARGET_OBJECTS:std_partitions_objects> std.cppm)
+target_link_libraries(std_modules std_partitions_objects)
+set_target_properties(std_modules
+                      PROPERTIES
+                         LINKER_LANGUAGE CXX
+                         COMPILE_FLAGS "${MODULES_COMPILE_FLAGS}"
+                         LINK_FLAGS    "${LIBCXX_LINK_FLAGS}")

libcxx/modules/std-coroutine.cppm

+module;
+#include <coroutine>
+export module std:coroutine;
+export namespace std {
+    using std::coroutine_traits;
+    using std::coroutine_handle;
+    using std::operator==;
+    using std::operator<=>;
+    using std::noop_coroutine;
+    using std::suspend_never;
+    using std::suspend_always;
+
+    using std::hash;
+}

libcxx/modules/std-exception.cppm

+module;
+#include <exception>
+export module std:exception;
+export namespace  std {
+    using std::exception;
+    using std::bad_exception;
+    using std::set_terminate;
+    using std::get_terminate;
+    using std::terminate;
+    using std::uncaught_exception;
+    using std::exception_ptr;
+    using std::current_exception;
+    using std::make_exception_ptr;
+    using std::nested_exception;
+    using std::throw_with_nested;
+    using std::rethrow_if_nested;
+}

libcxx/modules/std-type_traits.cppm

+module;
+#include <type_traits>
+export module std:type_traits;
+export namespace std {
+    using std::integral_constant;
+    using std::true_type;
+    using std::false_type;
+    
+    // helper traits
+    using std::enable_if;
+    using std::conditional;
+
+    // Primary classification traits:
+    using std::is_void;
+    using std::is_null_pointer;  // C++14
+    using std::is_integral;
+    using std::is_floating_point;
+    using std::is_array;
+    using std::is_pointer;
+    using std::is_lvalue_reference;
+    using std::is_rvalue_reference;
+    using std::is_member_object_pointer;
+    using std::is_member_function_pointer;
+    using std::is_enum;
+    using std::is_union;
+    using std::is_class;
+    using std::is_function;
+
+    // Secondary classification traits:
+    using std::is_reference;
+    using std::is_arithmetic;
+    using std::is_fundamental;
+    using std::is_member_pointer;
+    using std::is_scoped_enum; // C++2b
+    using std::is_scalar;
+    using std::is_object;
+    using std::is_compound;
+
+    // Const-volatile properties and transformations:
+    using std::is_const;
+    using std::is_volatile;
+    using std::remove_const;
+    using std::remove_volatile;
+    using std::remove_cv;
+    using std::add_const;
+    using std::add_volatile;
+    using std::add_cv;
+
+    // Reference transformations:
+    using std::remove_reference;
+    using std::add_lvalue_reference;
+    using std::add_rvalue_reference;
+
+    // Pointer transformations:
+    using std::remove_pointer;
+    using std::add_pointer;
+
+    using std::type_identity;                     // C++20
+    using std::type_identity_t;
+
+    // Integral properties:
+    using std::is_signed;
+    using std::is_unsigned;
+    using std::make_signed;
+    using std::make_unsigned;
+
+    // Array properties and transformations:
+    using std::rank;
+    using std::extent;
+    using std::remove_extent;
+    using std::remove_all_extents;
+
+    using std::is_bounded_array;                 // C++20
+    using std::is_unbounded_array;               // C++20
+
+    // Member introspection:
+    using std::is_pod;
+    using std::is_trivial;
+    using std::is_trivially_copyable;
+    using std::is_standard_layout;
+    using std::is_empty;
+    using std::is_polymorphic;
+    using std::is_abstract;
+    using std::is_final; // C++14
+    using std::is_aggregate; // C++17
+
+    using std::is_constructible;
+    using std::is_default_constructible;
+    using std::is_copy_constructible;
+    using std::is_move_constructible;
+    using std::is_assignable;
+    using std::is_copy_assignable;
+    using std::is_move_assignable;
+    using std::is_swappable_with;       // C++17
+    using std::is_swappable;            // C++17
+    using std::is_destructible;
+
+    using std::is_trivially_constructible;
+    using std::is_trivially_default_constructible;
+    using std::is_trivially_copy_constructible;
+    using std::is_trivially_move_constructible;
+    using std::is_trivially_assignable;
+    using std::is_trivially_copy_assignable;
+    using std::is_trivially_move_assignable;
+    using std::is_trivially_destructible;
+
+    using std::is_nothrow_constructible;
+    using std::is_nothrow_default_constructible;
+    using std::is_nothrow_copy_constructible;
+    using std::is_nothrow_move_constructible;
+    using std::is_nothrow_assignable;
+    using std::is_nothrow_copy_assignable;
+    using std::is_nothrow_move_assignable;
+    using std::is_nothrow_swappable_with; // C++17
+    using std::is_nothrow_swappable;      // C++17
+    using std::is_nothrow_destructible;
+
+    using std::has_virtual_destructor;
+
+    using std::has_unique_object_representations;         // C++17
+
+    // Relationships between types:
+    using std::is_same;
+    using std::is_base_of;
+
+    using std::is_convertible;
+    using std::is_nothrow_convertible;                  // C++20
+    using std::is_nothrow_convertible_v; // C++20
+
+    using std::is_invocable;
+    using std::is_invocable_r;
+
+    using std::is_nothrow_invocable;
+    using std::is_nothrow_invocable_r;
+
+    // Alignment properties and transformations:
+    using std::alignment_of;
+    using std::aligned_storage;
+    using std::aligned_union;
+    using std::remove_cvref; // C++20
+
+    using std::decay;
+    using std::common_type;
+    using std::underlying_type;
+    using std::invoke_result;  // C++17
+
+    // const-volatile modifications:
+    using std::remove_const_t;
+    using std::remove_volatile_t;
+    using std::remove_cv_t;
+    using std::add_const_t;
+    using std::add_volatile_t;
+    using std::add_cv_t;
+
+    // reference modifications:
+    using std::remove_reference_t;
+    using std::add_lvalue_reference_t;
+    using std::add_rvalue_reference_t;
+
+    // sign modifications:
+    using std::make_signed_t;
+    using std::make_unsigned_t;
+
+    // array modifications:
+    using std::remove_extent_t;
+    using std::remove_all_extents_t;
+
+    using std::is_bounded_array_v;                                     // C++20
+    using std::is_unbounded_array_v;                                   // C++20
+
+    // pointer modifications:
+    using std::remove_pointer_t;  // C++14
+    using std::add_pointer_t;  // C++14
+
+    // other transformations:
+    using std::aligned_storage_t;  // C++14
+    using std::aligned_union_t;  // C++14
+    using std::remove_cvref_t;  // C++20
+    using std::decay_t;  // C++14
+    using std::enable_if_t;  // C++14
+    using std::conditional_t;  // C++14
+    using std::common_type_t;  // C++14
+    using std::underlying_type_t;
+    using std::invoke_result_t;
+
+    using std::void_t;
+
+      // See C++14 20.10.4.1, primary type categories
+      using  std::is_void_v;
+      using  std::is_null_pointer_v;
+      using  std::is_integral_v;
+      using  std::is_floating_point_v;
+      using  std::is_array_v;
+      using  std::is_pointer_v;
+      using  std::is_lvalue_reference_v;
+      using  std::is_rvalue_reference_v;
+      using  std::is_member_object_pointer_v;
+      using  std::is_member_function_pointer_v;
+      using  std::is_enum_v;
+      using  std::is_union_v;
+      using  std::is_class_v;
+      using  std::is_function_v;
+
+      // See C++14 20.10.4.2, composite type categories
+      using  std::is_reference_v;
+      using  std::is_arithmetic_v;
+      using  std::is_fundamental_v;
+      using  std::is_object_v;
+      using  std::is_scalar_v;
+      using  std::is_compound_v;
+      using  std::is_member_pointer_v;
+      using  std::is_scoped_enum_v;
+
+      // See C++14 20.10.4.3, type properties
+      using  std::is_const_v;
+      using  std::is_volatile_v;
+      using  std::is_trivial_v;
+      using  std::is_trivially_copyable_v;
+      using  std::is_standard_layout_v;
+      using  std::is_pod_v;
+      using  std::is_empty_v;
+      using  std::is_polymorphic_v;
+      using  std::is_abstract_v;
+      using  std::is_final_v;
+      using  std::is_aggregate_v;
+      using  std::is_signed_v;
+      using  std::is_unsigned_v;
+      using  std::is_constructible_v;
+      using  std::is_default_constructible_v;
+      using  std::is_copy_constructible_v;
+      using  std::is_move_constructible_v;
+      using  std::is_assignable_v;
+      using  std::is_copy_assignable_v;
+      using  std::is_move_assignable_v;
+      using  std::is_swappable_with_v;
+      using  std::is_swappable_v;
+      using  std::is_destructible_v;
+      using std::is_trivially_constructible_v;
+      using  std::is_trivially_default_constructible_v;
+      using  std::is_trivially_copy_constructible_v;
+      using  std::is_trivially_move_constructible_v;
+      using  std::is_trivially_assignable_v;
+      using  std::is_trivially_copy_assignable_v;
+      using  std::is_trivially_move_assignable_v;
+      using  std::is_trivially_destructible_v;
+      using  std::is_nothrow_constructible_v;
+      using  std::is_nothrow_default_constructible_v;
+      using  std::is_nothrow_copy_constructible_v;
+      using  std::is_nothrow_move_constructible_v;
+      using  std::is_nothrow_assignable_v;
+      using  std::is_nothrow_copy_assignable_v;
+      using  std::is_nothrow_move_assignable_v;
+      using  std::is_nothrow_swappable_with_v;
+      using  std::is_nothrow_swappable_v;
+      using  std::is_nothrow_destructible_v;
+      using  std::has_virtual_destructor_v;
+      using  std::has_unique_object_representations_v; // C++17;
+
+      // See C++14 20.10.5, type property queries
+      using std::alignment_of_v;                                   // C++17
+      using std::rank_v;                                             // C++17
+      using std::extent_v;                                           // C++17
+
+      // See C++14 20.10.6, type relations
+      using  std::is_same_v;
+      using  std::is_base_of_v;
+      using  std::is_convertible_v;
+      using  std::is_invocable_v;
+      using  std::is_invocable_r_v;
+      using  std::is_nothrow_invocable_v;
+      using  std::is_nothrow_invocable_r_v;
+
+      // [meta.logical], logical operator traits:                        // C++17
+      using  std::conjunction_v;
+      using  std::disjunction_v;
+      using  std::negation_v;
+}

libcxx/modules/std-utility.cppm

+module;
+#include <utility>
+export module std:utility;
+export namespace std {
+    using std::swap;
+
+    namespace rel_ops {
+        using rel_ops::operator!=;
+        using rel_ops::operator>;
+        using rel_ops::operator<=;
+        using rel_ops::operator>=;
+    }
+
+    using std::forward;
+    using std::forward_like;
+    using std::move;
+    using std::move_if_noexcept;
+    using std::as_const;
+    using std::declval;
+    using std::cmp_equal;
+    using std::cmp_not_equal;     // C++20
+    using std::cmp_less;          // C++20
+    using std::cmp_greater;       // C++20
+    using std::cmp_less_equal;    // C++20
+    using std::cmp_greater_equal; // C++20
+    using std::in_range;          // C++20
+
+    using std::pair;
+    using std::operator==;
+
+    using std::make_pair;
+    using std::piecewise_construct_t;
+    // FIXME: We can't export non-inline constexpr variables.
+    // using std::piecewise_construct;
+
+    using std::tuple_size;
+    using std::tuple_element;
+
+    using std::get;
+    using std::integer_sequence;
+    using std::index_sequence;
+    using std::make_index_sequence;
+    using std::make_integer_sequence;
+    using std::index_sequence_for;
+
+    using std::exchange;
+    using std::in_place_t;
+    using std::in_place;
+
+    using std::in_place_type_t;
+    using std::in_place_type;
+    using std::in_place_index_t;
+
+    using std::in_place_index;
+    using std::to_underlying;
+}

libcxx/modules/std-vector.cppm

+module;
+#include <vector>
+export module std:vector;
+export namespace std {
+    using std::vector;
+    using std::hash;
+    using std::swap;
+    using std::operator==;
+    using std::erase;
+    using std::erase_if;
+}
+
+export {
+    using ::operator new;
+}

libcxx/modules/std.cppm

+export module std;
+export import :coroutine;
+export import :type_traits;
+export import :utility;
+export import :vector;
+export import :exception;

libcxx/test/std_modules/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, c++20, c++20
+// UNSUPPORTED: libcpp-no-coroutines
+
+// <coroutine>
+
+// template <class Promise = void>
+// struct coroutine_handle;
+
+// constexpr explicit operator bool() const noexcept
+
+// FIXME: How to get a better name than `%{lib}/../libcxx/modules/CMakeFiles/pcm.cache`?
+// ADDITIONAL_COMPILE_FLAGS: -fmodules-cache-path=%{lib}/../libcxx/modules/CMakeFiles/pcm.cache -lstd_modules
+
+#include <cassert>
+#include "test_macros.h"
+import std;
+
+template <class C>
+constexpr bool do_test() {
+  static_assert(std::is_nothrow_constructible<bool, C>::value, "");
+  static_assert(!std::is_convertible<C, bool>::value, "");
+  {
+    constexpr C c;
+    static_assert(bool(c) == false, "");
+  }
+  { // null case
+    const C c = {};
+    ASSERT_NOEXCEPT(bool(c));
+    assert(c.address() == nullptr);
+    assert(bool(c) == false);
+  }
+  { // non-null case
+    char dummy = 42;
+    C c = C::from_address((void*)&dummy);
+    assert(c.address() == &dummy);
+    assert(bool(c) == true);
+  }
+  return true;
+}
+
+int main(int, char**)
+{
+  do_test<std::coroutine_handle<>>();
+  do_test<std::coroutine_handle<int>>();
+  static_assert(do_test<std::coroutine_handle<>>());
+  static_assert(do_test<std::coroutine_handle<int>>());
+
+  return 0;
+}

libcxx/test/std_modules/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, c++20
+// UNSUPPORTED: libcpp-no-coroutines
+
+// <coroutine>
+
+// template <class Promise = void>
+// struct coroutine_handle;
+
+// constexpr bool operator==(coroutine_handle<> x, coroutine_handle<> y) noexcept;
+// FIXME: How to get a better name than `%{lib}/../libcxx/modules/CMakeFiles/pcm.cache`?
+// ADDITIONAL_COMPILE_FLAGS: -fmodules-cache-path=%{lib}/../libcxx/modules/CMakeFiles/pcm.cache -lstd_modules
+
+#include <cassert>
+#include "test_macros.h"
+import std;
+
+template <class C>
+void do_test(int *LHSVal, int *RHSVal) {
+  const C LHS = C::from_address(LHSVal);
+  const C RHS = C::from_address(RHSVal);
+  const bool ExpectIsEqual = (LHSVal == RHSVal);
+  assert((LHS == RHS) == ExpectIsEqual);
+  assert((RHS == LHS) == ExpectIsEqual);
+  assert((LHS != RHS) == !ExpectIsEqual);
+  assert((RHS != LHS) == !ExpectIsEqual);
+  {
+    static_assert(noexcept(LHS == RHS), "");
+    static_assert(noexcept(LHS != RHS), "");
+    ASSERT_SAME_TYPE(decltype(LHS == RHS), bool);
+    ASSERT_SAME_TYPE(decltype(LHS != RHS), bool);
+  }
+}
+
+int main(int, char**)
+{
+  int i;
+  std::pair<int *, int *> const TestCases[] = {
+      {nullptr, nullptr},
+      {&i, &i},
+      {nullptr, &i},
+      {&i, nullptr}
+  };
+  for (auto& TC : TestCases) {
+    do_test<std::coroutine_handle<>>(TC.first, TC.second);
+    do_test<std::coroutine_handle<int>>(TC.first, TC.second);
+  }
+
+  return 0;
+}

libcxx/test/std_modules/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, c++20
+// UNSUPPORTED: libcpp-no-coroutines
+
+// <coroutine>
+
+// template <class Promise = void>
+// struct coroutine_handle;
+
+// constexpr strong_ordering operator<=>(coroutine_handle<> x, coroutine_handle<> y) noexcept;
+
+// FIXME: How to get a better name than `%{lib}/../libcxx/modules/CMakeFiles/pcm.cache`?
+// ADDITIONAL_COMPILE_FLAGS: -fmodules-cache-path=%{lib}/../libcxx/modules/CMakeFiles/pcm.cache -lstd_modules
+
+#include <cassert>
+#include "test_macros.h"
+import std;
+
+template <class C>
+void do_test(int *LHSVal, int *RHSVal) {
+  const C LHS = C::from_address(LHSVal);
+  const C RHS = C::from_address(RHSVal);
+  assert((LHS < RHS) == (LHSVal < RHSVal));
+  assert((RHS < LHS) == (RHSVal < LHSVal));
+  assert((LHS > RHS) == (LHSVal > RHSVal));
+  assert((RHS > LHS) == (RHSVal > LHSVal));
+  assert((LHS <= RHS) == (LHSVal <= RHSVal));
+  assert((RHS <= LHS) == (RHSVal <= LHSVal));
+  assert((LHS >= RHS) == (LHSVal >= RHSVal));
+  assert((RHS >= LHS) == (RHSVal >= LHSVal));
+  {
+    static_assert(noexcept(LHS < RHS), "");
+    static_assert(noexcept(LHS > RHS), "");
+    static_assert(noexcept(LHS <= RHS), "");
+    static_assert(noexcept(LHS >= RHS), "");
+    ASSERT_SAME_TYPE(decltype(LHS < RHS), bool);
+    ASSERT_SAME_TYPE(decltype(LHS > RHS), bool);
+    ASSERT_SAME_TYPE(decltype(LHS <= RHS), bool);
+    ASSERT_SAME_TYPE(decltype(LHS >= RHS), bool);
+  }
+}
+
+int main(int, char**)
+{
+  int i;
+  std::pair<int *, int *> const TestCases[] = {
+      {nullptr, nullptr},
+      {&i, &i},
+      {nullptr, &i},
+      {&i, nullptr}
+  };
+  for (auto& TC : TestCases) {
+    do_test<std::coroutine_handle<>>(TC.first, TC.second);
+    do_test<std::coroutine_handle<int>>(TC.first, TC.second);
+  }
+
+  return 0;
+}

libcxx/test/std_modules/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, c++20
+// UNSUPPORTED: libcpp-no-coroutines
+
+// <coroutine>
+
+// template <class Promise = void>
+// struct coroutine_handle;
+
+// bool done() const
+
+// FIXME: How to get a better name than `%{lib}/../libcxx/modules/CMakeFiles/pcm.cache`?
+// ADDITIONAL_COMPILE_FLAGS: -fmodules-cache-path=%{lib}/../libcxx/modules/CMakeFiles/pcm.cache -lstd_modules
+
+#include <cassert>
+#include "test_macros.h"
+import std;
+
+template <class Promise>
+void do_test(std::coroutine_handle<Promise> const& H) {
+  // FIXME Add a runtime test
+  {
+    ASSERT_SAME_TYPE(decltype(H.done()), bool);
+    LIBCPP_ASSERT_NOT_NOEXCEPT(H.done());
+  }
+}
+
+int main(int, char**)
+{
+  do_test(std::coroutine_handle<>{});
+  do_test(std::coroutine_handle<int>{});
+
+  return 0;
+}

libcxx/test/std_modules/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, c++20
+// UNSUPPORTED: libcpp-no-coroutines
+
+// <coroutine>
+
+// template <class Promise = void>
+// struct coroutine_handle;
+
+// coroutine_handle& operator=(nullptr_t) noexcept
+
+// FIXME: How to get a better name than `%{lib}/../libcxx/modules/CMakeFiles/pcm.cache`?
+// ADDITIONAL_COMPILE_FLAGS: -fmodules-cache-path=%{lib}/../libcxx/modules/CMakeFiles/pcm.cache -lstd_modules
+
+#include <cassert>
+// For std::nullptr_t. We're not intentioned to implement std.comp yet.
+#include <cstddef>
+#include "test_macros.h"
+import std;
+
+template <class C>
+void do_test() {
+  int dummy = 42;
+  void* dummy_h = &dummy;
+  {
+    static_assert(std::is_nothrow_assignable<C&, std::nullptr_t>::value, "");
+    static_assert(!std::is_assignable<C&, void*>::value, "");
+  }
+  {
+    C c = C::from_address(dummy_h);
+    assert(c.address() == &dummy);
+    c = nullptr;
+    assert(c.address() == nullptr);
+    c = nullptr;
+    assert(c.address() == nullptr);
+  }
+  {
+    C c;
+    C& cr = (c = nullptr);
+    assert(&c == &cr);
+  }
+}
+
+int main(int, char**)
+{
+  do_test<std::coroutine_handle<>>();
+  do_test<std::coroutine_handle<int>>();
+
+  return 0;
+}

libcxx/test/std_modules/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, c++20
+// UNSUPPORTED: libcpp-no-coroutines
+
+// <coroutine>
+
+// template <class Promise = void>
+// struct coroutine_handle;
+
+// constexpr coroutine_handle() noexcept
+// constexpr coroutine_handle(nullptr_t) noexcept
+
+// FIXME: How to get a better name than `%{lib}/../libcxx/modules/CMakeFiles/pcm.cache`?
+// ADDITIONAL_COMPILE_FLAGS: -fmodules-cache-path=%{lib}/../libcxx/modules/CMakeFiles/pcm.cache -lstd_modules
+
+#include <cassert>
+// For std::nullptr_t. We're not intentioned to implement std.comp yet.
+#include <cstddef>
+#include "test_macros.h"
+import std;
+
+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, "");
+  {
+    C c;
+    assert(c.address() == nullptr);
+  }
+  {
+    C c = C(nullptr);
+    assert(c.address() == nullptr);
+  }
+  return true;
+}
+
+int main(int, char**)
+{
+  do_test<std::coroutine_handle<>>();
+  do_test<std::coroutine_handle<int>>();
+  static_assert(do_test<std::coroutine_handle<>>());
+  static_assert(do_test<std::coroutine_handle<int>>());
+
+  return 0;
+}

libcxx/test/std_modules/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, c++20
+// UNSUPPORTED: libcpp-no-coroutines
+
+// FIXME: How to get a better name than `%{lib}/../libcxx/modules/CMakeFiles/pcm.cache`?
+// ADDITIONAL_COMPILE_FLAGS: -fmodules-cache-path=%{lib}/../libcxx/modules/CMakeFiles/pcm.cache -lstd_modules
+
+#include <cassert>
+#include "test_macros.h"
+import std;
+
+struct coro_t {
+  struct promise_type {
+    coro_t get_return_object() {
+      std::coroutine_handle<promise_type>{};
+      return {};
+    }
+    std::suspend_never initial_suspend() { return {}; }
+    std::suspend_never final_suspend() noexcept { return {}; }
+    void return_void() {}
+    static void unhandled_exception() {}
+  };
+};
+
+struct B {
+  ~B() {}
+  bool await_ready() { return true; }
+  B await_resume() { return {}; }
+  template <typename F> void await_suspend(F) {}
+};
+
+
+struct A {
+  ~A() {}
+  bool await_ready() { return true; }
+  int await_resume() { return 42; }
+  template <typename F> void await_suspend(F) {}
+};
+
+int last_value = -1;
+void set_value(int x) {
+  last_value = x;
+}
+
+coro_t f(int n) {
+  if (n == 0) {
+    set_value(0);
+    co_return;
+  }
+  int val = co_await A{};
+  ((void)val);
+  set_value(42);
+}
+
+coro_t g() { B val = co_await B{}; }
+
+int main(int, char**) {
+  last_value = -1;
+  f(0);
+  assert(last_value == 0);
+  f(1);
+  assert(last_value == 42);
+
+  return 0;
+}

libcxx/test/std_modules/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, c++20
+// UNSUPPORTED: libcpp-no-coroutines
+
+// See https://llvm.org/PR33271
+// UNSUPPORTED: ubsan
+
+// FIXME: How to get a better name than `%{lib}/../libcxx/modules/CMakeFiles/pcm.cache`?
+// ADDITIONAL_COMPILE_FLAGS: -fmodules-cache-path=%{lib}/../libcxx/modules/CMakeFiles/pcm.cache -lstd_modules
+
+#include <cassert>
+#include "test_macros.h"
+import std;
+
+template <typename Ty> struct generator {
+  struct promise_type {
+    Ty current_value;
+    std::suspend_always yield_value(Ty value) {
+      this->current_value = value;
+      return {};
+    }
+    std::suspend_always initial_suspend() { return {}; }
+    std::suspend_always final_suspend() noexcept { return {}; }
+    generator get_return_object() { return generator{this}; };
+    void return_void() {}
+    void unhandled_exception() {}
+  };
+
+  struct iterator {
+    std::coroutine_handle<promise_type> Coro_;
+    bool Done_;
+
+    iterator(std::coroutine_handle<promise_type> Coro, bool Done)
+        : Coro_(Coro), Done_(Done) {}
+
+    iterator &operator++() {
+      Coro_.resume();
+      Done_ = Coro_.done();
+      return *this;
+    }
+
+    bool operator==(iterator const &_Right) const {
+      return Done_ == _Right.Done_;
+    }
+
+    bool operator!=(iterator const &_Right) const { return !(*this == _Right); }
+
+    Ty const &operator*() const { return Coro_.promise().current_value; }
+
+    Ty const *operator->() const { return &(operator*()); }
+  };
+
+  iterator begin() {
+    p.resume();
+    return {p, p.done()};
+  }
+
+  iterator end() { return {p, true}; }
+
+  generator(generator &&rhs) : p(rhs.p) { rhs.p = nullptr; }
+
+  ~generator() {
+    if (p)
+      p.destroy();
+  }
+
+private:
+  explicit generator(promise_type *promise)
+      : p(std::coroutine_handle<promise_type>::from_promise(*promise)) {}
+
+  std::coroutine_handle<promise_type> p;
+};
+
+struct minig {
+  struct promise_type {
+    int current_value;
+    std::suspend_always yield_value(int value) {
+      this->current_value = value;
+      return {};
+    }
+    std::suspend_always initial_suspend() { return {}; }
+    std::suspend_always final_suspend() noexcept { return {}; }
+    minig get_return_object() { return minig{this}; };
+    void return_void() {}
+    void unhandled_exception() {}
+  };
+
+  bool move_next() {
+    p.resume();
+    return !p.done();
+  }
+  int current_value() { return p.promise().current_value; }
+
+  minig(minig &&rhs) : p(rhs.p) { rhs.p = nullptr; }
+
+  ~minig() {
+    if (p)
+      p.destroy();
+  }
+
+private:
+  explicit minig(promise_type *promise)
+      : p(std::coroutine_handle<promise_type>::from_promise(*promise)) {}
+
+  std::coroutine_handle<promise_type> p;
+};
+
+
+minig mini_count(int n) {
+  for (int i = 0; i < n; i++) {
+    co_yield i;
+  }
+}
+
+generator<int> count(int n) {
+  for (int i = 0; i < n; ++i)
+    co_yield i;
+}
+
+generator<int> range(int from, int n) {
+  for (int i = from; i < n; ++i)
+    co_yield i;
+}
+
+void test_count() {
+  const std::vector<int> expect = {0, 1, 2, 3, 4};
+  std::vector<int> got;
+  for (auto x : count(5))
+    got.push_back(x);
+  assert(expect == got);
+}
+
+void test_range() {
+  int sum = 0;
+   for (auto v: range(1, 20))
+      sum += v;
+   assert(sum == 190);
+}
+
+void test_mini_generator() {
+  int sum = 0;
+  auto g = mini_count(5);
+  while (g.move_next()) {
+     sum += g.current_value();
+  }
+  assert(sum == 10);
+}
+
+int main(int, char**) {
+  test_count();
+  test_range();
+  test_mini_generator();
+
+  return 0;
+}

libcxx/test/std_modules/language.support/support.exception/propagation/current_exception.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
+//
+//===----------------------------------------------------------------------===//
+
+// FIXME: This test needs to be rewritten for the MSVC exception_ptr semantics
+// which copy the exception each time the exception_ptr is copied.
+// XFAIL: msvc
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED: no-exceptions
+// <exception>
+
+// exception_ptr current_exception();
+
+// FIXME: How to get a better name than `%{lib}/../libcxx/modules/CMakeFiles/pcm.cache`?
+// ADDITIONAL_COMPILE_FLAGS: -fmodules-cache-path=%{lib}/../libcxx/modules/CMakeFiles/pcm.cache -lstd_modules
+
+#include <cassert>
+#include "test_macros.h"
+import std;
+
+struct A
+{
+    static int constructed;
+
+    A() {++constructed;}
+    ~A() {--constructed;}
+    A(const A&)  {++constructed;}
+};
+
+int A::constructed = 0;
+
+int main(int, char**)
+{
+    {
+        std::exception_ptr p = std::current_exception();
+        assert(p == nullptr);
+    }
+    {
+        try
+        {
+            assert(A::constructed == 0);
+            throw A();
+            assert(false);
+        }
+        catch (...)
+        {
+            assert(A::constructed == 1);
+        }
+        assert(A::constructed == 0);
+    }
+    assert(A::constructed == 0);
+    {
+        std::exception_ptr p2;
+        try
+        {
+            assert(A::constructed == 0);
+            throw A();
+            assert(false);
+        }
+        catch (...)
+        {
+            std::exception_ptr p = std::current_exception();
+            assert(A::constructed == 1);
+            assert(p != nullptr);
+            p2 = std::current_exception();
+            assert(A::constructed == 1);
+            assert(p == p2);
+        }
+        assert(A::constructed == 1);
+    }
+    assert(A::constructed == 0);
+    {
+        std::exception_ptr p2;
+        try
+        {
+            assert(A::constructed == 0);
+            throw A();
+            assert(false);
+        }
+        catch (A&)
+        {
+            std::exception_ptr p = std::current_exception();
+            assert(A::constructed == 1);
+            assert(p != nullptr);
+            p2 = std::current_exception();
+            assert(A::constructed == 1);
+            assert(p == p2);
+        }
+        assert(A::constructed == 1);
+    }
+    assert(A::constructed == 0);
+    {
+        std::exception_ptr p2;
+        try
+        {
+            assert(A::constructed == 0);
+            throw A();
+            assert(false);
+        }
+        catch (A)
+        {
+            std::exception_ptr p = std::current_exception();
+            assert(A::constructed == 2);
+            assert(p != nullptr);
+            p2 = std::current_exception();
+            assert(A::constructed == 2);
+            assert(p == p2);
+        }
+        assert(A::constructed == 1);
+    }
+    assert(A::constructed == 0);
+    {
+        try
+        {
+            assert(A::constructed == 0);
+            throw A();
+            assert(false);
+        }
+        catch (...)
+        {
+            assert(A::constructed == 1);
+            try
+            {
+                assert(A::constructed == 1);
+                throw;
+                assert(false);
+            }
+            catch (...)
+            {
+                assert(A::constructed == 1);
+            }
+            assert(A::constructed == 1);
+        }
+        assert(A::constructed == 0);
+    }
+    assert(A::constructed == 0);
+    {
+        try
+        {
+            assert(A::constructed == 0);
+            throw A();
+            assert(false);
+        }
+        catch (...)
+        {
+            assert(A::constructed == 1);
+            try
+            {
+                std::exception_ptr p = std::current_exception();
+                assert(A::constructed == 1);
+                assert(p != nullptr);
+                throw;
+                assert(false);
+            }
+            catch (...)
+            {
+                assert(A::constructed == 1);
+            }
+            assert(A::constructed == 1);
+        }
+        assert(A::constructed == 0);
+    }
+    assert(A::constructed == 0);
+    {
+        try
+        {
+            assert(A::constructed == 0);
+            throw A();
+            assert(false);
+        }
+        catch (...)
+        {
+            assert(A::constructed == 1);
+            try
+            {
+                assert(A::constructed == 1);
+                throw;
+                assert(false);
+            }
+            catch (...)
+            {
+                std::exception_ptr p = std::current_exception();
+                assert(A::constructed == 1);
+                assert(p != nullptr);
+            }
+            assert(A::constructed == 1);
+        }
+        assert(A::constructed == 0);
+    }
+    assert(A::constructed == 0);
+    {
+        try
+        {
+            assert(A::constructed == 0);
+            throw A();
+            assert(false);
+        }
+        catch (...)
+        {
+            assert(A::constructed == 1);
+            try
+            {
+                assert(A::constructed == 1);
+                throw;
+                assert(false);
+            }
+            catch (...)
+            {
+                assert(A::constructed == 1);
+            }
+            std::exception_ptr p = std::current_exception();
+            assert(A::constructed == 1);
+            assert(p != nullptr);
+        }
+        assert(A::constructed == 0);
+    }
+    assert(A::constructed == 0);
+    {
+        try
+        {
+            assert(A::constructed == 0);
+            throw A();
+            assert(false);
+        }
+        catch (...)
+        {
+            assert(A::constructed == 1);
+            try
+            {
+                assert(A::constructed == 1);
+                throw;
+                assert(false);
+            }
+            catch (...)
+            {
+                assert(A::constructed == 1);
+            }
+            assert(A::constructed == 1);
+        }
+        std::exception_ptr p = std::current_exception();
+        assert(A::constructed == 0);
+        assert(p == nullptr);
+    }
+    assert(A::constructed == 0);
+    {
+        std::exception_ptr p;
+        try
+        {
+            assert(A::constructed == 0);
+            throw A();
+            assert(false);
+        }
+        catch (...)
+        {
+            assert(A::constructed == 1);
+            try
+            {
+                assert(A::constructed == 1);
+                throw;
+                assert(false);
+            }
+            catch (...)
+            {
+                p = std::current_exception();
+                assert(A::constructed == 1);
+            }
+            assert(A::constructed == 1);
+        }
+        assert(A::constructed == 1);
+        assert(p != nullptr);
+    }
+    assert(A::constructed == 0);
+
+  return 0;
+}