Java-Compiler

Elide enthält javac für Java 25; ein separates JDK ist nicht nötig.

Quelldateien kompilieren

elide javac -- -d out src/Hello.java
elide java -- -cp out Hello

~/demo  elide javac -- -d out Greeter.java

✅ 1 Java sources compiled to `out` (81ms)

~/demo  elide java -- -cp out Greeter

Hello, Ada!

Hello, Linus!

0:12 / 0:12

javac-Optionen folgen nach --. Ohne -d werden die Klassendateien neben ihre Quelldateien geschrieben. elide javac -- -help listet alle javac-Optionen auf.

Elide-Optionen

Elide-Optionen stehen vor --:

Option	Zweck
`--jar PATH`	Die Ausgabe in ein JAR unter `PATH` packen.
`--manifest FILE`	Manifest für die `--jar`-Ausgabe.
`--max-errors N`	Angezeigte Fehler, bevor die übrigen nur gezählt werden; `0` zeigt alle. Warnungen werden dedupliziert und nie begrenzt.
`--report-used-deps PATH`	Die Classpath-Einträge schreiben, auf die die Ausgabe verweist (Bazel Strict Deps).
`--capabilities`	Compiler-Fähigkeiten als JSON ausgeben.
`--persistent_worker`	Als persistenter Bazel-Worker laufen, Singleplex oder Multiplex.
`--classpath-cache`	Nur im Worker: Classpath-Zustand über Kompilierungen hinweg wiederverwenden. `ELIDE_WORKER_CLASSPATH_CACHE=0` schaltet es ab.

elide javac --jar target/app.jar -- src/Main.java src/Util.java
elide javac --jar target/app.jar --manifest src/MANIFEST.MF -- src/Main.java

Projekte bauen

elide build kompiliert src/main/java und src/test/java oder die Source-Sets, die elide.pkl deklariert. Um nur main zu kompilieren:

elide build compile-java-main

jvm {
  target = 25
  java {
    release = 25
    compiler {
      mode = "embedded"
      flags { "-Xlint:all" }
    }
  }
  features {
    graalvm = false
  }
}

Eigenschaft	Bedeutung	Standard
`jvm.target`	Bytecode-Ziel; die `--release`-Stufe, wenn `java.release` nicht gesetzt ist.	`"auto"` (21)
`jvm.java.release`	`--release`-Stufe: nur gegen die API dieses JDK kompilieren.	`"auto"`
`jvm.java.source`	`--source`/`--target` statt `--release` verwenden; wird ignoriert, wenn `release` gesetzt ist.	`"auto"`
`jvm.java.compiler.mode`	`"embedded"` verwendet das `javac` von Elide; `"external"` startet das aus `jvm.javaHome`.	`"embedded"`
`jvm.java.compiler.flags`	Zusätzliche `javac`-Flags; `--release`, `-source` oder `-target` ersetzen hier die von Elide.	keine
`jvm.java.sourceSets["<set>"].release`	`--release`-Stufe nur für dieses Source-Set.	`"auto"` (die des Projekts)
`jvm.java.sourceSets["<set>"].flags`	`javac`-Flags für dieses Source-Set, nach `compiler.flags`.	keine
`jvm.javaHome`	Java-Home für externe Kompilierungen und abgezweigte JVMs.	das von Elide
`jvm.debug`	Mit `-g` kompilieren.	`true`
`jvm.features.graalvm`	`org.graalvm.nativeimage`, `word` und `collections` auf den Compile-Classpath legen.	`false`
`jvm.features.automodules`	JARs ohne Moduldeskriptor als automatische Module auf den Modulpfad legen.	`true`

Ein Source-Set, das andere Einstellungen braucht, etwa eines, das nur gegen java.base kompiliert wird, nennt sie unter sourceSets. Wird ein Source-Set genannt, das das Projekt nicht hat, schlägt der Build fehl.

sources {
  ["desktopless"] { paths { "src/desktopless/java" } }
}
jvm {
  java {
    sourceSets {
      ["desktopless"] {
        flags { "--limit-modules"; "java.base" }
      }
    }
  }
}

Jede Kompilierung schreibt ihre Argumente in javac.args neben ihrer Ausgabe. Annotationsprozessoren: Maven-Abhängigkeiten.

Persistente Bazel-Worker

elide javac --persistent_worker und elide kotlinc --persistent_worker halten einen Compiler über Bazel-Aktionen hinweg aktiv. Regeln, Einrichtung und ein vollständiges Beispiel: Bazel.

Beispiele

Java-Records und -Streams

Beginnen Sie mit einer Vorlage:

elide init --template java        # Java app with a JUnit test