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

package/src/rules/fires-declarations.ts

@@ -13,14 +13,26 @@
 
 import {
   buildSignalIdentifierResolver,
+  deriveConstString,
   extractStringLiteral,
-  findConfigProperty,
   findBlazeBodies,
+  findConfigProperty,
   findTrailDefinitions,
+  getNodeBodyNode,
+  getNodeBodyStatements,
+  getNodeDeclarations,
+  getNodeId,
+  getNodeInit,
+  getNodeKey,
+  getNodeKind,
+  getNodeLeft,
+  getNodeObject,
+  getNodeProperties,
+  getNodeProperty,
+  getNodeValueNode,
   identifierName,
   offsetToLine,
   parse,
-  deriveConstString,
   walkScope,
 } from './ast.js';
 import type { AstNode, SignalIdentifierResolver } from './ast.js';
@@ -34,11 +46,9 @@ import type { WardenDiagnostic, WardenRule } from './types.js';
 /**
  * Resolve an array element to a static signal ID when possible.
  *
- * Returns null for entries the rule can't statically resolve — callers should
- * treat "unresolved" as "trust the runtime" rather than a missing declaration.
- * In particular, object-form references (e.g. `fires: [orderPlaced]` where
- * `orderPlaced` is a `Signal` imported from elsewhere) resolve via runtime
- * normalization in `trail()`, not at lint time.
+ * Returns null for entries the rule can't statically resolve. Unresolved entries
+ * are not proof of missingness, but they also do not suppress diagnostics for
+ * statically resolved `ctx.fire()` calls that target different signals.
  */
 const resolveFireElementId = (
   element: AstNode,
@@ -99,10 +109,10 @@ interface DeclaredFires {
 /**
  * Extract declared fires from a `fires: [...]` array.
  *
- * Object-form entries (`fires: [someSignal]`) cannot be resolved at lint time;
- * they're normalized at runtime by `trail()`. When any entry is unresolved,
- * the rule reports `hasUnresolved: true`, and callers should suppress the
- * "undeclared" diagnostic since the declared set is incomplete from our view.
+ * Object-form entries (`fires: [someSignal]`) can be unresolved at lint time
+ * when they come from imports the rule cannot prove. Those unresolved entries
+ * do not soften concrete undeclared `ctx.fire()` calls; this mirrors
+ * `composes-declarations` and keeps real drift hard-failing.
  */
 const resolveDeclaredFiresElements = (
   elements: readonly AstNode[],
@@ -147,12 +157,8 @@ const extractMemberPair = (
     return null;
   }
 
-  const objName = identifierName(
-    (callee as unknown as { object?: AstNode }).object
-  );
-  const propName = identifierName(
-    (callee as unknown as { property?: AstNode }).property
-  );
+  const objName = identifierName(getNodeObject(callee));
+  const propName = identifierName(getNodeProperty(callee));
 
   return objName && propName ? { objName, propName } : null;
 };
@@ -177,8 +183,8 @@ const extractFireLocalName = (prop: AstNode): string | null => {
   if (prop.type !== 'Property') {
     return null;
   }
-  const { key } = prop as unknown as { key?: AstNode };
-  const { value } = prop as unknown as { value?: AstNode };
+  const key = getNodeKey(prop);
+  const value = getNodeValueNode(prop);
   const keyName = identifierName(key);
   if (keyName !== 'fire') {
     return null;
@@ -193,9 +199,7 @@ const collectFireNamesFromPattern = (
   pattern: AstNode,
   names: Set<string>
 ): void => {
-  const { properties } = pattern as unknown as {
-    properties?: readonly AstNode[];
-  };
+  const properties = getNodeProperties(pattern);
   if (!properties) {
     return;
   }
@@ -224,7 +228,7 @@ const extractContextParamName = (blazeBody: AstNode): string | null => {
     return null;
   }
   if (param.type === 'AssignmentPattern') {
-    const { left } = param as unknown as { left?: AstNode };
+    const left = getNodeLeft(param);
     return identifierName(left);
   }
   return identifierName(param);
@@ -364,10 +368,8 @@ const getCtxDestructurePattern = (
   if (node.type !== 'VariableDeclarator') {
     return null;
   }
-  const { id, init } = node as unknown as {
-    readonly id?: AstNode;
-    readonly init?: AstNode;
-  };
+  const id = getNodeId(node);
+  const init = getNodeInit(node);
   if (!id || id.type !== 'ObjectPattern' || !init) {
     return null;
   }
@@ -398,11 +400,11 @@ const getCtxDestructurePattern = (
  */
 /** Get the top-level statements of a blaze function's BlockStatement body. */
 const getTopLevelStatements = (body: AstNode): readonly AstNode[] => {
-  const blockBody = (body as unknown as { body?: AstNode }).body;
+  const blockBody = getNodeBodyNode(body);
   if (!blockBody || blockBody.type !== 'BlockStatement') {
     return [];
   }
-  return (blockBody as unknown as { body?: readonly AstNode[] }).body ?? [];
+  return getNodeBodyStatements(blockBody);
 };
 
 /** Collect fire-local names from a single top-level VariableDeclaration. */
@@ -419,13 +421,11 @@ const collectFireNamesFromDeclaration = (
   // fire('x')` would otherwise be a false positive. Skipping non-const is a
   // small precision loss (see TSDoc on `collectDestructuredFireNames`) in
   // exchange for eliminating that class of false positives.
-  const { kind } = stmt as unknown as { kind?: string };
+  const kind = getNodeKind(stmt);
   if (kind !== 'const') {
     return;
   }
-  const declarations =
-    (stmt as unknown as { declarations?: readonly AstNode[] }).declarations ??
-    [];
+  const declarations = getNodeDeclarations(stmt) ?? [];
   for (const decl of declarations) {
     const pattern = getCtxDestructurePattern(decl, ctxNames);
     if (pattern) {
@@ -576,16 +576,13 @@ const buildUndeclaredDiagnostic = (
   trailId: string,
   signalId: string,
   filePath: string,
-  line: number,
-  softened = false
+  line: number
 ): WardenDiagnostic => ({
   filePath,
   line,
-  message: softened
-    ? `Trail "${trailId}": ctx.fire('${signalId}') called but '${signalId}' is not declared in fires (may be declared via object-form fires entries)`
-    : `Trail "${trailId}": ctx.fire('${signalId}') called but '${signalId}' is not declared in fires`,
+  message: `Trail "${trailId}": ctx.fire('${signalId}') called but '${signalId}' is not declared in fires`,
   rule: 'fires-declarations',
-  severity: softened ? 'warn' : 'error',
+  severity: 'error',
 });
 
 const buildStringFireDiagnostic = (
@@ -626,20 +623,13 @@ const reportUndeclared = (
     trailId: string;
     filePath: string;
     line: number;
-    softened?: boolean;
   },
   diagnostics: WardenDiagnostic[]
 ): void => {
   for (const id of called) {
     if (!declared.has(id)) {
       diagnostics.push(
-        buildUndeclaredDiagnostic(
-          ctx.trailId,
-          id,
-          ctx.filePath,
-          ctx.line,
-          ctx.softened
-        )
+        buildUndeclaredDiagnostic(ctx.trailId, id, ctx.filePath, ctx.line)
       );
     }
   }
@@ -648,12 +638,9 @@ const reportUndeclared = (
 /**
  * Emit warning for each declared ID not present in called set.
  *
- * Note: unlike `reportUndeclared`, this function does NOT soften its
- * diagnostics when `hasUnresolved` is true. The asymmetry is intentional —
- * softening only applies to the undeclared direction because unresolved
- * Signal-value entries might cover an unknown set of called IDs. In the
- * unused direction, a declared string-literal that is never called is
- * genuinely unused regardless of whether other entries are unresolved.
+ * Unused string-literal declarations remain warnings: a declared string that is
+ * never called is visible cleanup debt even when other object-form declarations
+ * are unresolved.
  */
 const reportUnused = (
   declared: ReadonlySet<string>,
@@ -708,17 +695,7 @@ const checkTrailDefinition = (
   );
 
   reportStringFireCalls(called.stringIds, ctx, diagnostics);
-  // When the declared array contains object-form references we can't resolve,
-  // downgrade "undeclared" diagnostics from error to warn with a disclaimer
-  // instead of suppressing entirely. The developer still sees genuinely
-  // undeclared calls, but we can't statically prove the call isn't covered by
-  // a Signal-value entry the runtime will normalize.
-  reportUndeclared(
-    signalValueCalledIds,
-    declared.ids,
-    { ...ctx, softened: declared.hasUnresolved },
-    diagnostics
-  );
+  reportUndeclared(signalValueCalledIds, declared.ids, ctx, diagnostics);
   reportUnused(declared.ids, called.ids, ctx, diagnostics);
 };