[libc++][modules] Simplifies C++20 module testing.

[Mordante]

Summary

The building of the std module has been moved from params.py and
dsl.py to a lit.local.cfg for the entire test suite. In theory this
change allows testing modules in most configurations, except:

• combined with clang modules
• C++ versions that don't support the std module

Currently only C++23 with all parts enabled works.
C++26 is expected to work properly with CMake 3.27. That versions of CMake
knows how to invoke clang using C++26.
The parts disabled modi of libc++ have not been modularized yet.

It still is the goal that in the future CMake will be able to do the work
done in lit.local.cfg. Doing this in CMake would require a more mature
libc++ implementation.

Thanks a lot to @ldionne for giving hints how to enable modules in a
lit.local.cfg.

[Mordante]

Fix CI.

[Mordante]

CI fixes.

[Mordante]

CI fixes.

[ldionne]

libcxx/CMakeLists.txt

750

Commit message: let's say Simplifies C++20 module testing.

Just to make it real clear.

libcxx/test/lit.local.cfg

43

What is quit()?

libcxx/utils/libcxx/test/features.py

283

I don't think this is required since we're keying off of the __config_site macro.

libcxx/utils/libcxx/test/params.py

135

In a separate patch, we should probably change this to clang-modules-build or modules-build=clang (and then we could have modules-build=std).

[Mordante]

Addresses review comments.

[Mordante]

libcxx/test/libcxx/module_std.gen.py

130

The C++26 support should be enabled again in D153408

libcxx/test/lit.local.cfg

43

This is a left over and doesn't work correctly. I'll remove it.

[Mordante]

Rebased to work on dependent patches.

[Mordante]

libcxx/utils/libcxx/test/params.py

135

See D158927

libcxx/CMakeLists.txt

 config_define_if(LIBCXX_ABI_FORCE_MICROSOFT _LIBCPP_ABI_FORCE_MICROSOFT)
 config_define_if_not(LIBCXX_ENABLE_THREADS _LIBCPP_HAS_NO_THREADS)
 config_define_if_not(LIBCXX_ENABLE_MONOTONIC_CLOCK _LIBCPP_HAS_NO_MONOTONIC_CLOCK)
 if (NOT LIBCXX_TYPEINFO_COMPARISON_IMPLEMENTATION STREQUAL "default")
   config_define("${LIBCXX_TYPEINFO_COMPARISON_IMPLEMENTATION}" _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION)
 endif()
 config_define_if(LIBCXX_HAS_PTHREAD_API _LIBCPP_HAS_THREAD_API_PTHREAD)
 config_define_if(LIBCXX_HAS_EXTERNAL_THREAD_API _LIBCPP_HAS_THREAD_API_EXTERNAL)
 config_define_if(LIBCXX_HAS_WIN32_THREAD_API _LIBCPP_HAS_THREAD_API_WIN32)
 config_define_if(LIBCXX_HAS_MUSL_LIBC _LIBCPP_HAS_MUSL_LIBC)
 config_define_if(LIBCXX_NO_VCRUNTIME _LIBCPP_NO_VCRUNTIME)
 config_define_if_not(LIBCXX_ENABLE_FILESYSTEM _LIBCPP_HAS_NO_FILESYSTEM)
 config_define_if_not(LIBCXX_ENABLE_RANDOM_DEVICE _LIBCPP_HAS_NO_RANDOM_DEVICE)
 config_define_if_not(LIBCXX_ENABLE_LOCALIZATION _LIBCPP_HAS_NO_LOCALIZATION)
 config_define_if_not(LIBCXX_ENABLE_UNICODE _LIBCPP_HAS_NO_UNICODE)
 config_define_if_not(LIBCXX_ENABLE_WIDE_CHARACTERS _LIBCPP_HAS_NO_WIDE_CHARACTERS)
+config_define_if_not(LIBCXX_ENABLE_STD_MODULES _LIBCPP_HAS_NO_STD_MODULES)
 config_define_if_not(LIBCXX_ENABLE_VENDOR_AVAILABILITY_ANNOTATIONS _LIBCPP_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS)
 if (LIBCXX_HARDENING_MODE STREQUAL "hardened")
   config_define(1 _LIBCPP_ENABLE_HARDENED_MODE_DEFAULT)
   config_define(0 _LIBCPP_ENABLE_DEBUG_MODE_DEFAULT)
 elseif (LIBCXX_HARDENING_MODE STREQUAL "debug")
   config_define(0 _LIBCPP_ENABLE_HARDENED_MODE_DEFAULT)
   config_define(1 _LIBCPP_ENABLE_DEBUG_MODE_DEFAULT)
 elseif (LIBCXX_HARDENING_MODE STREQUAL "unchecked")

libcxx/cmake/caches/Generic-module-std-cxx23.cmake

 set(LIBCXX_ENABLE_STD_MODULES ON CACHE BOOL "")
-set(LIBCXX_TEST_PARAMS "enable_modules=std;std=c++23" CACHE STRING "")
+set(LIBCXX_TEST_PARAMS "std=c++23" CACHE STRING "")
 set(LIBCXXABI_TEST_PARAMS "std=c++23" CACHE STRING "")
 

libcxx/include/__config_site.in

 #cmakedefine _LIBCPP_DISABLE_VISIBILITY_ANNOTATIONS
 #cmakedefine _LIBCPP_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS
 #cmakedefine _LIBCPP_NO_VCRUNTIME
 #cmakedefine _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION @_LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION@
 #cmakedefine _LIBCPP_HAS_NO_FILESYSTEM
 #cmakedefine _LIBCPP_HAS_NO_RANDOM_DEVICE
 #cmakedefine _LIBCPP_HAS_NO_LOCALIZATION
 #cmakedefine _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#cmakedefine _LIBCPP_HAS_NO_STD_MODULES
 
 // PSTL backends
 #cmakedefine _LIBCPP_PSTL_CPU_BACKEND_SERIAL
 #cmakedefine _LIBCPP_PSTL_CPU_BACKEND_THREAD
 #cmakedefine _LIBCPP_PSTL_CPU_BACKEND_LIBDISPATCH
 
 // Hardening.
 #cmakedefine01 _LIBCPP_ENABLE_HARDENED_MODE_DEFAULT

libcxx/test/libcxx/module_std.gen.py

 # newline needs to be escaped for the module partition output.
 nl = '\\\\n'
 
 # Create empty file with all parts.
 print(
     f"""\
 //--- module_std.sh.cpp
 // UNSUPPORTED{BLOCKLIT}: c++03, c++11, c++14, c++17, c++20
+// UNSUPPORTED{BLOCKLIT}: c++26
+// UNSUPPORTED{BLOCKLIT}: libcpp-has-no-std-modules
+// UNSUPPORTED{BLOCKLIT}: modules-build
 
 // REQUIRES{BLOCKLIT}: has-clang-tidy
-// REQUIRES{BLOCKLIT}: use_module_std
 
 // The GCC compiler flags are not always compatible with clang-tidy.
 // UNSUPPORTED{BLOCKLIT}: gcc
 
 // RUN{BLOCKLIT}: echo -n > %t.all_partitions
 """
 )
 

libcxx/test/libcxx/modules_include.gen.py

 
 BLOCKLIT = '' # block Lit from interpreting a RUN/XFAIL/etc inside the generation script
 
 for header in public_headers:
   print(f"""\
 //--- {header}.compile.pass.cpp
 // RUN{BLOCKLIT}: %{{cxx}} %s %{{flags}} %{{compile_flags}} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only
 
-// UNSUPPORTED{BLOCKLIT}: use_module_std
-
 // GCC doesn't support -fcxx-modules
 // UNSUPPORTED{BLOCKLIT}: gcc
 
 // The Windows headers don't appear to be compatible with modules
 // UNSUPPORTED{BLOCKLIT}: windows
 // UNSUPPORTED{BLOCKLIT}: buildhost=windows
 
 // The AIX headers don't appear to be compatible with modules

 #include <{header}>
 """)
 
 print(f"""\
 //--- __std_clang_module.compile.pass.mm
 // RUN{BLOCKLIT}: %{{cxx}} %s %{{flags}} %{{compile_flags}} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only
 
 // REQUIRES{BLOCKLIT}: modules-build
-// UNSUPPORTED{BLOCKLIT}: use_module_std
 
 // GCC doesn't support -fcxx-modules
 // UNSUPPORTED{BLOCKLIT}: gcc
 
 // The Windows headers don't appear to be compatible with modules
 // UNSUPPORTED{BLOCKLIT}: windows
 // UNSUPPORTED{BLOCKLIT}: buildhost=windows
 

libcxx/test/lit.local.cfg

+# ===----------------------------------------------------------------------===##
+#
+# 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
+#
+# ===----------------------------------------------------------------------===##
+
+# This configuration builds the C++23 std module.
+# It is build when the current lit configuration supports modules.
+#
+# TODO MODULES Evaluate whether this file can be removed when CMake supports
+# modules in libc++.
+
+import os
+import site
+import subprocess
+import libcxx.test.params, libcxx.test.config, libcxx.test.dsl
+
+
+def getSubstitution(substitution, config):
+    for orig, replacement in config.substitutions:
+        if orig == substitution:
+            return replacement
+    raise ValueError("Substitution {} is not in the config.".format(substitution))
+
+
+def appendToSubstitution(substitutions, key, value):
+    return [(k, v + " " + value) if k == key else (k, v) for (k, v) in substitutions]
+
+
+std = getSubstitution("%{cxx_std}", config)
+if std == "cxx26":
+    # This fails to work properly. It might be due to
+    #   CMAKE_CXX_STANDARD 26
+    # does not work in CMake 3.26, it requires the upcomming CMake 3.27.
+    # TODO MODULES test whether this is fixed with CMake 3.27.
+    std = ""
+elif std == "cxx23":
+    std = "23"
+else:
+    std = ""
+
+if (
+    std
+    and not "libcpp-has-no-std-modules" in config.available_features
+    and not "modules-build" in config.available_features
+):
+    build = os.path.join(config.test_exec_root, "__config_module__")
+    config.substitutions = appendToSubstitution(
+        config.substitutions,
+        "%{compile_flags}",
+        "-fprebuilt-module-path="
+        + os.path.join(config.test_exec_root, "__config_module__/CMakeFiles/std.dir"),
+    )
+
+    flags = getSubstitution("%{flags}", config)
+    cmake = getSubstitution("%{cmake}", config)
+
+    subprocess.check_call(
+        [cmake, f"-DCMAKE_CXX_STANDARD={std}", f"-DCMAKE_CXX_FLAGS={flags}", build],
+        env={},
+    )
+    subprocess.check_call([cmake, "--build", build, "--", "-v"], env={})
+    config.substitutions = appendToSubstitution(
+        config.substitutions,
+        "%{link_flags}",
+        os.path.join(build, "libc++std.a"),
+    )

libcxx/test/std/modules/std.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
 // TODO MODULES fix c++26
 // XFAIL: c++26
 
-// REQUIRES: use_module_std
+// UNSUPPORTED: libcpp-has-no-std-modules
+// UNSUPPORTED: modules-build
 
 // A minimal test to validate import works.
 
 import std;
 
 int main(int, char**) {
   std::println("Hello modular world");
   return 0;
 }

libcxx/utils/libcxx/test/dsl.py

def applyTo(self, config):
         ), "Trying to enable flag {}, which is not supported".format(flag)
         config.substitutions = _appendToSubstitution(
             config.substitutions, "%{flags}", flag
         )
 
     def pretty(self, config, litParams):
         return "add {} to %{{flags}}".format(self._getFlag(config))
 
-class BuildStdModule(ConfigAction):
-  def applyTo(self, config):
-    build = os.path.join(config.test_exec_root, '__config_module__')
-
-    std = _getSubstitution('%{cxx_std}', config)
-    if std == 'cxx26':
-        # This fails to work properly. It might be due to
-        #   CMAKE_CXX_STANDARD 26
-        # does not work in CMake 3.26, it requires the upcomming CMake 3.27.
-        # TODO MODULES test whether this is fixed with CMake 3.27.
-        std = '17'
-    elif std == 'cxx23':
-        std = '23'
-    else:
-        std = '17' # Not allowed for modules
-
-    flags = _getSubstitution('%{flags}', config)
-    cmake = _getSubstitution('%{cmake}', config)
-
-    subprocess.check_call([cmake, f"-DCMAKE_CXX_STANDARD={std}", f"-DCMAKE_CXX_FLAGS={flags}", build], env={})
-    subprocess.check_call([cmake, "--build", build, "--", "-v"], env={})
-    config.substitutions = _appendToSubstitution(
-       # TODO MODULES Avoid manually modifying link_flags.
-       config.substitutions, "%{link_flags}",  os.path.join(build, "libc++std.a")
-    )
-
-  def pretty(self, config, litParams):
-    return "building std module with flags {}".format(_getSubstitution('%{flags}', config))
-
 class AddFlagIfSupported(ConfigAction):
     """
     This action adds the given flag to the %{flags} substitution, only if
     the compiler supports the flag.
 
     The flag can be a string or a callable, in which case it is called with the
     configuration to produce the actual flag (as a string).
     """

libcxx/utils/libcxx/test/features.py

DEFAULT_FEATURES = [
     Feature(
         name=lambda cfg: "gcc-{__GNUC__}.{__GNUC_MINOR__}.{__GNUC_PATCHLEVEL__}".format(**compilerMacros(cfg)),
         when=_isGCC,
     ),
     Feature(name="msvc", when=_isMSVC),
     Feature(name=lambda cfg: "msvc-{}".format(*_msvcVersion(cfg)), when=_isMSVC),
     Feature(name=lambda cfg: "msvc-{}.{}".format(*_msvcVersion(cfg)), when=_isMSVC),
 ]
 
 # Deduce and add the test features that that are implied by the #defines in
 # the <__config_site> header.
 #
 # For each macro of the form `_LIBCPP_XXX_YYY_ZZZ` defined below that
 # is defined after including <__config_site>, add a Lit feature called
 # `libcpp-xxx-yyy-zzz`. When a macro is defined to a specific value
 # (e.g. `_LIBCPP_ABI_VERSION=2`), the feature is `libcpp-xxx-yyy-zzz=<value>`.
 #
 # Note that features that are more strongly tied to libc++ are named libcpp-foo,
 # while features that are more general in nature are not prefixed with 'libcpp-'.
 macros = {
     "_LIBCPP_HAS_NO_MONOTONIC_CLOCK": "no-monotonic-clock",
     "_LIBCPP_HAS_NO_THREADS": "no-threads",
     "_LIBCPP_HAS_THREAD_API_EXTERNAL": "libcpp-has-thread-api-external",
     "_LIBCPP_HAS_THREAD_API_PTHREAD": "libcpp-has-thread-api-pthread",
     "_LIBCPP_NO_VCRUNTIME": "libcpp-no-vcruntime",
     "_LIBCPP_ABI_VERSION": "libcpp-abi-version",
     "_LIBCPP_HAS_NO_FILESYSTEM": "no-filesystem",
     "_LIBCPP_HAS_NO_RANDOM_DEVICE": "no-random-device",
     "_LIBCPP_HAS_NO_LOCALIZATION": "no-localization",
     "_LIBCPP_HAS_NO_WIDE_CHARACTERS": "no-wide-characters",
     "_LIBCPP_HAS_NO_UNICODE": "libcpp-has-no-unicode",
+    "_LIBCPP_HAS_NO_STD_MODULES":  "libcpp-has-no-std-modules",
     "_LIBCPP_PSTL_CPU_BACKEND_LIBDISPATCH": "libcpp-pstl-cpu-backend-libdispatch",
 }
 for macro, feature in macros.items():
     DEFAULT_FEATURES.append(
         Feature(
             name=lambda cfg, m=macro, f=feature: f + ("={}".format(compilerMacros(cfg)[m]) if compilerMacros(cfg)[m] else ""),
             when=lambda cfg, m=macro: m in compilerMacros(cfg),
         )

libcxx/utils/libcxx/test/params.py

def getStdFlag(cfg, std):
     fallbacks = {
         "c++23": "c++2b",
     }
     if std in fallbacks and hasCompileFlag(cfg, "-std=" + fallbacks[std]):
         return "-std=" + fallbacks[std]
     return None
 
 
-_allModules = ["none", "clang", "std"]
+_allModules = ["none", "clang"]
 
 
 def getModuleFlag(cfg, enable_modules):
     if enable_modules in _allModules:
         return enable_modules
     return None
 
 
Parameter(
             AddCompileFlag(lambda cfg: getStdFlag(cfg, std)),
         ],
     ),
     Parameter(
         name="enable_modules",
         choices=_allModules,
         type=str,
         help="Whether to build the test suite with modules enabled. Select "
-        "`clang` for Clang modules and `std` for C++23 std module",
+        "`clang` for Clang modules",
         default=lambda cfg: next(s for s in _allModules if getModuleFlag(cfg, s)),
         actions=lambda enable_modules: [
             AddFeature("modules-build"),
             AddCompileFlag("-fmodules"),
             AddCompileFlag("-fcxx-modules"), # AppleClang disregards -fmodules entirely when compiling C++. This enables modules for C++.
             # Note: We use a custom modules cache path to make sure that we don't reuse
             #       the default one, which can be shared across CI builds with different
             #       configurations.
             AddCompileFlag(lambda cfg: f"-fmodules-cache-path={cfg.test_exec_root}/ModuleCache"),
         ]
         if enable_modules == "clang"
-        else [
-            AddFeature("use_module_std"),
-            AddCompileFlag("-DTEST_USE_MODULE"),
-            AddCompileFlag("-DTEST_USE_MODULE_STD"),
-            AddCompileFlag(
-                lambda cfg: "-fprebuilt-module-path="
-                + os.path.join(
-                    cfg.test_exec_root, "__config_module__/CMakeFiles/std.dir"
-                )
-            ),
-            BuildStdModule(),
-        ]
-        if enable_modules == "std"
         else [],
     ),
     Parameter(
         name="enable_modules_lsv",
         choices=[True, False],
         type=bool,
         default=False,
         help="Whether to enable Local Submodule Visibility in the Modules build.",