Propagate CcInfo for native dependencies

This will, in a follow-up, allow us to create and link `java_{binary,test}#laucher`
as the docs suggest.

Unfortunately, `JavaInfo#transitive_native_libraries` fails to propagate
sufficient information about transitive dependencies of the native
libraries, so linking fails because of missing symbols from transitive
libraries that should be there.

Author: Yannic

java/bazel/rules/bazel_java_library.bzl

@@ -16,6 +16,7 @@
 Definition of java_library rule.
 """
 
+load("@rules_cc//cc:find_cc_toolchain.bzl", "use_cc_toolchain")
 load("//java/common:java_semantics.bzl", "semantics")
 load("//java/common/rules:android_lint.bzl", "android_lint_subrule")
 load("//java/common/rules:java_library.bzl", "JAVA_LIBRARY_ATTRS")
@@ -60,6 +61,6 @@ java_library = rule(
         "sourcejar": "lib%{name}-src.jar",
     },
     fragments = ["java", "cpp"],
-    toolchains = [semantics.JAVA_TOOLCHAIN],
+    toolchains = [semantics.JAVA_TOOLCHAIN] + use_cc_toolchain(mandatory = False),
     subrules = [android_lint_subrule],
 )

java/common/rules/impl/basic_java_library_impl.bzl

@@ -16,7 +16,10 @@
 Common code for reuse across java_* rules
 """
 
+load("@rules_cc//cc:find_cc_toolchain.bzl", "CC_TOOLCHAIN_TYPE", "find_cc_toolchain")
+load("@rules_cc//cc/common:cc_common.bzl", "cc_common")
 load("@rules_cc//cc/common:cc_info.bzl", "CcInfo")
+load("//java/common:java_semantics.bzl", "semantics")
 load("//java/common/rules:android_lint.bzl", "android_lint_subrule")
 load("//java/private:boot_class_path_info.bzl", "BootClassPathInfo")
 load("//java/private:java_common_internal.bzl", "target_kind")
@@ -124,6 +127,7 @@ def basic_java_library(
         resources = list(resources)
         resources.extend(properties)
 
+    native_libraries = _collect_native_libraries(deps, runtime_deps, exports)
     java_info, compilation_info = compile_action(
         ctx,
         ctx.outputs.classjar,
@@ -138,7 +142,7 @@ def basic_java_library(
         resources,
         resource_jars,
         classpath_resources,
-        _collect_native_libraries(deps, runtime_deps, exports),
+        native_libraries,
         javacopts,
         neverlink,
         ctx.fragments.java.strict_java_deps,
@@ -150,6 +154,25 @@ def basic_java_library(
     )
     target = {"JavaInfo": java_info}
 
+    if native_libraries:
+        native_header_cc_info = _make_native_header_cc_info(ctx, java_info)
+        dependencies_cc_info = cc_common.merge_cc_infos(cc_infos = native_libraries)
+
+        target["CcInfo"] = cc_common.merge_cc_infos(
+            cc_infos = [
+                native_header_cc_info,
+                # Native dependencies have the same semantics as
+                # `cc_library#implementation_deps`. We only want to propagate
+                # `Cc{Debug,Linking}Context` to libraries depending on this.
+                CcInfo(
+                    linking_context = dependencies_cc_info.linking_context,
+                    debug_context = dependencies_cc_info.debug_context(),
+                ),
+            ],
+        )
+    else:
+        target["CcInfo"] = _make_native_header_cc_info(ctx, java_info)
+
     output_groups = dict(
         compilation_outputs = compilation_info.files_to_build,
         _source_jars = java_info.transitive_source_jars,
@@ -234,6 +257,82 @@ def _collect_native_libraries(*attrs):
     """
     return _filter_provider(CcInfo, *attrs)
 
+def _make_native_header_cc_info(ctx, java_info):
+    """Creates a `CcInfo` for compiling and linking against generated headers.
+
+    Use this call to generate a single header from the `-native.jar` and wrap it
+    in `CcInfo` for consumers.
+
+    Args:
+      ctx: (RuleContext) The rule context of the caller.
+      java_info: (JavaInfo) The `JavaInfo` provider to extract headers from.
+    Returns:
+      (CcInfo): The `CcInfo` provider for compiling and linking against
+                generated headers.
+    """
+
+    # 1. Check if there's jar with native headers.
+    native_headers_jar = java_info.outputs.native_headers
+    if not native_headers_jar:
+        # There's no jar with native headers. Simply return an empty provider so
+        # we have a well-defined API.
+        return CcInfo()
+
+    # 2. Check if there's a `cc_toolchain` available.
+    if CC_TOOLCHAIN_TYPE in ctx.toolchains:
+        cc_toolchain = find_cc_toolchain(ctx, mandatory = False)
+    else:
+        # Work around a bug in `find_cc_toolchain()` which requires a rule to
+        # declare an (optional) dependency on the Cc toolchain even if
+        # `mandatory = False`.
+        cc_toolchain = None
+    if not cc_toolchain:
+        # No `cc_toolchain` available, so there's no way for users to build
+        # native dependencies. Simply return an empty provider so we have a
+        # well-defined API.
+        return CcInfo()
+
+    # 3. Get tool to generate header from jar.
+    java_toolchain = semantics.find_java_toolchain(ctx)
+    if not java_toolchain.native_header_generator:
+        # We don't have a tool to generate the combined header. Simply return an
+        # empty provider so we have a well-defined API.
+        return CcInfo()
+
+    args = ctx.actions.args()
+    args.add("--jar", native_headers_jar)
+
+    native_header = ctx.actions.declare_file("{}.native.h".format(ctx.attr.name))
+    args.add("--output", native_header)
+
+    ctx.actions.run(
+        executable = java_toolchain.native_header_generator,
+        outputs = [
+            native_header,
+        ],
+        inputs = [
+            native_headers_jar,
+        ],
+        mnemonic = "JavaNativeHeader",
+        progress_message = "Generating native header for %{label}",
+        toolchain = semantics.JAVA_TOOLCHAIN_TYPE,
+        arguments = [
+            args,
+        ],
+    )
+
+    # TODO(yannic): Add `CcCompilationContext` for `jni.h`.
+    compilation_context = cc_common.create_compilation_context(
+        headers = depset(
+            direct = [
+                native_header,
+            ],
+        ),
+    )
+    return CcInfo(
+        compilation_context = compilation_context,
+    )
+
 def construct_defaultinfo(ctx, files_to_build, files, neverlink, *extra_attrs):
     """Constructs DefaultInfo for Java library like rule.
 

java/common/rules/java_toolchain.bzl

@@ -38,6 +38,7 @@ JavaToolchainInfo, _new_javatoolchaininfo = provider(
     fields = {
         "bootclasspath": "(depset[File]) The Java target bootclasspath entries. Corresponds to javac's -bootclasspath flag.",
         "ijar": "(FilesToRunProvider) The ijar executable.",
+        "native_header_generator": "(FilesToRunProvider) (optional) The executable to generate a combined native header file.",
         "jacocorunner": "(FilesToRunProvider) The jacocorunner used by the toolchain.",
         "java_runtime": "(JavaRuntimeInfo) The java runtime information.",
         "jvm_opt": "(depset[str]) The default options for the JVM running the java compiler and associated tools.",
@@ -97,6 +98,7 @@ def _java_toolchain_impl(ctx):
     java_toolchain_info = _new_javatoolchaininfo(
         bootclasspath = bootclasspath_info.bootclasspath,
         ijar = ctx.attr.ijar.files_to_run if ctx.attr.ijar else None,
+        native_header_generator = ctx.attr.native_header_generator.files_to_run if ctx.attr.native_header_generator else None,
         jacocorunner = ctx.attr.jacocorunner.files_to_run if ctx.attr.jacocorunner else None,
         java_runtime = java_runtime,
         jvm_opt = depset(get_internal_java_common().expand_java_opts(ctx, "jvm_opts", tokenize = False, exec_paths = True)),
@@ -390,6 +392,15 @@ include any API-generating annotation processors.
 Label of the ijar executable.
             """,
         ),
+        "native_header_generator": attr.label(
+            cfg = "exec",
+            allow_files = True,
+            executable = True,
+            doc = """
+Label of the executable to generate a native header from a jar of native
+headers.
+            """,
+        ),
         "jacocorunner": attr.label(
             cfg = "exec",
             allow_single_file = True,

test/repo/BUILD.bazel

@@ -1,9 +1,32 @@
+load("@rules_cc//cc:defs.bzl", "cc_library", "cc_test")
 load("@rules_java//java:defs.bzl", "java_binary", "java_library", "java_test")  # copybara-use-repo-external-label
 load("@rules_java//toolchains:default_java_toolchain.bzl", "default_java_toolchain")  # copybara-use-repo-external-label
 
+cc_library(
+    name = "native_dep",
+    srcs = [
+        "src/native_dep.cc",
+    ],
+)
+
 java_library(
     name = "lib",
     srcs = ["src/Main.java"],
+    deps = [
+        ":native_dep",
+    ],
+)
+
+cc_test(
+    name = "native_test",
+    srcs = [
+        "src/native_test.cc",
+    ],
+    deps = [
+        ":lib",
+        "@googletest//:gtest",
+        "@googletest//:gtest_main",
+    ],
 )
 
 java_binary(

test/repo/MODULE.bazel

@@ -1,5 +1,7 @@
 module(name = "integration_test_repo")
 
+bazel_dep(name = "googletest", version = "1.15.2")
+bazel_dep(name = "rules_cc", version = "0.0.15")
 bazel_dep(name = "rules_java", version = "7.5.0")
 archive_override(
     module_name = "rules_java",

test/repo/src/native_dep.cc

@@ -0,0 +1,3 @@
+int my_number() {
+    return 42;
+}

test/repo/src/native_test.cc

@@ -0,0 +1,8 @@
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+int my_number();
+
+TEST(MyNativeTest, MyNumberReturnsExpectedValue) {
+  EXPECT_THAT(my_number(), testing::Eq(42));
+}