feat: add cpp binary rule (#19)

Author: alexbatashev

cpp/private/actions/compile.bzl

@@ -2,30 +2,48 @@
 Compile input C++ files into object files
 """
 
-load("//cpp/private:common.bzl", "get_compile_command_args")
 load("@bazel_tools//tools/build_defs/cc:action_names.bzl", "ACTION_NAMES")
+load("//cpp/private:common.bzl", "get_compile_command_args")
+load("//cpp/private:extra_actions.bzl", "EXTRA_ACTIONS")
 
-def _cpp_compile_impl(ctx, sources, headers, includes, features, toolchain):
+def _cpp_compile_impl(ctx, sources, headers, includes, modules, features, toolchain, module_srcs = []):
     obj_files = []
 
-    compiler = cc_common.get_tool_for_action(
-        feature_configuration = features,
-        action_name = ACTION_NAMES.cpp_compile,
-    )
+    extra_vars = {
+        "cpp_precompiled_modules": [],
+    }
+
+    module_files = []
+    module_vars = []
+
+    for m in modules:
+        module_files.append(m["file"])
+        module_vars.append("{name}={file}".format(name = m["name"], file = m["file"].path))
+
+    extra_vars["cpp_precompiled_modules"] = module_vars
 
     for src in sources:
+        action_name = ACTION_NAMES.cpp_compile
+        if src.extension in ["pcm"]:
+            action_name = EXTRA_ACTIONS.cpp_module_compile
+        compiler = cc_common.get_tool_for_action(
+            feature_configuration = features,
+            action_name = action_name,
+        )
+
         outfile = ctx.actions.declare_file("_objs/" + src.basename + ".o")
         args = get_compile_command_args(
             toolchain,
             source = src.path,
             output = outfile.path,
             features = features,
             include_directories = includes,
+            extra_vars = extra_vars,
         )
 
         ctx.actions.run(
             outputs = [outfile],
-            inputs = depset([src], transitive = [depset(headers), toolchain.all_files]),
+            inputs = depset([src], transitive = [depset(headers), depset(module_files), toolchain.all_files, depset(module_srcs)]),
             executable = compiler,
             arguments = args,
             mnemonic = "CppCompile",

cpp/private/common.bzl

@@ -1,20 +1,44 @@
 load("@bazel_tools//tools/build_defs/cc:action_names.bzl", "ACTION_NAMES")
+load("//cpp:providers.bzl", "CppModuleInfo")
 
 def collect_external_headers(deps):
     headers = []
 
     for dep in deps:
-        headers.extend(dep[CcInfo].compilation_context.direct_public_headers)
-        headers.extend(dep[CcInfo].compilation_context.direct_textual_headers)
+        if CcInfo in dep:
+            headers.extend(dep[CcInfo].compilation_context.direct_public_headers)
+            headers.extend(dep[CcInfo].compilation_context.direct_textual_headers)
 
     return headers
 
 def collect_external_includes(deps):
     includes = []
     for dep in deps:
-        includes.extend(dep[CcInfo].compilation_context.includes.to_list())
+        if CcInfo in dep:
+            includes.extend(dep[CcInfo].compilation_context.includes.to_list())
     return depset(includes)
 
+def collect_modules(deps):
+    modules = []
+
+    for dep in deps:
+        if CppModuleInfo in dep:
+            modules.append({
+                "name": dep[CppModuleInfo].module_name,
+                "file": dep[CppModuleInfo].pcm,
+            })
+
+    return modules
+
+def collect_module_objects(deps):
+    obj_files = []
+
+    for dep in deps:
+        if CppModuleInfo in dep:
+            obj_files.extend(dep[CppModuleInfo].objs)
+
+    return obj_files
+
 def create_compilation_context(ctx, headers = [], is_aspect = False):
     """
     Creates a compiler context structure to be used with C++ rules.
@@ -59,13 +83,18 @@ def create_compilation_context(ctx, headers = [], is_aspect = False):
         includes = includes,
     )
 
-def get_compile_command_args(toolchain, source = None, output = None, features = None, include_directories = None, pic = True, action_name = "", extra_vars = {}):
+def get_compile_command_args(toolchain, source = None, output = None, features = None, include_directories = None, pic = True, action_name = "", extra_vars = None):
     action = action_name
     if action == "":
         action = ACTION_NAMES.c_compile
         if source.endswith(".cpp") or source.endswith(".hpp"):
             action = ACTION_NAMES.cpp_compile
 
+    if extra_vars == None:
+        extra_vars = {
+            "cpp_precompiled_modules": [],
+        }
+
     variables = cc_common.create_compile_variables(
         cc_toolchain = toolchain,
         feature_configuration = features,
@@ -97,15 +126,16 @@ def resolve_dependency_libraries(ctx, prefer_static):
     always_link_libs = []
 
     for dep in ctx.attr.deps:
-        dep_libs = dep[CcInfo].linking_context.linker_inputs.to_list()
-        for input in dep_libs:
-            for item in input.libraries:
-                if not item.resolved_symlink_dynamic_library == None and (not prefer_static or item.pic_static_library == None):
-                    libs.append(item.resolved_symlink_dynamic_library)
-                elif not item.pic_static_library == None:
-                    libs.append(item.pic_static_library)
-                else:
-                    libs.append(item.static_library)
+        if CcInfo in dep:
+            dep_libs = dep[CcInfo].linking_context.linker_inputs.to_list()
+            for input in dep_libs:
+                for item in input.libraries:
+                    if not item.resolved_symlink_dynamic_library == None and (not prefer_static or item.pic_static_library == None):
+                        libs.append(item.resolved_symlink_dynamic_library)
+                    elif not item.pic_static_library == None:
+                        libs.append(item.pic_static_library)
+                    else:
+                        libs.append(item.static_library)
 
     return depset(libs), depset(always_link_libs)
 
@@ -138,9 +168,14 @@ def resolve_linker_arguments(ctx, toolchain, features, output_file, is_linking_d
         library_search_directories = depset(link_dirs),
     )
 
+    action_name = ACTION_NAMES.cpp_link_executable
+
+    if is_linking_dynamic_library:
+        action_name = ACTION_NAMES.cpp_link_dynamic_library
+
     link_flags_frozen = cc_common.get_memory_inefficient_command_line(
         feature_configuration = features,
-        action_name = ACTION_NAMES.cpp_link_dynamic_library,
+        action_name = action_name,
         variables = link_variables,
     )
 

cpp/private/extra_actions.bzl

@@ -1,9 +1,11 @@
 load("@bazel_tools//tools/build_defs/cc:action_names.bzl", "ACTION_NAMES")
 
-CPP_MODULE_INTEFACE = "cpp-module-interface"
+CPP_MODULE_INTEFACE = "cpp20-module-interface"
+CPP_MODULE_COMPILE = "cpp20-module-compile"
 
 EXTRA_ACTIONS = struct(
     cpp_module_precompile_interface = CPP_MODULE_INTEFACE,
+    cpp_module_compile = CPP_MODULE_COMPILE,
 )
 
 all_c_compile_actions = [
@@ -18,6 +20,7 @@ all_cpp_compile_actions = [
     ACTION_NAMES.cpp_header_parsing,
     ACTION_NAMES.cpp_module_compile,
     ACTION_NAMES.cpp_module_codegen,
+    EXTRA_ACTIONS.cpp_module_compile,
 ]
 
 all_compile_actions = all_c_compile_actions + all_cpp_compile_actions

cpp/private/target_rules.bzl

@@ -4,7 +4,7 @@ Contains rules implementations for building C++ targets
 
 load("@bazel_tools//tools/cpp:toolchain_utils.bzl", "find_cpp_toolchain")
 load("//cpp:providers.bzl", "CppModuleInfo")
-load("//cpp/private:common.bzl", "collect_external_headers", "collect_external_includes", "get_compile_command_args", "resolve_linker_arguments")
+load("//cpp/private:common.bzl", "collect_external_headers", "collect_external_includes", "collect_module_objects", "collect_modules", "get_compile_command_args", "resolve_linker_arguments")
 load("//cpp/private:extra_actions.bzl", "EXTRA_ACTIONS")
 load("//cpp/private/actions:compile.bzl", "cpp_compile")
 load("//cpp/private/actions:strip.bzl", "cpp_strip_binary", "cpp_strip_objects")
@@ -49,9 +49,10 @@ def shlib_impl(ctx):
 
     all_headers = headers + collect_external_headers(ctx.attr.deps)
     includes = depset([ctx.bin_dir.path + "/_virtual_includes/" + ctx.attr.name] + ctx.attr.includes, transitive = [collect_external_includes(ctx.attr.deps)])
+    modules = collect_modules(ctx.attr.deps)
 
-    obj_files = cpp_compile(ctx.files.srcs, all_headers, includes, features, toolchain)
-    obj_files = cpp_strip_objects(obj_files, features, toolchain)
+    obj_files = cpp_compile(ctx.files.srcs, all_headers, includes, modules, features, toolchain)
+    obj_files = cpp_strip_objects(obj_files, features, toolchain) + collect_module_objects(ctx.attr.deps)
 
     shlib = ctx.actions.declare_file(ctx.attr.lib_prefix + ctx.attr.name + ctx.attr.lib_suffix)
     compile_output = shlib
@@ -73,7 +74,7 @@ def shlib_impl(ctx):
         inputs = depset(obj_files, transitive = [lib_inputs, toolchain.all_files]),
         executable = linker,
         arguments = link_flags,
-        mnemonic = "CppLink",
+        mnemonic = "CppLinkSharedLibrary",
         progress_message = "Compiling %{output}",
     )
 
@@ -116,23 +117,26 @@ def module_impl(ctx):
     Returns:
         A tuple of providers
     """
-    toolchain = ctx.attr._cc_toolchain[cc_common.CcToolchainInfo]
+    toolchain = find_cpp_toolchain(ctx)
 
     features = cc_common.configure_features(ctx = ctx, cc_toolchain = toolchain, requested_features = ctx.features + ["no_agressive_strip"], unsupported_features = ctx.disabled_features)
 
     headers = collect_external_headers(ctx.attr.deps)
     includes = depset(ctx.attr.includes, transitive = [collect_external_includes(ctx.attr.deps)])
+    modules = collect_modules(ctx.attr.deps)
+
+    extra_vars = {
+        "cpp_precompiled_modules": [],
+    }
 
-    extra_modules = []
     module_files = []
-    for dep in ctx.attr.deps:
-        if CppModuleInfo in dep:
-            module = dep[CppModuleInfo]
-            extra_modules.append({
-                "name": module.module_name,
-                "file": module.pcm.path,
-            })
-            module_files.append(module.pcm)
+    module_vars = []
+
+    for m in modules:
+        module_files.append(m["file"])
+        module_vars.append("{name}={file}".format(name = m["name"], file = m["file"].path))
+
+    extra_vars["cpp_precompiled_modules"] = module_vars
 
     pcm = ctx.actions.declare_file("_pcm/" + ctx.attr.module_name + "-" + ctx.files.interface[0].basename[:-(len(ctx.files.interface[0].extension) + 1)] + ".pcm")
 
@@ -143,8 +147,7 @@ def module_impl(ctx):
         features = features,
         include_directories = includes,
         action_name = EXTRA_ACTIONS.cpp_module_precompile_interface,
-        extra_vars = {
-        },
+        extra_vars = extra_vars,
     )
 
     compiler = cc_common.get_tool_for_action(
@@ -155,17 +158,72 @@ def module_impl(ctx):
     ctx.actions.run(
         outputs = [pcm],
         mnemonic = "CppModulePrecompile",
-        inputs = depset(ctx.files.interface, transitive = [depset(headers), toolchain.all_files]),
+        inputs = depset(ctx.files.interface, transitive = [depset(headers), depset(module_files), toolchain.all_files]),
         arguments = precompile_args,
         executable = compiler,
         progress_message = "Precompiling %{output}",
     )
 
-    obj_files = cpp_compile(ctx.files.srcs + [pcm], headers, includes, features, toolchain)
-    obj_files = cpp_strip_objects(obj_files, features, toolchain)
+    obj_files = cpp_compile(ctx.files.srcs + [pcm], headers, includes, modules, features, toolchain, module_srcs = ctx.files.interface)
+    obj_files = cpp_strip_objects(obj_files, features, toolchain) + collect_module_objects(ctx.attr.deps)
 
     return CppModuleInfo(
         module_name = ctx.attr.module_name,
         pcm = pcm,
         objs = obj_files,
     )
+
+def binary_impl(ctx):
+    """
+    Implements C++ rules for building C++ 20 modules
+
+    Return a tuple of providers
+
+    Args:
+        ctx: rule context
+
+    Returns:
+        A tuple of providers
+    """
+    toolchain = find_cpp_toolchain(ctx)
+
+    features = cc_common.configure_features(ctx = ctx, cc_toolchain = toolchain, requested_features = ctx.features + ["no_agressive_strip"], unsupported_features = ctx.disabled_features)
+
+    all_headers = collect_external_headers(ctx.attr.deps)
+    includes = collect_external_includes(ctx.attr.deps)
+
+    modules = collect_modules(ctx.attr.deps)
+
+    obj_files = cpp_compile(ctx.files.srcs, all_headers, includes, modules, features, toolchain)
+    obj_files = cpp_strip_objects(obj_files, features, toolchain) + collect_module_objects(ctx.attr.deps)
+
+    bin = ctx.actions.declare_file(ctx.attr.name + ctx.attr.bin_suffix)
+    compile_output = bin
+    if _has_agressive_strip(features, toolchain):
+        compile_output = ctx.actions.declare_file(ctx.attr.name + ".nonstripped" + ctx.attr.bin_suffix)
+
+    link_flags, lib_inputs = resolve_linker_arguments(ctx, toolchain, features, compile_output.path, False)
+
+    for obj in obj_files:
+        link_flags.append(obj.path)
+
+    linker = cc_common.get_tool_for_action(
+        feature_configuration = features,
+        action_name = ACTION_NAMES.cpp_link_executable,
+    )
+
+    ctx.actions.run(
+        outputs = [compile_output],
+        inputs = depset(obj_files, transitive = [lib_inputs, toolchain.all_files]),
+        executable = linker,
+        arguments = link_flags,
+        mnemonic = "CppLinkExecutable",
+        progress_message = "Linking %{output}",
+    )
+
+    if _has_agressive_strip(features, toolchain):
+        cpp_strip_binary(compile_output, compile_output, bin, toolchain)
+
+    default_provider = DefaultInfo(executable = bin)
+
+    return default_provider

cpp/private/toolchain.bzl

@@ -166,8 +166,31 @@ def _get_clang_features(ctx):
                 actions = [EXTRA_ACTIONS.cpp_module_precompile_interface],
                 flag_groups = [
                     flag_group(
-                        flags = ["-x", "c++-module", "%{cpp_module_interface_file}"],
-                        expand_if_available = "cpp_module_interface_file",
+                        flags = ["-x", "c++-module"],
+                    ),
+                ],
+            ),
+        ],
+    )
+
+    use_modules = feature(
+        name = "c++20_modules",
+        flag_sets = [
+            flag_set(
+                actions = all_cpp_compile_actions + [EXTRA_ACTIONS.cpp_module_precompile_interface],
+                flag_groups = [
+                    flag_group(
+                        iterate_over = "cpp_precompiled_modules",
+                        expand_if_available = "cpp_precompiled_modules",
+                        flags = ["-fmodule-file=%{cpp_precompiled_modules}"],
+                    ),
+                ],
+            ),
+            flag_set(
+                actions = [EXTRA_ACTIONS.cpp_module_precompile_interface],
+                flag_groups = [
+                    flag_group(
+                        flags = ["--precompile"],
                     ),
                 ],
             ),
@@ -195,12 +218,13 @@ def _get_clang_features(ctx):
         stdlib_feature,
         module_interface_precompile_feature,
         lld_feature,
+        use_modules,
     ]
 
 def _get_action_configs(compiler, strip, archiver):
     return [
         action_config(action_name = name, enabled = True, tools = [struct(type_name = "tool", tool = compiler)])
-        for name in all_c_compile_actions + all_cpp_compile_actions + all_link_actions
+        for name in all_c_compile_actions + all_cpp_compile_actions + all_link_actions + [EXTRA_ACTIONS.cpp_module_precompile_interface]
     ] + [
         action_config(action_name = name, enabled = True, tools = [struct(type_name = "tool", tool = archiver)])
         for name in [ACTION_NAMES.cpp_link_static_library]