> This is the compatibility table of the Java engine that code-playpad ships (engine 0.39.0). > Paths such as `tests/…`, `SPEC.md` and `docs/…` refer to the engine's source (`java-engine/` in code-playpad's repository), which is not part of the package. # Compatibility — engine 0.39.0 (Stage A, compact source files, objects, numbers and control flow, collections, lambdas, practice mode, String, format, regex, Math, Random, System, Scanner and IO.readln, inheritance, interfaces, Object, instanceof, enums, records, exceptions, hash order, fixed collections, TreeMap, TreeSet, LinkedList, Stack, lambdas, method references, generic classes and methods, var, annotations, varargs, anonymous classes, streams, subList, local classes, raw types, float, byte and short, pattern matching, sealed classes, BigInteger, BigDecimal, EnumMap, EnumSet, fast I/O, static imports, initializer blocks, text blocks, enum constant bodies, Interface.super, ListIterator, reversed views, access-ordered LinkedHashMap, var lambda parameters, array clone, library subclasses, bridge methods, Vector, Hashtable, StringBuffer, StringJoiner, java.util.regex, outer.new, BitSet, parallel streams, java.time dates, AbstractList, LocalTime, LocalDateTime, Duration, Instant, time zones, packages) This document records what the engine accepts, what it rejects, and the evidence that it behaves like Java. Every method of every library class, with its status and the tests that call it, is in docs/feature-manifest.json (`npm run manifest`). The reference is Java SE 25 (SPEC.md §4), and what the engine implements is **a documented subset of Java 25**, not "Java 25". Every feature has one status: - **Supported:** parsing, type checking, execution, diagnostics, and tests are all implemented. - **Supported with limits:** the same, but the limits are listed here. - **Unsupported:** the engine reports "… not supported in this version" and never runs the code with a different meaning. > **Evidence:** everything below is checked against the pinned JDK, Temurin 25.0.4.1 (docs/reference-jdk.md). > - **Golden programs:** all 47 in `tests/programs` (the SPEC.md §4.1 Stage A corpus among them) match byte for byte: stdout, stderr, and exit code. > - **Recorded snippets:** all 1636 cases in `tests/jdk-cases` match. 1613 match byte for byte (once the JDK's own stack frames are removed, as *Known divergences* explains); the other 23 are listed under *Known divergences*, each with the narrower comparison the tests apply to it. > - **Practice corpus:** all 10 Stage 4 programs in `tests/corpus` (docs/practice-corpus.md) run and match. > - **Field corpus:** 337 of 339 programs written as learners and solvers write Java, kept whether or not the engine supports them, match the JDK exactly. None runs differently; 1 is rejected as unsupported (`Thread`), 1 stops on an engine limitation and none on the instruction limit (`corpus/REPORT.md`, docs/corpus-harness.md). ## Program structure | Feature | Status | Notes | | --- | --- | --- | | **Compact source files** (Java 25): top-level methods, fields and classes, with no class declaration | Supported | They form an implicitly declared class named after the file (`Main` for `Main.java`), which the program cannot refer to by name (`Main.f()` is `cannot find symbol`, as in javac). Classes declared in the file are its member classes: inner unless `static`, named `Main$Node` at run time and `Main.Node` in diagnostics, as javac does. | | **Several top-level classes** | Supported | Any number, in any order, each with its own fields, methods and constructors. `duplicate class: Node`. A public class need not match the file name (source-file mode allows it). | | **Member classes**: `static` nested and inner | Supported with limits | `static class Node` inside `Main`, or an inner class, whose instances hold their enclosing instance (`this$0`) and can use its fields and methods by simple name. `new Inner()` needs an enclosing instance (`non-static variable this cannot be referenced from a static context`). Names: `Main$Node` at run time, `Node` in diagnostics, `Main.Node` as a qualified type. Classes nest to any depth (`static class MyList { class Node { T val; } }`): an inner class reaches each enclosing instance through javac's `this$N` fields, so NPE messages name them as the JDK does. An inner class of a generic class, seen from outside it, keeps its outer class's type variables. `Outer.this` names an enclosing instance. `outer.new Inner()` (JLS 15.9.2) gives the enclosing instance explicitly, with javac's `NullPointerException` for a null one and `qualified new of static class`; with an anonymous class body, or of a generic class or a generic class's inner class, it is unsupported. | | **Launch protocol** (Java 25) | Supported | The first top-level class runs if it has a `main`, otherwise the class named after the file (`can't find class: Main` if there is none). `main(String[])` is preferred over `main()`. Either may be `static` or an instance method, and need not be `public` (but not `private`). An instance `main` runs on an instance made with the no-argument constructor, which may be private (`can't find no argument constructor in class: A`). `String... args` and `String args[]` are accepted; `args` is empty. | | Methods: parameters, `return`, recursion, overloading; `static` and instance | Supported | Overload resolution follows JLS 15.12.2: the strict phase, then the boxing phase, then the most specific method, with javac's "cannot be applied", "no suitable method", and "ambiguous" reports. An ambiguous call names the two methods javac names (its most-specific fold over each class's methods, last declared first: `sb.append(null)` names `append(CharSequence)` and `append(char[])`). An argument that is a generic call whose result only an implicit lambda or an inexact method reference decides (`collect(groupingBy(f, TreeMap::new, counting()))`, `collect(collectingAndThen(toList(), l -> …))`) does not count for applicability (JLS 15.12.2.2) for any overloaded method or constructor, the program's own included: it fits every parameter its type variable's bound allows, so `show(String)` beats `show(Object)` and `show(String)`/`show(Integer)` is ambiguous, then fails with javac's `inference variable R has incompatible bounds` and its `where` clause. Calls are `f(x)`, `this.f(x)`, `obj.f(x)`, `Node.f(x)`, or an enclosing class's `f(x)`. Using an instance member from a static context gives javac's `non-static … cannot be referenced from a static context`. | | **Constructors** | Supported with limits | Overloaded, with javac's resolution errors (`constructor Point in class Point cannot be applied to given types;`, `no suitable constructor found for Point(String)`, `reference to Pair is ambiguous`). A class without one gets the default constructor. `this(...)` as the first statement, with `recursive constructor invocation` detected. Statements before `this(...)` (Java 25's flexible constructor bodies) and `super(...)` are unsupported. | | `new C(args)` | Supported | Objects have identity: `==`, `!=`, `null`, and `Object.equals(Object)` by reference. | | Fields: `static` and instance, `final`, initializers, `this.x`, `obj.x`, `Node.x` | Supported | Defaults are 0, false, null. Instance initializers run at the start of each constructor that does not call `this(...)`, in source order. `final` fields with constant initializers are constants. `illegal forward reference` and `self-reference in initializer` follow JLS 8.3.3. Blank `final` fields must be assigned exactly once by every constructor: `variable y might not have been initialized`, `might already have been assigned`, `might be assigned in loop`, `not initialized in the default constructor`. | | **Class initialization** (JLS 12.4) | Supported | Each class initializes on its first active use (`new`, a static method call, a non-constant static field), not at startup; reading a constant does not initialize it. An exception in a static initializer becomes `ExceptionInInitializerError` where the class was first used, with `Caused by:`. | | Access | Supported | `private` members are visible within their top-level class, nested classes included: `secret has private access in Box`, `hide() has private access in Box`, `Box() has private access in Box`. `public`, `protected` and package access are equivalent here (one package). | | `toString()`, `equals(Object)`, `hashCode()` | Supported | Declared or inherited, they are used wherever the JDK uses them: string conversion and `println`, `HashMap` and `HashSet` keys, `List.contains`. Without them, `Object`'s: `Node@hash` and identity. `super.toString()` is `Object`'s own. `@Override` is checked with javac's reasons. | | **Inheritance** (`extends`, JLS 8.1.4) | Supported with limits | A class extends one class of the program: inherited fields and methods, overriding with dispatch on the object's class, `super(...)` (or the implicit `super()`), `super.f()` and `super.x`, covariant return types, field hiding, static methods inherited and hidden. Superclass constructors and field initializers run first, so a superclass constructor calling an overridden method sees the subclass's fields at their defaults, as on the JDK. `abstract` classes and methods, `final` classes and methods, `protected`. javac's errors: `B is not abstract and does not override abstract method f() in A`, `A is abstract; cannot be instantiated`, `cannot inherit from final A`, `f() in B cannot override f() in A` (with `overridden method is final`, `attempting to assign weaker access privileges; was public`, `return type long is not compatible with int`, `overriding method is static`), `cyclic inheritance involving A`, `abstract method f() in A cannot be accessed directly`, `x has private access in A` for a superclass's private member. NPE messages name the receiver's static type (`Cannot invoke "Main$B.f()"`), as the JDK does. A class may also extend the JDK's exception classes (*Exceptions* below) and its collections (*Library subclasses* below). javac's bridge methods (JLS 15.12.4.5) are reproduced: where an override's erasure differs from what it overrides (`compareTo(Box)` for `Comparable`, `Integer apply(Integer)` for `Function`, a covariant return type), a call through the supertype goes through a bridge, so a stack trace shows its frame at the class's line, and a raw call with a wrong argument is the bridge's `ClassCastException`. Extending other library classes, extending an inner (non-static) class, and statements before `super(...)` (Java 25's flexible constructor bodies) are unsupported. | | **Interfaces** (JLS 9) | Supported with limits | Interfaces of the program, nested or top-level: abstract methods, `default` methods, `static` methods, `private` methods, constants; `extends` among interfaces; a class implementing several. Implementing methods must be `public` (`g() in C cannot implement g() in I`), and two unrelated defaults conflict (`types I and J are incompatible;`). A class may also implement the library's `Comparable`, `Comparator`, `Iterable` and `Iterator`: then sorting, `PriorityQueue`, `Collections.sort`, for-each and `Objects.compare` call its methods as Java code. Their other methods are its too, declared or not: `cmp.reversed()` of an abstract class implementing `Comparator`, `op.applyAsInt(2, 3)` of an enum whose constant bodies implement `IntBinaryOperator`. `Interface.super.f()` calls a direct superinterface's default method (JLS 15.12.3), also from an interface extending it and inside a lambda, with javac's errors: `not an enclosing class: I` (not a direct superinterface, or a static context), `bad type qualifier I in default super call` (`redundant interface I is extended by J`), `abstract method m() in I cannot be accessed directly`, `illegal static interface method call`. `Main.super.f()` in Main is `super.f()`; `Outer.super.f()` for an enclosing class and implementing other library interfaces are unsupported. | | The `Object` type | Supported | Variables, parameters, fields, arrays (`Object[]`), returns. Any value converts to `Object` (primitives box). Its methods on any value: `toString()`, `equals(Object)`, `hashCode()` (each dispatched on the value's class: a String compares by content, an `Integer` by value) and `getClass()`. `new Object()` makes an object with nothing but identity (`java.lang.Object@…`, equal only to itself). `wait` and `notify` are unsupported, and so is `clone` except on arrays (below). | | Casts and `instanceof` (JLS 15.16, 15.20.2) | Supported | Casts between classes, interfaces, library types and arrays, checked as javac checks them (`incompatible types: A cannot be converted to B` for impossible ones) and when they run: `ClassCastException: class Main$A cannot be cast to class Main$B (…)`, as the JDK words it. `(int) object` checks for an `Integer`, then unboxes. `x instanceof T`, raw types included (`x instanceof List`), and the type pattern `x instanceof T t`, whose variable is in scope where the test is true: in `&&`, the `if` or `while` body, after `if (!(x instanceof T t)) return;` (JLS 6.3.1). A store into an array seen through a supertype is checked: `ArrayStoreException: java.lang.String`. A cast the run cannot fully check (`(T) o`, `(T[]) new Object[n]`, `(List) o`) checks the erasure and gives javac's `[unchecked] unchecked cast` warning (with `required:`, `found:` and a `where` clause); a cast between different parameterizations (`(List) intList`) is javac's `incompatible types`. Record patterns: `o instanceof Line(Point(int a, int b), var to)`, their variables in scope as a type pattern's are. `instanceof` with a parameterized type (`x instanceof List`) is unsupported. | | **Enums** (JLS 8.9) | Supported with limits | Nested or top-level, with fields, constructors (with the hidden name and ordinal, so NPE messages say ``), methods, static members, and `implements`. `values()` (a new array each time), `valueOf(String)` (`IllegalArgumentException: No enum constant Main.Color.PURPLE`, `NullPointerException: Name is null`, with the enum's own frame), `name()`, `ordinal()`, `compareTo` (by ordinal), `toString()` (overridable), `getDeclaringClass()`, `equals` and `hashCode` (identity). The constants are made when the enum initializes, before its other static fields; an exception there is `ExceptionInInitializerError`. `switch` on an enum, with simple or qualified labels (`case RED`, `case Color.RED`); a switch expression naming every constant needs no `default`; a null selector fails as the JDK's does (`Cannot invoke "Main$Color.ordinal()"`). Enums are Comparable, so they sort and queue in declaration order. javac's errors: `enum classes may not be instantiated`, `modifier public not allowed here`, `name() in E cannot override name() in Enum`. `EnumMap` and `EnumSet` are supported (see *Library*). Constants with a class body (`PLUS { int apply(int a, int b) { return a + b; } }`): each is an anonymous subclass of the enum (`Main$Op$1`, numbered with the anonymous classes of the constants' arguments, before the members'), with its own fields, methods, `super` calls and initializer blocks; `getClass()` is the body's class and `getDeclaringClass()` the enum, also in EnumMap and EnumSet. An enum may leave abstract methods to its constants' bodies. javac's errors: ` is not abstract and does not override abstract method apply(int,int) in Op`, `Op is abstract; cannot be instantiated` (a constant without a body), `non-static variable symbol cannot be referenced from a static context` (the enum's private members are not inherited by a body), `equals(Object) in cannot override equals(Object) in Enum`. | | **Records** (JLS 8.10) | Supported with limits | Nested or top-level, with components, accessors (generated, or declared: `invalid accessor method in record R`), the canonical constructor (generated, compact `R { ... }` with the fields assigned after its body, or explicit), other constructors (which must call another: `constructor is not canonical, so it must invoke another constructor of class R`), static fields and methods, instance methods, and `implements`. `toString()` (`Point[x=1, y=2]`, components as String.valueOf shows them, with the record's own frame when one fails), `equals` (doubles compared as `Double.compare` does) and `hashCode` (`31 * h + hash(component)`) as the JDK computes them, unless declared. javac's errors: `field declaration must be static`, `cannot assign a value to final variable v`. Generic records (`record Pair(A first, B second)`) are supported; so are local records and record patterns (see *Pattern matching*). | | `getClass()`, `X.class` | Supported with limits | A `Class` value per class: `getName()` (`Main$Node`, `[I`), `getSimpleName()` (`Node`, `int[]`), `isInterface()`, `isArray()`, printing as `class Main$Node`, and `==` between classes, as `equals` methods use it. `X.class` is a `Class` (so `new EnumMap<>(Day.class)` infers its key type); `Class` may be declared. The reflection methods are unsupported. | | Running a file, and programs in several files (JEP 458) | Supported with limits | Behaves like `java ` in source-file mode. The program's other `.java` files (`Session.java` beside `Main.java`) are compiled as the JDK's launcher compiles them: a file when the program first names the class it is named after, so a file nothing names is never compiled, and its errors never reported. Each file has its own imports. A class of the entry file wins over another file's of the same name. Errors and stack traces name each file (`Session.java:2: error: …`, `at Session.describe(Session.java:5)`); where the JDK prints another file's absolute path on disk, the engine prints its name. A file's warnings print again when the program first uses one of its classes, as the launcher's second compilation prints them (a class literal, `Helper.class`, is not counted as a use). Limits: 32 files, 500,000 characters per file and 1,000,000 together. A requested entry that is not among the files fails as `java Missing.java` does (`Error: Could not find or load main class Missing.java`); another file never runs in its place. Folders are packages (see the next row); a name with `\\` is reported as not supported. A file first needed by the launch file's declarations (an import, a field's or parameter's type) rather than its code is compiled, as by the launcher, only when the program first loads one of its classes: its code's errors print then, after the output so far, with exit status 2, and a class never loaded is never compiled (ADR 0033). Unsupported: another compact source file with a `main`, and using another file's secondary class (one not named after its file) from outside that file, which the JDK finds only if that file happened to be compiled first. | | Packages: `package` declarations, files in folders (ADR 0033) | Supported with limits | `util/Tool.java` declares `package util;` and holds class `util.Tool`, found as the launcher finds it: under the root that the entry's package gives (`app/Main.java` in package `app`: the root is the folder above `app`; `src/Main.java` in no package: `src/`). Single-type, on-demand and static imports of the program's classes and member classes, fully qualified names (`util.MathUtil.square(3)`, `new app.model.Item()`), and JLS 6.4.1's order: the file's classes, single-type imports (the library's too), the package's classes, then on-demand imports, two of which giving a name are javac's `reference to Stack is ambiguous`. Access across packages (JLS 6.6): `Hidden is not public in util; cannot be accessed from outside package`, the same for package-private members and member classes, `describe() has protected access in Shape` (protected members from subclasses, instance ones through the subclass; protected constructors through `super(...)` and anonymous classes), and an inaccessible overload is listed as not applicable. A named package does not see the unnamed one. Binary names everywhere: `getClass().getName()` is `util.Counter`, `getPackageName()` is `util`, stack traces are `at util.MathUtil.boom(MathUtil.java:6)`, uncaught exceptions `errors.AppException: …`. javac's errors for an entry whose folders do not match its package (`end of path to source file does not match its package name app: Main.java`), a package in a compact file, a missing package or class (`package nope does not exist`; `cannot find symbol` with `location: package util`), two imports of one simple name, and an import of the file's own class. Not supported: a file whose package is not its folder's (`util/Tool.java` declaring another package or none; javac reports `bad source file`), and on-demand imports of a class's member types (`import util.Outer.*;`). | | No class / no usable main | Supported | `error: no class declared in source file`; `error: can't find main(String[]) or main() method in class: Main`; `error: can't find class: Main`; for a compact file, `compact source file does not have main method in the form of void main() or void main(String[] args)` | | `import`: single-type and on-demand | Supported with limits | `import java.util.List;` and `import java.util.*;` for the supported java.util classes (see *Library*); the java.lang ones need no import. A compact source file sees java.util without imports, as Java 25's implicit `import module java.base` gives it. A wrong name gets javac's error: `package java.utill does not exist`, or `cannot find symbol` with `location: package java.util`. Real JDK classes outside the subset (`Clock`, `UUID`, …) are unsupported where they are used. Fully qualified names work without an import, in types and in expressions, for every package the subset has: `java.util.stream.IntStream.range(0, 3)`, `java.util.Map.Entry.comparingByKey()`; `java.time.Clock.systemUTC()` is unsupported, not `cannot find symbol`. Classes of java.io, java.math, java.util.function and java.util.stream that the subset has are imported the same way. | | `import static`: single and on-demand (JLS 7.5.3, 7.5.4) | Supported | Methods and fields of the supported classes: `import static java.lang.Math.*;`, `import static java.lang.System.out;`, `import static java.util.stream.Collectors.*;`, `import static java.util.Map.entry;`, and member types (`import static java.util.Map.Entry;`). A simple name means the program's own local, field or method first, then a single import, then an on-demand one (JLS 6.4.1). A method of the class or an enclosing one, Object's included, hides every import of that name, so `toString(a)` with `Arrays.*` imported is javac's `method toString in class Object cannot be applied`. Overloads from several on-demand imports are resolved together (`sort(int[])` from Arrays, `sort(List)` from Collections). javac's errors: `reference to MAX_VALUE is ambiguous` (fields, and methods equally specific in two classes), `cannot find symbol` with `symbol: static foo`, a missing class or package, `static import only from classes and interfaces`. Imported constants are constants (switch labels). Importing from a JDK class outside the subset (`TimeUnit`) is fine until a name from it is used, which is unsupported. | | Variable-arity methods and constructors (`int... xs`, JLS 8.4.1) | Supported | Chosen in the third phase of overload resolution, as javac chooses (`f(int)` over `f(int...)`, `g(Integer)` over `g(int...)`); the trailing arguments go into a new array, or an array is passed as it is. javac's `varargs parameter must be the last parameter`, `varargs mismatch; …`, and its `[unchecked]` warnings for a parameter type the run cannot check: `Possible heap pollution from parameterized vararg type T` at the declaration and `unchecked generic array creation for varargs parameter of type List[]` at the call, unless the method is `@SafeVarargs`. | | **Anonymous classes** (JLS 15.9.5) | Supported with limits | `new Comparator() { public int compare(...) { ... } }`, `new Shape("sq") { double area() { ... } }`, `new Iterator<>() { ... }`: extending a class of the program (its constructor's arguments passed on) or a built-in exception, or implementing an interface of the program or the library's `Comparable`, `Comparator`, `Iterable`, `Iterator` and functional interfaces (`Runnable`, `Function`, …), with fields, methods, `@Override`, and the diamond inferred from where the object goes. Named as javac names them (`Main$1`, `Main$Holder$1`, `Main$2$1`, in source order per enclosing class), so stack traces, `getClass().getName()` and `` in diagnostics match; `getSimpleName()` is empty. They capture effectively final locals of the code around them into javac's `val$x` fields (NPE messages say `"this.val$s"`) and use the enclosing instance's members. javac's errors: ` is not abstract and does not override abstract method …`, `anonymous class implements interface; cannot have arguments`, `cannot inherit from final F`, `local variables referenced from an inner class must be final or effectively final`. Extending an inner class or a library class is unsupported. | | **Local classes, interfaces, enums and records** (JLS 14.3) | Supported | `class Point { ... }` (or `record Pair(...)`, `enum Dir { ... }`, `interface Shape { ... }`) declared in a block, visible from its declaration to the end of the block. Named as javac names them, `Main$1Point`, numbered per simple name in source order (`Main$1Helper`, `Main$2Helper`), alongside anonymous classes (`Main$1`). A local class in instance code is inner; it captures the locals it uses as `val$x` fields, so NPE messages name `this.val$s`. javac's errors: `cannot find symbol` outside the block, `class A is already defined in method main(String[])`, `local variables referenced from an inner class must be final or effectively final`, `illegal start of expression` for `static class` in a block. | | Initializer blocks (JLS 8.6, 8.7) | Supported | `static { ... }` runs once when the class initializes, with the static field initializers in source order (after an enum's constants); `{ ... }` runs in every constructor that does not call `this(...)`, after the superclass constructor, with the instance field initializers in source order. In classes, enums, records (static only), nested, local and anonymous classes (`new Base("x") {{ add(1); }}`). They may declare locals, loop, catch and use lambdas (`lambda$static$0`, `lambda$new$0`), and assign blank `final` fields, with javac's definite-assignment errors across blocks and constructors. An exception in a static block is `ExceptionInInitializerError`, then `NoClassDefFoundError: Could not initialize class`, as on the JDK. javac's errors: `return outside method`, `initializer must be able to complete normally`, `illegal forward reference`, `unreported exception` (an instance block may throw what every constructor declares), `initializers not allowed in interfaces`, `instance initializers not allowed in records`. | | **Generic classes, interfaces, records and methods** (JLS 8.1.2, 8.4.4) | Supported with limits | `class Node`, `class BST, V> implements Iterable`, `interface Fn`, `static > void sort(T[] a)`, ` Pair withValue(R r)`. Members are seen through the type arguments (`T val` of a `Node` is an `Integer`; a type variable's members are its bound's), supertypes are parameterized (`class Strs extends Base`, with the bridge methods javac generates so overriding dispatches), the diamond and generic methods are inferred from the arguments, the target, implicit lambdas' bodies and the parameter a diamond is passed to, and explicit type arguments (`Main.repeat(7, 2)`) work. Bounds are checked: `type argument String is not within bounds of type-variable T`, `inference variable T has incompatible bounds` (with javac's `upper bounds`, `lower bounds` and `equality constraints` lines), `cannot infer type arguments for Box<>`. javac's other errors: `non-static type variable T cannot be referenced from a static context`, `generic array creation`, `unexpected type` for `new T()`, `wrong number of type arguments`, `name clash: … have the same erasure`, `cannot use '<>' with non-generic class`. Every diagnostic that names a type variable ends with javac's `where T is a type-variable:` clause. As javac does, a generic member's value is checked against the type it has where it is used, so `Integer[] a = box.items` fails with the JDK's `ClassCastException` when the array is really an `Object[]`. Raw types of the program's generic classes are supported as the library's are (see *Generic types at use sites*). Generic constructors are unsupported. | | Annotations (JLS 9.7) | Supported with limits | `@Override`, `@SuppressWarnings` (a string or an array of them; `"unchecked"` and `"deprecation"` silence those warnings on the class, method, field or local declaration, and `"all"` silences nothing, as in the source launcher), `@FunctionalInterface` (javac's `Unexpected @FunctionalInterface annotation` with its reason), `@SafeVarargs` (javac's `Invalid SafeVarargs annotation` errors) and `@Deprecated` (`since`, `forRemoval`; on a local variable, javac's `[deprecation] … has no effect on this variable declaration` warning), on classes, methods, constructors, fields, parameters and locals. javac's errors: `cannot find symbol` for an unknown annotation, `annotation interface not applicable to this kind of declaration`, `… is not a repeatable annotation interface`, `annotation @SuppressWarnings is missing a default value for the element 'value'`, `incompatible types` for a non-String value. Other annotations (the JDK's, or declared with `@interface`), annotations on types and type arguments, and values other than literals are unsupported. | | Warnings | Supported | javac's `[unchecked]` and `[deprecation]` warnings, as the source launcher prints them: before the program's output on a run, among the errors in source order when compilation fails, and counted (`1 warning`, `2 warnings`) after the errors. | | Declaring annotation interfaces | Unsupported | | ## Types and values | Feature | Status | Notes | | --- | --- | --- | | `int` | Supported | 32-bit two's complement: overflow wraps, `/` truncates, `%` takes the dividend's sign, `MIN_VALUE / -1` wraps. `/ by zero` throws. Shift distances are masked. | | `char` | Supported | A UTF-16 code unit (0–65535). Arithmetic promotes to `int` (`'a' + 1` is `98`). `char c = 65` is allowed because the constant fits. `c = c + 1` is an error ("possible lossy conversion"), while `c += 1` and `c++` wrap. | | `long` | Supported | 64-bit two's complement, like `int`: wrapping, truncating `/`, `/ by zero`, `MIN_VALUE / -1`, shifts masked to 6 bits, `>>>`. Literals with `L`, in any radix, with underscores (`integer number too large`). Long values stay exact past 2^53 (engine numbers become BigInts there, an implementation detail). | | `double` | Supported | IEEE 754 binary64, as Java: `NaN`, infinities, `-0.0`, `%` as fmod, division by zero giving `Infinity`. Literals in decimal and hexadecimal (`0x1.8p1`), with `d`/`D`, `floating-point number too large` / `too small`. Printed exactly as `Double.toString` (`0.30000000000000004`, `1.0E7`, `9.999E-4`, `4.9E-324`). | | Numeric promotion and conversions (JLS 5.1–5.6) | Supported | Widening in assignment, invocation, and operators (`int` + `long` is `long`, anything with `double` is `double`); casts in every direction with Java's rules (`(int) 1e300` saturates, `(int) NaN` is 0, `(char) 65601L` keeps the low bits); compound assignment's implicit cast (`long l = 5; l += 2.7;` is `7`); `possible lossy conversion from long to int`. Constant expressions fold with the same arithmetic. | | `boolean` | Supported | | | `String` | Supported with limits | Literals and text blocks (`"""`, JLS 3.10.6: the incidental indentation and trailing spaces are stripped, line ends become `\n`, and escapes, `\s` and the line-joining `\` included, are interpreted last; javac's `illegal text block open delimiter sequence, missing line terminator`, `unclosed text block`, `illegal escape character`), `null`, concatenation with any supported type, and `==` by reference (constants are interned). Methods: see the Library section; `new String(...)` makes a new object, so `new String("a") == "a"` is `false`. Contents are arbitrary Unicode (UTF-16). | | Wrapper classes: `Integer`, `Long`, `Double`, `Character`, `Boolean` | Supported with limits | Boxing and unboxing (JLS 5.1.7–5.1.8) in assignment, invocation, operators, `?:`, compound assignment and `++`/`--`. `==` compares references, and the JDK's caches are reproduced (`Integer` and `Long` -128 to 127, `Character` 0 to 127, both `Boolean`s): `Integer a = 127, b = 127;` gives `a == b` true, and 128 gives false. Unboxing null is the JDK's NPE, `Cannot invoke "java.lang.Integer.intValue()" because …`. The deprecated constructors (`new Integer(5)`, `new Double("3.5")`, and those of `Long`, `Float`, `Short`, `Byte`, `Character`, `Boolean`) make a new object every time, never a cached one, with javac's `[deprecation] Integer(int) in Integer has been deprecated` warnings. A switch on a wrapper is unsupported. | | Generic types at use sites: `List`, `Map>`, `new ArrayList<>()` | Supported with limits | Type arguments are checked as javac checks them: invariance (`ArrayList cannot be converted to List`), `unexpected type` with `required: reference` for `List`, and `wrong number of type arguments`. The diamond is inferred from the target type, the constructor's arguments, or the parameter it is passed to. Types print as javac prints them (`Map`). Wildcards (`List`, `List`, `Comparator`) are supported: a value read through one has its bound's type, and a parameter of `? super T` takes a `T`. Generic array creation is javac's error, except of raw types (`new ArrayList[n]`, `new List[n]`) and unbounded wildcards (`new List[n]`); a raw array assigned, returned or initialized as `List[]` is javac's `[unchecked] unchecked conversion` warning. Raw types (`List raw = new ArrayList();`, `Map m`, `Box b = new Box("s")`, `(List) o`, `o instanceof List`) are supported: their members are erased (`raw.get(0)` is an `Object`), and javac's warnings are reported: `[unchecked] unchecked call to add(E) as a member of the raw type List`, `unchecked conversion` (raw to parameterized), `unchecked method invocation`, `unchecked assignment to variable v as member of raw type Box`, each with its `where` clause, and silenced by `@SuppressWarnings("unchecked")`. An argument that converts only unchecked makes the call `unchecked method invocation` and its type erased (`new ArrayList<>(raw)` is a raw `ArrayList`). As on the JDK, heap pollution through a raw type fails where the value is used (`int v = ints.get(0)` of a `String` is a `ClassCastException`). Generic calls are target-typed as javac types them: arguments bound a type variable from below (`List.of(1, 2.5)` is a `List`, `List.of(new Sq(1), new Circle(2))` a `List` when both implement `Shape`), and an assignment, return or parameter that names the type argument decides it (`List s = List.of(new Sq(1))`, `take(List.of(new Sq(1)))`), with javac's `inference variable E has incompatible bounds` when an argument does not fit. The engine has no intersection types: where javac infers one (`List.of(1, "a")` with no target), it keeps a common class or interface, or Object. | | The program's classes as types | Supported | `Node n = new Node(1);`, parameters, return types, fields. `incompatible types: Bag cannot be converted to Box`, `incomparable types: Box and Bag`. | | Arrays of any supported type, any number of dimensions | Supported | `new T[n]`, `new int[3][4]`, `new int[3][]` (jagged), `new T[]{…}`, nested `{{…}, {…}}` initializers, `a[i][j]`, and `.length`. Arrays are default-initialized, bounds-checked, and compared by reference. `int a[]` and `int[] a[]` declarations are accepted. They print with JVM descriptors: `[[I@hash`, `[J@hash`, `[LNode;@hash`. `a.clone()` is a shallow copy of the same type (`int[][]`'s rows are shared), as on the JDK. | | Casts between `int` and `char`, and identity casts | Supported | `(char) 65601` keeps the low 16 bits. A cast from boolean to int is an error, as in Java. | | `var` (JLS 14.4.1) | Supported | For locals, `for` and enhanced-`for` variables and resources: the type of the initializer (a diamond nothing decides is `Object`'s, `new ArrayList<>()` an `ArrayList