Support C++20 modules in the rules-based toolchain API

The rules-based cc/toolchains toolchain API was missing several pieces
needed to drive Bazel's C++20 modules pipeline (clang-scan-deps -> .ddi
-> aggregate-ddi -> generate-modmap -> module compile):

- Add a cpp20_module_actions action type set grouping the module
  interface compile, codegen and dependency scanning actions. These are
  deliberately kept out of compile_actions/source_compile_actions so that
  flags incompatible with C++20 modules can keep targeting only the
  non-module compiles.
- Register the cpp_module_output_file and cpp_module_modmap_file build
  variables and make dependency_file, output_file, source_file and
  user_compile_flags available to the C++20 module actions.
- Include the C++20 module actions in the compiler_files legacy file
  group so their tools (e.g. the dependency scanner) are available to the
  compile actions.
- Fix _create_scan_deps_action to pass needs_include_validation and to
  not request a .d dotd file (the scanner emits a P1689 .ddi file), and
  let _create_compile_action forward the C++20 module output/modmap
  arguments to the underlying action.

The C++20 modules pipeline lives only in rules_cc's compile.bzl (Bazel's
native rules do not implement it), and was previously untested here:
Bazel's CppModulesConfiguredTargetTest only checks the
--experimental_cpp_modules / cpp_modules gating, and the shell
integration test self-skips unless a host clang >= 17 is present. Add an
analysis test that drives the module interface compile + dependency
scanning actions with a mock toolchain (no real compiler needed) and
asserts the scanning action emits a .ddi and not a .d file. This test
fails without the fixes above.

Author: fmeum

cc/private/compile/compile.bzl

@@ -527,21 +527,9 @@ def _create_scan_deps_action(
         ddi_file,
         ddi_output_name,
         progress_message_prefix):
+    # The dependency scanner (e.g. clang-scan-deps) emits the P1689 .ddi file,
+    # not a Make-style .d dependency file, so no dotd file is requested here.
     dotd_file = None
-    if (
-        dotd_files_enabled(language, cpp_configuration, feature_configuration) and
-        _use_dotd_file(feature_configuration, source_artifact)
-    ):
-        dotd_file = _get_compile_output_file(
-            action_construction_context,
-            label,
-            configuration = configuration,
-            output_name = _cc_internal.get_artifact_name_for_category(
-                cc_toolchain = cc_toolchain,
-                category = artifact_category.INCLUDED_FILE_LIST,
-                output_name = ddi_output_name,
-            ),
-        )
     specific_compile_build_variables = get_specific_compile_build_variables(
         feature_configuration,
         use_pic = use_pic,
@@ -579,6 +567,7 @@ def _create_scan_deps_action(
         compile_build_variables = compile_variables,
         action_name = ACTION_NAMES.cpp_module_deps_scanning,
         toolchain_type = _starlark_cc_semantics.toolchain,
+        needs_include_validation = _starlark_cc_semantics.needs_include_validation(language),
         progress_message_prefix = progress_message_prefix,
     )
 
@@ -2319,11 +2308,24 @@ def _create_compile_action(
         progress_message_prefix = None,
         source = None,
         toolchain_type = None,
-        use_pic = False):
+        use_pic = False,
+        additional_outputs = [],
+        module_files = None,
+        modmap_file = None,
+        modmap_input_file = None):
     # TODO(bgorshenev): use bazel_features checks
     version_dependent_kwargs = {}
     if progress_message_prefix:
         version_dependent_kwargs["progress_message_prefix"] = progress_message_prefix
+
+    # Provide the C++20 module args conditionally as they require a recent
+    # version of Bazel.
+    if modmap_file:
+        version_dependent_kwargs["additional_outputs"] = additional_outputs
+        version_dependent_kwargs["module_files"] = module_files
+        version_dependent_kwargs["modmap_file"] = modmap_file
+        version_dependent_kwargs["modmap_input_file"] = modmap_input_file
+
     return _cc_internal.create_cc_compile_action(
         action_construction_context = action_construction_context,
         action_name = action_name,

cc/toolchains/actions/BUILD

@@ -272,6 +272,31 @@ cc_action_type_set(
     ],
 )
 
+# The C++20 module actions: module interface compilation, module codegen and
+# module dependency scanning. These are deliberately kept out of
+# `compile_actions`/`source_compile_actions` so that flags incompatible with
+# C++20 modules can keep targeting only the non-module compiles. Toolchains that
+# support C++20 modules typically combine this set with `compile_actions` or
+# `source_compile_actions` on the relevant `cc_args`, e.g.
+#
+#     actions = [
+#         "//cc/toolchains/actions:compile_actions",
+#         "//cc/toolchains/actions:cpp20_module_actions",
+#     ]
+#
+# The module interface compilation and codegen actions are ordinary C++ compiles
+# and the dependency scanning action reuses the regular compiler command line,
+# so toolchain flags that apply to compiles (target, sysroot, include search
+# paths, ...) generally need to apply to these actions as well.
+cc_action_type_set(
+    name = "cpp20_module_actions",
+    actions = [
+        ":cpp20_module_compile",
+        ":cpp20_module_codegen",
+        ":cpp_module_deps_scanning",
+    ],
+)
+
 cc_action_type_set(
     name = "compile_actions_without_header_parsing",
     actions = [

cc/toolchains/legacy_file_group.bzl

@@ -28,6 +28,11 @@ LEGACY_FILE_GROUPS = {
         Label("//cc/toolchains/actions:c_compile"),
         Label("//cc/toolchains/actions:cpp_compile"),
         Label("//cc/toolchains/actions:cpp_header_parsing"),
+        # C++20 module actions: their tools (e.g. the dependency scanner) must
+        # be part of compiler_files so they are available to compile actions.
+        Label("//cc/toolchains/actions:cpp20_module_compile"),
+        Label("//cc/toolchains/actions:cpp20_module_codegen"),
+        Label("//cc/toolchains/actions:cpp_module_deps_scanning"),
     ],
     # There are no actions listed for coverage and objcopy in action_names.bzl.
     "coverage_files": [],

cc/toolchains/variables/BUILD

@@ -2,6 +2,22 @@ load("//cc/toolchains/impl:variables.bzl", "cc_builtin_variables", "cc_variable"
 
 package(default_visibility = ["//visibility:public"])
 
+cc_variable(
+    name = "cpp_module_modmap_file",
+    actions = [
+        "//cc/toolchains/actions:cpp_compile",
+        "//cc/toolchains/actions:cpp20_module_compile",
+        "//cc/toolchains/actions:cpp20_module_codegen",
+    ],
+    type = types.option(types.file),
+)
+
+cc_variable(
+    name = "cpp_module_output_file",
+    actions = ["//cc/toolchains/actions:cpp20_module_compile"],
+    type = types.option(types.file),
+)
+
 cc_variable(
     name = "cs_fdo_instrument_path",
     actions = [
@@ -19,7 +35,10 @@ cc_variable(
 
 cc_variable(
     name = "dependency_file",
-    actions = ["//cc/toolchains/actions:compile_actions"],
+    actions = [
+        "//cc/toolchains/actions:compile_actions",
+        "//cc/toolchains/actions:cpp20_module_actions",
+    ],
     type = types.option(types.file),
 )
 
@@ -412,6 +431,7 @@ cc_variable(
     name = "output_file",
     actions = [
         "//cc/toolchains/actions:compile_actions",
+        "//cc/toolchains/actions:cpp20_module_actions",
         "//cc/toolchains/actions:strip",
     ],
     type = types.option(types.file),
@@ -473,7 +493,10 @@ cc_variable(
 
 cc_variable(
     name = "source_file",
-    actions = ["//cc/toolchains/actions:compile_actions"],
+    actions = [
+        "//cc/toolchains/actions:compile_actions",
+        "//cc/toolchains/actions:cpp20_module_actions",
+    ],
     type = types.option(types.file),
 )
 
@@ -554,7 +577,10 @@ cc_variable(
 
 cc_variable(
     name = "user_compile_flags",
-    actions = ["//cc/toolchains/actions:compile_actions"],
+    actions = [
+        "//cc/toolchains/actions:compile_actions",
+        "//cc/toolchains/actions:cpp20_module_actions",
+    ],
     type = types.option(types.list(types.string)),
 )
 
@@ -569,6 +595,8 @@ cc_builtin_variables(
     srcs = [
         ":attr_linkopts",
         ":cc_library_exec_paths",
+        ":cpp_module_modmap_file",
+        ":cpp_module_output_file",
         ":cs_fdo_instrument_path",
         ":def_file_path",
         ":dep_linkopts",

tests/cc/common/BUILD

@@ -2,6 +2,7 @@ load(":cc_binary_configured_target_tests.bzl", "cc_binary_configured_target_test
 load(":cc_common_test.bzl", "cc_common_tests")
 load(":cc_import_configured_target_tests.bzl", "cc_import_configured_target_tests")
 load(":cc_library_configured_target_tests.bzl", "cc_library_configured_target_tests")
+load(":cc_module_compile_configured_target_tests.bzl", "cc_module_compile_configured_target_tests")
 load(":cc_objc_library_configured_target_tests.bzl", "cc_objc_library_configured_target_tests")
 
 cc_binary_configured_target_tests(name = "cc_binary_configured_target_tests")
@@ -12,4 +13,6 @@ cc_import_configured_target_tests(name = "cc_import_configured_target_tests")
 
 cc_library_configured_target_tests(name = "cc_library_configured_target_tests")
 
+cc_module_compile_configured_target_tests(name = "cc_module_compile_configured_target_tests")
+
 cc_objc_library_configured_target_tests(name = "cc_objc_library_configured_target_tests")

tests/cc/common/cc_module_compile_configured_target_tests.bzl

@@ -0,0 +1,85 @@
+"""Tests for C++20 module compilation in cc_library.
+
+The C++20 modules pipeline (dependency scanning -> aggregate ddi -> generate
+modmap -> module interface compile) is implemented in rules_cc's compile.bzl and
+is not exercised by Bazel's own analysis tests (which only check the
+`--experimental_cpp_modules` / `cpp_modules` gating). These analysis tests cover
+the action-creation paths so that regressions in e.g. forwarding the module
+output/modmap arguments or the dependency-scanning action's outputs are caught
+without needing a real compiler.
+"""
+
+load("@bazel_features//:features.bzl", "bazel_features")
+load("@rules_testing//lib:analysis_test.bzl", "test_suite")
+load("@rules_testing//lib:truth.bzl", "matching")
+load("@rules_testing//lib:util.bzl", "TestingAspectInfo", "util")
+load("//cc:cc_library.bzl", "cc_library")
+load("//tests/cc/testutil:cc_analysis_test.bzl", "cc_analysis_test")
+
+# Action names of the C++20 module actions. Passing these to the mock toolchain's
+# with_action_configs makes it provide (dummy) tools for them so the actions can
+# be created during analysis.
+_CPP20_MODULE_ACTION_CONFIGS = [
+    "c++-module-deps-scanning",
+    "c++20-module-compile",
+    "c++20-module-codegen",
+]
+
+def _test_cpp20_module_interface_actions(name, **kwargs):
+    util.helper_target(
+        cc_library,
+        name = name + "_subject",
+        module_interfaces = ["mod.cppm"],
+    )
+    cc_analysis_test(
+        name = name,
+        impl = _test_cpp20_module_interface_actions_impl,
+        target = name + "_subject",
+        # Enables rules_cc's C++20 modules pipeline.
+        test_features = ["cpp_modules"],
+        # Provide (dummy) tools for the module actions so they can be created.
+        with_action_configs = _CPP20_MODULE_ACTION_CONFIGS,
+        # The module_interfaces attribute is gated behind this flag.
+        config_settings = {
+            "//command_line_option:experimental_cpp_modules": True,
+        },
+        **kwargs
+    )
+
+def _test_cpp20_module_interface_actions_impl(env, target):
+    actions = target[TestingAspectInfo].actions
+
+    # Reaching the assertions at all means the dependency-scanning action and the
+    # module interface compile action were created without error. That covers
+    # regressions where the scanning action does not pass needs_include_validation
+    # or where the module output / modmap arguments are not forwarded to the
+    # compile action, both of which fail analysis.
+    scan_actions = [a for a in actions if a.mnemonic == "CppDepsScanning"]
+    env.expect.that_collection(scan_actions).has_size(1)
+
+    for scan in scan_actions:
+        basenames = [f.basename for f in scan.outputs.to_list()]
+
+        # The scanner writes a P1689 .ddi file ...
+        env.expect.that_collection(basenames).contains_predicate(
+            matching.str_endswith(".ddi"),
+        )
+
+        # ... and must not declare a Make-style .d dependency file, which the
+        # scanner never produces.
+        env.expect.that_collection(basenames).not_contains_predicate(
+            matching.str_endswith(".d"),
+        )
+
+    # The .ddi files are aggregated into the modules info before the modmap is
+    # generated; assert the rest of the pipeline is wired up too.
+    aggregate_actions = [a for a in actions if a.mnemonic == "CppAggregateDdi"]
+    env.expect.that_collection(aggregate_actions).has_size(1)
+
+def cc_module_compile_configured_target_tests(name):
+    test_suite(
+        name = name,
+        tests = [
+            _test_cpp20_module_interface_actions,
+        ] if bazel_features.cc.cc_common_is_in_rules_cc else [],
+    )

tests/cc/common/mod.cppm

@@ -0,0 +1,5 @@
+export module mod;
+
+export int answer() {
+  return 42;
+}