@intentius/chant 0.21.0 → 0.23.0

package/src/fold/subset.ts

@@ -69,8 +69,22 @@ import { intrinsicCallFolds, type IntrinsicDef } from "../lexicon";
  *      the flow-sensitivity note below — the single divergence in the other
  *      direction, and the one this module treats as a wart). A caller with
  *      no registry degrades to "assume it runs", which is safe and cheap to
- *      reason about; EVL is exactly such a caller and its behavior on calls
- *      is unchanged by #1044.
+ *      reason about.
+ *
+ *      chant #1106 — EVL is no longer such a caller by default. `runLint`
+ *      (../lint/engine.ts) takes the active lexicons' `IntrinsicDef[]` as a
+ *      parameter and puts it on `LintContext.intrinsics`
+ *      (../lint/rule.ts), and EVL001 (evl001-non-literal-expression.ts)
+ *      passes it straight through to `checkObjectMember`. `chant lint`'s
+ *      three CLI entry points (the `lint` command's initial pass, its
+ *      `--fix` re-lint, and the LSP's per-file diagnostics) all resolve the
+ *      project's lexicons and thread their intrinsics through, mirroring
+ *      how `discover()` has done it for the fold path since #1039/#1105 —
+ *      so `chant lint` on a real project no longer flags `Ref(...)` that
+ *      `fold()` accepts. A `LintContext` built without that plumbing (a
+ *      unit test constructing one directly, a consumer that hasn't
+ *      resolved lexicons) still gets the pre-#1044 conservative answer —
+ *      that path was never wrong, only stricter than it had to be.
  *   3. Runtime *type* of a folded value — e.g. spreading `const n = 5`
  *      (`{...n}`) is shape-valid (`n` is a plain identifier) but `fold()`
  *      rejects it once it discovers `n` folds to a number, not an object.
@@ -141,6 +155,22 @@ export function isLiteralElementKey(node: ts.Expression): node is ts.StringLiter
   return ts.isStringLiteral(node) || ts.isNumericLiteral(node);
 }
 
+/**
+ * A short, single-line rendering of `node`'s source text for embedding in a
+ * diagnostic message — never the raw `getText()`, which reproduces the
+ * node's ENTIRE source verbatim and can span dozens of lines for a real
+ * composite call or object literal (chant #1054: a fold fallback reason that
+ * embeds one of these buries the actual error after it, and breaks any
+ * line-oriented consumer of `[fold:run]` output). Internal whitespace
+ * (including newlines) collapses to a single space, and the result is capped
+ * to a bounded length so one pathological node can't blow out an otherwise
+ * one-line reason either.
+ */
+export function briefNodeText(node: ts.Node, maxLength = 60): string {
+  const collapsed = node.getText().replace(/\s+/g, " ").trim();
+  return collapsed.length > maxLength ? `${collapsed.slice(0, maxLength - 3)}...` : collapsed;
+}
+
 // ---------------------------------------------------------------------------
 // Shared message builders — `fold()` and `findSubsetViolation` both call
 // these so the diagnostic text for the same violation kind is the same
@@ -148,11 +178,11 @@ export function isLiteralElementKey(node: ts.Expression): node is ts.StringLiter
 // ---------------------------------------------------------------------------
 
 export function computedPropertyNameMessage(node: ts.PropertyName): string {
-  return `computed/dynamic property name not foldable: ${node.getText()}`;
+  return `computed/dynamic property name not foldable: ${briefNodeText(node)}`;
 }
 
 export function dynamicElementAccessMessage(keyNode: ts.Expression): string {
-  return `dynamic property access — computed key must be a string or numeric literal: ${keyNode.getText()}`;
+  return `dynamic property access — computed key must be a string or numeric literal: ${briefNodeText(keyNode)}`;
 }
 
 export const UNSUPPORTED_OBJECT_MEMBER_MESSAGE = "unsupported object member";
@@ -163,8 +193,19 @@ export function unsupportedBinaryMessage(opKind: ts.SyntaxKind): string {
   return `unsupported binary operator: ${ts.SyntaxKind[opKind]}`;
 }
 
+/**
+ * chant #1054 — the ONE wording for "a bare function/method call used where
+ * chant needs a value it can fold." Before this, `fold()` (this message) and
+ * `../discovery/fold-import.ts`'s `resolveCallExpression` (a top-level
+ * export's own call-as-a-value check) had each grown their own hand-written
+ * copy — "function call as a value" here, "call expression as a value"
+ * there — for the identical rejection, which meant a tool grouping fallback
+ * reasons by text had to match both to avoid silently under-counting one of
+ * them. `resolveCallExpression` now calls this function directly instead of
+ * building its own string.
+ */
 export function callExpressionMessage(node: ts.CallExpression): string {
-  return `function call as a value is not foldable: ${node.expression.getText()}(...)`;
+  return `function call as a value is not foldable: ${briefNodeText(node.expression)}(...)`;
 }
 
 export function unsupportedExpressionMessage(node: ts.Node): string {

package/src/lint/engine.ts

@@ -1,4 +1,5 @@
 import type { LintRule, LintDiagnostic, LintContext } from "./rule";
+import type { IntrinsicDef } from "../lexicon";
 import { parseFile } from "./parser";
 import { readFileSync } from "fs";
 
@@ -193,12 +194,22 @@ function isDiagnosticDisabled(
  * @param files - Array of file paths to lint
  * @param rules - Array of lint rules to execute
  * @param ruleOptions - Optional map of rule ID to options object
+ * @param intrinsics - chant #1106 — the active lexicons' registered
+ *   intrinsics (e.g. AWS's `Ref`, `GetAtt`), put on every file's
+ *   `LintContext.intrinsics` so a rule built on `../fold/subset.ts`'s
+ *   shared predicate (EVL001) answers exactly like `fold()` does for a
+ *   registered, opted-in call, instead of degrading to "every call is a
+ *   violation". Mirrors how `discover()` has threaded the same
+ *   `IntrinsicDef[]` into the fold path since #1039/#1105. Optional and
+ *   defaulting to none, so a caller that hasn't resolved a project's
+ *   lexicons (a unit test, `bench.test.ts`) is unaffected.
  * @returns LintRunResult with diagnostics and suppressed items
  */
 export async function runLint(
   files: string[],
   rules: LintRule[],
   ruleOptions?: Map<string, Record<string, unknown>>,
+  intrinsics?: readonly IntrinsicDef[],
 ): Promise<LintRunResult> {
   const allDiagnostics: LintDiagnostic[] = [];
   const allSuppressed: Array<LintDiagnostic & { reason?: string }> = [];
@@ -219,6 +230,7 @@ export async function runLint(
         entities: [],
         filePath,
         lexicon: undefined,
+        intrinsics,
       };
 
       // Execute each rule

package/src/lint/rule.ts

@@ -1,4 +1,5 @@
 import type * as ts from "typescript";
+import type { IntrinsicDef } from "../lexicon";
 
 /**
  * Severity level for lint diagnostics
@@ -60,6 +61,19 @@ export interface LintContext {
   filePath: string;
   /** Optional lexicon context (undefined for core rules) */
   lexicon?: string;
+  /**
+   * chant #1106 — the active lexicons' registered intrinsics (`Ref`,
+   * `GetAtt`, ...), threaded down from `runLint` (../lint/engine.ts) so a
+   * rule built on the shared `../fold/subset.ts` predicate
+   * (`findSubsetViolation`/`checkObjectMember`, used by EVL001) gets the
+   * SAME answer `fold()` does for a registered, opted-in call. Mirrors how
+   * `discover()` has threaded `IntrinsicDef[]` into the fold path since
+   * #1039/#1105. Undefined when the caller hasn't resolved a project's
+   * lexicons (a bare unit test constructing a `LintContext` directly, for
+   * instance) — subset.ts then falls back to its pre-#1044 answer: every
+   * call is a violation.
+   */
+  intrinsics?: readonly IntrinsicDef[];
 }
 
 /**

package/src/lint/rules/evl001-non-literal-expression.test.ts

@@ -2,6 +2,7 @@ import { describe, test, expect } from "vitest";
 import * as ts from "typescript";
 import { evl001NonLiteralExpressionRule } from "./evl001-non-literal-expression";
 import type { LintContext } from "../rule";
+import type { IntrinsicDef } from "../../lexicon";
 
 function createContext(code: string, filePath = "test.ts"): LintContext {
   const sourceFile = ts.createSourceFile(filePath, code, ts.ScriptTarget.Latest, true);
@@ -155,4 +156,42 @@ describe("EVL001: non-literal-expression", () => {
     expect(diags).toHaveLength(1);
     expect(diags[0].ruleId).toBe("EVL001");
   });
+
+  /**
+   * chant #1106 — `LintContext.intrinsics`, threaded from `runLint`, is what
+   * lets this rule answer a registered call-form intrinsic exactly like
+   * `fold()` does instead of flagging every call. See ../../fold/subset.ts
+   * and ../../fold/subset.test.ts for the shared predicate this rule calls.
+   */
+  describe("context.intrinsics (#1106)", () => {
+    const REF: IntrinsicDef[] = [{ name: "Ref", isTag: false, foldsAsCall: true }];
+
+    test("flags a call to a registered, opted-in intrinsic when the context carries no registry", () => {
+      const ctx = createContext(`new Bucket({ name: Ref(env) });`);
+      const diags = evl001NonLiteralExpressionRule.check(ctx);
+      expect(diags).toHaveLength(1);
+      expect(diags[0].ruleId).toBe("EVL001");
+    });
+
+    test("does not flag that same call once the context carries the registry", () => {
+      const ctx: LintContext = { ...createContext(`new Bucket({ name: Ref(env) });`), intrinsics: REF };
+      expect(evl001NonLiteralExpressionRule.check(ctx)).toHaveLength(0);
+    });
+
+    test("a registered name WITHOUT the call opt-in still flags, even with the registry present", () => {
+      const notOptedIn: IntrinsicDef[] = [{ name: "Reference", isTag: false }];
+      const ctx: LintContext = {
+        ...createContext(`new Bucket({ name: Reference(env) });`),
+        intrinsics: notOptedIn,
+      };
+      const diags = evl001NonLiteralExpressionRule.check(ctx);
+      expect(diags).toHaveLength(1);
+    });
+
+    test("an unregistered call still flags with the registry present", () => {
+      const ctx: LintContext = { ...createContext(`new Bucket({ name: makeName() });`), intrinsics: REF };
+      const diags = evl001NonLiteralExpressionRule.check(ctx);
+      expect(diags).toHaveLength(1);
+    });
+  });
 });

package/src/lint/rules/evl001-non-literal-expression.ts

@@ -31,7 +31,7 @@ function checkNode(node: ts.Node, context: LintContext, diagnostics: LintDiagnos
       const firstArg = node.arguments[0];
       if (ts.isObjectLiteralExpression(firstArg)) {
         for (const prop of firstArg.properties) {
-          const violation = checkObjectMember(prop);
+          const violation = checkObjectMember(prop, context.intrinsics);
           if (violation) {
             const { line, character } = context.sourceFile.getLineAndCharacterOfPosition(
               violation.node.getStart(context.sourceFile),

package/src/serializer-walker.ts

@@ -61,6 +61,20 @@ export function walkValue(
     if (name) {
       return visitor.resourceRef(name);
     }
+    // A resource-kind Declarable constructed inline rather than exported as
+    // its own top-level entity (e.g. K8s `new PersistentVolumeClaim({...})`
+    // embedded directly in a StatefulSet's `volumeClaimTemplates`) has no
+    // logical name to Ref — it was never a key in `entities`, so
+    // resolveAttrRefs() never assigns one. Falling through to the generic
+    // "object" branch below would walk the Declarable's own enumerable
+    // properties, which for a Declarable are its self-referencing attribute
+    // accessors (AttrRef instances whose parent is the Declarable itself,
+    // still unresolved) — never its authored `.props`. That either threw
+    // "logical name not set" (when the resource type declares any
+    // attributes) or silently serialized as `{}` (when it doesn't), instead
+    // of the embedded spec the caller wrote. Embed its own props inline
+    // instead, exactly like a property-kind Declarable already does.
+    return visitor.propertyDeclarable(decl, (v) => walkValue(v, entityNames, visitor));
   }
 
   // Handle arrays