Preserve the L suffix on converted long literals (#175)

## Problem

`LongLiteralExpressionVisitor` stripped the trailing `L`/`l` from a Java
long literal and emitted the remaining text verbatim, so the generated
C# lost the suffix that makes it a long.

That produced code which **does not compile**. C# types a bare numeric
literal as `int`, so:

```java
long allOnes = 0xFFFFFFFFFFFFFFFFL;
```

converted to:

```csharp
long allOnes = 0xFFFFFFFFFFFFFFFF;   // error CS0266: cannot implicitly convert 'ulong' to 'long'
```

## Fix

- Re-append the `L` suffix when building the literal token.
- Strip the incoming `L`/`l` as a *suffix* rather than via a blanket
`Replace` over the whole string, which was scanning every character of a
value we echo back into the generated source.
- A hex literal above `long.MaxValue` stays invalid in C# even with the
suffix, because the literal is typed by its magnitude. For that case
emit the wrapped decimal value, which is the number Java means:
`0xFFFFFFFFFFFFFFFFL` → `-1L`.

## Why it went unnoticed

The existing long-literal tests asserted only the parsed numeric
`Value`, never the emitted token text — so a literal with a correct
value but uncompilable text passed. The new cases assert `Text`.

## Testing

- New `VisitLiteralExpression_Long_PreservesSuffixInText` theory
covering hex, binary, octal, underscore separators, lowercase `l`, and
both overflow boundaries.
- Extra `VisitLiteralExpression_Long` cases for the two's-complement and
above-`int.MaxValue` values.
- `Resources/LongLiterals.java` wired into `FullIntegrationTests`, which
compiles the generated C# and asserts its runtime output matches Java's.

Full suite: **378 passed, 0 failed** (was 363).

## Note on #128

The binary-literal crash originally reported in #128 (`0b10`, `0b100`)
**no longer reproduces on master** — it was fixed sometime after the
3.0.0 build in that report. Investigating it surfaced this adjacent
defect in the long-literal path, which this PR fixes. Worth confirming
whether #128 should now be closed.

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

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

Author: paulirwin

JavaToCSharp.Tests/IntegrationTests.cs

@@ -89,6 +89,7 @@ public void GeneralUnsuccessfulConversionTest(string filePath)
     [InlineData("Resources/StaticImports.java")]
     [InlineData("Resources/LabeledBreakContinue.java")]
     [InlineData("Resources/ExceptionGetMessage.java")]
+    [InlineData("Resources/LongLiterals.java")]
     public void FullIntegrationTests(string filePath, bool allowWarnings = false)
         => RunFullIntegrationTest(filePath, allowWarnings);
 

JavaToCSharp.Tests/Resources/LongLiterals.java

@@ -0,0 +1,21 @@
+/// Expect:
+/// - output: "-1 9223372036854775807 10 2147483648 255 8 1000000\n"
+package example;
+
+public class Program {
+    public static void main(String[] args) {
+        // An all-ones hex long is -1 in Java's two's-complement representation. Without the
+        // L suffix the generated C# literal is a ulong and fails to compile (CS0266).
+        long allOnes = 0xFFFFFFFFFFFFFFFFL;
+        long maxValue = 0x7FFFFFFFFFFFFFFFL;
+        long small = 10L;
+        // Above int.MaxValue, so a bare literal would not be typed as int in C#.
+        long aboveIntMax = 2147483648L;
+        long hex = 0xFFL;
+        long octal = 010L;
+        long separated = 1_000_000L;
+
+        System.out.println(allOnes + " " + maxValue + " " + small + " " + aboveIntMax
+            + " " + hex + " " + octal + " " + separated);
+    }
+}

JavaToCSharp.Tests/VisitLiteralExpressionTests.cs

@@ -55,10 +55,42 @@ public void VisitLiteralExpression_Integer(string javaLiteral, int expected)
     [InlineData("0B1010L", 10L)]
     [InlineData("0x1FL", 31L)]
     [InlineData("010L", 8L)]
+    [InlineData("10L", 10L)]
+    [InlineData("2147483648L", 2147483648L)]
+    // Java long literals are two's-complement, so an all-ones hex literal is -1.
+    [InlineData("0xFFFFFFFFFFFFFFFFL", -1L)]
+    [InlineData("0x7FFFFFFFFFFFFFFFL", long.MaxValue)]
+    // A lowercase l suffix is equally valid Java.
+    [InlineData("42l", 42L)]
     public void VisitLiteralExpression_Long(string javaLiteral, long expected)
     {
         var expr = ExpressionVisitor.VisitExpression(new ConversionContext(new JavaConversionOptions()), new LongLiteralExpr(javaLiteral));
         Assert.Equal(expected, expr?.GetFirstToken().Value);
     }
+
+    /// <summary>
+    /// The emitted text must keep the L suffix. C# types a bare numeric literal as int, so
+    /// dropping it makes 0xFFFFFFFFFFFFFFFF a ulong that will not implicitly convert to long
+    /// (CS0266), and pushes any value above int.MaxValue to a different inferred type.
+    /// </summary>
+    [Theory]
+    // Above long.MaxValue C# would type the hex literal as ulong (CS0266), so the wrapped
+    // decimal value is emitted instead.
+    [InlineData("0xFFFFFFFFFFFFFFFFL", "-1L")]
+    [InlineData("0x8000000000000000L", "-9223372036854775808L")]
+    [InlineData("2147483648L", "2147483648L")]
+    [InlineData("0x1FL", "0x1FL")]
+    [InlineData("0b10L", "0b10L")]
+    [InlineData("10L", "10L")]
+    [InlineData("42l", "42L")]
+    // Underscores are separators in Java and are dropped from the emitted literal.
+    [InlineData("1_000_000L", "1000000L")]
+    // Java octal has no C# equivalent, so it is rewritten in decimal - still suffixed.
+    [InlineData("010L", "8L")]
+    public void VisitLiteralExpression_Long_PreservesSuffixInText(string javaLiteral, string expectedText)
+    {
+        var expr = ExpressionVisitor.VisitExpression(new ConversionContext(new JavaConversionOptions()), new LongLiteralExpr(javaLiteral));
+        Assert.Equal(expectedText, expr?.GetFirstToken().Text);
+    }
 }
 

JavaToCSharp/Expressions/LongLiteralExpressionVisitor.cs

@@ -9,16 +9,30 @@ public class LongLiteralExpressionVisitor : ExpressionVisitor<LiteralStringValue
     protected override ExpressionSyntax Visit(ConversionContext context, LiteralStringValueExpr expr)
     {
         string value = expr is LongLiteralExpr longLiteralExpr ? longLiteralExpr.getValue() : expr.toString();
-        value = value.Trim('\"')
-            .Replace("L", string.Empty)
-            .Replace("l", string.Empty)
-            .Replace("_", string.Empty);
+        value = value.Trim('\"').Replace("_", string.Empty);
+
+        // Java marks a long literal with a trailing L/l. Strip it as a suffix only: a blanket
+        // Replace would also corrupt digits in a value we echo back into the generated source.
+        if (value.EndsWith('L') || value.EndsWith('l'))
+        {
+            value = value[..^1];
+        }
 
         long int64Value;
 
         if (value.StartsWith("0x", StringComparison.OrdinalIgnoreCase))
         {
+            // Convert.ToInt64 accepts the 0x prefix and wraps values above long.MaxValue
+            // (e.g. 0xFFFFFFFFFFFFFFFF -> -1), matching Java's two's-complement semantics.
             int64Value = Convert.ToInt64(value, 16);
+
+            // C# types a hex literal by its magnitude, so anything above long.MaxValue becomes
+            // ulong and will not implicitly convert to long (CS0266) even with the L suffix.
+            // Emit the wrapped decimal value instead, which is the number Java means.
+            if (int64Value < 0)
+            {
+                value = int64Value.ToString();
+            }
         }
         else if (value.StartsWith("0b", StringComparison.OrdinalIgnoreCase))
         {
@@ -34,6 +48,10 @@ protected override ExpressionSyntax Visit(ConversionContext context, LiteralStri
             int64Value = Convert.ToInt64(value);
         }
 
-        return SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(value, int64Value));
+        // Re-append the L suffix. C# infers int for a bare literal, so without it a value above
+        // int.MaxValue either fails to compile (0xFFFFFFFFFFFFFFFF is ulong) or changes type.
+        return SyntaxFactory.LiteralExpression(
+            SyntaxKind.NumericLiteralExpression,
+            SyntaxFactory.Literal(value + "L", int64Value));
     }
 }