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

package/dist/review/typed/redundancy.js

@@ -284,24 +284,51 @@ function redundancyFailures(typed, changedLines, config) {
         }
         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 flowsInto = (t) => {
+    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];
+        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);
@@ -371,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;
@@ -390,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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/core",
-  "version": "6.12.2-rc.3",
+  "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.3",
-    "@rigour-labs/brain-linux-arm64": "6.12.2-rc.3",
-    "@rigour-labs/brain-darwin-x64": "6.12.2-rc.3",
-    "@rigour-labs/brain-win-x64": "6.12.2-rc.3",
-    "@rigour-labs/brain-linux-x64": "6.12.2-rc.3"
+    "@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",