Update rust_bindgen_library to only link cc_lib into the direct consumer

Author: UebelAndre

bindgen/private/BUILD.bazel

@@ -1,4 +1,18 @@
 load("@bazel_skylib//:bzl_library.bzl", "bzl_library")
+load("//rust:defs.bzl", "rust_binary")
+load(":bindgen_utils.bzl", "empty_out_dir")
+
+empty_out_dir(
+    name = "out_dir",
+    visibility = ["//visibility:public"],
+)
+
+rust_binary(
+    name = "empty_dir_maker",
+    srcs = ["empty_dir_maker.rs"],
+    edition = "2021",
+    visibility = ["//visibility:public"],
+)
 
 bzl_library(
     name = "bzl_lib",

bindgen/private/bindgen.bzl

@@ -20,6 +20,7 @@ load(
 )
 load("@rules_cc//cc:defs.bzl", "CcInfo")
 load("//rust:defs.bzl", "rust_library")
+load("//rust:rust_common.bzl", "BuildInfo")
 
 # buildifier: disable=bzl-visibility
 load("//rust/private:rustc.bzl", "get_linker_and_args")
@@ -64,27 +65,109 @@ def rust_bindgen_library(
     if "tags" in kwargs:
         kwargs.pop("tags")
 
+    sub_tags = tags + ([] if "manual" in tags else ["manual"])
+
     deps = kwargs.get("deps") or []
     if "deps" in kwargs:
         kwargs.pop("deps")
 
+    bindgen_kwargs = {}
+    if "linkstatic" in kwargs:
+        bindgen_kwargs.update({"linkstatic": kwargs.pop("linkstatic")})
+
     rust_bindgen(
         name = name + "__bindgen",
         header = header,
         cc_lib = cc_lib,
         bindgen_flags = bindgen_flags or [],
         clang_flags = clang_flags or [],
-        tags = ["manual"],
+        tags = sub_tags,
+        **bindgen_kwargs
+    )
+
+    compile_data = kwargs.pop("compile_data", []) + [name + "__bindgen.compile_data"]
+    native.filegroup(
+        name = name + "__bindgen.compile_data",
+        srcs = [name + "__bindgen"],
+        output_group = "bindgen_compile_data",
+        tags = sub_tags,
     )
 
+    for custom_tag in ["__bindgen", "no-clippy", "no-rustfmt"]:
+        tags = tags + ([] if custom_tag in tags else [custom_tag])
+
     rust_library(
         name = name,
         srcs = [name + "__bindgen.rs"],
-        tags = tags + ["__bindgen", "noclippy"],
-        deps = deps + [cc_lib],
+        deps = deps + [name + "__bindgen"],
+        compile_data = compile_data,
+        tags = tags,
         **kwargs
     )
 
+def _generate_cc_link_build_info(ctx, cc_lib):
+    """Produce the eqivilant cargo_build_script providers for use in linking the library.
+
+    Args:
+        ctx (ctx): The rule's context object
+        cc_lib (Target): The `rust_bindgen.cc_lib` target.
+
+    Returns:
+        The `BuildInfo` provider.
+    """
+    compile_data = []
+    linker_flags = []
+    linker_search_paths = []
+
+    for linker_input in cc_lib[CcInfo].linking_context.linker_inputs.to_list():
+        for lib in linker_input.libraries:
+            if lib.static_library:
+                linker_flags.append("-lstatic={}".format(lib.static_library.owner.name))
+                linker_search_paths.append(lib.static_library.dirname)
+                compile_data.append(lib.static_library)
+            elif lib.pic_static_library:
+                linker_flags.append("-lstatic={}".format(lib.pic_static_library.owner.name))
+                linker_search_paths.append(lib.pic_static_library.dirname)
+                compile_data.append(lib.pic_static_library)
+
+        linker_flags.extend(linker_input.user_link_flags)
+
+    if not compile_data:
+        fail("No static libraries found in {}".format(
+            cc_lib.label,
+        ))
+
+    empty_file = ctx.actions.declare_file("{}.empty".format(ctx.label.name))
+    ctx.actions.write(
+        output = empty_file,
+        content = "",
+    )
+
+    link_flags = ctx.actions.declare_file("{}.link_flags".format(ctx.label.name))
+    ctx.actions.write(
+        output = link_flags,
+        content = "\n".join(linker_flags),
+    )
+
+    link_search_paths = ctx.actions.declare_file("{}.link_search_paths".format(ctx.label.name))
+    ctx.actions.write(
+        output = link_search_paths,
+        content = "\n".join([
+            "-Lnative=${{pwd}}/{}".format(path)
+            for path in depset(linker_search_paths).to_list()
+        ]),
+    )
+
+    return BuildInfo(
+        out_dir = ctx.file._bindgen_out_dir,
+        rustc_env = empty_file,
+        dep_env = empty_file,
+        flags = empty_file,
+        link_flags = link_flags,
+        link_search_paths = link_search_paths,
+        compile_data = depset(compile_data),
+    )
+
 def _rust_bindgen_impl(ctx):
     # nb. We can't grab the cc_library`s direct headers, so a header must be provided.
     cc_lib = ctx.attr.cc_lib
@@ -200,6 +283,19 @@ def _rust_bindgen_impl(ctx):
         tools = tools,
     )
 
+    if ctx.attr.linkstatic:
+        providers = [_generate_cc_link_build_info(ctx, cc_lib)]
+    else:
+        providers = [cc_common.merge_cc_infos(
+            direct_cc_infos = [cc_lib[CcInfo]],
+        )]
+
+    return providers + [
+        OutputGroupInfo(
+            bindgen_bindings = depset([output]),
+        ),
+    ]
+
 rust_bindgen = rule(
     doc = "Generates a rust source file from a cc_library and a header.",
     implementation = _rust_bindgen_impl,
@@ -220,6 +316,17 @@ rust_bindgen = rule(
             allow_single_file = True,
             mandatory = True,
         ),
+        "linkstatic": attr.bool(
+            doc = (
+                "If True, `cc_lib` will be statically linked directly into `rust_library that consumes it. " +
+                "This will stop the propagation of the `CcInfo` provider from `cc_lib` into downstream targets. "
+            ),
+            default = False,
+        ),
+        "_bindgen_out_dir": attr.label(
+            default = Label("//bindgen/private:out_dir"),
+            allow_single_file = True,
+        ),
         "_cc_toolchain": attr.label(
             default = Label("@bazel_tools//tools/cpp:current_cc_toolchain"),
         ),

bindgen/private/bindgen_utils.bzl

@@ -0,0 +1,28 @@
+"""Rust Bindgen utilities"""
+
+def _empty_out_dir_impl(ctx):
+    output = ctx.actions.declare_directory(ctx.label.name)
+
+    args = ctx.actions.args()
+    args.add(output.path)
+
+    ctx.actions.run(
+        mnemonic = "RustBindgenOutDir",
+        executable = ctx.executable._generator,
+        arguments = [args],
+        outputs = [output],
+    )
+
+    return [DefaultInfo(files = depset([output]))]
+
+empty_out_dir = rule(
+    doc = "A rule which creates an empty directory.",
+    implementation = _empty_out_dir_impl,
+    attrs = {
+        "_generator": attr.label(
+            cfg = "exec",
+            executable = True,
+            default = Label("//bindgen/private:empty_dir_maker"),
+        ),
+    },
+)

bindgen/private/empty_dir_maker.rs

@@ -0,0 +1,9 @@
+//! A utility binary for creating directories.
+
+use std::env;
+use std::fs;
+
+fn main() {
+    let dir = env::args().last().expect("No arguments passed");
+    fs::create_dir_all(dir).expect("Failed to create directory");
+}

cargo/private/cargo_build_script.bzl

@@ -269,6 +269,7 @@ def _cargo_build_script_impl(ctx):
             flags = flags_out,
             link_flags = link_flags,
             link_search_paths = link_search_paths,
+            compile_data = depset([]),
         ),
         OutputGroupInfo(
             streams = depset([streams.stdout, streams.stderr]),
@@ -417,6 +418,7 @@ def _cargo_dep_env_implementation(ctx):
             link_search_paths = empty_file,
             out_dir = out_dir,
             rustc_env = empty_file,
+            compile_data = depset([]),
         ))
     return [
         DefaultInfo(files = depset(ctx.files.src)),
@@ -435,6 +437,7 @@ def _cargo_dep_env_implementation(ctx):
             link_search_paths = empty_file,
             out_dir = empty_dir,
             rustc_env = empty_file,
+            compile_data = depset([]),
         ),
         # Information here is used directly by dependencies, and it is an error to have more than
         # one dependency which sets this. This is the main way to specify information from build

examples/bindgen/BUILD.bazel

@@ -1,19 +1,15 @@
-load("@rules_cc//cc:defs.bzl", "cc_library")
 load("@rules_rust//bindgen:bindgen.bzl", "rust_bindgen_library")
 load("@rules_rust//rust:defs.bzl", "rust_binary", "rust_test")
 
-cc_library(
-    name = "simple",
-    srcs = ["simple.h"],
-)
-
 rust_bindgen_library(
     name = "simple_bindgen",
     bindgen_flags = [
+        "--allowlist-function=simple_.*",
         "--allowlist-var=SIMPLE_.*",
     ],
-    cc_lib = ":simple",
-    header = "simple.h",
+    cc_lib = "//bindgen/simple",
+    header = "//bindgen/simple:simple.h",
+    linkstatic = True,
 )
 
 rust_binary(

examples/bindgen/main.rs

@@ -1,11 +1,22 @@
+use simple_bindgen;
+
+fn simple_function() -> i64 {
+    unsafe { return simple_bindgen::simple_function() }
+}
+
 fn main() {
-    println!("The value is {}!", simple_bindgen::SIMPLE_VALUE);
+    println!(
+        "The values are {} and {}!",
+        simple_bindgen::SIMPLE_VALUE,
+        simple_function()
+    );
 }
 
 #[cfg(test)]
 mod test {
     #[test]
     fn do_the_test() {
         assert_eq!(42, simple_bindgen::SIMPLE_VALUE);
+        assert_eq!(1337, super::simple_function());
     }
 }

examples/bindgen/main_shared.rs

@@ -0,0 +1,22 @@
+use simple_shared_bindgen;
+
+fn simple_function() -> i64 {
+    unsafe { return simple_shared_bindgen::simple_function() }
+}
+
+fn main() {
+    println!(
+        "The values are {} and {}!",
+        simple_shared_bindgen::SIMPLE_VALUE,
+        simple_function()
+    );
+}
+
+#[cfg(test)]
+mod test {
+    #[test]
+    fn do_the_test() {
+        assert_eq!(42, simple_shared_bindgen::SIMPLE_VALUE);
+        assert_eq!(1337, super::simple_function());
+    }
+}

examples/bindgen/simple.h

@@ -0,0 +1,15 @@
+load("@rules_cc//cc:defs.bzl", "cc_library")
+
+exports_files(
+    [
+        "simple.h",
+    ],
+    visibility = ["//bindgen:__pkg__"],
+)
+
+cc_library(
+    name = "simple",
+    srcs = ["simple.cc"],
+    hdrs = ["simple.h"],
+    visibility = ["//bindgen:__pkg__"],
+)