@elaraai/tsserver-plugin-east 1.0.90 → 1.0.92

package/dist/index.cjs

@@ -793,10 +793,112 @@ var noUnexecutedEastExpression = {
 // ../east-diagnostics/dist/src/rules/no-reinlined-east-binding.js
 var NAME10 = "no-reinlined-east-binding";
 var CODE10 = 990010;
+var REPEATING_METHODS = /* @__PURE__ */ new Set([
+  "map",
+  "filter",
+  "filterMap",
+  "firstMap",
+  "flatMap",
+  "flattenToArray",
+  "flattenToSet",
+  "flattenToDict",
+  "forEach",
+  "reduce",
+  "scan",
+  "mapReduce",
+  "groupReduce",
+  "groupBy",
+  "groupSize",
+  "groupSum",
+  "groupMean",
+  "groupEvery",
+  "groupSome",
+  "groupMaximum",
+  "groupMinimum",
+  "groupToArrays",
+  "groupToSets",
+  "groupToDicts",
+  "groupFindAll",
+  "groupFindFirst",
+  "groupFindMaximum",
+  "groupFindMinimum",
+  "toDict",
+  "toSet",
+  "toArray",
+  "toTree",
+  "sort",
+  "sortInPlace",
+  "isSorted",
+  "findFirst",
+  "findAll",
+  "findMaximum",
+  "findMinimum",
+  "findSortedFirst",
+  "findSortedLast",
+  "findSortedRange",
+  "mergeAll",
+  "unionInPlace",
+  "mapRows",
+  "some",
+  "every",
+  "sum",
+  "mean",
+  "maximum",
+  "minimum",
+  "getKeys",
+  "generate"
+]);
+var LOOP_METHODS = /* @__PURE__ */ new Set(["for", "while"]);
+function isFunctionLike(node, t) {
+  return t.isArrowFunction(node) || t.isFunctionExpression(node) || t.isFunctionDeclaration(node) || t.isMethodDeclaration(node);
+}
+function enclosingFunction(node, t) {
+  let current = node.parent;
+  while (current !== void 0 && !isFunctionLike(current, t))
+    current = current.parent;
+  return current;
+}
+function hostKind(fn, ctx) {
+  const t = ctx.ts;
+  const call = fn.parent;
+  if (call === void 0 || !t.isCallExpression(call) || !call.arguments.some((arg) => arg === fn))
+    return void 0;
+  const callee = call.expression;
+  if (isEastFunctionCall(call, t))
+    return "nested function";
+  if (!t.isPropertyAccessExpression(callee))
+    return void 0;
+  const method = callee.name.text;
+  const receiver = callee.expression;
+  if (LOOP_METHODS.has(method)) {
+    return isBlockBuilderType(ctx.checker.getTypeAtLocation(receiver)) ? "loop body" : void 0;
+  }
+  if (!REPEATING_METHODS.has(method))
+    return void 0;
+  if (isEastExprType(ctx.checker.getTypeAtLocation(receiver)))
+    return "callback";
+  if (t.isPropertyAccessExpression(receiver) && t.isIdentifier(receiver.expression) && receiver.expression.text === "East") {
+    return "callback";
+  }
+  return void 0;
+}
+function repeatingHostBetween(use, declFunction, ctx) {
+  let found;
+  let current = use.parent;
+  while (current !== void 0 && current !== declFunction) {
+    if (isFunctionLike(current, ctx.ts)) {
+      const kind = hostKind(current, ctx);
+      if (kind !== void 0)
+        found = kind;
+    }
+    current = current.parent;
+  }
+  return found;
+}
 var noReinlinedEastBinding = {
   name: NAME10,
   code: CODE10,
-  description: "An East Expr bound to a JS const/let and reused inside an East block is re-inlined per use \u2014 bind it once with $.let/$.const.",
+  description: "An East Expr bound to a JS const/let and read twice inside one East body, or read inside a per-element callback, a loop body or a nested East.function, is re-inlined \u2014 and re-evaluated \u2014 at each read; bind it once with $.let/$.const.",
   check(node, ctx) {
     const t = ctx.ts;
     if (!t.isVariableDeclaration(node))
@@ -818,32 +920,39 @@ var noReinlinedEastBinding = {
     if (declSymbol === void 0)
       return;
     const name = node.name.text;
-    const perBody = /* @__PURE__ */ new Map();
+    const declFunction = enclosingFunction(node, t);
+    const perFunction = /* @__PURE__ */ new Map();
+    let repeating;
     const visit = (n) => {
-      if (t.isIdentifier(n) && n !== node.name && n.text === name) {
-        if (ctx.checker.getSymbolAtLocation(n) === declSymbol) {
-          const body = enclosingBlockScope(n, ctx);
-          if (body !== void 0)
-            perBody.set(body, (perBody.get(body) ?? 0) + 1);
+      if (t.isIdentifier(n) && n !== node.name && n.text === name && ctx.checker.getSymbolAtLocation(n) === declSymbol) {
+        if (enclosingBlockScope(n, ctx) !== void 0) {
+          const multiplied = repeatingHostBetween(n, declFunction, ctx);
+          if (multiplied !== void 0) {
+            repeating ??= multiplied;
+          } else {
+            const bucket = enclosingFunction(n, t) ?? ctx.sourceFile;
+            perFunction.set(bucket, (perFunction.get(bucket) ?? 0) + 1);
+          }
         }
       }
       t.forEachChild(n, visit);
     };
     visit(ctx.sourceFile);
-    let maxInBody = 0;
-    for (const count of perBody.values())
-      if (count > maxInBody)
-        maxInBody = count;
-    if (maxInBody < 2)
+    let worst = 0;
+    for (const count of perFunction.values())
+      if (count > worst)
+        worst = count;
+    if (worst < 2 && repeating === void 0)
       return;
     const sf = ctx.sourceFile;
     const start = node.getStart(sf);
+    const messageText = worst >= 2 ? `This East expression is bound to a JS \`const\`/\`let\` and read ${worst} times inside one East body, so it is re-inlined \u2014 and re-evaluated, with a fresh identity for mutable values \u2014 at each read. Bind it once with \`$.const\`/\`$.let\`.` : `This East expression is bound to a JS \`const\`/\`let\` outside a ${repeating} and read inside it, so it is re-inlined there \u2014 and re-evaluated every time the ${repeating} runs. Bind it once with \`$.const\`/\`$.let\` before the call.`;
     ctx.report({
       ruleName: NAME10,
       code: CODE10,
       start,
       length: node.getEnd() - start,
-      messageText: "This East expression is bound to a JS `const`/`let` and used more than once inside an East block, so it is re-inlined \u2014 and re-evaluated, with a fresh identity for mutable values \u2014 at each use. Bind it once with `$.const`/`$.let`.",
+      messageText,
       category: "error"
     });
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elaraai/tsserver-plugin-east",
-  "version": "1.0.90",
+  "version": "1.0.92",
   "license": "AGPL-3.0-or-later",
   "description": "TypeScript language service plugin for East — East idiom diagnostics and localized East type-diff error messages as native editor squiggles.",
   "main": "dist/index.cjs",
@@ -32,8 +32,8 @@
   "devDependencies": {
     "esbuild": "^0.27.3",
     "typescript": "~5.9.2",
-    "@elaraai/east-diagnostics": "1.0.90",
-    "@elaraai/east": "1.0.90"
+    "@elaraai/east": "1.0.92",
+    "@elaraai/east-diagnostics": "1.0.92"
   },
   "scripts": {
     "build": "node scripts/build.mjs",