Bazel

rules_elide es un módulo de Bazel con reglas de Java y Kotlin que compilan mediante elide javac y elide kotlinc, ejecutados como workers persistentes. Descarga Elide por sí mismo; no hace falta ningún JDK ni cadena de herramientas de Kotlin.

Requisitos

	Versión
Bazel	8 o 9, con Bzlmod
`rules_elide`	0.7.0
Elide	1.6.0-rc.2 (la predeterminada)
Plataformas	Linux x86_64 y arm64, macOS arm64

Instalar

# 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() descarga la versión de Elide para el host y la comprueba con un hash fijado; version debe ser una de las que lista el módulo. Para usar un Elide que haya instalado usted mismo:

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

Reglas

Cárguelas desde @rules_elide//elide:defs.bzl.

Regla	Qué hace
`elide_java_library`	Compila fuentes `.java` en un JAR
`elide_java_binary`	Biblioteca más un lanzador (`bazel run`)
`elide_java_test`	Biblioteca más un lanzador de JUnit Platform (`bazel test`)
`elide_kotlin_library`	Compila fuentes `.kt` y mixtas `.kt`/`.java`
`elide_kotlin_binary`, `elide_kotlin_test`	Como las variantes de Java, para Kotlin
`elide_format`	Destino de `bazel run` que da formato a las fuentes in situ (Java o Kotlin, uno por destino)
`elide_native_image`	Binario nativo a partir de destinos de la JVM

Cada regla de compilación devuelve JavaInfo, así que los destinos java_library, kt_jvm_library y rules_jvm_external se combinan libremente en deps. Las reglas de prueba necesitan org.junit.platform:junit-platform-console-standalone en runtime_deps.

Referencia completa de atributos: documentación de rules_elide.

Ejemplo

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.

Workers persistentes

Las reglas de compilación ejecutan elide javac --persistent_worker y elide kotlinc --persistent_worker: un único proceso en caliente por herramienta atiende todas las acciones de compilación, acepta solicitudes concurrentes y las compila de una en una. bazel shutdown los detiene.

Para compilar cada destino en un proceso nuevo (por ejemplo, con ejecución remota):

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

Workers desde sus propias reglas

Sin rules_elide, cualquier regla puede ejecutar Elide como worker. Bazel añade --persistent_worker por su cuenta; la regla pasa los argumentos en un archivo de parámetros:

# 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.

Para javac, pase ["javac", "--classpath-cache", args] para reutilizar los JAR del classpath ya analizados entre solicitudes. Una regla de kotlinc tiene la misma forma, sin --classpath-cache.

Conservar los destinos `kt_jvm_*`

register_elide_kotlin_toolchain de @rules_elide//elide/kotlin:toolchain.bzl sustituye el builder de una cadena de herramientas de rules_kotlin, de modo que los destinos kt_jvm_library, kt_jvm_binary y kt_jvm_test existentes compilan con Elide sin cambios en los archivos BUILD. Los destinos con procesadores de anotaciones vuelven al builder estándar de rules_kotlin. Configuración: adaptador KotlinBuilder.

OpenRewrite y consultas de dependencias

Para proyectos con un elide.pkl, consulte OpenRewrite e Índice de código de dependencias. Estos comandos no consumen el JavaInfo de Bazel ni su grafo de destinos, y las reglas anteriores no añaden destinos de reescritura ni de índice de código. Consulte el alcance de la configuración del proyecto antes de usarlos junto a Bazel.

Límites

Windows no es compatible.
elide.install solo acepta las versiones que lista el módulo; use elide.use para otras.
Los plugins del compilador de Kotlin procedentes de JAR externos (el atributo plugins de las reglas elide_kotlin_*) distintos de all-open, no-arg, sam-with-receiver, assignment y Lombok fallan con un error del compilador.