@rigour-labs/core 6.12.2-rc.2 → 6.12.2-rc.4

package/dist/review/typed/redundancy.js

@@ -264,6 +264,86 @@ function redundancyFailures(typed, changedLines, config) {
         escapeMemo.set(t.sym, found);
         return found;
     };
+    // Where a value of T is put in a place declared as another type (a property typed as a same-shape inline type, a
+    // variable, a parameter, a return), T's members travel as that type: the declared types the place names.
+    const isFlowSite = (node) => {
+        const p = node.parent;
+        return !!p && ((ts.isPropertyAssignment(p) && p.initializer === node) || ts.isSpreadAssignment(p) || (ts.isVariableDeclaration(p) && p.initializer === node)
+            || ts.isReturnStatement(p) || (ts.isArrowFunction(p) && p.body === node) || (ts.isCallExpression(p) && p.arguments.includes(node)));
+    };
+    // The declared types a place names. A property or spread in an object literal whose own declared type names none
+    // (an inline type) is carried by the literal: the declared types of the place the literal goes, a level up at a time.
+    const namedAt = (node, t) => {
+        for (let at = node; at && ts.isExpression(at); at = ts.isObjectLiteralExpression(at.parent?.parent) ? at.parent.parent : undefined) {
+            const target = checker.getContextualType(at);
+            if (!target || target.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown) || mentionsType(t, target))
+                return [];
+            const named = declaredTypes.filter(d => d.sym !== t.sym && mentionsType(d, target));
+            if (named.length)
+                return named;
+        }
+        return [];
+    };
+    // The parts of `target` that receive T's values inside `value`, found by walking both the same way: arrays, union
+    // members of the value, and same-named properties (`R[]` receiving `{ …, p: T }[]` gives the type of `R.p`).
+    const receiving = (t, value, target, depth = 0) => {
+        const to = checker.getNonNullableType(target);
+        if (value.symbol === t.sym || value.aliasSymbol === t.sym)
+            return mentionsType(t, to) ? [] : [to];
+        if (depth > MENTION_DEPTH)
+            return [];
+        if (value.isUnion())
+            return value.types.flatMap(v => receiving(t, v, target, depth + 1));
+        if (checker.isArrayType(value))
+            return checker.isArrayType(to) ? receiving(t, checker.getTypeArguments(value)[0], checker.getTypeArguments(to)[0], depth + 1) : [];
+        if (!(value.flags & ts.TypeFlags.Object))
+            return [];
+        return checker.getPropertiesOfType(value).flatMap(p => {
+            const into = checker.getPropertyOfType(to, p.name);
+            return into ? receiving(t, checker.getTypeOfSymbol(p), checker.getTypeOfSymbol(into), depth + 1) : [];
+        });
+    };
+    // Where T's values go: the declared types they travel as (`into`), and the types of the places that receive them
+    // (`receivers`: a same-shape inline type, a parameter's type), whose members are T's members under another type.
+    const flowMemo = new Map();
+    const flowsOf = (t) => {
+        const cached = flowMemo.get(t.sym);
+        if (cached)
+            return cached;
+        const into = new Set();
+        const receivers = new Set();
+        for (const sf of typed.appSources) {
+            walk(sf, node => {
+                if (!ts.isExpression(node) || !isFlowSite(node) || !mentionsType(t, checker.getTypeAtLocation(node)))
+                    return;
+                const target = checker.getContextualType(node);
+                if (target && !(target.flags & (ts.TypeFlags.Any | ts.TypeFlags.Unknown)) && !mentionsType(t, target))
+                    for (const r of receiving(t, checker.getTypeAtLocation(node), target))
+                        receivers.add(r);
+                for (const d of namedAt(node, t))
+                    into.add(d);
+            });
+        }
+        const found = { into: [...into], receivers: [...receivers] };
+        flowMemo.set(t.sym, found);
+        return found;
+    };
+    const flowsInto = (t) => flowsOf(t).into;
+    // T leaves the program where its own values do, or where a type it travels as does.
+    const leaves = (t, seen = new Set([t.sym])) => {
+        const direct = escapes(t);
+        if (direct)
+            return direct;
+        for (const d of flowsInto(t)) {
+            if (seen.has(d.sym))
+                continue;
+            seen.add(d.sym);
+            const via = leaves(d, seen);
+            if (via)
+                return `${via}, carried as ${d.name}`;
+        }
+        return undefined;
+    };
     // Values of the type read back from JSON (JSON.parse, readJson, a response's .json()) as the type: an assertion,
     // an annotated variable, a type argument, or the declared return of the function that returns them. Data written
     // before a member existed lacks it, so the member stays optional however every host in the code supplies it now.
@@ -318,8 +398,27 @@ function redundancyFailures(typed, changedLines, config) {
         if (!sym)
             return 'no such property';
         const declaration = sym.declarations?.[0];
-        const isOurs = (s) => !!s && (s === sym || !!s.declarations?.some(d => d === declaration));
-        const ofType = (expr) => mentionsType(t, checker.getTypeAtLocation(expr));
+        const ownRead = (s) => !!s && (s === sym || !!s.declarations?.some(d => d === declaration));
+        const ownType = (expr) => mentionsType(t, checker.getTypeAtLocation(expr));
+        let found = scanReads(name, ownRead, ownType);
+        if (found)
+            return found;
+        // A value of T received as another type (`p?: { x: string }` holding a T) is read through that type's member of the same name.
+        const { receivers } = flowsOf(t);
+        const members = new Set(receivers.map(r => checker.getPropertyOfType(r, name)).filter((m) => !!m));
+        if (members.size) {
+            const memberDecls = new Set([...members].flatMap(m => m.declarations ?? []));
+            const viaRead = (s) => !!s && (members.has(s) || !!s.declarations?.some(d => memberDecls.has(d)));
+            const viaType = (expr) => receivers.includes(checker.getNonNullableType(checker.getTypeAtLocation(expr)));
+            found = scanReads(name, viaRead, viaType);
+            if (found)
+                return found;
+        }
+        const text = textReads(t, name);
+        return text ? `${text.file} (by name)` : undefined;
+    };
+    // A read of `name` in a non-test file: an access whose symbol `isOurs` accepts, or a destructuring or `['name']` of a value `ofType` accepts.
+    const scanReads = (name, isOurs, ofType) => {
         for (const sf of typed.appSources) {
             if (!sf.text.includes(name) && !sf.text.includes('...'))
                 continue;
@@ -337,8 +436,7 @@ function redundancyFailures(typed, changedLines, config) {
             if (read)
                 return at(read);
         }
-        const text = textReads(t, name);
-        return text ? `${text.file} (by name)` : undefined;
+        return undefined;
     };
     for (const t of declaredTypes) {
         const hosts = hostsOf(t);
@@ -375,7 +473,7 @@ function redundancyFailures(typed, changedLines, config) {
                 }
             }
             if (supplied.length && !wire && !isRead(t, name)) {
-                const exit = escapes(t);
+                const exit = leaves(t);
                 if (exit)
                     hints.push(`write-only-property ${at(m)}: ${t.name}.${name} is set by ${supplied.length} host(s) and read by no code; the value leaves only through ${exit}. Confirm an external reader needs it, else delete it`);
                 else if (published)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/core",
-  "version": "6.12.2-rc.2",
+  "version": "6.12.2-rc.4",
   "description": "Rigour's review engine: deterministic gates on changed lines, rules and lessons learned from your team's fixes, and per-check precision from what you fix versus dismiss, across TypeScript, JavaScript, Python, Go, Ruby and C#.",
   "engines": {
     "node": ">=22.13"
@@ -75,11 +75,11 @@
     "@anthropic-ai/sdk": "^0.132.1",
     "pg": "^8.16.3",
     "openai": "^5.23.2",
-    "@rigour-labs/brain-darwin-arm64": "6.12.2-rc.2",
-    "@rigour-labs/brain-darwin-x64": "6.12.2-rc.2",
-    "@rigour-labs/brain-linux-arm64": "6.12.2-rc.2",
-    "@rigour-labs/brain-win-x64": "6.12.2-rc.2",
-    "@rigour-labs/brain-linux-x64": "6.12.2-rc.2"
+    "@rigour-labs/brain-darwin-arm64": "6.12.2-rc.4",
+    "@rigour-labs/brain-linux-x64": "6.12.2-rc.4",
+    "@rigour-labs/brain-linux-arm64": "6.12.2-rc.4",
+    "@rigour-labs/brain-win-x64": "6.12.2-rc.4",
+    "@rigour-labs/brain-darwin-x64": "6.12.2-rc.4"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",