fix(fmt): count lone carriage returns in LSP position mapping

Author: fi3ework

packages/rstack/src/fmt/lsp/minimalEdit.ts

@@ -105,9 +105,9 @@ interface MinimalTextEdit {
 /**
  * Reduces a reformat to the single LSP text edit that actually changed.
  *
- * The offset → position mapping only counts line feeds because LSP characters
- * and JS offsets share the UTF-16 unit, and because `computeMinimalEdit` never
- * places a boundary inside a surrogate pair or a `\r\n`.
+ * Positions count UTF-16 code units, like JS offsets, and lines end at `\n`,
+ * `\r\n`, or a lone `\r`, like the protocol's. `computeMinimalEdit` keeping
+ * boundaries out of surrogate pairs and `\r\n` is what makes the mapping exact.
  */
 const computeMinimalTextEdit = (source: string, formatted: string): MinimalTextEdit | undefined => {
   const edit = computeMinimalEdit(source, formatted);
@@ -117,13 +117,18 @@ const computeMinimalTextEdit = (source: string, formatted: string): MinimalTextE
 
   let line = 0;
   let lineStart = 0;
-  // Resumes from the previous call's line, so start and end share one scan.
+  // Resumes from the previous call's line, so start and end share one scan. A
+  // `\r` followed by `\n` defers to the `\n` so the pair counts once.
   const advanceTo = (offset: number): Position => {
-    let lineFeed = source.indexOf('\n', lineStart);
-    while (lineFeed !== -1 && lineFeed < offset) {
-      line++;
-      lineStart = lineFeed + 1;
-      lineFeed = source.indexOf('\n', lineStart);
+    for (let index = lineStart; index < offset; index++) {
+      const code = source.charCodeAt(index);
+      if (
+        code === LINE_FEED ||
+        (code === CARRIAGE_RETURN && source.charCodeAt(index + 1) !== LINE_FEED)
+      ) {
+        line++;
+        lineStart = index + 1;
+      }
     }
 
     return { line, character: offset - lineStart };

packages/rstack/tests/fmt/lsp/minimalEdit.test.ts

@@ -1,6 +1,6 @@
 import { expect, test } from 'rstack/test';
 import { TextDocument } from 'vscode-languageserver-textdocument';
-import { computeMinimalEdit } from '../../../src/fmt/lsp/minimalEdit.ts';
+import { computeMinimalEdit, computeMinimalTextEdit } from '../../../src/fmt/lsp/minimalEdit.ts';
 
 /** Applies an edit the way an editor does, to prove it rewrites the document. */
 const applyMinimalEdit = (source: string, formatted: string): string => {
@@ -165,12 +165,31 @@ test('addresses every combination of line terminators', () => {
       if (applied !== formatted) {
         failures.push(`${JSON.stringify(source)} -> ${JSON.stringify(formatted)}`);
       }
+
+      // The hand-rolled position mapping must agree with the reference
+      // implementation on every terminator combination.
+      const range = computeMinimalTextEdit(source, formatted)?.range;
+      const expected = {
+        start: document.positionAt(edit.start),
+        end: document.positionAt(edit.end),
+      };
+      if (JSON.stringify(range) !== JSON.stringify(expected)) {
+        failures.push(`positions ${JSON.stringify(source)} -> ${JSON.stringify(formatted)}`);
+      }
     }
   }
 
   expect(failures).toEqual([]);
 });
 
+// The protocol counts a lone `\r` as a line break, so the mapping must too.
+test('maps positions across lone carriage returns', () => {
+  expect(computeMinimalTextEdit('a\rb=2;\r', 'a\rb = 2;\r')).toEqual({
+    range: { start: { line: 1, character: 1 }, end: { line: 1, character: 2 } },
+    newText: ' = ',
+  });
+});
+
 // U+2028 ends a line for JavaScript but never for the protocol.
 test('treats a line separator as ordinary content', () => {
   const source = 'const a = "\u2028";\nconst b=2;\n';