Fix four Java <= 21 syntax conversion gaps

[paulirwin]

Fixes four Java syntax constructs at or below Java 21 that either failed to convert or produced code with different runtime behavior than the Java source. Labeled break/continue is tracked separately.

Local records (Java 16)

Previously threw InvalidOperationException and aborted conversion of the entire file, since LocalRecordDeclarationStmt was missing from the statement visitor registry.

C# has no local record declaration — the compiler parses record R(int a); in a method body as a local function, which I confirmed against the compiler directly (error CS8112 / CS0246). The record is therefore hoisted to the enclosing type, reusing the queue that already lifts anonymous class bodies. This widens the record's scope, which is harmless unless the enclosing type already declares a member of the same name.

Method references

Emitted as invocations rather than method groups, so String::length became string.Length() — calling the method at the point of reference instead of passing it as a delegate.

-Function<string, int> f = string.Length();
+Function<string, int> f = string.Length;

Constructor references have no C# equivalent, so ArrayList<String>::new becomes () => new List<string>(), preserving generic arguments.

Static imports

import.isStatic() was never checked, so import static java.lang.Math.max became a plain namespace using with the declaring type stripped off, leaving the imported members unresolvable.

-using Java.Lang;
+using static Java.Lang.Math;

An on-demand static import (import static Foo.*) already ends in the type, so it is used as-is. Non-static imports are unchanged.

Instance initializer blocks

Emitted as a static constructor, which runs once per type rather than once per instance, and collided with any real static initializer (two static Foo() declarations).

They are now prepended to each constructor body, matching Java's semantics:

• Skipped for constructors chaining to this(...), since the initializer already ran in the constructor being chained to.
• A class declaring an initializer but no constructor gets one synthesized.
• Nested types save/restore the pending list so initializers cannot leak across type boundaries.
• Static initializers still become static constructors.

Testing

• 9 new unit tests in ConvertJava21GapTests.cs covering each fix, including the negative cases (non-static imports stay namespace usings; static initializers stay static constructors; chained constructors do not re-run the initializer).
• 4 new integration resources wired into IntegrationTests, all converting warning-free.
• Generated C# for the new resources was compile-checked with the real compiler, not just inspected.
• Full suite: 348 passing, 0 failing.

Notes

Two pre-existing issues were observed while testing and deliberately left out of scope: record accessor methods (rect.width()) convert to a call on a property, and methods inside a record are emitted with an invalid virtual modifier. Both affect member-level records equally and are unrelated to these fixes.

🤖 Generated with Claude Code