Split mixed array ranks into separate variable declarations (#100) (#177)

Fixes #100.

## Problem

Java allows C-style array brackets on individual declarators, so one
declaration can mix array ranks:

```java
int multi[][] = new int[2][2],
    single[] = new int[2];
```

This failed conversion outright with `AssertionError: The variables do
not have a common type.` The error comes from JavaParser's
`getCommonType()`, which asserts every declarator shares a type. Because
it was called before the visitor's own array-level check, the friendlier
`InvalidOperationException` on the next lines was unreachable.

## Fix

Group declarators by array level and emit one C# declaration per
distinct rank.

The groups are emitted as **flat sibling statements** through the
existing `PendingStatements` mechanism rather than a nested block — a
block would put the variables in an inner scope and break every later
reference to them. Declarators that share a rank stay together in a
single declaration, and declaration order is preserved.

```csharp
// int single[] = new int[2], scalar = 7, other[] = {8, 9};
int[] single = new int[2], other = new[] { 8, 9 };
int scalar = 7;
```

## Scope

This covers **local variable declarations**, matching the issue's repro.
`FieldDeclarationVisitor` has the same limitation, but `VisitForClass`
returns a single `MemberDeclarationSyntax`, so splitting fields would
require changing that signature across every body-declaration visitor.
That felt out of scope here; fields remain unsupported, as already noted
in `ArrayField.java`.

Note the pre-existing, separate limitation that jagged arrays
(`int[][]`) are emitted as rectangular (`int[,]`) while indexing stays
`[0][0]` — that's the known issue behind `MultidimensionalArrays.java`
being conversion-only, and is untouched by this PR.

## Testing

**Unit tests** — new `ConvertMixedArrayRankDeclarationTests` covers the
split, same-rank grouping, declaration order and absence of a nested
scope, uninitialized declarators, the #100 repro, and a regression guard
that single-rank declarations are unchanged.

**Integration test** — new `MixedArrayRankDeclarations.java` registered
in `FullIntegrationTests`, which compiles the generated C# with Roslyn,
runs it, and asserts on stdout. It converts with **no warnings**.

Full suite: 389 passed, 0 failed. I also confirmed 6 of the 7 new tests
fail without the fix and pass with it (the 7th is the unchanged-behavior
guard, which correctly passes both ways).

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

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

Author: paulirwin

JavaToCSharp.Tests/ConvertMixedArrayRankDeclarationTests.cs

@@ -0,0 +1,134 @@
+namespace JavaToCSharp.Tests;
+
+/// <summary>
+/// Java permits C-style array brackets on individual declarators, so a single declaration can mix
+/// array ranks. C# has no equivalent, so these must be split into one declaration per rank.
+/// </summary>
+public class ConvertMixedArrayRankDeclarationTests
+{
+    [Fact]
+    public void Mixed_Ranks_Split_Into_Separate_Declarations()
+    {
+        var parsed = Convert("""
+                             package com.example;
+                             public class Program {
+                                 public void run() {
+                                     int single[] = new int[2], scalar = 7;
+                                 }
+                             }
+                             """);
+
+        Assert.Contains("int[] single = new int[2];", parsed);
+        Assert.Contains("int scalar = 7;", parsed);
+    }
+
+    [Fact]
+    public void Declarators_Of_The_Same_Rank_Stay_In_One_Declaration()
+    {
+        var parsed = Convert("""
+                             package com.example;
+                             public class Program {
+                                 public void run() {
+                                     int a[] = new int[1], b = 0, c[] = new int[2];
+                                 }
+                             }
+                             """);
+
+        // `a` and `c` share a rank, so they must remain a single declaration rather than being
+        // split one-per-declarator.
+        Assert.Contains("int[] a = new int[1], c = new int[2];", parsed);
+        Assert.Contains("int b = 0;", parsed);
+    }
+
+    [Fact]
+    public void Declaration_Groups_Are_Emitted_As_Siblings_In_Declaration_Order()
+    {
+        var parsed = Convert("""
+                             package com.example;
+                             public class Program {
+                                 public void run() {
+                                     int single[] = new int[2], scalar = 7;
+                                 }
+                             }
+                             """);
+
+        int arrayDecl = parsed.IndexOf("int[] single", StringComparison.Ordinal);
+        int scalarDecl = parsed.IndexOf("int scalar", StringComparison.Ordinal);
+
+        Assert.True(arrayDecl > 0 && scalarDecl > 0);
+        Assert.True(arrayDecl < scalarDecl, "Groups must preserve the original declaration order.");
+
+        // The split must not introduce a nested scope, which would put the variables out of reach
+        // of later statements in the enclosing block.
+        Assert.DoesNotContain("{\n            {", parsed.ReplaceLineEndings("\n"));
+    }
+
+    [Fact]
+    public void Uninitialized_Declarators_Are_Preserved_When_Split()
+    {
+        var parsed = Convert("""
+                             package com.example;
+                             public class Program {
+                                 public void run() {
+                                     int values[], count = 0;
+                                 }
+                             }
+                             """);
+
+        Assert.Contains("int[] values;", parsed);
+        Assert.Contains("int count = 0;", parsed);
+    }
+
+    [Fact]
+    public void Single_Rank_Declarations_Are_Unaffected()
+    {
+        var parsed = Convert("""
+                             package com.example;
+                             public class Program {
+                                 public void run() {
+                                     int x = 1, y = 2;
+                                 }
+                             }
+                             """);
+
+        Assert.Contains("int x = 1, y = 2;", parsed);
+    }
+
+    [Fact]
+    public void Mixed_Ranks_Convert_Without_Error()
+    {
+        // Regression test for #100: asking JavaParser for a common type across mixed ranks
+        // threw "The variables do not have a common type."
+        var warnings = new List<string>();
+
+        var parsed = Convert("""
+                             package com.example;
+                             public class Program {
+                                 public void run() {
+                                     int multi[][] = new int[2][2], single[] = new int[2];
+                                 }
+                             }
+                             """, warnings);
+
+        // The two ranks must land in separate declarations. Note the 2-D array is emitted as a
+        // rectangular `int[,]` rather than a jagged `int[][]`; that is a pre-existing limitation
+        // independent of the mixed-rank split under test here.
+        Assert.Contains("int[, ] multi = new int[2, 2];", parsed);
+        Assert.Contains("int[] single = new int[2];", parsed);
+
+        // The only warning permitted here is the pre-existing multi-dimensional array caveat.
+        Assert.All(warnings, w => Assert.Contains("Multi-dimensional arrays", w));
+    }
+
+    private static string Convert(string javaCode, List<string>? warnings = null)
+    {
+        var options = new JavaConversionOptions
+        {
+            IncludeComments = false,
+        };
+
+        options.WarningEncountered += (_, eventArgs) => warnings?.Add(eventArgs.Message);
+
+        return JavaToCSharpConverter.ConvertText(javaCode, options) ?? "";
+    }
+}

JavaToCSharp.Tests/IntegrationTests.cs

@@ -21,6 +21,9 @@ public class IntegrationTests(ITestOutputHelper testOutputHelper)
     [InlineData("Resources/Java9DiamondOperatorInnerClass.java")]
     [InlineData("Resources/Java11LambdaInference.java")]
     [InlineData("Resources/MultidimensionalArrays.java", true)]
+    // Warnings are expected: jagged arrays are still emitted as rectangular C# arrays, so this
+    // converts but cannot be compiled and run. See the note in the resource file.
+    [InlineData("Resources/MixedArrayRankMultidimensional.java", true)]
     [InlineData("Resources/Java17SealedClasses.java", true)]
     // Conversion-only: java.util.function has no BCL delegate mapping, so the output cannot be run.
     [InlineData("Resources/Java8MethodReferences.java")]
@@ -90,6 +93,7 @@ public void GeneralUnsuccessfulConversionTest(string filePath)
     [InlineData("Resources/LabeledBreakContinue.java")]
     [InlineData("Resources/ExceptionGetMessage.java")]
     [InlineData("Resources/LongLiterals.java")]
+    [InlineData("Resources/MixedArrayRankDeclarations.java")]
     public void FullIntegrationTests(string filePath, bool allowWarnings = false)
         => RunFullIntegrationTest(filePath, allowWarnings);
 

JavaToCSharp.Tests/Resources/MixedArrayRankDeclarations.java

@@ -0,0 +1,24 @@
+/// Expect:
+/// - output: "5\n7\n9\n2\n0\n"
+package example;
+
+public class Program {
+    public static void main(String[] args) {
+        // Java allows C-style array brackets per declarator, so one declaration can mix ranks.
+        // These must split into separate C# declarations, preserving declaration order.
+        int single[] = new int[2], scalar = 7, other[] = {8, 9};
+
+        single[0] = 5;
+
+        System.out.println(single[0]);
+        System.out.println(scalar);
+        System.out.println(other[1]);
+
+        // A rank group with more than one declarator, and an uninitialized declarator.
+        int a[] = {1, 2}, b = 0, c[];
+        c = new int[1];
+
+        System.out.println(a[1]);
+        System.out.println(c[0] + b);
+    }
+}

JavaToCSharp.Tests/Resources/MixedArrayRankMultidimensional.java

@@ -0,0 +1,25 @@
+// NOTE: this test case only parses and converts successfully, it does not yet run.
+// The mixed-rank declaration is split correctly by this test's coverage, but jagged arrays are
+// still emitted as rectangular C# arrays (`int[,]`) while indexing stays `multi[0][0]`, so the
+// generated code does not compile. That is the pre-existing limitation tracked by
+// MultidimensionalArrays.java, not by the mixed-rank split.
+package example;
+
+public class Program {
+    public static void main(String[] args) {
+        // The example from issue #100: mixing a 2-D and a 1-D declarator in one declaration.
+        int multi[][] = new int[2][2],
+            single[] = new int[2];
+        multi[0][0] = 1;
+        multi[0][1] = 2;
+        multi[1][0] = 3;
+        multi[1][1] = 4;
+        single[0] = 5;
+
+        System.out.println(multi[0][0]);
+        System.out.println(multi[0][1]);
+        System.out.println(multi[1][0]);
+        System.out.println(multi[1][1]);
+        System.out.println(single[0]);
+    }
+}

JavaToCSharp/Statements/ExpressionStatementVisitor.cs

@@ -43,28 +43,54 @@ public class ExpressionStatementVisitor : StatementVisitor<ExpressionStmt>
         return expressionSyntax is null ? null : SyntaxFactory.ExpressionStatement(expressionSyntax);
     }
 
-    private static StatementSyntax VisitVariableDeclarationStatement(ConversionContext context, VariableDeclarationExpr varExpr)
+    private static StatementSyntax? VisitVariableDeclarationStatement(ConversionContext context, VariableDeclarationExpr varExpr)
+    {
+        var variableDeclarators = varExpr.getVariables()?.ToList<VariableDeclarator>() ?? [];
+
+        // Java allows C-style array brackets on individual declarators, so a single declaration can mix
+        // ranks (`int multi[][] = ..., single[] = ...;`). C# has no equivalent, and asking JavaParser for
+        // a common type throws in that case, so emit one C# declaration per distinct array rank. The
+        // groups stay flat siblings rather than a nested block so the variables remain in the same scope.
+        var declaratorGroups = variableDeclarators
+            .GroupBy(item => item.getType().getArrayLevel())
+            .ToList();
+
+        if (declaratorGroups.Count > 1)
+        {
+            StatementSyntax? last = null;
+
+            foreach (var group in declaratorGroups)
+            {
+                if (last is not null)
+                {
+                    context.PendingStatements.Add(last);
+                }
+
+                last = VisitVariableDeclarationGroup(context, group.First().getType(), group.ToList());
+            }
+
+            return last;
+        }
+
+        return VisitVariableDeclarationGroup(context, varExpr.getCommonType(), variableDeclarators);
+    }
+
+    private static StatementSyntax? VisitVariableDeclarationGroup(
+        ConversionContext context,
+        com.github.javaparser.ast.type.Type commonType,
+        List<VariableDeclarator> variableDeclarators)
     {
-        var commonType = varExpr.getCommonType();
         int? arrayRank = null;
 
         var variables = new List<VariableDeclaratorSyntax>();
         var loweredSwitches = new List<StatementSyntax>();
 
-        var variableDeclarators = varExpr.getVariables()?.ToList<VariableDeclarator>() ?? [];
-
         foreach (var item in variableDeclarators)
         {
             var type = item.getType();
 
-            if (arrayRank is not null && type.getArrayLevel() != arrayRank)
-            {
-                throw new InvalidOperationException("Different array levels in the same field declaration are not yet supported");
-            }
-
             arrayRank ??= type.getArrayLevel();
 
-            var id = item.getType();
             string name = item.getNameAsString();
 
             if (type.getArrayLevel() > 0)