@0xcraft/powershot 1.1.4 → 1.2.0

package/dist/session.js

@@ -110,6 +110,7 @@ export class Session {
             verifyOnly: verdict.verifyOnly,
             minSeverity: verdict.minSeverity,
             filesReviewed: verdict.filesReviewed,
+            filesChanged: verdict.filesChanged,
             deterministicChecks: verdict.deterministicChecks,
             scopeDetails: verdict.scopeDetails ? [...verdict.scopeDetails] : undefined,
         };

package/dist/verifiers/dropped-guard.js

@@ -1,123 +1,224 @@
 import { Node, SyntaxKind } from 'ts-morph';
 import { locate, relPath } from '#app/ground.js';
+import { typescriptSourceFingerprint, typescriptTokenFingerprint } from '#app/reinvention.js';
+import { hasOtherExecutableChange, provenGuardRemovals, } from './guard-diff.js';
+function fingerprintWithoutRange(root, start, end, marker) {
+    const source = root.getFullText();
+    const rootStart = root.getFullStart();
+    return typescriptSourceFingerprint(source.slice(0, start - rootStart) + marker + source.slice(end - rootStart));
+}
+function fingerprintWithoutRanges(root, ranges, marker) {
+    const source = root.getFullText();
+    const rootStart = root.getFullStart();
+    const ordered = [...ranges].sort((left, right) => left.getStart() - right.getStart());
+    const parts = [];
+    let cursor = 0;
+    for (const range of ordered) {
+        const start = range.getFullStart() - rootStart;
+        const end = range.getEnd() - rootStart;
+        if (start < cursor)
+            continue;
+        parts.push(source.slice(cursor, start), marker);
+        cursor = end;
+    }
+    parts.push(source.slice(cursor));
+    return typescriptSourceFingerprint(parts.join(''));
+}
+function fingerprintWithoutBody(identityNode, body) {
+    return fingerprintWithoutRange(identityNode, body.getStart(), body.getEnd(), '__powershot_body__');
+}
+function callable(name, node, moduleContract, identityNode = node, owner = '') {
+    if (!Node.isFunctionDeclaration(node) &&
+        !Node.isMethodDeclaration(node) &&
+        !Node.isArrowFunction(node) &&
+        !Node.isFunctionExpression(node))
+        return undefined;
+    const body = node.getBody();
+    if (!body)
+        return undefined;
+    const fingerprint = fingerprintWithoutBody(identityNode, body);
+    return fingerprint ? { name, node, identity: moduleContract + '|' + owner + '|' + name + '|' + fingerprint } : undefined;
+}
+function classContract(node) {
+    if (!Node.isClassDeclaration(node))
+        return undefined;
+    const members = node.getMembers();
+    const first = members[0];
+    const last = members.at(-1);
+    if (!first || !last)
+        return typescriptTokenFingerprint(node.getText());
+    return fingerprintWithoutRange(node, first.getStart(), last.getEnd(), '__powershot_members__');
+}
+function moduleContract(source) {
+    const bodies = [];
+    for (const declaration of source.getFunctions()) {
+        const body = declaration.getBody();
+        if (body)
+            bodies.push(body);
+    }
+    for (const declaration of source.getClasses()) {
+        for (const method of declaration.getMethods()) {
+            const body = method.getBody();
+            if (body)
+                bodies.push(body);
+        }
+    }
+    for (const declaration of source.getVariableDeclarations()) {
+        const initializer = declaration.getInitializer();
+        if (initializer && (Node.isArrowFunction(initializer) || Node.isFunctionExpression(initializer))) {
+            bodies.push(initializer.getBody());
+        }
+    }
+    return fingerprintWithoutRanges(source, bodies, '__powershot_callable_body__');
+}
 function functionsOf(sf) {
     const out = [];
+    const module = moduleContract(sf);
+    if (!module)
+        return out;
     for (const fn of sf.getFunctions()) {
         const name = fn.getName();
-        if (name)
-            out.push({ name, node: fn });
+        const found = name ? callable(name, fn, module) : undefined;
+        if (found)
+            out.push(found);
     }
     for (const cls of sf.getClasses()) {
         const prefix = (cls.getName() ?? 'anonymous') + '.';
-        for (const m of cls.getMethods())
-            out.push({ name: prefix + m.getName(), node: m });
+        const owner = classContract(cls);
+        if (!owner)
+            continue;
+        for (const m of cls.getMethods()) {
+            const found = callable(prefix + m.getName(), m, module, m, owner);
+            if (found)
+                out.push(found);
+        }
     }
     for (const v of sf.getVariableDeclarations()) {
         const init = v.getInitializer();
         if (init?.isKind(SyntaxKind.ArrowFunction) || init?.isKind(SyntaxKind.FunctionExpression)) {
-            out.push({ name: v.getName(), node: v });
+            const found = callable(v.getName(), init, module, v);
+            if (found)
+                out.push(found);
         }
     }
     return out;
 }
+function functionsByName(sf) {
+    const out = new Map();
+    for (const fn of functionsOf(sf)) {
+        const list = out.get(fn.name) ?? [];
+        list.push(fn);
+        out.set(fn.name, list);
+    }
+    return out;
+}
 /** collapse whitespace so reformatting alone never reads as a dropped guard */
 function normalize(text) {
     return text.replace(/\s+/g, ' ').trim();
 }
-/** every identifier the new version of a function still mentions */
-function identifiersIn(fn) {
-    const out = new Set();
-    for (const id of fn.getDescendantsOfKind(SyntaxKind.Identifier))
-        out.add(id.getText());
-    return out;
-}
 /**
- * The things a condition actually reads: the base of each reference, never the
- * property names hanging off it. In `!inv.customer` the root is `inv` — `customer`
- * is a field, and a rewritten body has no reason to mention it.
+ * A guard is an `if` whose branch bails out — throw, return, continue, or break.
+ * That shape is what protects the code below it, so losing one changes behaviour.
  */
-function rootsOf(condition) {
-    const roots = [];
-    for (const id of condition.getDescendantsOfKind(SyntaxKind.Identifier)) {
-        const parent = id.getParent();
-        // skip the `.name` half of a property access, and object-literal keys
-        if (Node.isPropertyAccessExpression(parent) && parent.getNameNode() === id)
-            continue;
-        if (Node.isPropertyAssignment(parent) && parent.getNameNode() === id)
+function guardOf(statement) {
+    if (!Node.isIfStatement(statement))
+        return undefined;
+    if (statement.getElseStatement())
+        return undefined;
+    const branch = statement.getThenStatement();
+    const directBail = (node) => node.isKind(SyntaxKind.ThrowStatement) ||
+        node.isKind(SyntaxKind.ReturnStatement) ||
+        node.isKind(SyntaxKind.ContinueStatement) ||
+        node.isKind(SyntaxKind.BreakStatement);
+    const last = Node.isBlock(branch) ? branch.getStatements().at(-1) : branch;
+    if (!last || !directBail(last))
+        return undefined;
+    const expression = statement.getExpression();
+    const fingerprint = typescriptTokenFingerprint(expression.getText());
+    return fingerprint ? { key: 'if|' + fingerprint, label: normalize(expression.getText()) } : undefined;
+}
+function proofOf(fn) {
+    const statements = new Map();
+    const blocks = [];
+    for (const block of fn.node.getDescendantsOfKind(SyntaxKind.Block)) {
+        if (!belongsTo(fn.node, block))
             continue;
-        roots.push(id.getText());
+        const entries = [];
+        let complete = true;
+        for (const statement of block.getStatements()) {
+            const id = pathFrom(fn.node, statement);
+            const fingerprint = typescriptTokenFingerprint(statement.getText());
+            if (!id || !fingerprint) {
+                complete = false;
+                break;
+            }
+            statements.set(id, statement);
+            entries.push({ id, fingerprint, guard: guardOf(statement) });
+        }
+        if (complete)
+            blocks.push({ path: pathFrom(fn.node, block), entries });
     }
-    if (Node.isIdentifier(condition))
-        roots.push(condition.getText());
-    return roots;
-}
-/**
- * A guard whose roots the rewritten function no longer has is not a guard someone
- * dropped — it stopped existing along with the code it protected. `formatWeight`
- * rewritten from ounces to grams cannot keep `if (pounds === 0)`, and reporting it
- * would accuse a deliberate rewrite of losing a check it could not have kept.
- */
-function stillApplicable(roots, available) {
-    return roots.every((n) => available.has(n) || GLOBALS.has(n));
+    return {
+        identity: fn.identity,
+        blocks,
+        residualFingerprint(omitted) {
+            const ranges = [];
+            for (const id of omitted) {
+                const statement = statements.get(id);
+                if (!statement)
+                    return undefined;
+                ranges.push(statement);
+            }
+            return fingerprintWithoutRanges(fn.node.getSourceFile(), ranges, '');
+        },
+    };
 }
-/**
- * The same check, respelled. When `pool` turns from an array into a number,
- * `pool.length === 0` becomes `pool === 0`: different text, same guarantee. Matching
- * on what a guard reads rather than how it is written keeps a rewrite from reading
- * as a removal — at the cost of missing a guard narrowed on the same variable, which
- * is the direction this tool chooses to err in.
- */
-function guardedElsewhere(roots, after) {
-    if (roots.length === 0)
-        return false;
-    return [...after.values()].some((other) => roots.every((r) => other.includes(r)));
+function belongsTo(root, node) {
+    let current = node.getParent();
+    while (current && current !== root) {
+        if (Node.isFunctionLikeDeclaration(current))
+            return false;
+        current = current.getParent();
+    }
+    return current === root;
 }
-const GLOBALS = new Set(['undefined', 'NaN', 'Number', 'String', 'Array', 'Object', 'Boolean', 'Math', 'JSON', 'Date']);
-/**
- * A guard is an `if` whose branch bails out — throw, return, continue, or break.
- * That shape is what protects the code below it, so losing one changes behaviour.
- */
-function guardsOf(fn) {
-    const guards = new Map();
-    for (const ifStmt of fn.getDescendantsOfKind(SyntaxKind.IfStatement)) {
-        const branch = ifStmt.getThenStatement();
-        const bails = branch.getDescendantsOfKind(SyntaxKind.ThrowStatement).length > 0 ||
-            branch.getDescendantsOfKind(SyntaxKind.ReturnStatement).length > 0 ||
-            branch.getDescendantsOfKind(SyntaxKind.ContinueStatement).length > 0 ||
-            branch.getDescendantsOfKind(SyntaxKind.BreakStatement).length > 0 ||
-            Node.isThrowStatement(branch) ||
-            Node.isReturnStatement(branch);
-        if (bails)
-            guards.set(normalize(ifStmt.getExpression().getText()), rootsOf(ifStmt.getExpression()));
+function pathFrom(root, node) {
+    const path = [];
+    let current = node;
+    while (current && current !== root) {
+        const parent = current.getParent();
+        if (!parent)
+            return '';
+        path.push(current.getChildIndex());
+        current = parent;
     }
-    return guards;
+    return path.reverse().join('.');
 }
 /**
- * A guard that existed before the change and is gone after it, in a function that
- * still exists. The pre/post AST pair is the oracle, so this is proven: the
- * condition text was there and now it is not.
+ * The pre/post AST pair proves only a guard-only deletion from the same callable and
+ * lexical block. Refactors that move or change the continuation deliberately abstain.
  */
 export const droppedGuard = {
     name: 'dropped-guard',
     needs: ['syntax', 'base'],
     run(g) {
         const findings = [];
-        for (const { sf, before } of g.files) {
+        for (const { sf, before, changed } of g.files) {
             if (!before)
                 continue; // a new file cannot have dropped anything
-            const after = new Map(functionsOf(sf).map((f) => [f.name, f]));
-            for (const prev of functionsOf(before)) {
-                const now = after.get(prev.name);
-                if (!now)
-                    continue; // function removed entirely — that is a different finding
-                const had = guardsOf(prev.node);
-                if (had.size === 0)
+            const file = relPath(sf, g.root);
+            if (changed.beforePath && changed.beforePath !== changed.path)
+                continue;
+            if (hasOtherExecutableChange(g, file))
+                continue;
+            const after = functionsByName(sf);
+            for (const [name, previous] of functionsByName(before)) {
+                const current = after.get(name) ?? [];
+                if (previous.length !== 1 || current.length !== 1)
                     continue;
-                const has = guardsOf(now.node);
-                const available = identifiersIn(now.node);
-                const dropped = [...had.entries()]
-                    .filter(([guard, roots]) => !has.has(guard) && stillApplicable(roots, available) && !guardedElsewhere(roots, has))
-                    .map(([guard]) => guard);
+                const prev = previous[0];
+                const now = current[0];
+                const dropped = provenGuardRemovals(proofOf(prev), proofOf(now));
                 if (dropped.length === 0)
                     continue;
                 // one finding per function, not per guard: several guards lost in the same
@@ -128,13 +229,16 @@ export const droppedGuard = {
                     check: 'dropped-guard',
                     severity: 'high',
                     confidence: 'proven',
-                    file: relPath(sf, g.root),
+                    file,
                     line: now.node.getStartLineNumber(),
                     span: locate(sf, now.node.getStart(), Math.min(now.node.getWidth(), 80)).span,
                     title: dropped.map((d) => '`if (' + d + ')`').join(' and ') +
                         ' ' + (dropped.length > 1 ? 'were' : 'was') +
-                        ' present in ' + prev.name + '() before this change and ' + (dropped.length > 1 ? 'are' : 'is') + ' gone',
-                    evidence: { oracle: 'pre/post AST', detail: 'early-exit branch removed while the function still exists and still uses the same names' },
+                        ' present in ' + name + '() before this change and ' + (dropped.length > 1 ? 'are' : 'is') + ' gone',
+                    evidence: {
+                        oracle: 'pre/post control-flow AST',
+                        detail: 'every other file token matches after removing only the guard, with no executable change in another source file',
+                    },
                 });
             }
         }

package/dist/verifiers/foreign-dropped-guard.js

@@ -1,38 +1,163 @@
 import { nodesOfType } from '#app/lang/packs.js';
-import { declaredName, finding } from './foreign-tokens.js';
-function guardsOf(fn, pack) {
-    const guards = new Map();
-    for (const stmt of nodesOfType(fn, pack.nodes.ifStatement)) {
-        const cond = stmt.childForFieldName(pack.nodes.ifCondition);
-        const body = stmt.childForFieldName(pack.nodes.ifBody);
-        if (!cond || !body)
-            continue;
-        const bails = nodesOfType(body, pack.nodes.bail).length > 0;
-        if (!bails)
-            continue;
-        const roots = nodesOfType(cond, pack.nodes.identifier).map((n) => n.text);
-        guards.set(cond.text.replace(/\s+/g, ' ').trim(), roots);
+import { implementationFingerprint } from '#app/reinvention.js';
+import { hasOtherExecutableChange, provenGuardRemovals, } from './guard-diff.js';
+import { declaredName, fileScopeIdentity, finding, sourceTokensFor, tokensFor } from './foreign-tokens.js';
+function bodyOf(root, types) {
+    const field = root.childForFieldName('body');
+    if (field && types.includes(field.type))
+        return field;
+    for (const child of root.namedChildren) {
+        if (types.includes(child.type))
+            return child;
     }
-    return guards;
+    return undefined;
 }
-/** Declarations at module level — the names another file could actually import. */
-export function functionsByName(root, pack) {
-    const all = nodesOfType(root, pack.nodes.declaration);
+function contractPart(node, bodyTypes, pack) {
+    const body = bodyOf(node, bodyTypes);
+    if (body)
+        return node.type + ':' + implementationFingerprint(tokensFor(node, pack, body));
+    const name = node.childForFieldName('name');
+    return name
+        ? node.type + ':name:' + implementationFingerprint(tokensFor(name, pack))
+        : node.type + ':anonymous';
+}
+function callablesByIdentity(root, pack) {
     const out = new Map();
-    for (const decl of all) {
-        const containsAnother = all.some((other) => other !== decl &&
-            other.startPosition.row >= decl.startPosition.row &&
-            other.endPosition.row <= decl.endPosition.row);
-        if (containsAnother)
-            continue;
-        const name = declaredName(decl, pack);
-        if (name)
-            out.set(name, decl);
-    }
+    const callableBodies = nodesOfType(root, pack.nodes.callable)
+        .flatMap((node) => {
+        const body = bodyOf(node, pack.nodes.callableBody);
+        return body ? [body] : [];
+    });
+    const moduleContract = 'module:' + implementationFingerprint(tokensFor(root, pack, callableBodies));
+    const visit = (node, context) => {
+        let currentContext = context;
+        if (pack.nodes.callableOwner.includes(node.type)) {
+            currentContext = [...context, contractPart(node, pack.nodes.callableOwnerBody, pack)];
+        }
+        if (pack.nodes.callable.includes(node.type)) {
+            const name = declaredName(node, pack);
+            const body = bodyOf(node, pack.nodes.callableBody);
+            if (name && body) {
+                const part = contractPart(node, pack.nodes.callableBody, pack);
+                const identity = [...currentContext, part].join('/');
+                const list = out.get(identity) ?? [];
+                list.push({ name, node, identity });
+                out.set(identity, list);
+                // A nested callable belongs to this exact outer callable, not merely to a
+                // same-named function elsewhere in the file.
+                currentContext = [...currentContext, part];
+            }
+        }
+        for (const child of node.namedChildren)
+            visit(child, currentContext);
+    };
+    const fileScope = fileScopeIdentity(root, pack);
+    visit(root, [moduleContract, ...(fileScope ? [fileScope] : [])]);
     return out;
 }
-/** A guard the change removed from a function that still exists — see the TS version
- *  for why obsolete and respelled guards are excluded. */
+function endsInBail(node, pack) {
+    if (pack.nodes.bail.includes(node.type))
+        return true;
+    const children = node.namedChildren.filter((child) => !pack.nodes.comment.includes(child.type));
+    if (pack.nodes.block.includes(node.type)) {
+        const last = children.at(-1);
+        return last !== undefined && endsInBail(last, pack);
+    }
+    // Some grammars wrap a return expression in one expression-statement node.
+    return children.length === 1 && endsInBail(children[0], pack);
+}
+function childForAnyField(node, fields) {
+    for (const field of fields) {
+        const child = node.childForFieldName(field);
+        if (child)
+            return child;
+    }
+    return null;
+}
+function sameNode(left, right) {
+    return left.type === right.type &&
+        left.startPosition.row === right.startPosition.row &&
+        left.startPosition.column === right.startPosition.column &&
+        left.endPosition.row === right.endPosition.row &&
+        left.endPosition.column === right.endPosition.column;
+}
+function guardOf(statement, pack) {
+    let conditional = statement;
+    while (!pack.nodes.ifStatement.includes(conditional.type)) {
+        const children = conditional.namedChildren.filter((child) => !pack.nodes.comment.includes(child.type));
+        if (children.length !== 1)
+            return undefined;
+        conditional = children[0];
+    }
+    const children = conditional.namedChildren.filter((child) => !pack.nodes.comment.includes(child.type));
+    const condition = childForAnyField(conditional, pack.nodes.ifCondition) ?? children[0] ?? null;
+    const branch = childForAnyField(conditional, pack.nodes.ifBody) ?? children[1] ?? null;
+    if (!condition || !branch || !endsInBail(branch, pack))
+        return undefined;
+    if (childForAnyField(conditional, pack.nodes.ifAlternative))
+        return undefined;
+    // Postfix conditionals put the branch before the condition. Reject a real
+    // alternative by identity, not by assuming every grammar orders children alike.
+    if (children.some((child) => !sameNode(child, condition) && !sameNode(child, branch)))
+        return undefined;
+    const polarity = conditional.type.includes('unless') ? 'unless' : 'if';
+    return {
+        key: polarity + '|' + implementationFingerprint(tokensFor(condition, pack)),
+        label: condition.text.replace(/\s+/g, ' ').trim(),
+    };
+}
+function proofOf(callable, pack, root) {
+    const out = [];
+    const statements = new Map();
+    const visit = (node, path) => {
+        // Nested callables have their own before/after identity. Including their blocks
+        // in the parent could pair a moved continuation with the wrong lexical scope.
+        if (node !== callable.node && pack.nodes.callable.includes(node.type))
+            return;
+        if (pack.nodes.block.includes(node.type)) {
+            const blockPath = path.join('.');
+            out.push({
+                path: blockPath,
+                entries: node.namedChildren
+                    .filter((child) => !pack.nodes.comment.includes(child.type))
+                    .map((statement, index) => {
+                    const id = blockPath + ':statement:' + index;
+                    statements.set(id, statement);
+                    return {
+                        id,
+                        fingerprint: implementationFingerprint(tokensFor(statement, pack)),
+                        guard: guardOf(statement, pack),
+                    };
+                }),
+            });
+        }
+        for (let index = 0; index < node.childCount; index++) {
+            const child = node.child(index);
+            if (child)
+                visit(child, [...path, index]);
+        }
+    };
+    visit(callable.node, []);
+    return {
+        identity: callable.identity,
+        blocks: out,
+        residualFingerprint(omitted) {
+            const excluded = [];
+            for (const id of omitted) {
+                const statement = statements.get(id);
+                if (!statement)
+                    return undefined;
+                excluded.push(statement);
+            }
+            return implementationFingerprint(sourceTokensFor(root, pack, excluded));
+        },
+    };
+}
+/**
+ * Report only the narrow deterministic case: a uniquely identified callable and
+ * lexical block are unchanged except for deleting an unconditional early-exit guard.
+ * Helper extraction, delegation, moved code, and overloaded names all abstain.
+ */
 export const foreignDroppedGuard = {
     name: 'dropped-guard',
     needs: ['syntax', 'base'],
@@ -41,34 +166,33 @@ export const foreignDroppedGuard = {
         for (const file of g.foreign) {
             if (!file.beforeTree)
                 continue;
-            const after = functionsByName(file.tree.rootNode, file.pack);
-            for (const [name, prev] of functionsByName(file.beforeTree.rootNode, file.pack)) {
-                const now = after.get(name);
-                if (!now)
-                    continue;
-                const had = guardsOf(prev, file.pack);
-                if (had.size === 0)
+            if (file.changed.beforePath && file.changed.beforePath !== file.path)
+                continue;
+            if (hasOtherExecutableChange(g, file.path))
+                continue;
+            const before = callablesByIdentity(file.beforeTree.rootNode, file.pack);
+            const after = callablesByIdentity(file.tree.rootNode, file.pack);
+            for (const [identity, previous] of before) {
+                const current = after.get(identity) ?? [];
+                // A duplicate contract is still ambiguous. Without types or symbol
+                // resolution, choosing one declaration would turn ambiguity into fact.
+                if (previous.length !== 1 || current.length !== 1)
                     continue;
-                const has = guardsOf(now, file.pack);
-                const available = new Set(nodesOfType(now, file.pack.nodes.identifier).map((n) => n.text));
-                const dropped = [...had.entries()]
-                    .filter(([text, roots]) => {
-                    if (has.has(text))
-                        return false;
-                    if (!roots.every((r) => available.has(r)))
-                        return false; // obsolete with the code it protected
-                    return ![...has.values()].some((other) => roots.every((r) => other.includes(r))); // respelled
-                })
-                    .map(([text]) => text);
+                const prev = previous[0];
+                const now = current[0];
+                const dropped = provenGuardRemovals(proofOf(prev, file.pack, file.beforeTree.rootNode), proofOf(now, file.pack, file.tree.rootNode));
                 if (dropped.length === 0)
                     continue;
-                findings.push(finding(file, now, {
+                findings.push(finding(file, now.node, {
                     check: 'dropped-guard',
                     severity: 'high',
                     confidence: 'proven',
-                    title: dropped.map((d) => '`' + d + '`').join(' and ') + ' guarded ' + name + '() before this change and ' +
+                    title: dropped.map((d) => '`' + d + '`').join(' and ') + ' guarded ' + now.name + '() before this change and ' +
                         (dropped.length > 1 ? 'are' : 'is') + ' gone',
-                    evidence: { oracle: file.pack.name + ' pre/post AST', detail: 'early-exit branch removed while the function still uses the same names' },
+                    evidence: {
+                        oracle: file.pack.name + ' pre/post control-flow AST',
+                        detail: 'every other file token matches after removing only the guard, with no executable change in another source file',
+                    },
                 }));
             }
         }

package/dist/verifiers/foreign-reinvented.js

@@ -1,5 +1,6 @@
+import { posix } from 'node:path';
 import { createReinventionScopeResolver, implementationFingerprint } from '#app/reinvention.js';
-import { finding, tokensFor, topLevelDeclarations } from './foreign-tokens.js';
+import { finding, reusableDeclarations } from './foreign-tokens.js';
 /** Names too common to mean anything across files, as in the TypeScript version. */
 const GENERIC = new Set([
     'render', 'handler', 'handle', 'create', 'update', 'remove', 'delete', 'insert',
@@ -18,12 +19,19 @@ const TESTISH = /(^|\/)(tests?|spec|__tests__)\/|(^|\/)(test_[^/]+|[^/]+_test|[^
 function normalized(name) {
     return name.toLowerCase().replace(/[^a-z0-9]/g, '');
 }
-function declarationIndex(root, pack) {
+function declarationIndex(root, pack, path) {
     const index = new Map();
-    for (const [name, node] of topLevelDeclarations(root, pack)) {
-        const key = normalized(name);
+    const sourceScope = pack.name === 'go'
+        ? ['directory:' + posix.dirname(path.replaceAll('\\', '/'))]
+        : [];
+    for (const declaration of reusableDeclarations(root, pack, path)) {
+        const { scope, name, node, tokens } = declaration;
+        // Declaration names deliberately bridge snake/camel spelling. Language
+        // namespaces do not: changing only their case still names a different scope in
+        // case-sensitive languages.
+        const key = [...sourceScope, ...scope].join('::') + '|' + normalized(name);
         const list = index.get(key) ?? [];
-        list.push({ name, node, fingerprint: implementationFingerprint(tokensFor(node, pack)) });
+        list.push({ name, node, fingerprint: implementationFingerprint(tokens) });
         index.set(key, list);
     }
     return index;
@@ -43,8 +51,10 @@ export const foreignReinvented = {
         const declarations = new Map();
         for (const file of g.foreign) {
             declarations.set(file.path, {
-                current: declarationIndex(file.tree.rootNode, file.pack),
-                base: file.beforeTree ? declarationIndex(file.beforeTree.rootNode, file.pack) : undefined,
+                current: declarationIndex(file.tree.rootNode, file.pack, file.path),
+                base: file.beforeTree
+                    ? declarationIndex(file.beforeTree.rootNode, file.pack, file.changed.beforePath ?? file.path)
+                    : undefined,
             });
         }
         for (const file of g.foreign) {
@@ -58,6 +68,9 @@ export const foreignReinvented = {
                     // at the reviewed head. A removed or rewritten helper is not a candidate.
                     if (!currentDeclaration)
                         continue;
+                    const beforePath = file.changed.beforePath ?? file.path;
+                    if (scopeFor(beforePath) !== scopeFor(file.path))
+                        continue;
                     const key = file.pack.name + '|' + nameKey;
                     const list = index.get(key) ?? [];
                     list.push({
@@ -73,6 +86,8 @@ export const foreignReinvented = {
         for (const file of g.foreign) {
             if (TESTISH.test(file.path))
                 continue;
+            if (file.changed.beforePath && file.changed.beforePath !== file.path)
+                continue;
             const fileDeclarations = declarations.get(file.path);
             for (const [nameKey, currentDeclarations] of fileDeclarations.current) {
                 for (const { name, node: decl, fingerprint } of currentDeclarations) {