ts-codemod-lib 3.4.3 → 3.5.0

package/src/functions/ast-transformers/enable-no-unchecked-indexed-access.mts

@@ -56,7 +56,7 @@ const TRANSFORMER_NAME = 'enable-no-unchecked-indexed-access';
  *   enableNoUncheckedIndexedAccessTransformer(),
  * ]);
  *
- * assert.deepStrictEqual(
+ * assert.strictEqual(
  *   after.trim(),
  *   dedent`
  *     declare const xs: readonly number[];
@@ -169,6 +169,10 @@ const collectAssertionPositions = (
       noUncheckedIndexedAccess: true,
     });
 
+    // The type asked is the access's own, so an `as`, `satisfies` or `!` on
+    // its object is already in it. That is the type the option's error is
+    // reported against, and the `!` appended has no run-time effect for the
+    // unwrapped object to contradict.
     const widened = candidates.filter(
       (node) =>
         typeIncludesUndefined(node.getType()) &&

package/src/functions/ast-transformers/enable-no-unchecked-indexed-access.test.mts

@@ -481,6 +481,42 @@ describe(enableNoUncheckedIndexedAccessTransformer, () => {
     ])('$name', testFn);
   });
 
+  describe('objects judged by the type the access reads, through type wrappers', () => {
+    test.each([
+      {
+        name: 'as to an element type without undefined needs the assertion',
+        source: 'console.log((sparse as readonly number[])[0].toFixed());',
+        expected: 'console.log((sparse as readonly number[])[0]!.toFixed());',
+      },
+      {
+        name: 'as to an element type with undefined needs none',
+        source:
+          'console.log((xs as readonly (number | undefined)[])[0]?.toFixed());',
+        expected:
+          'console.log((xs as readonly (number | undefined)[])[0]?.toFixed());',
+      },
+      {
+        name: 'angle-bracket assertion to an element type without undefined',
+        source: 'console.log((<readonly number[]>sparse)[0].toFixed());',
+        expected: 'console.log((<readonly number[]>sparse)[0]!.toFixed());',
+      },
+      {
+        name: 'satisfies keeps the type of the object it wraps',
+        source:
+          'console.log((xs satisfies readonly (number | undefined)[])[0].toFixed());',
+        expected:
+          'console.log((xs satisfies readonly (number | undefined)[])[0]!.toFixed());',
+      },
+      {
+        name: 'non-null assertion on the object',
+        source:
+          'declare const maybe: readonly number[] | undefined; console.log(maybe![0].toFixed());',
+        expected:
+          'declare const maybe: readonly number[] | undefined; console.log(maybe![0]!.toFixed());',
+      },
+    ])('$name', testFn);
+  });
+
   describe('applyLevel: "avoidWhereUndefinedIsAllowed"', () => {
     test.each([
       {

package/src/functions/ast-transformers/replace-any-with-unknown.mts

@@ -4,6 +4,7 @@ import {
   isSpreadNamedTupleMemberNode,
   isSpreadParameterNode,
 } from '../functions/index.mjs';
+import { replaceNodeWithText } from '../utils/index.mjs';
 import type { TsMorphTransformer } from './types.mjs';
 
 const TRANSFORMER_NAME = 'replace-any-with-unknown';
@@ -37,12 +38,12 @@ const transformNode = (node: tsm.Node): void => {
         // `[name: E0, ...args: any)]` -> `[name: E0, ...args: unknown[]]`
         isSpreadNamedTupleMemberNode(parent))
     ) {
-      anyKeywordNode.replaceWithText('readonly unknown[]');
+      replaceNodeWithText(anyKeywordNode, 'readonly unknown[]');
 
       return;
     }
 
-    anyKeywordNode.replaceWithText('unknown');
+    replaceNodeWithText(anyKeywordNode, 'unknown');
 
     return;
   }

package/src/functions/ast-transformers/replace-record-with-unknown-record.mts

@@ -2,6 +2,7 @@
 import { Arr } from 'ts-data-forge';
 import * as tsm from 'ts-morph';
 import { hasDisableNextLineComment } from '../functions/index.mjs';
+import { replaceNodeWithText } from '../utils/index.mjs';
 import type { TsMorphTransformer } from './types.mjs';
 
 const TRANSFORMER_NAME = 'replace-record-with-unknown-record';
@@ -88,7 +89,8 @@ const processInterfaceDeclaration = (
 
     const interfaceName = interfaceDecl.getName();
 
-    interfaceDecl.replaceWithText(
+    replaceNodeWithText(
+      interfaceDecl,
       `${exportPrefix}type ${interfaceName} = UnknownRecord;`,
     );
 
@@ -128,7 +130,7 @@ const visitTypeNode = (node: tsm.TypeNode): boolean => {
             Arr.isFixedLengthArray(1, indexSigs) &&
             isStringUnknownIndexSignature(indexSigs[0])
           ) {
-            node.replaceWithText('UnknownRecord');
+            replaceNodeWithText(node, 'UnknownRecord');
 
             return true;
           }
@@ -156,7 +158,7 @@ const visitTypeNode = (node: tsm.TypeNode): boolean => {
       Arr.isFixedLengthArray(1, indexSigs) &&
       isStringUnknownIndexSignature(indexSigs[0])
     ) {
-      node.replaceWithText('UnknownRecord');
+      replaceNodeWithText(node, 'UnknownRecord');
 
       return true;
     }
@@ -229,7 +231,7 @@ const replaceIfRecordUnknown = (node: tsm.TypeReferenceNode): boolean => {
         typeArgs[0].getText() === 'string' &&
         typeArgs[1].getText() === 'unknown'
       ) {
-        node.replaceWithText('UnknownRecord');
+        replaceNodeWithText(node, 'UnknownRecord');
 
         return true;
       }
@@ -255,7 +257,7 @@ const replaceIfRecordUnknown = (node: tsm.TypeReferenceNode): boolean => {
               innerTypeArgs[0].getText() === 'string' &&
               innerTypeArgs[1].getText() === 'unknown'
             ) {
-              node.replaceWithText('UnknownRecord');
+              replaceNodeWithText(node, 'UnknownRecord');
 
               return true;
             }

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/functions/wrap-with-parentheses.mts

@@ -60,17 +60,17 @@ const isWrappedWithParentheses = (str: string): boolean => {
  * @example
  *
  * ```ts
- * assert.deepStrictEqual(wrapWithParentheses('A'), '(A)');
+ * assert.strictEqual(wrapWithParentheses('A'), '(A)');
  *
  * // already wrapped, so not '((A))'
- * assert.deepStrictEqual(wrapWithParentheses('(A)'), '(A)');
+ * assert.strictEqual(wrapWithParentheses('(A)'), '(A)');
  *
- * assert.deepStrictEqual(wrapWithParentheses('A | B'), '(A | B)');
+ * assert.strictEqual(wrapWithParentheses('A | B'), '(A | B)');
  *
- * assert.deepStrictEqual(wrapWithParentheses('(A | B)'), '(A | B)');
+ * assert.strictEqual(wrapWithParentheses('(A | B)'), '(A | B)');
  *
  * // the outer parentheses do not span everything, so a pair is added
- * assert.deepStrictEqual(wrapWithParentheses('(A) | (B)'), '((A) | (B))');
+ * assert.strictEqual(wrapWithParentheses('(A) | (B)'), '((A) | (B))');
  * ```
  */
 export const wrapWithParentheses = (nodeStr: string): string => {

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);
 };