Support Java 16 record classes (#65)

[paulirwin]

Fixes #65.

Converts Java 16 record classes to C# records.

record Circle(int radius) implements Shape {
    public String describe() { return "Circle r=" + radius; }
}

public record Circle(int radius) : Shape
{
    public virtual string Describe() { return "Circle r=" + radius; }
}

Covers components, implements, generics, static members, nested records, secondary constructors (emitted as : this(v, v)), and value equality.

Also fixes a silent data-loss bug

The type dispatch in JavaToCSharpConverter had no else branch, so a top-level record was silently dropped — empty output, no warning, no error. Nested records instead threw from BodyDeclarationVisitor's exact-type lookup. Records already parsed, since the language level is JAVA_17; nothing consumed them.

The new else branch means any future unsupported type declaration warns rather than disappearing.

Compact constructors

A compact constructor's body runs against the constructor parameters and may reassign them, with the components assigned from those parameters afterwards. Verified against real Java:

public Point { y = y * 2; }   // new Point(1, 5)  ->  Point[x=1, y=10]

So the body cannot be lowered to property initializers — those would capture the original arguments and silently produce y=5. Such records are emitted in non-positional form instead:

public record Point
{
    public int x { get; init; }
    public int y { get; init; }

    public Point(int x, int y)
    {
        if (x < 0) throw new ArgumentException("neg");
        y = y * 2;
        this.x = x;   // assigned after the body, preserving the reassignment
        this.y = y;
    }
}

Value equality, ToString, and with still come from the record. Only the implicit Deconstruct is lost, and record deconstruction is not converted today.

Explicit canonical constructors need the same non-positional form to avoid colliding with the generated primary constructor (CS0111), and already assign the components themselves, so they are ported too. Java forbids declaring both a compact and a canonical constructor, so at most one is ever present.

Known limitation

Explicit accessor overrides (public int x()) are skipped with a warning. The component property exists in either form, so emitting the method would be a duplicate member (CS0102).

Separately, and not addressed here: accessor call sites convert incorrectly. MethodCallExpressionVisitor capitalizes every method call unconditionally, so Java p.x() becomes p.X(), matching neither the property's name nor its kind. Distinguishing an accessor call from an ordinary one needs type resolution. Worth a follow-up issue.

Component names are deliberately kept verbatim rather than capitalized to C# convention: bodies refer to components directly (x + y) and those references are not rewritten, so renaming them would emit code that does not compile.

Testing

Java16Records.java runs through the integration harness that compiles and executes the generated C#. Its output is byte-identical to that of the equivalent Java program run under java, including the reassigned component (range=1..50).

Plus 12 focused unit tests in ConvertRecordTests.cs. Full suite: 311 passing, clean build under TreatWarningsAsErrors.

Two fixture details work around pre-existing behaviors unrelated to records, rather than expanding this PR's scope: members are explicitly public (Java's package-private default maps to C# private, reproducible on a plain class), and e.getMessage() is avoided (it converts to .GetMessage() rather than .Message).

🤖 Generated with Claude Code