Fix multi-line Javadoc dropped when file and host line endings differ (#97) (#176)

Fixes #97.

## The bug

`CommentsHelper.ConvertDocComment` split Javadoc content on
`Environment.NewLine`:

```csharp
comment.getContent().Split([Environment.NewLine], StringSplitOptions.None)
```

JavaParser's `getContent()` preserves the line endings of the **parsed
file**, which are independent of the **host OS**. I confirmed this with
a throwaway probe: CRLF source yields content with 3 CRs, LF-only source
yields 0.

So when the two disagree — most commonly a Unix-line-ending file
converted on Windows, which is exactly what the reporter narrowed it
down to — the content stays one unsplit line, the per-line regex never
matches, and the Javadoc is dropped from the output entirely.

Single-line `/** ... */` comments were unaffected because they contain
no newline to split on. That's why the bug appeared specific to
multi-line Javadoc.

## Verification

Rather than assume, I reproduced it: on unmodified `master`, patching
the split to `"\r\n"` (simulating a Windows host) makes the new tests
fail with the Javadoc **completely absent** — no `<summary>`, no
`<param>`. With the fix, all cases pass.

## The change

- Added `SplitLines()`, which normalizes line endings before splitting,
and applied it to the three places that split text originating from the
Java source. `FormatAsBlockComment` already did this correctly by hand
and now shares the helper.
- Added `NormalizeLineEndings()` on the raw comment-trivia paths so
comment content adopts the generated file's line endings instead of
leaking the Java file's, consistent with the existing
`Whitespace.NewLine` convention.
- The remaining `Environment.NewLine` uses are all on the **output**
side — including `AdjustBlockCommentIndentation`, which splits trivia we
generate ourselves — and are correct as-is. Only the input-side splits
were platform-sensitive.

## Tests

Two new theories in `CommentTests.cs`, each run against both `\n` and
`\r\n` input.

Worth flagging: there was previously **no test anywhere** asserting
Javadoc → `<summary>`/`<param>`/`<returns>`/`<exception>` output — every
other suite sets `IncludeComments = false`, so that path was entirely
uncovered. These tests close that gap as well.

Full suite: 382/382 passing, 0 build warnings.

## Out of scope

Two pre-existing issues I noticed and left alone, each confirmed to
reproduce on `master` independently of this change:

- Generated output has mixed line endings because Roslyn's
`NormalizeWhitespace()` emits `\r\n` regardless of platform — this
happens even for a file containing no comments.
- The CLI's `file` mode ignored the package declaration and dropped the
type for one of my test inputs.

Happy to look into either separately.

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

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

Author: paulirwin

JavaToCSharp.Tests/CommentTests.cs

@@ -241,4 +241,86 @@ public class Foo
 
         Assert.Equal(expected.ReplaceLineEndings(), parsed.ReplaceLineEndings());
     }
+
+    [Theory]
+    [InlineData("\n")]
+    [InlineData("\r\n")]
+    public void MultiLineJavadoc_ShouldConvertToXmlDoc_RegardlessOfLineEndings(string newLine)
+    {
+        // Issue #97: the Javadoc content was split on Environment.NewLine, so a Java file whose
+        // line endings differ from the host OS collapsed into a single unparsed line.
+        string javaCode = """
+                          package foo;
+
+                          public class Foo {
+                              /**
+                               * Really cool field that contains something.
+                               * Keep in mind that this field is cooler than awesomeField.
+                               */
+                              public int reallyAwesomeField;
+                          }
+                          """.ReplaceLineEndings(newLine);
+
+        var options = new JavaConversionOptions();
+        options.Usings.Clear();
+
+        var parsed = JavaToCSharpConverter.ConvertText(javaCode, options) ?? "";
+
+        testOutputHelper.WriteLine(parsed);
+
+        const string expected = """
+                                namespace Foo
+                                {
+                                    public class Foo
+                                    {
+                                        /// <summary>
+                                        /// Really cool field that contains something.
+                                        /// Keep in mind that this field is cooler than awesomeField.
+                                        /// </summary>
+                                        public int reallyAwesomeField;
+                                    }
+                                }
+                                """;
+
+        Assert.Equal(expected.ReplaceLineEndings(), parsed.ReplaceLineEndings());
+    }
+
+    [Theory]
+    [InlineData("\n")]
+    [InlineData("\r\n")]
+    public void MultiLineJavadocWithTags_ShouldConvertToXmlDoc_RegardlessOfLineEndings(string newLine)
+    {
+        string javaCode = """
+                          package foo;
+
+                          public class Foo {
+                              /**
+                               * Does something useful.
+                               * Second line of the summary.
+                               *
+                               * @param name the name to use
+                               * @return the computed value
+                               * @throws IllegalStateException if it breaks
+                               */
+                              public int doIt(String name) {
+                                  return 1;
+                              }
+                          }
+                          """.ReplaceLineEndings(newLine);
+
+        var options = new JavaConversionOptions();
+        options.Usings.Clear();
+
+        var parsed = JavaToCSharpConverter.ConvertText(javaCode, options) ?? "";
+
+        testOutputHelper.WriteLine(parsed);
+
+        Assert.Contains("/// <summary>", parsed);
+        Assert.Contains("/// Does something useful.", parsed);
+        Assert.Contains("/// Second line of the summary.", parsed);
+        Assert.Contains("/// </summary>", parsed);
+        Assert.Contains("""/// <param name="name">the name to use</param>""", parsed);
+        Assert.Contains("/// <returns>the computed value</returns>", parsed);
+        Assert.Contains("""/// <exception cref="IllegalStateException">if it breaks</exception>""", parsed);
+    }
 }

JavaToCSharp/CommentsHelper.cs

@@ -102,7 +102,7 @@ public static CompilationUnitSyntax AddPackageComments(CompilationUnitSyntax syn
                 }
                 else
                 {
-                    var commentTrivia = SyntaxFactory.SyntaxTrivia(kind, pre + comment.getContent() + post);
+                    var commentTrivia = SyntaxFactory.SyntaxTrivia(kind, pre + NormalizeLineEndings(comment.getContent()) + post);
                     if (pos == CommentPosition.Leading)
                     {
                         leadingTriviaList.Add(commentTrivia);
@@ -136,13 +136,25 @@ private static SyntaxTrivia CreateNonMemberCommentTrivia(JavaComments.Comment co
                 FormatAsBlockComment(comment.getContent()) + suffix);
         }
 
-        return SyntaxFactory.SyntaxTrivia(kind, pre + comment.getContent() + post + suffix);
+        return SyntaxFactory.SyntaxTrivia(kind, pre + NormalizeLineEndings(comment.getContent()) + post + suffix);
     }
 
+    /// <summary>
+    /// Splits text that originated from the Java source into lines. The line endings of the parsed file are
+    /// preserved by JavaParser and are independent of the host OS, so splitting on <see cref="Environment.NewLine"/>
+    /// would fail whenever the two differ (see issue #97).
+    /// </summary>
+    private static string[] SplitLines(string text) => text.ReplaceLineEndings("\n").Split('\n');
+
+    /// <summary>
+    /// Rewrites line endings that came from the Java source to the ones used for the generated C# output, so that
+    /// multi-line comments do not introduce line endings foreign to the rest of the file.
+    /// </summary>
+    private static string NormalizeLineEndings(string text) => text.ReplaceLineEndings(Environment.NewLine);
+
     private static string FormatAsBlockComment(string content)
     {
-        var lines = content.ReplaceLineEndings("\n")
-            .Split('\n')
+        var lines = SplitLines(content)
             .Select(line => line.TrimStart().TrimStart('*').Trim())
             .ToList();
 
@@ -293,7 +305,7 @@ public static IEnumerable<SyntaxTrivia> ConvertToComment(IEnumerable<JavaAst.Nod
         var outputs = new List<string>();
         foreach (var code in codes)
         {
-            string[] input = code.ToString().Split([Environment.NewLine], StringSplitOptions.None);
+            string[] input = SplitLines(code.ToString());
             outputs.AddRange(input);
         }
 
@@ -318,7 +330,7 @@ public static IEnumerable<SyntaxTrivia> ConvertToComment(IEnumerable<JavaAst.Nod
 
     private static IEnumerable<SyntaxTrivia> ConvertDocComment(JavaComments.Comment comment, string? post)
     {
-        string[] input = comment.getContent().Split([Environment.NewLine], StringSplitOptions.None);
+        string[] input = SplitLines(comment.getContent());
         var output = new List<string>();
         var remarks = new List<string>(); // For Java tags unknown in C#
         var currentOutput = output;