Use the typed Roslyn API for C# 15 labeled jumps and closed

Upgrades Microsoft.CodeAnalysis.CSharp from 5.6.0 to 5.9.0, which adds real
support for both C# 15 features this project emits.

Labeled break/continue now use the new BreakStatement(IdentifierNameSyntax)
and ContinueStatement(IdentifierNameSyntax) overloads, replacing the `goto`
placeholder that was substituted into the final text. The sealed class
`closed` modifier now uses SyntaxKind.ClosedKeyword instead of fabricating
the token with ParseToken("closed ").

Both APIs are still marked experimental, so RSEXPERIMENTAL006 is suppressed
at each use site.

The integration test harness now parses generated code with
LanguageVersion.Preview, so the C# 15 labeled jump output is compiled and
executed rather than only string-asserted. LabeledBreakContinue.java runs
through both the default C# 15 path and the goto fallback, asserting the
same output for each.

Roslyn 5.9.0 depends on an unpublished Microsoft.CodeAnalysis.Analyzers
prerelease, so the released 5.9.0 is referenced explicitly to avoid NU1603.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: paulirwin

JavaToCSharp.Tests/IntegrationTests.cs

@@ -87,15 +87,26 @@ public void GeneralUnsuccessfulConversionTest(string filePath)
     [InlineData("Resources/Java16LocalRecords.java")]
     [InlineData("Resources/InstanceInitializers.java")]
     [InlineData("Resources/StaticImports.java")]
-    // Uses the `goto` fallback: the C# 15 labeled jump syntax cannot be compiled by the Roslyn version here.
     [InlineData("Resources/LabeledBreakContinue.java")]
     public void FullIntegrationTests(string filePath, bool allowWarnings = false)
+        => RunFullIntegrationTest(filePath, allowWarnings);
+
+    /// <summary>
+    /// Runs the labeled break/continue sample through the <c>goto</c> fallback, to confirm it behaves
+    /// identically to the C# 15 labeled jumps covered by <see cref="FullIntegrationTests"/>.
+    /// </summary>
+    [Theory]
+    [InlineData("Resources/LabeledBreakContinue.java")]
+    public void FullIntegrationTestsWithGotoFallback(string filePath)
+        => RunFullIntegrationTest(filePath, allowWarnings: false, useLabeledBreakAndContinue: false);
+
+    private void RunFullIntegrationTest(string filePath, bool allowWarnings, bool useLabeledBreakAndContinue = true)
     {
         var options = new JavaConversionOptions
         {
             ConvertSystemOutToConsole = true,
             IncludeComments = false,
-            UseLabeledBreakAndContinue = false,
+            UseLabeledBreakAndContinue = useLabeledBreakAndContinue,
         };
 
         options.AddUsing("System");
@@ -116,7 +127,10 @@ public void FullIntegrationTests(string filePath, bool allowWarnings = false)
 
         testOutputHelper.WriteLine(parsed);
 
-        var fileName = Path.GetFileNameWithoutExtension(filePath);
+        // The suffix keeps the two option variants in separate assemblies, because Assembly.LoadFile
+        // caches by path and would otherwise reuse the first variant's compiled output.
+        var fileName = Path.GetFileNameWithoutExtension(filePath)
+                       + (useLabeledBreakAndContinue ? "" : "_Goto");
         var assembly = CompileAssembly(fileName, parsed);
 
         var expectation = ParseExpectation(javaText);
@@ -171,7 +185,10 @@ public void FullIntegrationTests(string filePath, bool allowWarnings = false)
 
     private static Assembly CompileAssembly(string assemblyName, string cSharpLanguageText)
     {
-        var syntaxTree = CSharpSyntaxTree.ParseText(cSharpLanguageText);
+        // Preview is required for the C# 15 features the converter emits, such as labeled break/continue.
+        var syntaxTree = CSharpSyntaxTree.ParseText(
+            cSharpLanguageText,
+            new CSharpParseOptions(LanguageVersion.Preview));
 
         var options = new CSharpCompilationOptions(OutputKind.ConsoleApplication)
             .WithOverflowChecks(true)

JavaToCSharp/Declarations/ClassOrInterfaceDeclarationVisitor.cs

@@ -242,8 +242,10 @@ public static ClassDeclarationSyntax VisitClassDeclaration(ConversionContext con
         {
             if (context.Options.UseClosedForSealedClasses)
             {
-                // Roslyn has no ClosedKeyword token, as `closed` is a C# 15 feature.
-                classSyntax = classSyntax.AddModifiers(SyntaxFactory.ParseToken("closed "));
+                // The `closed` keyword is still marked experimental in Roslyn.
+#pragma warning disable RSEXPERIMENTAL006
+                classSyntax = classSyntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.ClosedKeyword));
+#pragma warning restore RSEXPERIMENTAL006
             }
             else
             {

JavaToCSharp/JavaToCSharp.csproj

@@ -18,7 +18,12 @@
     <ItemGroup>
         <PackageReference Include="IKVM" Version="8.15.0"/>
         <PackageReference Include="IKVM.Maven.Sdk" Version="1.12.0"/>
-        <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="5.6.0" />
+        <!--
+          Microsoft.CodeAnalysis.CSharp 5.9.0 depends on an unpublished Microsoft.CodeAnalysis.Analyzers
+          prerelease. Referencing the released 5.9.0 explicitly satisfies that range and avoids NU1603.
+        -->
+        <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="5.9.0" />
+        <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="5.9.0" />
         <PackageReference Include="Nullable.Extended.Analyzer" Version="1.15.6581"/>
         <PackageReference Include="System.Configuration.ConfigurationManager" Version="10.0.11" />
         <PackageReference Include="YamlDotNet" Version="18.1.0" />

JavaToCSharp/JavaToCSharpConverter.cs

@@ -156,8 +156,6 @@ public static class JavaToCSharpConverter
 
         context.ConversionStateChanged(ConversionState.Done);
 
-        // C# 15 labeled jumps cannot be represented in a Roslyn tree, so they are emitted as placeholders
-        // and substituted into the final text here. See LabeledJumpHelper.
-        return Statements.LabeledJumpHelper.RewritePlaceholders(tree.GetText().ToString());
+        return tree.GetText().ToString();
     }
 }

JavaToCSharp/Statements/LabeledJumpHelper.cs

@@ -1,4 +1,3 @@
-using System.Text.RegularExpressions;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 
@@ -10,24 +9,12 @@ namespace JavaToCSharp.Statements;
 /// <remarks>
 /// Two shapes are supported, selected by <see cref="JavaConversionOptions.UseLabeledBreakAndContinue"/>:
 /// <list type="bullet">
-/// <item>C# 15 labeled jumps (<c>break outer;</c>). Roslyn cannot model these — there is no label operand on
-/// <see cref="BreakStatementSyntax"/> and the parser rejects the syntax even at
-/// <c>LanguageVersion.Preview</c> — so a <c>goto</c> placeholder is emitted instead and rewritten to the real
-/// text after whitespace normalization by <see cref="SanitizingSyntaxRewriter"/>.</item>
+/// <item>C# 15 labeled jumps (<c>break outer;</c>), which map one-to-one onto the Java syntax.</item>
 /// <item>A <c>goto</c> to a generated target label, which is valid in every C# version.</item>
 /// </list>
 /// </remarks>
-internal static partial class LabeledJumpHelper
+internal static class LabeledJumpHelper
 {
-    /// <summary>
-    /// Prefix for the placeholder <c>goto</c> target that stands in for a C# 15 labeled jump.
-    /// Chosen to be a valid C# identifier so the placeholder tree parses and normalizes cleanly.
-    /// </summary>
-    private const string PlaceholderPrefix = "__javaToCSharp_labeled_";
-
-    [GeneratedRegex($@"goto {PlaceholderPrefix}(break|continue)_(\w+);")]
-    private static partial Regex PlaceholderRegex { get; }
-
     /// <summary>
     /// The label a <c>goto</c> jumps to in order to leave the loop labeled <paramref name="label"/>.
     /// Emitted immediately after the loop.
@@ -48,9 +35,14 @@ internal static StatementSyntax CreateJump(ConversionContext context, string lab
     {
         if (context.Options.UseLabeledBreakAndContinue)
         {
-            // Placeholder for `break <label>;` / `continue <label>;`, rewritten post-normalization.
-            return SyntaxFactory.ParseStatement(
-                $"goto {PlaceholderPrefix}{(isBreak ? "break" : "continue")}_{label};");
+            var name = SyntaxFactory.IdentifierName(label);
+
+            // The labeled break/continue factory overloads are still marked experimental in Roslyn.
+#pragma warning disable RSEXPERIMENTAL006
+            return isBreak
+                ? SyntaxFactory.BreakStatement(name)
+                : SyntaxFactory.ContinueStatement(name);
+#pragma warning restore RSEXPERIMENTAL006
         }
 
         var target = isBreak ? BreakTargetLabel(label) : ContinueTargetLabel(label);
@@ -68,11 +60,4 @@ internal static StatementSyntax CreateJump(ConversionContext context, string lab
             SyntaxKind.GotoStatement,
             SyntaxFactory.IdentifierName(target));
     }
-
-    /// <summary>
-    /// Replaces the placeholder <c>goto</c> statements with real C# 15 labeled jumps. Must run on the final
-    /// text, because the resulting syntax cannot be represented in a Roslyn syntax tree.
-    /// </summary>
-    internal static string RewritePlaceholders(string text) =>
-        PlaceholderRegex.Replace(text, "$1 $2;");
 }