@onrails/codemod 0.2.0 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onrails/codemod",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "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.4",
-    "@onrails/pattern": "0.1.4",
-    "@onrails/result": "0.1.4",
+    "@onrails/maybe": "0.2.0",
+    "@onrails/pattern": "0.2.0",
+    "@onrails/result": "0.2.0",
     "typescript": "^6.0.3"
   },
   "scripts": {

package/src/ast.ts

@@ -21,8 +21,19 @@ export const concatCollectors =
 export const walkSource = (
   src: string,
   visit: (node: ts.Node, sf: ts.SourceFile) => unknown,
+  jsx = false,
 ): void => {
-  const sf = ts.createSourceFile("codemod.ts", src, ts.ScriptTarget.Latest, true);
+  // Parse JSX files in TSX mode — otherwise `<`/`>` are read as comparison
+  // operators and `<T>expr` as a cast, which truncates node boundaries and
+  // corrupts span-based edits. The scriptKind is set explicitly (not just via
+  // the filename) so it can't drift from the extension.
+  const sf = ts.createSourceFile(
+    jsx ? "codemod.tsx" : "codemod.ts",
+    src,
+    ts.ScriptTarget.Latest,
+    true,
+    jsx ? ts.ScriptKind.TSX : ts.ScriptKind.TS,
+  );
   const go = (n: ts.Node) => {
     if (visit(n, sf)) return;
     ts.forEachChild(n, go);

package/src/boundary-spec.ts

@@ -0,0 +1,153 @@
+/**
+ * boundary-spec.ts — the single owning module for the boundary idioms
+ * onrails enforces on consumers:
+ *
+ * 1. no `Promise<Result<…>>` in public signatures (`no-promise-result`)
+ * 2. no unsafe unwraps outside tests (`no-unsafe-unwrap`)
+ * 3. no deprecated neverthrow-era synonyms (`no-deprecated-synonyms`)
+ *
+ * The ESLint plugin (plain JS, `packages/eslint-plugin/src/index.js`) and the
+ * Biome plugin (GritQL, `packages/biome-plugin/rules/*.grit`) cannot import
+ * this module — cross-package imports are forbidden — so they hand-copy the
+ * names. `packages/codemod/test/boundary-conformance.spec.ts` reads those
+ * artifacts off disk and asserts they stay in sync with this spec.
+ *
+ * Deliberate per-engine divergences are declared in `ENGINE_DIVERGENCES`;
+ * anything not declared there is drift.
+ */
+
+// ---------------------------------------------------------------------------
+// Unsafe unwraps
+// ---------------------------------------------------------------------------
+
+/**
+ * neverthrow-compat unsafe-unwrap methods → native named equivalents.
+ * The codemod rewrites `r._unsafeUnwrap()` to `unwrapOk(r)`; the natives are
+ * still unsafe (throw on the wrong branch) and stay lint-flagged.
+ */
+export const UNSAFE_UNWRAP_MEMBER_RENAMES: ReadonlyMap<string, string> = new Map([
+  ["_unsafeUnwrap", "unwrapOk"],
+  ["_unsafeUnwrapErr", "unwrapErr"],
+]);
+
+/** Free-function unwraps that throw on the unhappy branch. */
+export const UNSAFE_UNWRAP_CALL_NAMES = ["unwrapOk", "unwrapErr", "unwrap"] as const;
+
+/** Every identifier the `no-unsafe-unwrap` rule flags, across engines. */
+export const UNSAFE_UNWRAP_NAMES: ReadonlySet<string> = new Set([
+  ...UNSAFE_UNWRAP_MEMBER_RENAMES.keys(),
+  ...UNSAFE_UNWRAP_CALL_NAMES,
+]);
+
+/**
+ * Matches compat unsafe-unwrap member calls (`._unsafeUnwrap(` /
+ * `._unsafeUnwrapErr(`) in raw source. Derived from the rename map so the
+ * codemod's compat-only detection cannot drift from the spec.
+ */
+export const UNSAFE_UNWRAP_MEMBER_CALL_RE = new RegExp(
+  String.raw`\.(?:${[...UNSAFE_UNWRAP_MEMBER_RENAMES.keys()].join("|")})\s*\(`,
+);
+
+// ---------------------------------------------------------------------------
+// Deprecated synonyms
+// ---------------------------------------------------------------------------
+
+export interface DeprecatedSynonym {
+  /** The deprecated identifier as it appears in consumer code. */
+  readonly name: string;
+  /** `method` — flagged as `x.name(…)`; `call` — flagged as `name(…)`. */
+  readonly form: "method" | "call";
+  /** Canonical replacement identifier. */
+  readonly canonical: string;
+  /** Extra guidance when the rename is not a plain identifier swap. */
+  readonly hint?: string;
+}
+
+/**
+ * Deprecated neverthrow/fp-era synonyms → canonical onrails names.
+ * Matching is name-based in every engine — neither GritQL nor the ESLint
+ * rules scope by import, so same-named calls from other libraries (RxJS
+ * `of`, fp-ts `fold`) are flagged too.
+ */
+export const DEPRECATED_SYNONYMS: readonly DeprecatedSynonym[] = [
+  { name: "chain", form: "method", canonical: "flatMap" },
+  {
+    name: "isOk",
+    form: "method",
+    canonical: "isOk",
+    hint: "await the ResultAsync, then narrow with the isOk() free function",
+  },
+  {
+    name: "isErr",
+    form: "method",
+    canonical: "isErr",
+    hint: "await the ResultAsync, then narrow with the isErr() free function",
+  },
+  { name: "fold", form: "call", canonical: "match" },
+  { name: "matchResult", form: "call", canonical: "match" },
+  { name: "matchMaybe", form: "call", canonical: "match" },
+  { name: "getOrElse", form: "call", canonical: "unwrapOr" },
+  { name: "sequenceTupleAsync", form: "call", canonical: "ResultAsync.combineTuple" },
+  { name: "collect", form: "call", canonical: "combine" },
+  { name: "of", form: "call", canonical: "ok", hint: "or some() for Maybe" },
+];
+
+/** Flat old-name → canonical-name view of {@link DEPRECATED_SYNONYMS}. */
+export const DEPRECATED_SYNONYM_RENAMES: ReadonlyMap<string, string> = new Map(
+  DEPRECATED_SYNONYMS.map((s) => [s.name, s.canonical]),
+);
+
+// ---------------------------------------------------------------------------
+// Rule descriptors
+// ---------------------------------------------------------------------------
+
+/** `Promise<Result<…>>` in a type position → `ResultAsync<T, E>`. */
+export const NO_PROMISE_RESULT_RULE = {
+  id: "no-promise-result",
+  replacement: "ResultAsync",
+  boundaryHelpers: ["fromAsync", "tryAsync"],
+  message:
+    "Promise<Result<…>> in a type position — use ResultAsync<T, E> at the boundary (fromAsync / tryAsync).",
+} as const;
+
+/** Unsafe unwraps outside tests. Message is shared verbatim by both engines. */
+export const NO_UNSAFE_UNWRAP_RULE = {
+  id: "no-unsafe-unwrap",
+  message:
+    "Avoid _unsafeUnwrap* and unwrap* outside tests — use match(), resolve(), or yieldResult() in tryGen.",
+} as const;
+
+/** Deprecated synonym identifiers. Per-engine message wording differs. */
+export const NO_DEPRECATED_SYNONYMS_RULE = {
+  id: "no-deprecated-synonyms",
+} as const;
+
+// ---------------------------------------------------------------------------
+// Declared divergences
+// ---------------------------------------------------------------------------
+
+export interface EngineDivergence {
+  readonly rule: string;
+  /** Engine whose behaviour differs from the other(s). */
+  readonly engine: "eslint" | "biome" | "codemod";
+  /** Stable id the conformance test keys on. */
+  readonly divergence: string;
+  readonly detail: string;
+}
+
+/**
+ * Deliberate cross-engine behaviour differences. The conformance test treats
+ * these as declared (allowed); any other difference is accidental drift.
+ */
+export const ENGINE_DIVERGENCES: readonly EngineDivergence[] = [
+  {
+    rule: "no-unsafe-unwrap",
+    engine: "biome",
+    divergence: "no-test-file-exemption",
+    detail:
+      "The ESLint rule skips *.spec.* / *.test.* files where unsafe unwraps are " +
+      "acceptable; GritQL patterns cannot read the file path, so the Biome rule " +
+      "flags test code too. Suppress with a biome-ignore comment or a linter " +
+      "override for test globs.",
+  },
+];

package/src/chains.ts

@@ -213,28 +213,32 @@ export const applyEditStep = (acc: EditAcc, e: Edit): EditAcc => ({
   imports: new Set([...acc.imports, ...e.imports]),
 });
 
-export function rewriteCompatMethodChainsToNative(src: string): string {
+export function rewriteCompatMethodChainsToNative(src: string, jsx = false): string {
   const edits: Edit[] = [];
 
-  walkSource(src, (node, sf) => {
-    if (ts.isCallExpression(node)) {
-      const helper = helperCallToNative(node);
-      if (isSome(helper)) {
-        edits.push(spanEdit(node, sf, helper.value));
-        return true;
+  walkSource(
+    src,
+    (node, sf) => {
+      if (ts.isCallExpression(node)) {
+        const helper = helperCallToNative(node);
+        if (isSome(helper)) {
+          edits.push(spanEdit(node, sf, helper.value));
+          return true;
+        }
       }
-    }
 
-    if (
-      isSupportedChainCall(node) &&
-      !isNestedInSupportedChain(node) &&
-      !ts.isPropertyAccessExpression(node.parent)
-    ) {
-      const chain = collectChain(node);
-      const chained = chainToNative(chain.base, chain.steps);
-      if (isSome(chained)) edits.push(spanEdit(node, sf, chained.value));
-    }
-  });
+      if (
+        isSupportedChainCall(node) &&
+        !isNestedInSupportedChain(node) &&
+        !ts.isPropertyAccessExpression(node.parent)
+      ) {
+        const chain = collectChain(node);
+        const chained = chainToNative(chain.base, chain.steps);
+        if (isSome(chained)) edits.push(spanEdit(node, sf, chained.value));
+      }
+    },
+    jsx,
+  );
 
   if (edits.length === 0) return src;
 

package/src/cli.ts

@@ -3,7 +3,7 @@ import * as Maybe from "@onrails/maybe";
 import { match } from "@onrails/pattern";
 import { err, isErr, ok, type Result, ResultAsync } from "@onrails/result";
 import { Glob } from "bun";
-import { CODE_EXT, SKIP } from "./constants.js";
+import { CODE_EXT, JSX_EXT, SKIP } from "./constants.js";
 import { computeFileChange, toFileChange } from "./file-change.js";
 import { readFileText, writeFileText } from "./io.js";
 import { rewritePkg } from "./pkg.js";
@@ -64,7 +64,7 @@ const rewriteCode = (
 ): ResultAsync<Maybe.Maybe<FileChange>, Error> =>
   readFileText(path).flatMap((src) =>
     Maybe.match(
-      computeFileChange(src, mode),
+      computeFileChange(src, mode, JSX_EXT.test(path)),
       (c) => {
         const change = toFileChange(path, c);
         return c.changed && !dry

package/src/constants.ts

@@ -1,3 +1,5 @@
+import { UNSAFE_UNWRAP_MEMBER_CALL_RE, UNSAFE_UNWRAP_MEMBER_RENAMES } from "./boundary-spec.js";
+
 export const SKIP = new Set([
   "node_modules",
   "dist",
@@ -8,6 +10,7 @@ export const SKIP = new Set([
   "build",
 ]);
 export const CODE_EXT = /\.(ts|tsx|mts|cts)$/;
+export const JSX_EXT = /\.(tsx|jsx)$/;
 export const IMPORT_RE = /(from\s+|import\s*\(\s*)(['"])neverthrow\2/g;
 export const COMPAT_SPEC = "@onrails/result/compat/neverthrow";
 export const NATIVE_SPEC = "@onrails/result";
@@ -15,7 +18,7 @@ export const DEP_KEYS = ["dependencies", "devDependencies", "peerDependencies"]
 export const TYPE_ONLY_NATIVE = new Set(["Result", "Ok", "Err", "UnexpectedError"]);
 export const COMPAT_ONLY_PATTERNS = [
   { pattern: /\bResult\.(combine|fromThrowable)\b/, label: "Result static helper" },
-  { pattern: /\._unsafeUnwrap(Err)?\s*\(/, label: "unsafe compat unwrap" },
+  { pattern: UNSAFE_UNWRAP_MEMBER_CALL_RE, label: "unsafe compat unwrap" },
 ] as const;
 export const RESULT_SPECIFIC_CHAIN_METHODS = new Set([
   "andThen",
@@ -56,8 +59,5 @@ export const TEE_METHODS = new Map([
   ["orTee", "tapErr"],
 ]);
 export const PREDICATE_METHODS = new Set(["isOk", "isErr"]);
-export const UNSAFE_UNWRAP_METHODS = new Map([
-  ["_unsafeUnwrap", "unwrapOk"],
-  ["_unsafeUnwrapErr", "unwrapErr"],
-]);
+export const UNSAFE_UNWRAP_METHODS = new Map(UNSAFE_UNWRAP_MEMBER_RENAMES);
 export const SAFE_BASE_PATTERNS = [/^(ok|err)\s*\(/, /^Result\./, /^[a-zA-Z_$][\w$]*$/] as const;

package/src/file-change.ts

@@ -1,25 +1,25 @@
 import { type Maybe, none, some } from "@onrails/maybe";
-import { flow } from "@onrails/result";
-import { concatCollectors, countOccurrences } from "./ast.js";
+import { 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 type { ComputedChange, FileChange, Mode, ModeStrategy, Warning } from "./types.js";
 import {
   collectNativeMigrationWarnings,
   collectUnsupportedCompatImportWarnings,
 } from "./warnings.js";
 
-const rewriteCompatToNative = flow(rewriteCompatImportsToNative, rewriteCompatMethodChainsToNative);
+const rewriteCompatToNative = (src: string, jsx: boolean): string =>
+  rewriteCompatMethodChainsToNative(rewriteCompatImportsToNative(src), jsx);
 
 const rewriteNeverthrowToCompat = (src: string): string =>
   src.replace(IMPORT_RE, (_, lead, quote) => `${lead}${quote}${COMPAT_SPEC}${quote}`);
 
-const collectAllNativeWarnings = concatCollectors(
-  collectUnsupportedCompatImportWarnings,
-  collectNativeMigrationWarnings,
-);
+const collectAllNativeWarnings = (next: string, jsx: boolean): readonly Warning[] => [
+  ...collectUnsupportedCompatImportWarnings(next),
+  ...collectNativeMigrationWarnings(next, jsx),
+];
 
 const MODES: Record<Mode, ModeStrategy> = {
   compat: {
@@ -45,13 +45,13 @@ const MODES: Record<Mode, ModeStrategy> = {
   },
 };
 
-export const computeFileChange = (src: string, mode: Mode): Maybe<ComputedChange> => {
+export const computeFileChange = (src: string, mode: Mode, jsx = false): Maybe<ComputedChange> => {
   const strat = MODES[mode];
   const before = strat.countBefore(src);
   if (strat.earlyExit(src, before)) return none();
-  const next = strat.transform(src);
+  const next = strat.transform(src, jsx);
   const changed = next !== src;
-  const warnings = strat.warnings(next);
+  const warnings = strat.warnings(next, jsx);
   return !changed && warnings.length === 0
     ? none()
     : some({ next, before, after: strat.countAfter(next), changed, warnings });

package/src/index.ts

@@ -1,6 +1,20 @@
 #!/usr/bin/env bun
 import { main } from "./cli.js";
 
+export {
+  DEPRECATED_SYNONYM_RENAMES,
+  DEPRECATED_SYNONYMS,
+  type DeprecatedSynonym,
+  ENGINE_DIVERGENCES,
+  type EngineDivergence,
+  NO_DEPRECATED_SYNONYMS_RULE,
+  NO_PROMISE_RESULT_RULE,
+  NO_UNSAFE_UNWRAP_RULE,
+  UNSAFE_UNWRAP_CALL_NAMES,
+  UNSAFE_UNWRAP_MEMBER_CALL_RE,
+  UNSAFE_UNWRAP_MEMBER_RENAMES,
+  UNSAFE_UNWRAP_NAMES,
+} from "./boundary-spec.js";
 export { rewriteCompatMethodChainsToNative } from "./chains.js";
 export { main } from "./cli.js";
 export { computeFileChange } from "./file-change.js";

package/src/tersify-utils.ts

@@ -0,0 +1,177 @@
+import ts from "typescript";
+
+// Helper to check for single statement return
+export 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'
+export 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
+export 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;
+}
+
+export 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 "";
+}
+
+export const isSimpleExpression = (expr: ts.Expression): boolean =>
+  ts.isIdentifier(expr) ||
+  ts.isPropertyAccessExpression(expr) ||
+  ts.isElementAccessExpression(expr) ||
+  ts.isCallExpression(expr);
+
+export 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;
+}
+
+// A concise arrow body that is — or unwraps through `as` / `satisfies` to — an
+// object literal must be parenthesized, else `{ … }` parses as a block body.
+export 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);
+}
+
+export function getTernaryBranchText(node: ts.Expression, sf: ts.SourceFile): string {
+  let current = node;
+  let hasParens = false;
+  while (ts.isParenthesizedExpression(current)) {
+    current = current.expression;
+    hasParens = true;
+  }
+
+  let unwrapped: ts.Expression | undefined;
+  if (ts.isJsxFragment(current)) {
+    const children = current.children;
+    const nonTriviaChildren = children.filter((child) => {
+      if (ts.isJsxText(child)) {
+        return !child.containsOnlyTriviaWhiteSpaces;
+      }
+      return true;
+    });
+    if (nonTriviaChildren.length === 1) {
+      const soleChild = nonTriviaChildren[0];
+      if (soleChild && ts.isJsxExpression(soleChild) && soleChild.expression) {
+        unwrapped = soleChild.expression;
+      }
+    }
+  } else if (ts.isJsxElement(current)) {
+    const tagName = current.openingElement.tagName.getText(sf);
+    if (tagName === "Fragment" || tagName === "React.Fragment" || tagName.endsWith(".Fragment")) {
+      if (current.openingElement.attributes.properties.length === 0) {
+        const children = current.children;
+        const nonTriviaChildren = children.filter((child) => {
+          if (ts.isJsxText(child)) {
+            return !child.containsOnlyTriviaWhiteSpaces;
+          }
+          return true;
+        });
+        if (nonTriviaChildren.length === 1) {
+          const soleChild = nonTriviaChildren[0];
+          if (soleChild && ts.isJsxExpression(soleChild) && soleChild.expression) {
+            unwrapped = soleChild.expression;
+          }
+        }
+      }
+    }
+  }
+
+  if (unwrapped) {
+    const unwrappedText = getTernaryBranchText(unwrapped, sf);
+    return hasParens ? `(${unwrappedText})` : unwrappedText;
+  }
+
+  return node.getText(sf);
+}

package/src/tersify.ts

@@ -3,118 +3,18 @@ import ts from "typescript";
 import { edit, spanEdit, walkSource } from "./ast.js";
 import { applyEditStep, byStartDesc } from "./chains.js";
 import { scanIfToSwitchSequences } from "./switch.js";
+import {
+  containsConditional,
+  getSingleReturnExpression,
+  getTernaryBranchText,
+  getTypeParametersText,
+  isIdentifierReferencedBefore,
+  isSimpleExpression,
+  startsWithObjectLiteral,
+  usesThisOrArguments,
+} from "./tersify-utils.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);
@@ -138,24 +38,14 @@ function tryTersifyIfElse(node: ts.Node, sf: ts.SourceFile): Maybe<Edit> {
         return some(spanEdit(node, sf, edit(text)));
       }
 
-      const xText = x.getText(sf);
-      const yText = y.getText(sf);
+      const xText = getTernaryBranchText(x, sf);
+      const yText = getTernaryBranchText(y, 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);
@@ -353,8 +243,8 @@ function tryTersifyTernaryOrBooleanSequence(
       const needsParens = !isSimpleExpression(stmt.expression);
       text = needsParens ? `return !(${condText});` : `return !${condText};`;
     } else {
-      const xText = x.getText(sf);
-      const yText = y.getText(sf);
+      const xText = getTernaryBranchText(x, sf);
+      const yText = getTernaryBranchText(y, sf);
       text = `return ${condText} ? ${xText} : ${yText};`;
     }
 
@@ -422,29 +312,33 @@ const TRANSFORMS: ReadonlyArray<(node: ts.Node, sf: ts.SourceFile) => Maybe<Edit
   tryTersifyIdentityFilter,
 ];
 
-function tersifyOnce(src: string): string {
+function tersifyOnce(src: string, jsx: boolean): string {
   const edits: Edit[] = [];
   const skippedNodes = new Set<ts.Node>();
 
-  walkSource(src, (node, sf) => {
-    if (skippedNodes.has(node)) {
-      return true;
-    }
+  walkSource(
+    src,
+    (node, sf) => {
+      if (skippedNodes.has(node)) {
+        return true;
+      }
 
-    scanIfReturnSequences(node, sf, skippedNodes, edits);
-    scanIfToSwitchSequences(node, sf, skippedNodes, edits);
+      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;
+      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;
-  });
+      return false;
+    },
+    jsx,
+  );
 
   if (edits.length === 0) return src;
 
@@ -455,11 +349,11 @@ function tersifyOnce(src: string): string {
   return next;
 }
 
-export function tersify(src: string): string {
+export function tersify(src: string, jsx = false): string {
   let current = src;
   let iterations = 0;
   while (iterations < 10) {
-    const next = tersifyOnce(current);
+    const next = tersifyOnce(current, jsx);
     if (next === current) {
       break;
     }

package/src/types.ts

@@ -24,8 +24,8 @@ export type ComputedChange = {
 export type ModeStrategy = {
   countBefore: (src: string) => number;
   earlyExit: (src: string, before: number) => boolean;
-  transform: (src: string) => string;
-  warnings: (next: string) => readonly Warning[];
+  transform: (src: string, jsx: boolean) => string;
+  warnings: (next: string, jsx: boolean) => readonly Warning[];
   countAfter: (next: string) => number;
 };
 

package/src/warnings.ts

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { concatCollectors, walkSource } from "./ast.js";
+import { walkSource } from "./ast.js";
 import { COMPAT_ONLY_PATTERNS, COMPAT_SPEC } from "./constants.js";
 import type { Warning } from "./types.js";
 
@@ -12,7 +12,7 @@ export const collectRegexLineWarnings = (src: string): readonly Warning[] =>
       ),
     );
 
-export const collectAstCompatWarnings = (src: string): readonly Warning[] => {
+export const collectAstCompatWarnings = (src: string, jsx = false): readonly Warning[] => {
   const warnings: Warning[] = [];
   const lines = src.split(/\r?\n/);
   const lineTextAt = (sf: ts.SourceFile, node: ts.Node) => {
@@ -20,32 +20,36 @@ export const collectAstCompatWarnings = (src: string): readonly Warning[] => {
     return { line, text: lines[line - 1]?.trim() ?? node.getText(sf) };
   };
 
-  walkSource(src, (node, sf) => {
-    if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
-      const method = node.expression.name.text;
-      if (method === "isOk" || method === "isErr") {
-        warnings.push({ ...lineTextAt(sf, node), label: "compat predicate method" });
+  walkSource(
+    src,
+    (node, sf) => {
+      if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
+        const method = node.expression.name.text;
+        if (method === "isOk" || method === "isErr") {
+          warnings.push({ ...lineTextAt(sf, node), label: "compat predicate method" });
+        }
       }
-    }
 
-    if (ts.isPropertyAccessExpression(node)) {
-      const property = node.name.text;
-      if (property === "value" || property === "error") {
-        const receiver = node.expression.getText(sf);
-        if (/result$/i.test(receiver) || /^result$/i.test(receiver)) {
-          warnings.push({ ...lineTextAt(sf, node), label: "compat value/error property" });
+      if (ts.isPropertyAccessExpression(node)) {
+        const property = node.name.text;
+        if (property === "value" || property === "error") {
+          const receiver = node.expression.getText(sf);
+          if (/result$/i.test(receiver) || /^result$/i.test(receiver)) {
+            warnings.push({ ...lineTextAt(sf, node), label: "compat value/error property" });
+          }
         }
       }
-    }
-  });
+    },
+    jsx,
+  );
 
   return warnings;
 };
 
-export const collectNativeMigrationWarnings = concatCollectors(
-  collectRegexLineWarnings,
-  collectAstCompatWarnings,
-);
+export const collectNativeMigrationWarnings = (src: string, jsx = false): readonly Warning[] => [
+  ...collectRegexLineWarnings(src),
+  ...collectAstCompatWarnings(src, jsx),
+];
 
 export const collectUnsupportedCompatImportWarnings = (src: string): readonly Warning[] =>
   src.split(/\r?\n/).flatMap((line, i) =>