ts-codemod-lib 3.4.4 → 3.5.1

package/src/functions/functions/has-disable-next-line-comment.mts

@@ -1,3 +1,4 @@
+import { Arr } from 'ts-data-forge';
 import * as tsm from 'ts-morph';
 import { IGNORE_LINE_COMMENT_PREFIXES } from '../constants/index.mjs';
 
@@ -19,16 +20,22 @@ export const hasDisableNextLineComment = (
   node: tsm.Node,
   transformerName?: string,
 ): boolean => {
-  const nodeStartLine = node.getStartLineNumber();
+  // Most nodes have no leading comment, and then nothing below can match.
+  // Asking first spares them the line numbers, the costly part.
+  const leadingCommentRanges = node.getLeadingCommentRanges();
 
-  // Cannot be ignored if it's on the first line
-  if (nodeStartLine <= 1) {
+  if (Arr.isEmpty(leadingCommentRanges)) {
     return false;
   }
 
-  const sourceFile = node.getSourceFile(); // Get the SourceFile
+  const lineNumberAt = lineNumberLookup(node.getSourceFile().compilerNode);
 
-  const leadingCommentRanges = node.getLeadingCommentRanges();
+  const nodeStartLine = lineNumberAt(node.getStart());
+
+  // Cannot be ignored if it's on the first line
+  if (nodeStartLine <= 1) {
+    return false;
+  }
 
   // Iterate backwards through comments as the closest one is most relevant
   for (let mut_i = leadingCommentRanges.length - 1; mut_i >= 0; mut_i--) {
@@ -38,7 +45,7 @@ export const hasDisableNextLineComment = (
     // Get the end position and convert it to line number
     const commentEndPos = commentRange.getEnd();
 
-    const commentEndLine = sourceFile.getLineAndColumnAtPos(commentEndPos).line;
+    const commentEndLine = lineNumberAt(commentEndPos);
 
     // Check if the comment is on the immediately preceding line
     if (nodeStartLine === commentEndLine + 1) {
@@ -91,3 +98,69 @@ export const hasDisableNextLineComment = (
 
   return false;
 };
+
+/**
+ * The 1-based line number of a position in `sourceFile`, counted the way
+ * ts-morph's `getStartLineNumber` and `getLineAndColumnAtPos` count it: one
+ * plus the number of `\n` before the position (a lone `\r` starts no line,
+ * unlike in the compiler's own line map).
+ *
+ * ts-morph scans the text from its start on every call, which made this
+ * check, asked of every node a transformer visits, quadratic in the size of
+ * the file. The newline positions are collected once per compiler source file
+ * instead. ts-morph replaces that object whenever the file is edited, so an
+ * entry never outlives the text it was collected from.
+ */
+const lineNumberLookup = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  sourceFile: tsm.ts.SourceFile,
+): ((pos: number) => number) => {
+  const cached = newlinePositionsCache.get(sourceFile);
+
+  const newlinePositions = cached ?? newlinePositionsOf(sourceFile.text);
+
+  if (cached === undefined) {
+    newlinePositionsCache.set(sourceFile, newlinePositions);
+  }
+
+  return (pos) => countLessThan(newlinePositions, pos) + 1;
+};
+
+const newlinePositionsCache = new WeakMap<
+  tsm.ts.SourceFile,
+  readonly number[]
+>();
+
+const newlinePositionsOf = (text: string): readonly number[] => {
+  const mut_positions: number[] = [];
+
+  for (
+    let mut_index = text.indexOf('\n');
+    mut_index !== -1;
+    mut_index = text.indexOf('\n', mut_index + 1)
+  ) {
+    mut_positions.push(mut_index);
+  }
+
+  return mut_positions;
+};
+
+/** The number of elements of the ascending `sorted` that are below `value`. */
+const countLessThan = (sorted: readonly number[], value: number): number => {
+  let mut_low = 0;
+
+  let mut_high = sorted.length;
+
+  while (mut_low < mut_high) {
+    const mid = Math.floor((mut_low + mut_high) / 2);
+
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    if (sorted[mid]! < value) {
+      mut_low = mid + 1;
+    } else {
+      mut_high = mid;
+    }
+  }
+
+  return mut_low;
+};

package/src/functions/functions/has-disable-next-line-comment.test.mts

@@ -0,0 +1,96 @@
+import * as tsm from 'ts-morph';
+import { hasDisableNextLineComment } from './has-disable-next-line-comment.mjs';
+
+/** The first type alias in `source`, the node every case asks about. */
+const typeAliasOf = (source: string): tsm.TypeAliasDeclaration => {
+  const project = new tsm.Project({ useInMemoryFileSystem: true });
+
+  return project
+    .createSourceFile('source.ts', source)
+    .getFirstDescendantByKindOrThrow(tsm.SyntaxKind.TypeAliasDeclaration);
+};
+
+describe(hasDisableNextLineComment, () => {
+  test.each([
+    {
+      name: 'a comment on the line above (LF)',
+      source: '// transformer-ignore-next-line\ntype A = number[];\n',
+      expected: true,
+    },
+    {
+      name: 'a comment on the line above (CRLF)',
+      source: '// transformer-ignore-next-line\r\ntype A = number[];\r\n',
+      expected: true,
+    },
+    {
+      name: 'a comment two lines above',
+      source: '// transformer-ignore-next-line\n\ntype A = number[];\n',
+      expected: false,
+    },
+    {
+      name: 'a comment two lines above (CRLF)',
+      source: '// transformer-ignore-next-line\r\n\r\ntype A = number[];\r\n',
+      expected: false,
+    },
+    {
+      name: 'a later comment on the line above shadows an earlier ignore comment',
+      source:
+        '// transformer-ignore-next-line\n// something else\ntype A = number[];\n',
+      expected: false,
+    },
+    {
+      name: 'the node on the first line',
+      source: 'type A = number[];\n',
+      expected: false,
+    },
+    {
+      name: 'the node on the first line after a block comment',
+      source: '/* transformer-ignore-next-line */ type A = number[];\n',
+      expected: false,
+    },
+    {
+      name: 'a lone CR, which does not count as a line break',
+      source: '// transformer-ignore-next-line\rtype A = number[];\n',
+      expected: false,
+    },
+    {
+      name: 'a lone CR before the comment, deep in the file',
+      source:
+        'const x = 1;\r\nconst y = 2;\r// transformer-ignore-next-line\ntype A = number[];\n',
+      expected: true,
+    },
+    {
+      name: 'a node far below many lines',
+      source: `${'const x = 1;\n'.repeat(500)}// transformer-ignore-next-line\ntype A = number[];\n`,
+      expected: true,
+    },
+  ])('$name', ({ source, expected }) => {
+    expect(hasDisableNextLineComment(typeAliasOf(source))).toBe(expected);
+  });
+
+  test('matches the transformer name list', () => {
+    const node = typeAliasOf(
+      '// transformer-ignore-next-line append-as-const, convert-to-readonly\ntype A = number[];\n',
+    );
+
+    assert.isTrue(hasDisableNextLineComment(node, 'convert-to-readonly'));
+
+    assert.isFalse(hasDisableNextLineComment(node, 'replace-any-with-unknown'));
+  });
+
+  test('reads the current text after the file has been edited', () => {
+    const node = typeAliasOf('type A = number[];\n');
+
+    assert.isFalse(hasDisableNextLineComment(node));
+
+    const sourceFile = node.getSourceFile();
+
+    sourceFile.insertText(0, '// transformer-ignore-next-line\n');
+
+    const edited = sourceFile.getFirstDescendantByKindOrThrow(
+      tsm.SyntaxKind.TypeAliasDeclaration,
+    );
+
+    assert.isTrue(hasDisableNextLineComment(edited));
+  });
+});

package/src/functions/utils/index.mts

@@ -1 +1,2 @@
+export * from './replace-node-with-text.mjs';
 export * from './replace-with-debug.mjs';

package/src/functions/utils/replace-node-with-text.mts

@@ -0,0 +1,37 @@
+import type * as tsm from 'ts-morph';
+
+/**
+ * `node.replaceWithText(newNodeText)`, sparing a one-line text the indentation
+ * lookup.
+ *
+ * `replaceWithText` writes the text through a writer whose indentation it
+ * looks up first, for the lines after the first one, and the lookup reparses
+ * the whole file in the language service: on top of the reparse every
+ * replacement makes anyway, once per replacement, so it is quadratic in the
+ * size of the file. A text with no `\n` has no line after the first, the
+ * indentation is never applied, and a plain writer from the same project
+ * writes the same text — so the lookup is skipped. A multi-line text takes
+ * the original path.
+ *
+ * The writer is passed as `replaceWithText`'s second argument, which its
+ * declaration leaves out and ts-morph passes itself when it sets an
+ * expression. Were it ever dropped, the method would look the indentation up
+ * as before: slower, never different.
+ */
+export const replaceNodeWithText = (
+  node: tsm.Node,
+  newNodeText: string,
+): tsm.Node =>
+  newNodeText.includes('\n')
+    ? node.replaceWithText(newNodeText)
+    : (node.replaceWithText as ReplaceWithTextWithWriter).call(
+        node,
+        newNodeText,
+        node.getProject().createWriter(),
+      );
+
+type ReplaceWithTextWithWriter = (
+  this: tsm.Node,
+  textOrWriterFunction: string,
+  writer: tsm.CodeBlockWriter,
+) => tsm.Node;

package/src/functions/utils/replace-node-with-text.test.mts

@@ -0,0 +1,89 @@
+import dedent from 'dedent';
+import * as tsm from 'ts-morph';
+import { replaceNodeWithText } from './replace-node-with-text.mjs';
+
+/**
+ * Replaces the first type reference named `target` in `source`, once with
+ * `replaceNodeWithText` and once with ts-morph's own `replaceWithText`.
+ */
+const replaceBothWays = (
+  source: string,
+  target: string,
+  newNodeText: string,
+): Readonly<{ actual: string; expected: string; replacedKind: string }> => {
+  const replace = (
+    fn: (nodeToReplace: tsm.Node, text: string) => tsm.Node,
+  ): Readonly<{ text: string; replacedKind: string }> => {
+    const project = new tsm.Project({ useInMemoryFileSystem: true });
+
+    const sourceFile = project.createSourceFile('source.ts', source);
+
+    const node = sourceFile
+      .getDescendantsOfKind(tsm.SyntaxKind.TypeReference)
+      .find((n) => n.getText() === target);
+
+    assert.isDefined(node);
+
+    const replaced = fn(node, newNodeText);
+
+    return {
+      text: sourceFile.getFullText(),
+      replacedKind: replaced.getKindName(),
+    };
+  };
+
+  const actual = replace(replaceNodeWithText);
+
+  const expected = replace((node, text) => node.replaceWithText(text));
+
+  assert.strictEqual(actual.replacedKind, expected.replacedKind);
+
+  return {
+    actual: actual.text,
+    expected: expected.text,
+    replacedKind: actual.replacedKind,
+  };
+};
+
+const indentedSource = dedent`
+  namespace A {
+    namespace B {
+      export type C = {
+        readonly d: Foo;
+      };
+    }
+  }
+`;
+
+describe(replaceNodeWithText, () => {
+  test.each([
+    { name: 'a one-line text', newNodeText: 'readonly number[]' },
+    { name: 'an empty text', newNodeText: '' },
+    { name: 'a text with a lone CR', newNodeText: 'Bar\r' },
+    { name: 'a text with a trailing space', newNodeText: 'Bar ' },
+    { name: 'a text with a string literal', newNodeText: '\'a\' | "b"' },
+    { name: 'a text with a line comment', newNodeText: 'Bar /* c */' },
+    { name: 'a multi-line text', newNodeText: '{\n  a: number;\n}' },
+    { name: 'a CRLF text', newNodeText: '{\r\n  a: number;\r\n}' },
+  ])('writes the text replaceWithText writes: $name', ({ newNodeText }) => {
+    const { actual, expected } = replaceBothWays(
+      indentedSource,
+      'Foo',
+      newNodeText,
+    );
+
+    expect(actual).toBe(expected);
+  });
+
+  test('returns the node that took the place of the replaced one', () => {
+    const { actual, replacedKind } = replaceBothWays(
+      indentedSource,
+      'Foo',
+      'Readonly<Bar>',
+    );
+
+    expect(replacedKind).toBe('TypeReference');
+
+    expect(actual).toContain('readonly d: Readonly<Bar>;');
+  });
+});

package/src/functions/utils/replace-with-debug.mts

@@ -1,4 +1,5 @@
 import type * as tsm from 'ts-morph';
+import { replaceNodeWithText } from './replace-node-with-text.mjs';
 
 export const replaceNodeWithDebugPrint = (
   node: tsm.Node,
@@ -6,5 +7,5 @@ export const replaceNodeWithDebugPrint = (
 ): void => {
   console.debug(`${node.getText()} -> ${newNodeText}`);
 
-  node.replaceWithText(newNodeText);
+  replaceNodeWithText(node, newNodeText);
 };