@blumintinc/eslint-plugin-blumint 1.21.13 → 1.21.15

package/lib/index.js

@@ -224,7 +224,7 @@ function noFrontendImportsFromFunctionsPatterns(pattern) {
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.21.13',
+        version: '1.21.15',
     },
     parseOptions: {
         ecmaVersion: 2020,

package/lib/rules/enforce-empty-object-check.js

@@ -1404,6 +1404,68 @@ exports.enforceEmptyObjectCheck = (0, createRule_1.createRule)({
             }
             return false;
         }
+        /**
+         * The type the binding behind this value DECLARES, if it declares one.
+         *
+         * Parameters and variables are the two declarations that annotate the
+         * value a guard tests; an import is answered ahead of this by
+         * `tracesToImport`. The annotation has to sit on the BINDING: the one on
+         * `const { config }: Props = load()` describes the container, and reading
+         * it as a verdict on a single property would need exactly the resolution
+         * that failed, so a destructured binding keeps the naming heuristic.
+         */
+        function declaredTypeOf(identifier) {
+            const variable = variableFor(identifier);
+            if (!variable) {
+                return null;
+            }
+            for (const def of variable.defs) {
+                if (def.type !== 'Parameter' && def.type !== 'Variable') {
+                    continue;
+                }
+                if (def.name.typeAnnotation) {
+                    return def.name.typeAnnotation.typeAnnotation;
+                }
+            }
+            return null;
+        }
+        /**
+         * Whether a declared type declares NOTHING.
+         *
+         * An explicit `any` is the checker reporting what the source told it, not
+         * a resolution failure, so it leaves the value in the same position as an
+         * unannotated one and the naming heuristic keeps answering. `unknown` is
+         * excluded from this reading on purpose: `Object.keys` rejects an
+         * `unknown` operand, so the fix the heuristic would attach there does not
+         * typecheck.
+         */
+        function declaresNothing(node) {
+            if (node.type === utils_1.AST_NODE_TYPES.TSUnionType) {
+                return node.types.some(declaresNothing);
+            }
+            return node.type === utils_1.AST_NODE_TYPES.TSAnyKeyword;
+        }
+        /**
+         * Whether a declared type the checker could not resolve nonetheless
+         * SPELLS an index-signature dictionary.
+         *
+         * `Record<K, V>` is an index signature whichever way `K` and `V` resolve,
+         * so the value is a plain data map rather than a class instance and
+         * `Object.keys` measures its emptiness correctly. Reading that from the
+         * source keeps the verdict a complete program gives — `object` — reachable
+         * without one, which is why a union answers yes as soon as one member
+         * spells it, mirroring `isObjectLikeType`. A reference the source does not
+         * pin this way, `Readonly<NextResponse>` among them, carries no such
+         * guarantee.
+         */
+        function spellsDictionary(node) {
+            if (node.type === utils_1.AST_NODE_TYPES.TSUnionType) {
+                return node.types.some(spellsDictionary);
+            }
+            return (node.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                node.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.typeName.name === 'Record');
+        }
         function isLikelyObject(identifier) {
             if (checker && parserServices?.esTreeNodeToTSNodeMap) {
                 try {
@@ -1424,13 +1486,39 @@ exports.enforceEmptyObjectCheck = (0, createRule_1.createRule)({
                      * absence of evidence became evidence the value can be `{}`.
                      *
                      * The heuristic is still the right answer for a value with no
-                     * declaration to resolve — removing it outright silences 52 of this
-                     * rule's own 92 fixtures — so only the unresolved-IMPORT case is
-                     * carved out (#2252).
+                     * declaration to resolve — removing it outright silences 56 of this
+                     * rule's own 108 fixtures — so the fall-through is carved out only
+                     * where evidence EXISTS and went unread: a value from an unresolved
+                     * IMPORT (#2252), and a binding that DECLARES a type the checker
+                     * could not resolve (#2344). An unresolvable annotation means the
+                     * checker could not look, not that the value is loosely typed:
+                     * `response: Readonly<NextResponse>` read off its name alone
+                     * reported a class instance, whose state lives behind prototype
+                     * accessors, so the prescribed `Object.keys` clause holds for every
+                     * valid value and inverts the guard it was meant to harden.
+                     *
+                     * The carve-out costs reach, and the cost is measured rather than
+                     * assumed: across the consumer's 14,059 tracked sources it drops 8
+                     * reports, and re-running each under a real `ts.Program` — the
+                     * verdict this arm exists to preserve — agrees with 6 of them. The
+                     * remaining 2 annotate an all-optional imported type
+                     * (`Record<string, string[]>` behind a local alias, and an
+                     * `algoliasearch-helper` parameter bag), which a resolved program
+                     * calls `object` and reports. Nothing at the annotation site
+                     * separates those from `Readonly<NextResponse>`: both are bare
+                     * references into a module this program did not load, so recovering
+                     * them needs the cross-file resolution whose absence defines this
+                     * branch. Two silent true positives is the accepted price of six
+                     * guard inversions, because a fix that rewrites correct code costs
+                     * more than one the rule declines to make.
                      */
                     if (tracesToImport(identifier)) {
                         return false;
                     }
+                    const declared = declaredTypeOf(identifier);
+                    if (declared && !declaresNothing(declared)) {
+                        return spellsDictionary(declared);
+                    }
                 }
                 catch {
                     // TypeScript parser services can throw when AST-to-TS node mapping fails; fall back to naming heuristic so linting does not crash.

package/lib/rules/enforce-memoize-async.js

@@ -423,6 +423,168 @@ function transactionParticipantsOf(body) {
     }
     return participants;
 }
+/**
+ * Node types that own the statements written inside them. A walk bounded by
+ * them answers about what the method DOES rather than about what it merely
+ * defines: a `try`/`finally` written inside a callback is that callback's
+ * acquire/release pair, and a field written inside one is written on whatever
+ * schedule the callback runs on. The decorator caches the method's own promise,
+ * so only the method's own steps bear on whether caching is safe.
+ */
+const OWN_STEP_BOUNDARIES = new Set([
+    utils_1.AST_NODE_TYPES.ArrowFunctionExpression,
+    utils_1.AST_NODE_TYPES.FunctionDeclaration,
+    utils_1.AST_NODE_TYPES.FunctionExpression,
+]);
+/**
+ * Every node the enclosing function executes as its own step, `root` included.
+ * Descent stops at a nested function, which `subtreeOf` enters.
+ */
+function* ownSubtreeOf(root) {
+    yield root;
+    for (const [key, value] of Object.entries(root)) {
+        if (NON_TRAVERSABLE_KEYS.has(key)) {
+            continue;
+        }
+        const children = Array.isArray(value) ? value : [value];
+        for (const child of children) {
+            if (ASTHelpers_1.ASTHelpers.isNode(child) && !OWN_STEP_BOUNDARIES.has(child.type)) {
+                yield* ownSubtreeOf(child);
+            }
+        }
+    }
+}
+/**
+ * Whether the block performs a call as a step of the function that owns it.
+ * A call written inside a function the block only DEFINES — `finally { const
+ * undo = () => release(t); }` — performs nothing, so the bounded walk is what
+ * separates a release from a closure that could perform one elsewhere.
+ */
+function performsCall(block) {
+    for (const node of ownSubtreeOf(block)) {
+        if (node.type === utils_1.AST_NODE_TYPES.CallExpression) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Whether the method owns an acquire/release pair: a `try` among its own steps
+ * whose `finalizer` calls something.
+ *
+ * A `finally` that calls something exists to undo an effect the `try`
+ * performed. What such a method hands back describes one attempt — a grant held
+ * while a queue ticket was outstanding, a read taken while a lock was held —
+ * rather than a fact that stays true once the release has run.
+ *
+ * An empty `finalizer` releases nothing, and one that only writes a local
+ * (`finally { done = true; }`) records that the attempt finished instead of
+ * undoing it, so neither costs the method its report.
+ */
+function releasesInOwnFinalizer(fn) {
+    for (const node of ownSubtreeOf(fn.body)) {
+        if (node.type === utils_1.AST_NODE_TYPES.TryStatement &&
+            node.finalizer &&
+            performsCall(node.finalizer)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * The expression under the wrappers that stand between a value and the access
+ * path it evaluates. `await this.pending`, `this.pending!`, `this.pending as
+ * Ready` and `this?.pending` all read the same field, and a discriminator blind
+ * to one of those spellings would answer "hands back something else" about a
+ * method that hands back exactly what it wrote.
+ */
+function withoutValueWrappers(node) {
+    switch (node.type) {
+        case utils_1.AST_NODE_TYPES.AwaitExpression:
+            return withoutValueWrappers(node.argument);
+        case utils_1.AST_NODE_TYPES.ChainExpression:
+        case utils_1.AST_NODE_TYPES.TSAsExpression:
+        case utils_1.AST_NODE_TYPES.TSNonNullExpression:
+        case utils_1.AST_NODE_TYPES.TSSatisfiesExpression:
+        case utils_1.AST_NODE_TYPES.TSTypeAssertion:
+            return withoutValueWrappers(node.expression);
+        default:
+            return node;
+    }
+}
+/**
+ * The instance field an expression is rooted at: `cached` for `this.cached`,
+ * for `this.cached.value` and for `this.cache[id]` alike.
+ *
+ * Both sides of the discriminator below read the ROOT, so an element write
+ * (`this.cache[id] = …`) and the read that answers it (`return this.cache[id]`)
+ * meet on the same name. A computed root (`this[key]`) names no field
+ * statically and answers nothing, which leaves the method reporting.
+ */
+function rootThisField(node) {
+    const expression = withoutValueWrappers(node);
+    if (expression.type !== utils_1.AST_NODE_TYPES.MemberExpression) {
+        return undefined;
+    }
+    const object = withoutValueWrappers(expression.object);
+    if (object.type !== utils_1.AST_NODE_TYPES.ThisExpression) {
+        return rootThisField(object);
+    }
+    return !expression.computed &&
+        expression.property.type === utils_1.AST_NODE_TYPES.Identifier
+        ? expression.property.name
+        : undefined;
+}
+/**
+ * Whether the expression reads a field the method wrote. Depth and nesting are
+ * immaterial — `this.cached ?? EMPTY` and `() => this.cached` hand the written
+ * state back as plainly as a bare `this.cached` does — because the question is
+ * whether the result carries that state at all, not how it is spelled.
+ */
+function readsWrittenField(node, fields) {
+    for (const descendant of subtreeOf(node)) {
+        const field = rootThisField(descendant);
+        if (field !== undefined && fields.has(field)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Whether the method writes an instance field and hands back a result that
+ * reads none of the fields it wrote.
+ *
+ * Such a method reports on an effect: its result says what THIS call did, so
+ * the next call has to be free to do it again. Writing a field and returning it
+ * is the opposite shape — a hand-rolled cache, which is the very thing
+ * `@Memoize()` replaces — and the field read is what separates the two. A
+ * single returned read is enough, because a method with one cache-hit path
+ * hands back state on that path however many effects its other paths report.
+ *
+ * A method with no value-returning `return` is left alone. Its result is void
+ * by inference rather than by declaration, and #1548 fenced inferred void out
+ * of this rule deliberately: an unannotated body carries no declaration of
+ * intent to honour.
+ */
+function writesFieldItDoesNotReturn(fn) {
+    const written = new Set();
+    const results = [];
+    for (const node of ownSubtreeOf(fn.body)) {
+        if (node.type === utils_1.AST_NODE_TYPES.AssignmentExpression) {
+            const field = rootThisField(node.left);
+            if (field !== undefined) {
+                written.add(field);
+            }
+        }
+        else if (node.type === utils_1.AST_NODE_TYPES.ReturnStatement && node.argument) {
+            results.push(node.argument);
+        }
+    }
+    if (written.size === 0 || results.length === 0) {
+        return false;
+    }
+    return !results.some((result) => readsWrittenField(result, written));
+}
 /** The statically known name of a method, for matching call sites against it. */
 function methodName(node) {
     if (node.computed) {
@@ -664,6 +826,37 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
                 if (participatesInTransaction(node, node.value)) {
                     return;
                 }
+                // A `finally` that calls something exists to undo an effect the `try`
+                // performed: the method takes a resource, works while it holds it, and
+                // gives it back on the way out. What it hands back describes that one
+                // attempt, not a fact that stays true afterwards. Cached, the
+                // acquire/release pair runs once per instance and every later caller
+                // receives a value computed while a resource the `finally` has since
+                // released was still held — the hazard the resource-handle exemption
+                // above names, seen from the side where the method releases the handle
+                // itself, so nothing of it reaches the return type for a signature-keyed
+                // gate to read. The failure is silent and arrives only under
+                // concurrency, so the fixer would apply it unattended under `--fix`,
+                // and both report and fix are withheld.
+                if (releasesInOwnFinalizer(node.value)) {
+                    return;
+                }
+                // A method that writes an instance field and hands back a result
+                // reading none of the fields it wrote reports on an effect: the result
+                // says what THIS call did — "I reclaimed the slot" — and the next call
+                // has to be free to do it again. Cached, the write happens once per
+                // instance while every later caller reads the first call's verdict
+                // about work that call alone performed, and a caller passing a freshly
+                // built argument object instead accumulates one dead entry per call.
+                //
+                // The read is the discriminator, and it is deliberately the whole test:
+                // a method that writes a field and returns it is a hand-rolled cache,
+                // which is the shape `@Memoize()` exists to replace, so it keeps both
+                // report and fix. Carving out every write to `this` would silence that
+                // shape along with these.
+                if (writesFieldItDoesNotReturn(node.value)) {
+                    return;
+                }
                 const { aliases: memoizeAliases, namespaces: memoizeNamespaces } = memoizeImports();
                 const hasMemoizeImport = memoizeAliases.size > 0 || memoizeNamespaces.size > 0;
                 // Check if method already has @Memoize or @Memoize() decorator