@onrails/codemod 0.1.3 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onrails/codemod",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "Codemods for migrating onto @onrails/result (neverthrow → compat shim, and beyond)",
   "license": "MIT",
   "author": "Alan R. Soares",
@@ -42,9 +42,9 @@
     ".": "./src/index.ts"
   },
   "dependencies": {
-    "@onrails/maybe": "0.1.0",
-    "@onrails/pattern": "0.1.0",
-    "@onrails/result": "0.1.0",
+    "@onrails/maybe": "0.1.4",
+    "@onrails/pattern": "0.1.4",
+    "@onrails/result": "0.1.4",
     "typescript": "^6.0.3"
   },
   "scripts": {

package/src/chains.ts

@@ -1,4 +1,5 @@
 import { compactMap, isSome, type Maybe, map, none, some } from "@onrails/maybe";
+import { match } from "@onrails/pattern";
 import ts from "typescript";
 import { argsToText, edit, lookupMap, spanEdit, walkSource } from "./ast.js";
 import {
@@ -22,6 +23,21 @@ export function isSupportedChainCall(node: ts.Node): node is ts.CallExpression {
   return CHAIN_METHODS.has(method) || TERMINAL_METHODS.has(method);
 }
 
+const HELPERS = [
+  "sequenceTupleAsync",
+  "getOrElse",
+  "collect",
+  "matchResult",
+  "matchMaybe",
+  "fold",
+] as const;
+
+type HelperName = (typeof HELPERS)[number];
+
+function isHelperName(x: string): x is HelperName {
+  return (HELPERS as readonly string[]).includes(x);
+}
+
 function identifierCallToNative(node: ts.CallExpression): Maybe<Edit> {
   if (!ts.isIdentifier(node.expression)) return none();
   const name = node.expression.text;
@@ -30,24 +46,25 @@ function identifierCallToNative(node: ts.CallExpression): Maybe<Edit> {
     if (isSome(zero)) return zero;
   }
 
-  if (name === "sequenceTupleAsync") {
-    return some(edit(`ResultAsync.combineTuple(${argsToText(node.arguments)})`, ["ResultAsync"]));
-  }
-  if (name === "getOrElse") {
-    return some(edit(`unwrapOr(${argsToText(node.arguments)})`, ["unwrapOr"]));
-  }
-  if (name === "collect") {
-    return some(edit(`combine(${argsToText(node.arguments)})`, ["combine"]));
-  }
-  if (name === "matchResult" || name === "matchMaybe") {
-    return some(edit(`match(${argsToText(node.arguments)})`, ["match"]));
-  }
-  if (name === "fold") {
-    return map(foldHandlerTexts(node.arguments[0]), ({ okText, errText }) =>
-      edit(`match(${okText}, ${errText})`, ["match"]),
-    );
+  if (!isHelperName(name)) {
+    return none();
   }
-  return none();
+
+  return match(name)
+    .with("sequenceTupleAsync", () =>
+      some(edit(`ResultAsync.combineTuple(${argsToText(node.arguments)})`, ["ResultAsync"])),
+    )
+    .with("getOrElse", () => some(edit(`unwrapOr(${argsToText(node.arguments)})`, ["unwrapOr"])))
+    .with("collect", () => some(edit(`combine(${argsToText(node.arguments)})`, ["combine"])))
+    .withOneOf(["matchResult", "matchMaybe"], () =>
+      some(edit(`match(${argsToText(node.arguments)})`, ["match"])),
+    )
+    .with("fold", () =>
+      map(foldHandlerTexts(node.arguments[0]), ({ okText, errText }) =>
+        edit(`match(${okText}, ${errText})`, ["match"]),
+      ),
+    )
+    .exhaustive();
 }
 
 type FoldHandlerTexts = { okText: string; errText: string };
@@ -85,10 +102,11 @@ function curriedFoldToNative(node: ts.CallExpression): Maybe<Edit> {
     return none();
   }
   const receiver = node.arguments[0];
-  if (!receiver) return none();
-  return map(foldHandlerTexts(node.expression.arguments[0]), ({ okText, errText }) =>
-    edit(`match(${okText}, ${errText})(${receiver.getText()})`, ["match"]),
-  );
+  return !receiver
+    ? none()
+    : map(foldHandlerTexts(node.expression.arguments[0]), ({ okText, errText }) =>
+        edit(`match(${okText}, ${errText})(${receiver.getText()})`, ["match"]),
+      );
 }
 
 export function helperCallToNative(node: ts.CallExpression): Maybe<Edit> {

package/src/cli.ts

@@ -16,6 +16,7 @@ const applyArg = (s: ArgState, a: string): ArgState =>
     .returnType<ArgState>()
     .withEither("--dry", "-n", () => ({ ...s, dry: true }))
     .with("--to-native", () => ({ ...s, mode: "native" }))
+    .with("--tersify", () => ({ ...s, mode: "tersify" }))
     .with(
       (x) => x.startsWith(ONRAILS_FLAG),
       (x) => ({ ...s, onrails: resolve(x.slice(ONRAILS_FLAG.length)) }),
@@ -27,7 +28,7 @@ const applyArg = (s: ArgState, a: string): ArgState =>
     .otherwise(() => s);
 
 const USAGE =
-  "usage: onrails-codemod-neverthrow <target-dir> [--dry] [--to-native] [--onrails=<abs-path>]";
+  "usage: onrails-codemod-neverthrow <target-dir> [--dry] [--to-native] [--tersify] [--onrails=<abs-path>]";
 
 export function parseArgs(argv: string[]): Result<Args, string> {
   const initial: ArgState = {
@@ -37,15 +38,14 @@ export function parseArgs(argv: string[]): Result<Args, string> {
     onrails: resolve(import.meta.dir, "../../..", "packages/result"),
   };
   const { positional, dry, mode, onrails } = argv.reduce(applyArg, initial);
-  if (positional.length !== 1) {
-    return err(USAGE);
-  }
-  return ok({
-    target: resolve(positional[0] ?? "."),
-    dry,
-    onrails,
-    mode,
-  });
+  return positional.length !== 1
+    ? err(USAGE)
+    : ok({
+        target: resolve(positional[0] ?? "."),
+        dry,
+        onrails,
+        mode,
+      });
 }
 
 const shouldSkip = (path: string) => path.split("/").some((seg) => SKIP.has(seg));

package/src/file-change.ts

@@ -4,6 +4,7 @@ import { concatCollectors, countOccurrences } from "./ast.js";
 import { rewriteCompatMethodChainsToNative } from "./chains.js";
 import { COMPAT_SPEC, IMPORT_RE, NATIVE_SPEC } from "./constants.js";
 import { rewriteCompatImportsToNative } from "./imports.js";
+import { tersify } from "./tersify.js";
 import type { ComputedChange, FileChange, Mode, ModeStrategy } from "./types.js";
 import {
   collectNativeMigrationWarnings,
@@ -35,6 +36,13 @@ const MODES: Record<Mode, ModeStrategy> = {
     warnings: collectAllNativeWarnings,
     countAfter: (next) => countOccurrences(next, NATIVE_SPEC),
   },
+  tersify: {
+    countBefore: () => 0,
+    earlyExit: () => false,
+    transform: tersify,
+    warnings: () => [],
+    countAfter: () => 0,
+  },
 };
 
 export const computeFileChange = (src: string, mode: Mode): Maybe<ComputedChange> => {
@@ -44,8 +52,9 @@ export const computeFileChange = (src: string, mode: Mode): Maybe<ComputedChange
   const next = strat.transform(src);
   const changed = next !== src;
   const warnings = strat.warnings(next);
-  if (!changed && warnings.length === 0) return none();
-  return some({ next, before, after: strat.countAfter(next), changed, warnings });
+  return !changed && warnings.length === 0
+    ? none()
+    : some({ next, before, after: strat.countAfter(next), changed, warnings });
 };
 
 export const toFileChange = (path: string, c: ComputedChange): FileChange => ({

package/src/index.ts

@@ -6,6 +6,7 @@ export { main } from "./cli.js";
 export { computeFileChange } from "./file-change.js";
 export { rewriteCompatImportsToNative } from "./imports.js";
 export { computePkgRewrite } from "./pkg.js";
+export { tersify } from "./tersify.js";
 export { collectNativeMigrationWarnings } from "./warnings.js";
 
 if (import.meta.main) await main();

package/src/switch.ts

@@ -0,0 +1,209 @@
+import ts from "typescript";
+import type { Edit } from "./types.js";
+
+interface Comparison {
+  target: ts.Expression;
+  literal: ts.Expression;
+}
+
+function getComparison(node: ts.Expression): Comparison | undefined {
+  if (
+    ts.isBinaryExpression(node) &&
+    node.operatorToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken
+  ) {
+    const left = node.left;
+    const right = node.right;
+    const isLit = (n: ts.Expression) =>
+      ts.isLiteralExpression(n) ||
+      n.kind === ts.SyntaxKind.TrueKeyword ||
+      n.kind === ts.SyntaxKind.FalseKeyword ||
+      n.kind === ts.SyntaxKind.NullKeyword ||
+      (ts.isIdentifier(n) && n.text === "undefined");
+
+    if (isLit(left)) {
+      return { target: right, literal: left };
+    }
+    if (isLit(right)) {
+      return { target: left, literal: right };
+    }
+  }
+  return undefined;
+}
+
+function getComparisons(node: ts.Expression, list: Comparison[] = []): Comparison[] | undefined {
+  if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
+    const left = getComparisons(node.left, list);
+    if (!left) return undefined;
+    const right = getComparisons(node.right, list);
+    return !right ? undefined : list;
+  }
+  const comp = getComparison(node);
+  if (comp) {
+    list.push(comp);
+    return list;
+  }
+  return undefined;
+}
+
+function isSimpleTarget(node: ts.Expression): boolean {
+  if (ts.isIdentifier(node)) {
+    return true;
+  }
+  if (ts.isPropertyAccessExpression(node)) {
+    return isSimpleTarget(node.expression);
+  }
+  return false;
+}
+
+function endsWithReturn(statement: ts.Statement): boolean {
+  if (ts.isReturnStatement(statement)) {
+    return true;
+  }
+  if (ts.isBlock(statement)) {
+    const last = statement.statements[statement.statements.length - 1];
+    return last ? endsWithReturn(last) : false;
+  }
+  return false;
+}
+
+function getLinePrefix(pos: number, sf: ts.SourceFile): string {
+  const lineStarts = sf.getLineStarts();
+  const { line } = ts.getLineAndCharacterOfPosition(sf, pos);
+  const lineStart = lineStarts[line];
+  if (lineStart === undefined) return "";
+  const lineText = sf.text.slice(lineStart, pos);
+  const match = /^[ \t]+$/.exec(lineText);
+  return match ? lineText : "";
+}
+
+interface SwitchSequence {
+  seq: ts.IfStatement[];
+  targetText: string;
+}
+
+function findSwitchSequence(
+  statements: readonly ts.Statement[],
+  startIndex: number,
+  sf: ts.SourceFile,
+): SwitchSequence | undefined {
+  const seq: ts.IfStatement[] = [];
+  let targetText: string | undefined;
+
+  let j = startIndex;
+  while (j < statements.length) {
+    const s = statements[j];
+    if (!s || !ts.isIfStatement(s) || s.elseStatement) {
+      break;
+    }
+    const comps = getComparisons(s.expression, []);
+    if (!comps || comps.length === 0) {
+      break;
+    }
+    const target = comps[0]?.target;
+    if (!target || !isSimpleTarget(target)) {
+      break;
+    }
+    const tText = target.getText(sf);
+    if (targetText === undefined) {
+      targetText = tText;
+    } else if (targetText !== tText) {
+      break;
+    }
+    const allSame = comps.every((c) => c.target.getText(sf) === targetText);
+    if (!allSame) {
+      break;
+    }
+
+    seq.push(s);
+    j++;
+  }
+
+  return seq.length >= 3 && targetText !== undefined ? { seq, targetText } : undefined;
+}
+
+function buildSwitchStatement(
+  seq: readonly ts.IfStatement[],
+  targetText: string,
+  prefix: string,
+  sf: ts.SourceFile,
+): string {
+  let switchText = `switch (${targetText}) {\n`;
+  for (const s of seq) {
+    const comps = getComparisons(s.expression, []);
+    if (comps) {
+      for (const c of comps) {
+        switchText += `${prefix}  case ${c.literal.getText(sf)}:\n`;
+      }
+    }
+    let bodyText = "";
+    if (ts.isBlock(s.thenStatement)) {
+      bodyText = s.thenStatement.statements
+        .map((stmt) => {
+          const stmtPrefix = getLinePrefix(stmt.getStart(sf), sf);
+          return stmt
+            .getText(sf)
+            .split("\n")
+            .map((line) =>
+              line.startsWith(stmtPrefix)
+                ? `${prefix}    ${line.slice(stmtPrefix.length)}`
+                : `${prefix}    ${line.trimStart()}`,
+            )
+            .join("\n");
+        })
+        .join("\n");
+    } else {
+      const stmtPrefix = getLinePrefix(s.thenStatement.getStart(sf), sf);
+      bodyText = s.thenStatement
+        .getText(sf)
+        .split("\n")
+        .map((line) =>
+          line.startsWith(stmtPrefix)
+            ? `${prefix}    ${line.slice(stmtPrefix.length)}`
+            : `${prefix}    ${line.trimStart()}`,
+        )
+        .join("\n");
+    }
+    switchText += `${bodyText}\n`;
+    if (!endsWithReturn(s.thenStatement)) {
+      switchText += `${prefix}    break;\n`;
+    }
+  }
+  switchText += `${prefix}}`;
+  return switchText;
+}
+
+export function scanIfToSwitchSequences(
+  node: ts.Node,
+  sf: ts.SourceFile,
+  skippedNodes: Set<ts.Node>,
+  edits: Edit[],
+): void {
+  if (ts.isBlock(node) || ts.isSourceFile(node)) {
+    const statements = node.statements;
+    let i = 0;
+    while (i < statements.length) {
+      const result = findSwitchSequence(statements, i, sf);
+      if (result) {
+        const { seq, targetText } = result;
+        const firstSeq = seq[0];
+        const lastSeq = seq[seq.length - 1];
+        if (firstSeq && lastSeq) {
+          const prefix = getLinePrefix(firstSeq.getStart(sf), sf);
+          const switchText = buildSwitchStatement(seq, targetText, prefix, sf);
+
+          for (const s of seq) {
+            skippedNodes.add(s);
+          }
+          edits.push({
+            start: firstSeq.getStart(sf),
+            end: lastSeq.getEnd(),
+            text: switchText,
+            imports: [],
+          });
+          i += seq.length - 1;
+        }
+      }
+      i++;
+    }
+  }
+}

package/src/tersify.ts

@@ -0,0 +1,470 @@
+import { type Maybe, none, some } from "@onrails/maybe";
+import ts from "typescript";
+import { edit, spanEdit, walkSource } from "./ast.js";
+import { applyEditStep, byStartDesc } from "./chains.js";
+import { scanIfToSwitchSequences } from "./switch.js";
+import type { Edit } from "./types.js";
+
+// Helper to check for single statement return
+function getSingleReturnExpression(statement: ts.Statement): ts.Expression | undefined {
+  if (ts.isReturnStatement(statement)) {
+    return statement.expression;
+  }
+  if (ts.isBlock(statement)) {
+    if (statement.statements.length === 1) {
+      const single = statement.statements[0];
+      if (single && ts.isReturnStatement(single)) {
+        return single.expression;
+      }
+    }
+  }
+  return undefined;
+}
+
+// Helper to check if body uses 'this' or 'arguments'
+function usesThisOrArguments(body: ts.Node): boolean {
+  let found = false;
+  const visit = (n: ts.Node) => {
+    if (found) return;
+    if (n.kind === ts.SyntaxKind.ThisKeyword) {
+      found = true;
+      return;
+    }
+    if (ts.isIdentifier(n) && n.text === "arguments") {
+      found = true;
+      return;
+    }
+    if (
+      ts.isFunctionDeclaration(n) ||
+      ts.isFunctionExpression(n) ||
+      ts.isArrowFunction(n) ||
+      ts.isMethodDeclaration(n) ||
+      ts.isGetAccessorDeclaration(n) ||
+      ts.isSetAccessorDeclaration(n)
+    ) {
+      return; // Stop recursion for nested scopes
+    }
+    ts.forEachChild(n, visit);
+  };
+  ts.forEachChild(body, visit);
+  return found;
+}
+
+// Helper to check if identifier referenced before pos
+function isIdentifierReferencedBefore(name: string, pos: number, sf: ts.SourceFile): boolean {
+  let referenced = false;
+  const visit = (n: ts.Node) => {
+    if (referenced) return;
+    if (n.getStart(sf) >= pos) return;
+    if (ts.isIdentifier(n) && n.text === name) {
+      const parent = n.parent;
+      if (parent) {
+        if (ts.isPropertyAccessExpression(parent) && parent.name === n) {
+          return;
+        }
+        if (ts.isPropertyAssignment(parent) && parent.name === n) {
+          return;
+        }
+        if (ts.isMethodDeclaration(parent) && parent.name === n) {
+          return;
+        }
+        if (ts.isPropertyDeclaration(parent) && parent.name === n) {
+          return;
+        }
+        if (ts.isBindingElement(parent) && parent.propertyName === n) {
+          return;
+        }
+      }
+      referenced = true;
+      return;
+    }
+    ts.forEachChild(n, visit);
+  };
+  ts.forEachChild(sf, visit);
+  return referenced;
+}
+
+function getTypeParametersText(
+  node: ts.FunctionDeclaration | ts.FunctionExpression,
+  sf: ts.SourceFile,
+): string {
+  if (node.typeParameters && node.typeParameters.length > 0) {
+    const params = node.typeParameters.map((p) => p.getText(sf));
+    return params.length === 1 ? `<${params[0]},>` : `<${params.join(", ")}>`;
+  }
+  return "";
+}
+
+const isSimpleExpression = (expr: ts.Expression): boolean =>
+  ts.isIdentifier(expr) ||
+  ts.isPropertyAccessExpression(expr) ||
+  ts.isElementAccessExpression(expr) ||
+  ts.isCallExpression(expr);
+
+function containsConditional(node: ts.Node): boolean {
+  if (ts.isConditionalExpression(node)) {
+    return true;
+  }
+  let found = false;
+  ts.forEachChild(node, (child) => {
+    if (found) return;
+    if (containsConditional(child)) {
+      found = true;
+    }
+  });
+  return found;
+}
+
+function tryTersifyIfElse(node: ts.Node, sf: ts.SourceFile): Maybe<Edit> {
+  if (ts.isIfStatement(node) && node.elseStatement) {
+    const x = getSingleReturnExpression(node.thenStatement);
+    const y = getSingleReturnExpression(node.elseStatement);
+    if (x && y) {
+      if (containsConditional(x) || containsConditional(y)) {
+        return none();
+      }
+      const condText = node.expression.getText(sf);
+      const xIsTrue = x.kind === ts.SyntaxKind.TrueKeyword;
+      const xIsFalse = x.kind === ts.SyntaxKind.FalseKeyword;
+      const yIsTrue = y.kind === ts.SyntaxKind.TrueKeyword;
+      const yIsFalse = y.kind === ts.SyntaxKind.FalseKeyword;
+
+      if (xIsTrue && yIsFalse) {
+        return some(spanEdit(node, sf, edit(`return ${condText};`)));
+      }
+      if (xIsFalse && yIsTrue) {
+        const needsParens = !isSimpleExpression(node.expression);
+        const text = needsParens ? `return !(${condText});` : `return !${condText};`;
+        return some(spanEdit(node, sf, edit(text)));
+      }
+
+      const xText = x.getText(sf);
+      const yText = y.getText(sf);
+      return some(spanEdit(node, sf, edit(`return ${condText} ? ${xText} : ${yText};`)));
+    }
+  }
+  return none();
+}
+
+// A concise arrow body that is — or unwraps through `as` / `satisfies` to — an
+// object literal must be parenthesized, else `{ … }` parses as a block body.
+function startsWithObjectLiteral(expr: ts.Expression): boolean {
+  let e: ts.Expression = expr;
+  while (ts.isAsExpression(e) || ts.isSatisfiesExpression(e)) {
+    e = e.expression;
+  }
+  return ts.isObjectLiteralExpression(e);
+}
+
+function tryTersifyArrowBlock(node: ts.Node, sf: ts.SourceFile): Maybe<Edit> {
+  if (ts.isArrowFunction(node) && ts.isBlock(node.body)) {
+    const expr = getSingleReturnExpression(node.body);
+    if (expr) {
+      const exprText = expr.getText(sf);
+      const text = startsWithObjectLiteral(expr) ? `(${exprText})` : exprText;
+      return some(spanEdit(node.body, sf, edit(text)));
+    }
+  }
+  return none();
+}
+
+function tryTersifyFunctionExpression(node: ts.Node, sf: ts.SourceFile): Maybe<Edit> {
+  if (ts.isFunctionExpression(node) && !node.name && !node.asteriskToken) {
+    const expr = getSingleReturnExpression(node.body);
+    if (expr && !usesThisOrArguments(node.body)) {
+      const asyncKeyword = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)
+        ? "async "
+        : "";
+      const typeParamsText = getTypeParametersText(node, sf);
+      const paramsText = node.parameters.map((p) => p.getText(sf)).join(", ");
+      const returnType = node.type ? `: ${node.type.getText(sf)}` : "";
+      const exprText = expr.getText(sf);
+      const bodyText = startsWithObjectLiteral(expr) ? `(${exprText})` : exprText;
+      const text = `${asyncKeyword}${typeParamsText}(${paramsText})${returnType} => ${bodyText}`;
+      return some(spanEdit(node, sf, edit(text)));
+    }
+  }
+  return none();
+}
+
+function tryTersifyFunctionDeclaration(node: ts.Node, sf: ts.SourceFile): Maybe<Edit> {
+  if (ts.isFunctionDeclaration(node) && node.name && node.body && !node.asteriskToken) {
+    const isDefault = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword);
+    if (!isDefault) {
+      const expr = getSingleReturnExpression(node.body);
+      if (expr && !usesThisOrArguments(node.body)) {
+        const nameText = node.name.getText(sf);
+        if (!isIdentifierReferencedBefore(nameText, node.getStart(sf), sf)) {
+          const isExported = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+          const asyncKeyword = node.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword)
+            ? "async "
+            : "";
+          const typeParamsText = getTypeParametersText(node, sf);
+          const paramsText = node.parameters.map((p) => p.getText(sf)).join(", ");
+          const returnType = node.type ? `: ${node.type.getText(sf)}` : "";
+          const exprText = expr.getText(sf);
+          const bodyText = startsWithObjectLiteral(expr) ? `(${exprText})` : exprText;
+          const exportPrefix = isExported ? "export " : "";
+          const text = `${exportPrefix}const ${nameText} = ${asyncKeyword}${typeParamsText}(${paramsText})${returnType} => ${bodyText};`;
+          return some(spanEdit(node, sf, edit(text)));
+        }
+      }
+    }
+  }
+  return none();
+}
+
+function tryTersifyPropertyAssignment(node: ts.Node, sf: ts.SourceFile): Maybe<Edit> {
+  if (ts.isPropertyAssignment(node)) {
+    if (
+      ts.isIdentifier(node.name) &&
+      ts.isIdentifier(node.initializer) &&
+      node.name.text === node.initializer.text
+    ) {
+      return some(spanEdit(node, sf, edit(node.name.text)));
+    }
+  }
+  return none();
+}
+
+function tryTersifyNoSubstitutionTemplateLiteral(node: ts.Node, sf: ts.SourceFile): Maybe<Edit> {
+  if (ts.isNoSubstitutionTemplateLiteral(node)) {
+    if (node.parent && ts.isTaggedTemplateExpression(node.parent)) {
+      return none();
+    }
+    const rawText = node.getText(sf);
+    const content = rawText.slice(1, -1);
+    if (!content.includes("\n") && !content.includes("\r") && !content.includes('"')) {
+      return some(spanEdit(node, sf, edit(`"${content}"`)));
+    }
+  }
+  return none();
+}
+
+function tryTersifyIdentityFilter(node: ts.Node, sf: ts.SourceFile): Maybe<Edit> {
+  if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+    if (node.parameters.length === 1) {
+      const param = node.parameters[0];
+      if (param && ts.isIdentifier(param.name)) {
+        const paramName = param.name.text;
+        const body = node.body;
+        const expr = ts.isBlock(body) ? getSingleReturnExpression(body) : body;
+
+        if (expr) {
+          const isDirectIdentity = ts.isIdentifier(expr) && expr.text === paramName;
+          let isDoubleNegatedIdentity = false;
+          if (
+            ts.isPrefixUnaryExpression(expr) &&
+            expr.operator === ts.SyntaxKind.ExclamationToken &&
+            ts.isPrefixUnaryExpression(expr.operand) &&
+            expr.operand.operator === ts.SyntaxKind.ExclamationToken &&
+            ts.isIdentifier(expr.operand.operand) &&
+            expr.operand.operand.text === paramName
+          ) {
+            isDoubleNegatedIdentity = true;
+          }
+
+          if (isDirectIdentity || isDoubleNegatedIdentity) {
+            const parent = node.parent;
+            if (
+              parent &&
+              ts.isCallExpression(parent) &&
+              parent.arguments.includes(node as ts.Expression)
+            ) {
+              if (ts.isPropertyAccessExpression(parent.expression)) {
+                const method = parent.expression.name.text;
+                if (
+                  method === "filter" ||
+                  method === "some" ||
+                  method === "every" ||
+                  method === "find"
+                ) {
+                  return some(spanEdit(node, sf, edit("Boolean")));
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  return none();
+}
+
+function tryTersifyOptionalChainGuard(
+  stmt: ts.IfStatement,
+  nextStmt: ts.ReturnStatement,
+  sf: ts.SourceFile,
+): Maybe<Edit> {
+  const firstStmt = ts.isBlock(stmt.thenStatement) ? stmt.thenStatement.statements[0] : undefined;
+  const isThenEmptyReturn =
+    (ts.isReturnStatement(stmt.thenStatement) && !stmt.thenStatement.expression) ||
+    (ts.isBlock(stmt.thenStatement) &&
+      stmt.thenStatement.statements.length === 1 &&
+      firstStmt &&
+      ts.isReturnStatement(firstStmt) &&
+      !firstStmt.expression);
+
+  if (
+    isThenEmptyReturn &&
+    ts.isPrefixUnaryExpression(stmt.expression) &&
+    stmt.expression.operator === ts.SyntaxKind.ExclamationToken &&
+    nextStmt.expression &&
+    ts.isPropertyAccessExpression(nextStmt.expression)
+  ) {
+    const target = stmt.expression.operand;
+    const accessExpr = nextStmt.expression;
+    if (accessExpr.expression.getText(sf) === target.getText(sf)) {
+      const targetText = target.getText(sf);
+      const propName = accessExpr.name.getText(sf);
+      const text = `return ${targetText}?.${propName};`;
+      return some({
+        start: stmt.getStart(sf),
+        end: nextStmt.getEnd(),
+        text,
+        imports: [],
+      });
+    }
+  }
+  return none();
+}
+
+function tryTersifyTernaryOrBooleanSequence(
+  stmt: ts.IfStatement,
+  nextStmt: ts.ReturnStatement,
+  sf: ts.SourceFile,
+): Maybe<Edit> {
+  const x = getSingleReturnExpression(stmt.thenStatement);
+  const y = nextStmt.expression;
+  if (x && y) {
+    if (containsConditional(x) || containsConditional(y)) {
+      return none();
+    }
+    const condText = stmt.expression.getText(sf);
+    const xIsTrue = x.kind === ts.SyntaxKind.TrueKeyword;
+    const xIsFalse = x.kind === ts.SyntaxKind.FalseKeyword;
+    const yIsTrue = y.kind === ts.SyntaxKind.TrueKeyword;
+    const yIsFalse = y.kind === ts.SyntaxKind.FalseKeyword;
+
+    let text = "";
+    if (xIsTrue && yIsFalse) {
+      text = `return ${condText};`;
+    } else if (xIsFalse && yIsTrue) {
+      const needsParens = !isSimpleExpression(stmt.expression);
+      text = needsParens ? `return !(${condText});` : `return !${condText};`;
+    } else {
+      const xText = x.getText(sf);
+      const yText = y.getText(sf);
+      text = `return ${condText} ? ${xText} : ${yText};`;
+    }
+
+    return some({
+      start: stmt.getStart(sf),
+      end: nextStmt.getEnd(),
+      text,
+      imports: [],
+    });
+  }
+  return none();
+}
+
+function scanIfReturnSequences(
+  node: ts.Node,
+  sf: ts.SourceFile,
+  skippedNodes: Set<ts.Node>,
+  edits: Edit[],
+): void {
+  if (ts.isBlock(node) || ts.isSourceFile(node)) {
+    const statements = node.statements;
+    for (let i = 0; i < statements.length - 1; i++) {
+      const stmt = statements[i];
+      const nextStmt = statements[i + 1];
+      if (
+        stmt &&
+        nextStmt &&
+        ts.isIfStatement(stmt) &&
+        !stmt.elseStatement &&
+        ts.isReturnStatement(nextStmt)
+      ) {
+        // If this IfStatement is part of a sequence of IfStatements, do not convert it.
+        // We detect this by checking if the previous statement is also an IfStatement.
+        const prev = statements[i - 1];
+        if (prev && ts.isIfStatement(prev)) {
+          continue;
+        }
+
+        const optChainEdit = tryTersifyOptionalChainGuard(stmt, nextStmt, sf);
+        if (optChainEdit._tag === "Some") {
+          skippedNodes.add(stmt);
+          skippedNodes.add(nextStmt);
+          edits.push(optChainEdit.value);
+          continue;
+        }
+
+        const seqEdit = tryTersifyTernaryOrBooleanSequence(stmt, nextStmt, sf);
+        if (seqEdit._tag === "Some") {
+          skippedNodes.add(stmt);
+          skippedNodes.add(nextStmt);
+          edits.push(seqEdit.value);
+        }
+      }
+    }
+  }
+}
+
+const TRANSFORMS: ReadonlyArray<(node: ts.Node, sf: ts.SourceFile) => Maybe<Edit>> = [
+  tryTersifyIfElse,
+  tryTersifyArrowBlock,
+  tryTersifyFunctionExpression,
+  tryTersifyFunctionDeclaration,
+  tryTersifyPropertyAssignment,
+  tryTersifyNoSubstitutionTemplateLiteral,
+  tryTersifyIdentityFilter,
+];
+
+function tersifyOnce(src: string): string {
+  const edits: Edit[] = [];
+  const skippedNodes = new Set<ts.Node>();
+
+  walkSource(src, (node, sf) => {
+    if (skippedNodes.has(node)) {
+      return true;
+    }
+
+    scanIfReturnSequences(node, sf, skippedNodes, edits);
+    scanIfToSwitchSequences(node, sf, skippedNodes, edits);
+
+    for (const transform of TRANSFORMS) {
+      const editResult = transform(node, sf);
+      if (editResult._tag === "Some") {
+        edits.push(editResult.value);
+        skippedNodes.add(node);
+        return true;
+      }
+    }
+
+    return false;
+  });
+
+  if (edits.length === 0) return src;
+
+  const { src: next } = edits
+    .sort(byStartDesc)
+    .reduce(applyEditStep, { src, imports: new Set<string>() });
+
+  return next;
+}
+
+export function tersify(src: string): string {
+  let current = src;
+  let iterations = 0;
+  while (iterations < 10) {
+    const next = tersifyOnce(current);
+    if (next === current) {
+      break;
+    }
+    current = next;
+    iterations++;
+  }
+  return current;
+}

package/src/types.ts

@@ -1,4 +1,4 @@
-export type Mode = "compat" | "native";
+export type Mode = "compat" | "native" | "tersify";
 export type Args = { target: string; dry: boolean; onrails: string; mode: Mode };
 
 export type Warning = { line: number; label: string; text: string };