Support Java 21 switch pattern matching (#68)

[paulirwin]

Fixes #68.

Record pattern support (#67) already covered most of JEP 441 — pattern labels, when guards, and type patterns in both switch expressions and switch statements were all prerequisites for putting record patterns in switch positions. This PR fixes the one construct that slipped through and adds end-to-end coverage for the JEP as a whole.

The bug: case null, default silently dropped its default

javaparser models case null, default as a single null label carrying a separate isDefault() flag:

entry type=EXPRESSION labels=1 isDefault=true
   label class=NullLiteralExpr text=null

Both switch visitors keyed off the label list alone, so the default half was invisible:

case Integer i -> "int " + i;
case null, default -> "fallback";     // Java: null AND everything else

int i => "int " + i,
null => "fallback"                     // C#: only null

The arm ended up matching only null, so a non-null value matching no other arm threw SwitchExpressionException where Java returned a value. The generated code still compiled — C# only warns (CS8509) about the now-inexhaustive switch — so this failed at runtime rather than at conversion or build time.

Both visitors now consult isDefault(). C#'s discard pattern and default: section already match null (verified both), so the combined form collapses cleanly onto them.

What was already working

Confirmed by running each construct through the converter and comparing against a JDK:

JEP 441 feature	Status
Type patterns in switch	✅ Already worked (#67)
when guards	✅ Already worked (#67)
case null on its own	✅ Already worked
case null, default	❌ Fixed here
Exhaustive switch over sealed types	✅ Already worked

Testing

Java21SwitchPatternMatching.java is wired into FullIntegrationTests, which compiles the generated C#, executes it, and asserts on runtime output. It covers the null label, both combined case null, default forms (expression and statement), guards, exhaustive switching over a sealed hierarchy, and type patterns over unrelated types.

The expected output is the verbatim output of running the Java source under a JDK, so the test pins the conversion to Java's real behaviour.

Plus 5 unit tests in ConvertSwitchPatternTests. I verified the two covering case null, default fail against the unfixed visitors and pass with the fix, so they genuinely pin the bug rather than just passing.

Full suite: 335 passed, 0 failed (329 before this change).

Two pre-existing bugs found while writing the resource

Both reproduce on master without any of these changes, so they're left alone and worked around in the test resource. Happy to file issues:

1. Record accessor casing. record Circle(int r) keeps the lowercase property r, but a call to c.r() converts to c.R() — so the generated code doesn't compile. The resource uses deconstruction instead.
2. long literal suffix dropped. Object o = 9L converts to object o = 9, which boxes as int. In a type-pattern switch that means case Long l never matches and the value takes the Integer arm instead. The resource avoids Long patterns.

🤖 Generated with Claude Code