如何在Bazel工作空间中使用不同的bootclasspath？

Question

I'm currently trying to build a Bazel 0.11.1 workspace with projects that use different Java language levels. The actual application uses Java 7, but for some code that won't ship, I want to settle with a more recent Java version to be able to use the new language features.

I can solve this to some extent by using --javacopt in .bazelrc , setting -source 1.7 -target 1.7 and override the defaults on a project level with the javacopts attribute, but this is not enough to ensure proper Java 7 compatibility when compiling with a more recent Java version. For this I really need to compile Java 7 projects against a Java 7 classpath as well.

The only way to use a custom bootclasspath seems to be via java_toolchain . It works. But I could not found a way to use different bootclasspaths for different projects, because the toolchain affects all projects and unlike with javacopts cannot be overridden at the project level.

Is this a usecase that is simply not (yet?) possible with Bazel? Or is there some trickery to make it work?

Answer 1

It turns out there is a way: write a custom rule that performs compilation.

The java_common module provides an interface to the compiler.

library.bzl

def _impl(ctx):
    deps = []
    for dep in ctx.attr.deps:
        if java_common.provider in dep:
            deps.append(dep[java_common.provider])
    output_jar = ctx.new_file("lib{0}.jar".format(ctx.label.name))
    runtime = java_common.JavaRuntimeInfo
    compilation_provider = java_common.compile(
        ctx,
        source_jars = ctx.files.srcs_jars,
        source_files = ctx.files.srcs,
        output = output_jar,
        javac_opts = ctx.attr.javac_opts,
        deps = deps,
        strict_deps = ctx.attr.strict_deps,
        java_toolchain = ctx.attr.toolchain,
        host_javabase = ctx.attr._host_javabase,
        resources = ctx.files.resources,
        neverlink = ctx.attr.neverlink,
    )

    return struct(
        files = depset([output_jar]),
        providers = [compilation_provider],
    )

library = rule(
    implementation = _impl,
    attrs = {
        "srcs_jars": attr.label_list(allow_files=True),
        "srcs": attr.label_list(allow_files=True),
        "javac_opts": attr.string_list(default=[]),
        "deps": attr.label_list(),
        "strict_deps": attr.string(default="ERROR"),
        "toolchain": attr.label(default=Label("@bazel_tools//tools/jdk:toolchain")),
        "sourcepath": attr.label_list(),
        "resources": attr.label_list(),
        "neverlink": attr.bool(default=False),
        "_host_javabase": attr.label(default=Label("@local_jdk//:jdk")),
    },
    fragments = ["java"],
)

This rule I can now use to set a different toolchain for compilation.

BUILD

load('//build/jdk:library.bzl', 'library')

library(
    name = "test",
    srcs = glob(["src/main/java/**/*.java"]),
#    data = glob(["src/main/resources/**"]),
    toolchain = "//build/jdk:jdk8",
    deps = ["..."],
)

Unfortunately I'm not 100% there yet. java_common.compile does not seem to have an equivalent for the data attribute of java_library , but for the most part the toolchain problem is solved.