@ontrails/warden 1.0.0-beta.23 → 1.0.0-beta.29

package/src/rules/no-redundant-result-error-wrap.ts

@@ -3,10 +3,21 @@ import {
   findBlazeBodies,
   findTrailDefinitions,
   getMemberExpression,
+  getNodeArguments,
+  getNodeArgument,
+  getNodeBodyNode,
+  getNodeCallee,
+  getNodeId,
+  getNodeInit,
+  getNodeLeft,
+  getNodeOperator,
+  getNodeProperty,
+  getNodeRight,
   identifierName,
   isMemberAccessNonComputed,
   offsetToLine,
   parse,
+  walkWithParents,
   walkWithScopes,
 } from './ast.js';
 import {
@@ -19,7 +30,7 @@ import {
   trackScopedResultHelperDeclaration,
 } from './implementation-returns-result.js';
 import { isTestFile } from './scan.js';
-import type { AstNode } from './ast.js';
+import type { AstNode, AstParentContext } from './ast.js';
 import type {
   MutableScopedHelperMap,
   NamespaceHelperMap,
@@ -33,7 +44,7 @@ const getStaticMemberName = (node: AstNode | undefined): string | null => {
   if (!node || !isMemberAccessNonComputed(node)) {
     return null;
   }
-  return identifierName((node as unknown as { property?: AstNode }).property);
+  return identifierName(getNodeProperty(node));
 };
 
 const isResultObject = (node: AstNode | undefined): boolean => {
@@ -50,7 +61,7 @@ const isResultErrCall = (node: AstNode): boolean => {
   if (node.type !== 'CallExpression') {
     return false;
   }
-  const { callee } = node as unknown as { callee?: AstNode };
+  const callee = getNodeCallee(node);
   const member = getMemberExpression(callee);
   if (!member || getStaticMemberName(callee) !== 'err') {
     return false;
@@ -59,8 +70,7 @@ const isResultErrCall = (node: AstNode): boolean => {
 };
 
 const getSingleArgument = (node: AstNode): AstNode | null => {
-  const args = (node as unknown as { arguments?: readonly AstNode[] })
-    .arguments;
+  const args = getNodeArguments(node);
   return args?.length === 1 ? (args[0] ?? null) : null;
 };
 
@@ -115,12 +125,12 @@ const createDiagnostic = (
   filePath: string,
   sourceCode: string,
   node: AstNode,
-  trailId: string,
+  ownerLabel: string,
   variableName: string
 ): WardenDiagnostic => ({
   filePath,
   line: offsetToLine(sourceCode, node.start),
-  message: `Trail "${trailId}": Result.err(${variableName}.error) re-wraps a Result that already carries that error. Return ${variableName} directly to preserve the original Result boundary.`,
+  message: `${ownerLabel}: Result.err(${variableName}.error) re-wraps a Result that already carries that error. Return ${variableName} directly to preserve the original Result boundary.`,
   rule: RULE_NAME,
   severity: 'warn',
 });
@@ -133,7 +143,8 @@ const trackVariableDeclarator = (
   scopedHelpers: ScopedHelperMap,
   scopes: readonly ReadonlySet<string>[]
 ): void => {
-  const { id, init } = node as unknown as { id?: AstNode; init?: AstNode };
+  const id = getNodeId(node);
+  const init = getNodeInit(node);
   const name = identifierName(id);
   if (!name) {
     return;
@@ -166,11 +177,9 @@ const trackAssignmentExpression = (
   scopedHelpers: ScopedHelperMap,
   scopes: readonly ReadonlySet<string>[]
 ): void => {
-  const { left, operator, right } = node as unknown as {
-    left?: AstNode;
-    operator?: string;
-    right?: AstNode;
-  };
+  const left = getNodeLeft(node);
+  const operator = getNodeOperator(node);
+  const right = getNodeRight(node);
   const name = identifierName(left);
   if (!name) {
     return;
@@ -202,10 +211,10 @@ const checkReturnStatement = (
   scopes: readonly ReadonlySet<string>[],
   filePath: string,
   sourceCode: string,
-  trailId: string,
+  ownerLabel: string,
   diagnostics: WardenDiagnostic[]
 ): void => {
-  const { argument } = node as unknown as { argument?: AstNode };
+  const argument = getNodeArgument(node);
   if (!argument || !isResultErrCall(argument)) {
     return;
   }
@@ -218,13 +227,21 @@ const checkReturnStatement = (
     return;
   }
   diagnostics.push(
-    createDiagnostic(filePath, sourceCode, argument, trailId, variableName)
+    createDiagnostic(filePath, sourceCode, argument, ownerLabel, variableName)
   );
 };
 
-const checkBlazeBody = (
-  blaze: AstNode,
-  trailId: string,
+const functionBody = (node: AstNode): AstNode | null => {
+  const body = getNodeBodyNode(node);
+  return body &&
+    (body.type === 'BlockStatement' || body.type === 'FunctionBody')
+    ? body
+    : null;
+};
+
+const checkFunctionBody = (
+  owner: AstNode,
+  ownerLabel: string,
   filePath: string,
   sourceCode: string,
   helperNames: ReadonlySet<string>,
@@ -232,17 +249,14 @@ const checkBlazeBody = (
   resultTypeNames: ReadonlySet<string>,
   diagnostics: WardenDiagnostic[]
 ): void => {
-  const { body } = blaze as unknown as { body?: AstNode };
-  if (
-    !body ||
-    (body.type !== 'BlockStatement' && body.type !== 'FunctionBody')
-  ) {
+  const body = functionBody(owner);
+  if (!body) {
     return;
   }
 
   const provenance: ResultProvenance = new Map();
   const scopedHelpers: MutableScopedHelperMap = new Map();
-  const implScope = collectScopeFrameBindings(blaze);
+  const implScope = collectScopeFrameBindings(owner);
   const initialScopes = implScope.size > 0 ? [implScope] : [];
 
   walkWithScopes(
@@ -284,7 +298,7 @@ const checkBlazeBody = (
           scopes,
           filePath,
           sourceCode,
-          trailId,
+          ownerLabel,
           diagnostics
         );
       }
@@ -293,6 +307,28 @@ const checkBlazeBody = (
   );
 };
 
+const isFunctionLike = (node: AstNode): boolean =>
+  node.type === 'FunctionDeclaration' ||
+  node.type === 'FunctionExpression' ||
+  node.type === 'ArrowFunctionExpression';
+
+const functionName = (node: AstNode, context: AstParentContext): string => {
+  const declaredName = identifierName(getNodeId(node));
+  if (declaredName) {
+    return declaredName;
+  }
+  if (context.parent?.type === 'VariableDeclarator') {
+    const assignedName = identifierName(getNodeId(context.parent));
+    if (assignedName) {
+      return assignedName;
+    }
+  }
+  return 'anonymous function';
+};
+
+const functionOwnerLabel = (node: AstNode, context: AstParentContext): string =>
+  `Function "${functionName(node, context)}"`;
+
 export const noRedundantResultErrorWrap: WardenRule = {
   check(sourceCode: string, filePath: string): readonly WardenDiagnostic[] {
     if (isTestFile(filePath)) {
@@ -308,11 +344,13 @@ export const noRedundantResultErrorWrap: WardenRule = {
     const helperNames = collectAllResultHelperNames(ast, sourceCode, filePath);
     const namespaceHelpers = collectNamespaceHelperImports(ast, filePath);
     const resultTypeNames = collectResultTypeNames(ast);
+    const blazeStarts = new Set<number>();
     for (const def of findTrailDefinitions(ast)) {
       for (const blaze of findBlazeBodies(def.config)) {
-        checkBlazeBody(
+        blazeStarts.add(blaze.start);
+        checkFunctionBody(
           blaze,
-          def.id,
+          `Trail "${def.id}"`,
           filePath,
           sourceCode,
           helperNames,
@@ -322,10 +360,25 @@ export const noRedundantResultErrorWrap: WardenRule = {
         );
       }
     }
+    walkWithParents(ast, (node, context) => {
+      if (!isFunctionLike(node) || blazeStarts.has(node.start)) {
+        return;
+      }
+      checkFunctionBody(
+        node,
+        functionOwnerLabel(node, context),
+        filePath,
+        sourceCode,
+        helperNames,
+        namespaceHelpers,
+        resultTypeNames,
+        diagnostics
+      );
+    });
     return diagnostics;
   },
   description:
-    'Warn when blazes re-wrap an existing Result error with Result.err(x.error) instead of returning the Result directly.',
+    'Warn when code re-wraps an existing Result error with Result.err(x.error) instead of returning the Result directly.',
   name: RULE_NAME,
   severity: 'warn',
 };

package/src/rules/no-sync-result-assumption.ts

@@ -1,6 +1,33 @@
 import { resultAccessorNames } from '@ontrails/core';
 
-import { identifierName, isBlazeCall, offsetToLine, parse } from './ast.js';
+import {
+  getNodeArgument,
+  getNodeAlternate,
+  getNodeBodyNode,
+  getNodeBodyStatements,
+  getNodeConsequent,
+  getNodeDeclarations,
+  getNodeElements,
+  getNodeExpression,
+  getNodeId,
+  getNodeInit,
+  getNodeKey,
+  getNodeKind,
+  getNodeLeft,
+  getNodeName,
+  getNodeObject,
+  getNodeOperator,
+  getNodeParam,
+  getNodeParams,
+  getNodeProperties,
+  getNodeProperty,
+  getNodeRight,
+  getNodeValueNode,
+  identifierName,
+  isBlazeCall,
+  offsetToLine,
+  parse,
+} from './ast.js';
 import type { AstNode } from './ast.js';
 import { isFrameworkInternalFile, isTestFile } from './scan.js';
 import type { WardenDiagnostic, WardenRule } from './types.js';
@@ -104,11 +131,9 @@ const isBranchOfConditional = (outer: AstNode, parent: AstNode): boolean => {
   if (parent.type !== 'ConditionalExpression') {
     return false;
   }
-  const cond = parent as unknown as {
-    consequent?: AstNode;
-    alternate?: AstNode;
-  };
-  return cond.consequent === outer || cond.alternate === outer;
+  return (
+    getNodeConsequent(parent) === outer || getNodeAlternate(parent) === outer
+  );
 };
 
 /**
@@ -121,8 +146,7 @@ const isOperandOfLogical = (outer: AstNode, parent: AstNode): boolean => {
   if (parent.type !== 'LogicalExpression') {
     return false;
   }
-  const logical = parent as unknown as { left?: AstNode; right?: AstNode };
-  return logical.left === outer || logical.right === outer;
+  return getNodeLeft(parent) === outer || getNodeRight(parent) === outer;
 };
 
 const skipParensAndBranchConditionals = (
@@ -165,11 +189,11 @@ const memberPropertyName = (node: AstNode): string | null => {
   ) {
     return null;
   }
-  const prop = (node as unknown as { property?: AstNode }).property;
+  const prop = getNodeProperty(node);
   if (prop?.type !== 'Identifier') {
     return null;
   }
-  return (prop as unknown as { name?: string }).name ?? null;
+  return getNodeName(prop) ?? null;
 };
 
 /**
@@ -208,7 +232,7 @@ const extractAssignedBinding = (
   if (!parent || parent.type !== 'VariableDeclarator') {
     return null;
   }
-  const { id } = parent as unknown as { id?: AstNode };
+  const id = getNodeId(parent);
   return identifierName(id);
 };
 
@@ -231,7 +255,7 @@ const isResultAccessorMember = (node: AstNode): boolean => {
 };
 
 const getIdentifierObjectName = (node: AstNode): string | null => {
-  const { object } = node as unknown as { object?: AstNode };
+  const object = getNodeObject(node);
   return object?.type === 'Identifier' ? identifierName(object) : null;
 };
 
@@ -250,7 +274,7 @@ const collectAssignmentPatternBindings = (
   pattern: AstNode,
   out: Set<string>
 ): void => {
-  const { left } = pattern as unknown as { left?: AstNode };
+  const left = getNodeLeft(pattern);
   // eslint-disable-next-line no-use-before-define
   collectPatternBindings(left, out);
 };
@@ -259,7 +283,7 @@ const collectRestElementBindings = (
   pattern: AstNode,
   out: Set<string>
 ): void => {
-  const { argument } = pattern as unknown as { argument?: AstNode };
+  const argument = getNodeArgument(pattern);
   // eslint-disable-next-line no-use-before-define
   collectPatternBindings(argument, out);
 };
@@ -303,9 +327,7 @@ const collectArrayPatternBindings = (
   pattern: AstNode,
   out: Set<string>
 ): void => {
-  const { elements } = pattern as unknown as {
-    elements?: readonly (AstNode | null)[];
-  };
+  const elements = getNodeElements(pattern);
   if (!elements) {
     return;
   }
@@ -321,9 +343,7 @@ const collectObjectPatternBindings = (
   pattern: AstNode,
   out: Set<string>
 ): void => {
-  const { properties } = pattern as unknown as {
-    properties?: readonly AstNode[];
-  };
+  const properties = getNodeProperties(pattern);
   if (!properties) {
     return;
   }
@@ -333,7 +353,7 @@ const collectObjectPatternBindings = (
       collectPatternBindings(prop, out);
     } else {
       // Property node: value holds the binding pattern.
-      const { value } = prop as unknown as { value?: AstNode };
+      const value = getNodeValueNode(prop);
       // eslint-disable-next-line no-use-before-define
       collectPatternBindings(value, out);
     }
@@ -380,16 +400,12 @@ const collectVariableDeclarationBindings = (
   if (!declNode || declNode.type !== 'VariableDeclaration') {
     return;
   }
-  const declarators = (
-    declNode as unknown as {
-      declarations?: readonly AstNode[];
-    }
-  ).declarations;
+  const declarators = getNodeDeclarations(declNode);
   if (!declarators) {
     return;
   }
   for (const d of declarators) {
-    const { id } = d as unknown as { id?: AstNode };
+    const id = getNodeId(d);
     collectPatternBindings(id, out);
   }
 };
@@ -400,7 +416,7 @@ const getVariableDeclarationKind = (
   if (!declNode || declNode.type !== 'VariableDeclaration') {
     return null;
   }
-  return (declNode as unknown as { kind?: string }).kind ?? null;
+  return getNodeKind(declNode) ?? null;
 };
 
 /** True if declaration is `var` (function/program-scoped, hoistable). */
@@ -426,7 +442,7 @@ interface FunctionScopeBindings {
 
 const collectParamBindings = (scope: AstNode): Set<string> => {
   const paramBindings = new Set<string>();
-  const { params } = scope as unknown as { params?: readonly AstNode[] };
+  const params = getNodeParams(scope);
   if (params) {
     for (const param of params) {
       collectPatternBindings(param, paramBindings);
@@ -436,7 +452,7 @@ const collectParamBindings = (scope: AstNode): Set<string> => {
 };
 
 const addHoistedVarsFromBody = (scope: AstNode, out: Set<string>): void => {
-  const { body } = scope as unknown as { body?: AstNode };
+  const body = getNodeBodyNode(scope);
   if (!(body && isAstLike(body))) {
     return;
   }
@@ -462,7 +478,7 @@ const collectFunctionScopeBindings = (scope: AstNode): Set<string> =>
 
 const collectCatchScopeBindings = (scope: AstNode): Set<string> => {
   const bindings = new Set<string>();
-  const { param } = scope as unknown as { param?: AstNode };
+  const param = getNodeParam(scope);
   collectPatternBindings(param, bindings);
   return bindings;
 };
@@ -470,10 +486,10 @@ const collectCatchScopeBindings = (scope: AstNode): Set<string> => {
 const collectForScopeBindings = (scope: AstNode): Set<string> => {
   const bindings = new Set<string>();
   if (scope.type === 'ForStatement') {
-    const { init } = scope as unknown as { init?: AstNode };
+    const init = getNodeInit(scope);
     collectBlockScopedDeclaratorBindings(init, bindings);
   } else {
-    const { left } = scope as unknown as { left?: AstNode };
+    const left = getNodeLeft(scope);
     collectBlockScopedDeclaratorBindings(left, bindings);
   }
   return bindings;
@@ -483,7 +499,7 @@ const addFunctionDeclarationName = (stmt: AstNode, out: Set<string>): void => {
   if (stmt.type !== 'FunctionDeclaration') {
     return;
   }
-  const { id } = stmt as unknown as { id?: AstNode };
+  const id = getNodeId(stmt);
   const fnName = identifierName(id);
   if (fnName) {
     out.add(fnName);
@@ -494,7 +510,7 @@ const addClassDeclarationName = (stmt: AstNode, out: Set<string>): void => {
   if (stmt.type !== 'ClassDeclaration') {
     return;
   }
-  const { id } = stmt as unknown as { id?: AstNode };
+  const id = getNodeId(stmt);
   const className = identifierName(id);
   if (className) {
     out.add(className);
@@ -517,7 +533,7 @@ const collectBlockScopedStatementListBindings = (
 
 const collectBlockStatementBindings = (scope: AstNode): Set<string> => {
   const bindings = new Set<string>();
-  const { body } = scope as unknown as { body?: readonly AstNode[] };
+  const body = getNodeBodyStatements(scope);
   collectBlockScopedStatementListBindings(body, bindings);
   // Static initializer blocks own their own VariableEnvironment (per ES spec),
   // so `var` declarations inside them do not escape into the enclosing class
@@ -707,10 +723,8 @@ const extractPlainIdentifierAssignmentName = (
   if (!parent || parent.type !== 'AssignmentExpression') {
     return null;
   }
-  const { operator, left } = parent as unknown as {
-    operator?: string;
-    left?: AstNode;
-  };
+  const operator = getNodeOperator(parent);
+  const left = getNodeLeft(parent);
   // Only plain `=` assignments to a bare identifier. Member-expression LHS
   // (`obj.result = blaze(...)`) is a property write, not a bare binding we
   // can track by name.
@@ -759,10 +773,8 @@ const isAssignmentToParamName = (node: AstNode): boolean => {
   if (node.type !== 'AssignmentExpression') {
     return false;
   }
-  const { operator, left } = node as unknown as {
-    operator?: string;
-    left?: AstNode;
-  };
+  const operator = getNodeOperator(node);
+  const left = getNodeLeft(node);
   return operator === '=' && left?.type === 'Identifier';
 };
 
@@ -834,24 +846,19 @@ type CarrierChildExtractor = (
 ) => readonly (AstNode | undefined)[];
 
 const CARRIER_CHILDREN: Record<string, CarrierChildExtractor> = {
-  ConditionalExpression: (expr) => {
-    const { consequent, alternate } = expr as unknown as {
-      consequent?: AstNode;
-      alternate?: AstNode;
-    };
-    return [consequent, alternate];
-  },
+  ConditionalExpression: (expr) => [
+    getNodeConsequent(expr),
+    getNodeAlternate(expr),
+  ],
   LogicalExpression: (expr) => {
-    const { left, right } = expr as unknown as {
-      left?: AstNode;
-      right?: AstNode;
-    };
+    const left = getNodeLeft(expr);
+    const right = getNodeRight(expr);
     return [left, right];
   },
 };
 
 const unwrapTransparentWrapper = (expr: AstNode): AstNode | undefined =>
-  (expr as unknown as { expression?: AstNode }).expression;
+  getNodeExpression(expr);
 
 // biome-ignore lint/style/useConst: hoisted for recursive call
 // eslint-disable-next-line func-style
@@ -893,11 +900,9 @@ const extractIdentifierAssignment = (
   if (node.type !== 'AssignmentExpression') {
     return null;
   }
-  const { operator, left, right } = node as unknown as {
-    operator?: string;
-    left?: AstNode;
-    right?: AstNode;
-  };
+  const operator = getNodeOperator(node);
+  const left = getNodeLeft(node);
+  const right = getNodeRight(node);
   if (!(operator && left) || left.type !== 'Identifier') {
     return null;
   }
@@ -1012,15 +1017,12 @@ const propertyDestructuresResultAccessor = (prop: AstNode): boolean => {
   if (prop.type === 'RestElement') {
     return false;
   }
-  const { key } = prop as unknown as { key?: AstNode };
-  const keyName = identifierName(key);
+  const keyName = identifierName(getNodeKey(prop));
   return keyName !== null && RESULT_ACCESSOR_PROPERTIES.has(keyName);
 };
 
 const objectPatternHasResultAccessorKey = (pattern: AstNode): boolean => {
-  const { properties } = pattern as unknown as {
-    properties?: readonly AstNode[];
-  };
+  const properties = getNodeProperties(pattern);
   return properties?.some(propertyDestructuresResultAccessor) ?? false;
 };
 
@@ -1037,7 +1039,7 @@ const getDestructuredResultAccessorDeclarator = (
   if (!parent || parent.type !== 'VariableDeclarator') {
     return null;
   }
-  const { id } = parent as unknown as { id?: AstNode };
+  const id = getNodeId(parent);
   if (!id || id.type !== 'ObjectPattern') {
     return null;
   }
@@ -1138,7 +1140,7 @@ function walkWithScopes(node: AstNode, state: AnalyzeState): void {
 
 const collectProgramBindings = (ast: AstNode): Set<string> => {
   const bindings = new Set<string>();
-  const programBody = (ast as unknown as { body?: readonly AstNode[] }).body;
+  const programBody = getNodeBodyStatements(ast);
   // Top-level `let`/`const`/function declarations.
   collectBlockScopedStatementListBindings(programBody, bindings);
   // Top-level `var`s are program-scoped; also hoist any `var`s nested