Bazel

rules_elide ist ein Bazel-Modul mit Java- und Kotlin-Regeln, die über elide javac und elide kotlinc kompilieren; beide laufen als persistente Bazel-Worker. Es lädt Elide selbst herunter; weder ein JDK noch eine Kotlin-Werkzeugkette wird benötigt.

Voraussetzungen

	Version
Bazel	8 oder 9, mit Bzlmod
`rules_elide`	0.7.0
Elide	1.6.0-rc.2 (Standard)
Plattformen	Linux x86_64 und arm64, macOS arm64

Installation

# MODULE.bazel
bazel_dep(name = "rules_elide", version = "0.7.0")

elide = use_extension("@rules_elide//elide:extensions.bzl", "elide")
elide.install(version = "1.6.0-rc.2")
use_repo(elide, "elide_toolchains")
register_toolchains("@elide_toolchains//:all")

elide.install() lädt das Elide-Release für den Host herunter und prüft es gegen einen festgelegten Hash; version muss eine der Versionen sein, die das Modul auflistet. Um ein selbst installiertes Elide zu verwenden:

elide.use(local_path = "/opt/elide")

Regeln

Laden Sie sie aus @rules_elide//elide:defs.bzl.

Regel	Funktion
`elide_java_library`	Kompiliert `.java`-Quellen in ein JAR
`elide_java_binary`	Bibliothek plus Launcher (`bazel run`)
`elide_java_test`	Bibliothek plus JUnit-Platform-Launcher (`bazel test`)
`elide_kotlin_library`	Kompiliert `.kt`-Quellen und gemischte `.kt`/`.java`-Quellen
`elide_kotlin_binary`, `elide_kotlin_test`	Wie die Java-Varianten, für Kotlin
`elide_format`	`bazel run`-Target, das Quellen an Ort und Stelle formatiert (Java oder Kotlin, eines pro Target)
`elide_native_image`	Native Binärdatei aus JVM-Targets

Jede Kompilierregel liefert JavaInfo, daher lassen sich Targets aus java_library, kt_jvm_library und rules_jvm_external in deps frei mischen. Testregeln brauchen org.junit.platform:junit-platform-console-standalone in runtime_deps.

Vollständige Attributreferenz: rules_elide-Dokumentation.

Beispiel

MODULE.bazel
BUILD.bazel
src/Greeter.java
src/App.kt
src/GreeterTest.java

# MODULE.bazel
module(name = "hello")

bazel_dep(name = "rules_elide", version = "0.7.0")
bazel_dep(name = "rules_jvm_external", version = "7.1")

elide = use_extension("@rules_elide//elide:extensions.bzl", "elide")
elide.install(version = "1.6.0-rc.2")
use_repo(elide, "elide_toolchains")
register_toolchains("@elide_toolchains//:all")

maven = use_extension("@rules_jvm_external//:extensions.bzl", "maven")
maven.install(
    artifacts = [
        "org.junit.jupiter:junit-jupiter-api:5.13.4",
        "org.junit.platform:junit-platform-console-standalone:1.13.4",
    ],
)
use_repo(maven, "maven")

# BUILD.bazel
load("@rules_elide//elide:defs.bzl", "elide_java_library", "elide_java_test", "elide_kotlin_binary")

elide_java_library(
    name = "greeter",
    srcs = ["src/Greeter.java"],
)

elide_kotlin_binary(
    name = "app",
    srcs = ["src/App.kt"],
    main_class = "AppKt",
    deps = [":greeter"],
)

elide_java_test(
    name = "greeter_test",
    srcs = ["src/GreeterTest.java"],
    test_class = "GreeterTest",
    runtime_deps = ["@maven//:org_junit_platform_junit_platform_console_standalone"],
    deps = [
        ":greeter",
        "@maven//:org_junit_jupiter_junit_jupiter_api",
    ],
)

bazel build //...
bazel run //:app
bazel test //:greeter_test

INFO: 35 processes: 12 internal, 16 linux-sandbox, 7 worker.
INFO: Build completed successfully, 35 total actions

Hello, Bazel

//:greeter_test                                                 PASSED in 2.0s
Executed 1 out of 1 test: 1 test passes.

Persistente Worker

Die Kompilierregeln führen elide javac --persistent_worker und elide kotlinc --persistent_worker aus: Ein warmer Prozess pro Werkzeug bedient alle Kompilieraktionen, nimmt parallele Anfragen an und kompiliert sie nacheinander. bazel shutdown beendet sie.

Um jedes Target in einem neuen Prozess zu kompilieren (etwa bei Remote Execution):

bazel build --@rules_elide//elide:use_workers=false //...

Worker aus eigenen Regeln

Ohne rules_elide kann jede Regel Elide als Worker ausführen. Bazel fügt --persistent_worker selbst hinzu; die Regel übergibt die Argumente in einer Parameterdatei:

# elide.bzl
def _elide_javac_impl(ctx):
    out = ctx.actions.declare_directory(ctx.label.name + "_classes")
    args = ctx.actions.args()
    args.add("-d", out.path)
    args.add_all(ctx.files.srcs)
    args.use_param_file("@%s", use_always = True)
    args.set_param_file_format("multiline")
    ctx.actions.run(
        executable = ctx.executable._elide,
        arguments = ["javac", args],
        inputs = ctx.files.srcs,
        outputs = [out],
        mnemonic = "ElideJavac",
        execution_requirements = {"supports-workers": "1", "supports-multiplex-workers": "1"},
    )
    return [DefaultInfo(files = depset([out]))]

elide_javac = rule(
    implementation = _elide_javac_impl,
    attrs = {
        "srcs": attr.label_list(allow_files = [".java"]),
        "_elide": attr.label(default = "//tools:elide", executable = True, cfg = "exec", allow_single_file = True),
    },
)

# BUILD.bazel
load(":elide.bzl", "elide_javac")

elide_javac(
    name = "hello",
    srcs = glob(["src/*.java"]),
)

mkdir -p tools && ln -s "$(command -v elide)" tools/elide
echo 'exports_files(["elide"])' > tools/BUILD.bazel
bazel build //:hello

Target //:hello up-to-date:
  bazel-bin/hello_classes
INFO: 2 processes: 1 internal, 1 worker.

Übergeben Sie für javac ["javac", "--classpath-cache", args], um bereits geparste Classpath-JARs zwischen Anfragen wiederzuverwenden. Eine kotlinc-Regel hat dieselbe Form, ohne --classpath-cache.

`kt_jvm_*`-Targets behalten

register_elide_kotlin_toolchain aus @rules_elide//elide/kotlin:toolchain.bzl ersetzt den Builder einer rules_kotlin-Werkzeugkette, sodass bestehende Targets aus kt_jvm_library, kt_jvm_binary und kt_jvm_test ohne Änderungen an BUILD-Dateien mit Elide kompilieren. Targets mit Annotationsprozessoren fallen auf den regulären Builder von rules_kotlin zurück. Einrichtung: KotlinBuilder-Shim.

OpenRewrite und Abhängigkeitsabfragen

Für Projekte mit einer elide.pkl siehe OpenRewrite und Codeindex für Abhängigkeiten. Diese Befehle verarbeiten weder das JavaInfo von Bazel noch seinen Target-Graphen, und die oben aufgeführten Regeln fügen kein Target für Rewrite oder den Codeindex hinzu. Lesen Sie die Grenze der Projekteinrichtung, bevor Sie sie neben Bazel einsetzen.

Einschränkungen

Windows wird nicht unterstützt.
elide.install akzeptiert nur Versionen, die im Modul aufgelistet sind; verwenden Sie für andere elide.use.
Kotlin-Compiler-Plugins aus externen JARs (das Attribut plugins der Regeln elide_kotlin_*) außer all-open, no-arg, sam-with-receiver, assignment und Lombok schlagen mit einem Compilerfehler fehl.