janino-3.1.20

[stefan-zobel]

JANINO-3.1.20

Fourteen fixes in the compiler, from the 3.1.x maintenance line (see "Release lines" in Compatibility), and JAR files
without the dummy signature. Upgrade if your code declares two local classes with the same name in one class, or
uses super.m() for a private or static method of the superclass: such code compiled, but used the wrong
class or failed at run time.

<dependency>
    <groupId>io.github.janino-lts</groupId>
    <artifactId>janino</artifactId>
    <version>3.1.20</version>
</dependency>

Fixed

Code that compiled, but did not run as written:

• #143: Two local classes with the same name in one class, or a
  local class and a member class with the same name, got the same binary name, and only one class file was kept:
  the code used the wrong class, or failed with a NoSuchMethodError. Now such a local class gets a number, like
  with javac (P$2L, or P$1L next to a member class L); the names of all other local classes are unchanged.
• #136: super.m() for a private method of the superclass
  P, in a subclass of P declared in P, failed at run time with a NoSuchMethodError.
• #150: super.s() for a static method of the superclass
  failed at run time with an IncompatibleClassChangeError; Outer.super.s() was an internal compiler error.
• #160: super.a(o, v) for a variable arity method that the
  superclass implements from an interface compiled into a class that the JVM rejected (VerifyError on Java 25,
  IncompatibleClassChangeError on older JVMs).

Code that was rejected or crashed the compiler, and now compiles like with javac:

• #127: An array of a primitive type as the only variable arity
  argument of a parameter Object..., e.g. f(1, new int[] { 1, 2 }) with f(Integer i, Object... a).
• #134: Some invocations of overloaded methods or constructors
  with a null argument (internal compiler error).
• #147: Invocations of overloaded variable arity methods whose
  parameter types are the leading parameter types of another (internal compiler error; now reported as ambiguous).
• #156 and #169:
  Invocations of variable arity methods, one of which is more specific, e.g. g(1, 2, 3) with g(int...) and
  g(double...), were rejected as ambiguous.
• #157: super.f("a", "b") for a variable arity method
  f(String...) was rejected, super.f() was an internal compiler error.
• #138: An array type of a parameterized type, e.g.
  List<Object>[], as the type of some local variables, of a cast or a type argument.
• #133: A static method imported twice (internal compiler error
  when it was invoked).
• #153: if (b) {} with a condition of type Boolean.
• #154: A public or protected member of a class that is not
  accessible, inherited through an accessible subclass, e.g. p.B.m() with public class B extends A and a
  package-private class A.

Unsigned JAR files

The JAR files are no longer signed with the dummy certificate that Janino has used since 2.5.7
(META-INF/DUMMY.SF, META-INF/DUMMY.DSA). Its key is public, so the signature proved nothing. Fat JARs no longer
need to exclude these files. The classes, the OSGi headers and the automatic module names are unchanged; the
artifacts on Maven Central are signed with PGP as before, and the GitHub release has SHA256SUMS.

Performance

Measured interleaved on JDK 25 (janino-benchmarks, with and without JIT, each with an A/A control):

• Against 3.1.19, the compile time is unchanged within the measurement error on all workloads, including the code
  that Apache Spark generates for TPC-DS queries, and so is the memory that a compilation allocates (without JIT,
  where it is deterministic: +0.0 to +0.1 %). The generated class files are byte-identical for all workloads.
• Against 3.1.12, the last release of the original project: Janino's own sources compile 14 % faster without JIT
  and with 14 to 16 % less memory; the code that Spark generates compiles equally fast with JIT, and without JIT
  1.2 % faster and with 4.5 % less memory. Code with many nested try / finally statements needs 20 to 26 % more
  time and 16 to 17 % more memory, because the code that Janino generates for it since 3.1.14 is correct, but
  larger.

See the benchmark README for the method.

Compatibility notes

• No code that compiled with 3.1.19 is rejected now.
• The class files change only for the invocations of "super.m()" for a private method of the enclosing superclass fails with NoSuchMethodError #136, "super.m()" for a static method fails at run time with IncompatibleClassChangeError #150 and "super.m(...)" of a variable arity method that the superclass implements from an interface fails with a VerifyError #160, which failed at run time, and for local
  classes whose binary names collided (Two local classes with the same name in one class get the same binary name #143). For all workloads of the benchmarks, including Janino's own sources
  and the code that Apache Spark generates for TPC-DS queries, the class files are the same as with 3.1.19, byte for
  byte (see "Performance" above).
• The test suites of Apache Calcite (all modules), Spark Catalyst (349 suites) and Apache Fory (all Java modules),
  and about 4800 tests of the execution engine of Apache Drill, pass with this release as with the Janino that the
  projects declare.
• Java 8 or later is required. Janino is built with JDK 25 and tested on Java 8, 17, 21 and 25.

Assets

The artifacts on Maven Central are signed with the PGP key D7FA DB51 D921 93FC A6BA 204D C0D2 FF51 226A 8B8B. This
release additionally contains the same files as the previous releases: janino, commons-compiler, commons-compiler-jdk
(each with sources and Javadoc), commons-compiler-tests, and the POMs, including janino-parent.

Verify the downloads with:

sha256sum -c SHA256SUMS

---

This discussion was created from the release janino-3.1.20.