@0xcraft/powershot 1.1.3 → 1.1.5

package/README.md

@@ -123,8 +123,8 @@ oracle is never counted as a pass in either profile.
 | `phantom-dep` | Imports absent from project manifests | Dependency manifests |
 | `phantom-config` | Configuration keys with no declared source | Repository config index |
 | `contract-drift` | Signature changes with callers left behind | Types and references |
-| `reinvented` | New helpers duplicating existing symbols | Symbol index |
-| `dropped-guard` | Removed guards, early returns, protective branches | Pre/post AST |
+| `reinvented` | New cross-file declarations with a token-identical implementation, package, visibility, wrapper, and binding context | Base declaration + scoped token fingerprint |
+| `dropped-guard` | Early-exit guards deleted while every other token in the file and changed source set stays unchanged | Pre/post control-flow AST |
 | `swallowed-error` | Empty or ineffective error handling | AST shape |
 | `vacuous-test` | Tests that do not assert behavior | Test AST |
 | `assertion-drift` | Expectations changed under stable behavior | Pre/post test AST |

package/dist/git.js

@@ -89,7 +89,7 @@ function changedPaths(raw) {
         }
         const path = fields[i++];
         if (path)
-            out.push({ path, beforePath: status === 'A' ? undefined : path });
+            out.push({ path, beforePath: status === 'A' ? undefined : path, deleted: status === 'D' });
     }
     return out;
 }
@@ -195,9 +195,9 @@ export function collectChanges(root, range) {
     }
     const files = [];
     const tracked = changedPaths(git(root, [
-        'diff', '--name-status', '-z', '--diff-filter=ACMRT', '--find-renames', ...diffArgs,
+        'diff', '--name-status', '-z', '--diff-filter=ACDMRT', '--find-renames', ...diffArgs,
     ]));
-    for (const { path, beforePath } of tracked) {
+    for (const { path, beforePath, deleted } of tracked) {
         const pathspecs = beforePath && beforePath !== path
             ? [':(literal)' + beforePath, ':(literal)' + path]
             : [':(literal)' + path];
@@ -207,6 +207,8 @@ export function collectChanges(root, range) {
         ]);
         files.push({
             path,
+            beforePath: beforePath && beforePath !== path ? beforePath : undefined,
+            deleted,
             added: addedLinesInPatch(patch),
             before: beforePath === undefined ? undefined : fileAtRef(root, baseRef, beforePath),
         });

package/dist/ground.js

@@ -4,6 +4,7 @@ import { decode } from './text.js';
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { PACKS, packFor, parseIsolated } from './lang/packs.js';
 import { insideRepo, isSymlink, repoPath } from './fspolicy.js';
+import { createReinventionScopeResolver, exportedDeclarations, typescriptImplementationFingerprint } from './reinvention.js';
 const CODE_EXT = /\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/;
 const TS_CONFIG = /^tsconfig(?:\..+)?\.json$/i;
 const MISSING_TYPE_PREFIXES = [
@@ -215,7 +216,7 @@ function makeDepsFor(root) {
  * packages, a syntax-only project for unconfigured changes and the base-ref trees,
  * and one deduplicated symbol index over the relevant project closures.
  */
-export async function buildGround(root, changed, signal) {
+export async function buildGround(root, changed, signal, inventory = changed) {
     root = resolve(root);
     const directoryCache = new Map();
     const projectCache = new Map();
@@ -252,6 +253,7 @@ export async function buildGround(root, changed, signal) {
         }
     }
     const beforeProject = new Project({ useInMemoryFileSystem: true });
+    const beforeSources = new Map();
     const files = [];
     for (const c of changed) {
         if (!CODE_EXT.test(c.path))
@@ -263,7 +265,12 @@ export async function buildGround(root, changed, signal) {
         const sf = configured?.project.getSourceFile(abs) ?? syntaxProject.getSourceFile(abs);
         if (!sf)
             continue;
-        const before = c.before === undefined ? undefined : beforeProject.createSourceFile(`/before/${c.path}`, c.before, { overwrite: true });
+        const beforeKey = c.beforePath ?? c.path;
+        let before = c.before === undefined ? undefined : beforeSources.get(beforeKey);
+        if (c.before !== undefined && !before) {
+            before = beforeProject.createSourceFile(`/before/${beforeKey}`, c.before);
+            beforeSources.set(beforeKey, before);
+        }
         files.push({
             sf,
             changed: c,
@@ -288,8 +295,9 @@ export async function buildGround(root, changed, signal) {
         configFiles,
         beforeProject,
         changed,
+        inventory,
         files,
-        symbolIndex: buildSymbolIndex(sourceFiles, root),
+        symbolIndex: buildSymbolIndex(sourceFiles, root, changed, beforeProject),
         deps: depsFor(join(root, 'x.ts')),
         depsFor,
         typed,
@@ -437,35 +445,75 @@ async function parseForeign(root, changed, signal) {
         return result ? [result] : [];
     });
 }
-function buildSymbolIndex(sourceFiles, root) {
+function buildSymbolIndex(sourceFiles, root, changed, beforeProject) {
     const index = new Map();
+    const changes = new Map(changed.map((file) => [file.path, file]));
+    const scopeFor = createReinventionScopeResolver(root);
+    const relevantNames = new Set();
+    for (const sf of sourceFiles) {
+        const rel = repoPath(root, String(sf.getFilePath()));
+        if (!changes.has(rel))
+            continue;
+        for (const declaration of sf.getFunctions()) {
+            const name = declaration.getName();
+            if (name)
+                relevantNames.add(normalizeName(name));
+        }
+        for (const declaration of sf.getVariableDeclarations()) {
+            const initializer = declaration.getInitializer();
+            if (initializer?.isKind(SyntaxKind.ArrowFunction) || initializer?.isKind(SyntaxKind.FunctionExpression)) {
+                relevantNames.add(normalizeName(declaration.getName()));
+            }
+        }
+    }
     for (const sf of sourceFiles) {
         const path = String(sf.getFilePath());
         // the project glob follows symlinked directories, so what it loaded is not
         // proof of where the file is
         if (path.includes('/node_modules/') || !insideRepo(root, path))
             continue;
-        for (const [name, decls] of sf.getExportedDeclarations()) {
-            const decl = decls[0];
-            if (!decl)
+        for (const { name, node: decl } of exportedDeclarations(sf)) {
+            const key = normalizeName(name);
+            // Fingerprint only names the change could have introduced. This keeps index
+            // construction proportional to the diff even when the project closure is a
+            // very large monorepo.
+            if (!relevantNames.has(key))
                 continue;
             // only index things that could plausibly be reimplemented
             const kind = decl.getKind();
             if (kind !== SyntaxKind.FunctionDeclaration &&
-                kind !== SyntaxKind.VariableDeclaration &&
-                kind !== SyntaxKind.ClassDeclaration)
+                kind !== SyntaxKind.VariableDeclaration)
+                continue;
+            // A barrel alias can be new in this change even when its underlying callable
+            // predates it. Index the declaration from its own module, where both its name
+            // and base existence can be proved, rather than manufacturing history for the
+            // new alias or recording every `export *` as another copy.
+            if (decl.getSourceFile() !== sf)
                 continue;
-            // a barrel re-exports another module's symbol, so record where it is actually
-            // declared — otherwise `export * from './x'` makes every symbol look duplicated
             const declPath = String(decl.getSourceFile().getFilePath());
             if (declPath.includes('/node_modules/') || !insideRepo(root, declPath))
                 continue;
             const rel = repoPath(root, declPath);
-            const key = normalizeName(name);
+            const fingerprint = typescriptImplementationFingerprint(decl, rel);
+            if (!fingerprint)
+                continue;
+            const change = changes.get(rel);
+            const beforePath = change?.beforePath ?? rel;
+            const before = change?.before === undefined ? undefined : beforeProject.getSourceFile('/before/' + beforePath);
+            const sameScope = scopeFor(beforePath) === scopeFor(rel);
+            const existedInBase = change === undefined || (sameScope && before ? exportedDeclarations(before).some((baseDeclaration) => baseDeclaration.name === name &&
+                typescriptImplementationFingerprint(baseDeclaration.node, beforePath) === fingerprint) : false);
             const list = index.get(key) ?? [];
             if (list.some((e) => e.file === rel && e.line === decl.getStartLineNumber()))
                 continue;
-            list.push({ file: rel, name, line: decl.getStartLineNumber() });
+            list.push({
+                file: rel,
+                name,
+                line: decl.getStartLineNumber(),
+                fingerprint,
+                existedInBase,
+                scope: scopeFor(rel),
+            });
             index.set(key, list);
         }
     }

package/dist/lang/packs.js

@@ -5,11 +5,29 @@ import { Worker } from 'node:worker_threads';
 const COMMON_NODES = {
     identifier: ['identifier'],
     comment: ['comment', 'line_comment', 'block_comment'],
-    ifCondition: 'condition',
-    ifBody: 'consequence',
+    ifCondition: ['condition'],
+    ifBody: ['consequence', 'body'],
+    ifAlternative: ['alternative'],
     declarationName: 'name',
     block: ['block'],
+    callableBody: ['block'],
+    callableOwner: [],
+    callableOwnerBody: [],
+    fileScope: [],
+    reusableContainer: [],
+    reusableScope: [],
+    reusableWrapper: [],
+    reusablePrefix: [],
+    reusableBlocker: [],
+    bindingContext: [],
+    bindingDeclaration: [],
+    bindingIdentifier: ['identifier'],
 };
+function declarationHeader(node) {
+    const boundaries = [node.text.indexOf('{')];
+    const end = boundaries.filter((index) => index >= 0).sort((left, right) => left - right)[0];
+    return end === undefined ? node.text : node.text.slice(0, end);
+}
 /** Pull the key out of `getenv("HOME")` / `environ["HOME"]` style reads. */
 function envKeysFrom(root, callPattern, callTypes) {
     const out = [];
@@ -106,9 +124,16 @@ const PYTHON = {
     nodes: {
         ...COMMON_NODES,
         ifStatement: ['if_statement'],
-        ifBody: 'consequence',
         bail: ['return_statement', 'raise_statement', 'continue_statement', 'break_statement'],
         declaration: ['function_definition', 'class_definition'],
+        callable: ['function_definition'],
+        callableOwner: ['class_definition', 'decorated_definition'],
+        callableOwnerBody: ['block', 'function_definition', 'class_definition'],
+        reusableDeclaration: ['function_definition', 'class_definition'],
+        reusableContainer: ['decorated_definition'],
+        reusableWrapper: ['decorated_definition'],
+        bindingContext: ['import_statement', 'import_from_statement'],
+        bindingDeclaration: ['expression_statement'],
     },
     envReads(root) {
         return envKeysFrom(root, /os\.environ|getenv/, ['call', 'subscript']);
@@ -251,6 +276,12 @@ const PYTHON = {
         }
         return out;
     },
+    fileConstraints(root) {
+        return root.namedChildren
+            .filter((node) => COMMON_NODES.comment.includes(node.type) && node.startPosition.row <= 1)
+            .map((node) => node.text.trim())
+            .filter((text) => /coding\s*[:=]/.test(text));
+    },
 };
 const GO = {
     name: 'go',
@@ -261,6 +292,12 @@ const GO = {
         ifStatement: ['if_statement'],
         bail: ['return_statement', 'continue_statement', 'break_statement', 'goto_statement'],
         declaration: ['function_declaration', 'method_declaration', 'type_declaration'],
+        callable: ['function_declaration', 'method_declaration'],
+        fileScope: ['package_clause'],
+        reusableDeclaration: ['function_declaration', 'type_declaration'],
+        bindingContext: ['import_declaration'],
+        bindingDeclaration: ['const_declaration', 'var_declaration', 'type_declaration'],
+        bindingIdentifier: ['identifier', 'type_identifier'],
     },
     envReads(root) {
         return envKeysFrom(root, /os\.Getenv|os\.LookupEnv/, ['call_expression']);
@@ -281,6 +318,12 @@ const GO = {
         // the blank identifier is someone saying "I know". An empty `if err != nil` isn't.
         return out;
     },
+    fileConstraints(root) {
+        return root.namedChildren
+            .filter((node) => COMMON_NODES.comment.includes(node.type))
+            .map((node) => node.text.trim())
+            .filter((text) => /^\/\/go:build\b|^\/\/\s*\+build\b/.test(text));
+    },
 };
 const JAVA = {
     name: 'java',
@@ -291,6 +334,17 @@ const JAVA = {
         ifStatement: ['if_statement'],
         bail: ['return_statement', 'throw_statement', 'continue_statement', 'break_statement'],
         declaration: ['method_declaration', 'class_declaration', 'interface_declaration', 'record_declaration'],
+        callable: ['method_declaration', 'constructor_declaration'],
+        fileScope: ['package_declaration'],
+        callableBody: ['block', 'constructor_body'],
+        callableOwner: [
+            'class_declaration', 'interface_declaration', 'record_declaration',
+            'enum_declaration', 'annotation_type_declaration',
+        ],
+        callableOwnerBody: ['class_body', 'interface_body', 'record_body', 'enum_body', 'annotation_type_body'],
+        reusableDeclaration: ['class_declaration', 'interface_declaration', 'record_declaration'],
+        bindingContext: ['import_declaration'],
+        block: ['block', 'constructor_body'],
     },
     envReads(root) {
         return envKeysFrom(root, /System\.getenv/, ['method_invocation']);
@@ -304,10 +358,16 @@ const RUST = {
     nodes: {
         ...COMMON_NODES,
         ifStatement: ['if_expression'],
-        ifCondition: 'condition',
-        ifBody: 'consequence',
         bail: ['return_expression', 'break_expression', 'continue_expression'],
         declaration: ['function_item', 'struct_item', 'enum_item', 'trait_item'],
+        callable: ['function_item'],
+        callableOwner: ['impl_item', 'trait_item', 'mod_item'],
+        callableOwnerBody: ['declaration_list'],
+        reusableDeclaration: ['function_item', 'struct_item', 'enum_item', 'trait_item'],
+        reusablePrefix: ['attribute_item'],
+        bindingContext: ['use_declaration', 'extern_crate_declaration'],
+        bindingDeclaration: ['const_item', 'static_item', 'type_item', 'mod_item'],
+        bindingIdentifier: ['identifier', 'type_identifier'],
     },
     envReads(root) {
         return envKeysFrom(root, /env::var|env::var_os/, ['call_expression']);
@@ -328,6 +388,14 @@ const RUST = {
         }
         return out;
     },
+    reusableAcrossFiles(node) {
+        // `pub(self)`, `pub(super)`, and `pub(in ...)` need a module graph to prove
+        // accessibility from another file. Plain `pub` and crate-wide visibility do not.
+        return /\bpub(?:\s*\(\s*crate\s*\))?\s+/.test(declarationHeader(node));
+    },
+    fileConstraints(root) {
+        return nodesOfType(root, ['inner_attribute_item']).map((node) => node.text.trim());
+    },
 };
 const CLIKE_LOG = /^(std::(cout|cerr)|printf|fprintf|Console\.|Log|log|logger|error_log|print_r|var_dump)/;
 const CPP = {
@@ -339,11 +407,30 @@ const CPP = {
         ifStatement: ['if_statement'],
         bail: ['return_statement', 'throw_statement', 'break_statement', 'continue_statement', 'goto_statement'],
         declaration: ['function_definition'],
+        callable: ['function_definition'],
+        callableBody: ['compound_statement'],
+        callableOwner: [
+            'namespace_definition', 'class_specifier', 'struct_specifier', 'union_specifier', 'template_declaration',
+        ],
+        callableOwnerBody: ['declaration_list', 'field_declaration_list', 'function_definition'],
+        reusableDeclaration: ['function_definition'],
+        reusableContainer: ['namespace_definition', 'declaration_list', 'template_declaration'],
+        reusableScope: ['namespace_definition'],
+        reusableWrapper: ['template_declaration'],
+        bindingContext: [
+            'preproc_include', 'preproc_def', 'preproc_function_def',
+            'using_declaration', 'alias_declaration', 'namespace_alias_definition',
+        ],
+        bindingDeclaration: ['declaration', 'type_definition'],
+        bindingIdentifier: ['identifier', 'type_identifier', 'namespace_identifier'],
         declarationName: 'declarator',
         block: ['compound_statement'],
     },
     envReads: (root) => envKeysFrom(root, /getenv|GetEnvironmentVariable/, ['call_expression']),
     swallowedError: catchBased(['catch_clause'], 'body', CLIKE_LOG),
+    reusableAcrossFiles(node) {
+        return !/\bstatic\b/.test(declarationHeader(node));
+    },
 };
 const C = {
     name: 'c',
@@ -354,10 +441,19 @@ const C = {
         ifStatement: ['if_statement'],
         bail: ['return_statement', 'break_statement', 'continue_statement', 'goto_statement'],
         declaration: ['function_definition'],
+        callable: ['function_definition'],
+        callableBody: ['compound_statement'],
+        reusableDeclaration: ['function_definition'],
+        bindingContext: ['preproc_include', 'preproc_def', 'preproc_function_def'],
+        bindingDeclaration: ['declaration', 'type_definition'],
+        bindingIdentifier: ['identifier', 'type_identifier'],
         declarationName: 'declarator',
         block: ['compound_statement'],
     },
     envReads: (root) => envKeysFrom(root, /getenv/, ['call_expression']),
+    reusableAcrossFiles(node) {
+        return !/\bstatic\b/.test(declarationHeader(node));
+    },
     // C has no exceptions; its error handling is return codes, which cannot be told
     // from ordinary control flow without types. The other checks still apply.
 };
@@ -370,6 +466,17 @@ const CSHARP = {
         ifStatement: ['if_statement'],
         bail: ['return_statement', 'throw_statement', 'break_statement', 'continue_statement'],
         declaration: ['method_declaration', 'class_declaration', 'interface_declaration', 'record_declaration'],
+        callable: ['method_declaration', 'constructor_declaration', 'local_function_statement'],
+        callableOwner: [
+            'namespace_declaration', 'file_scoped_namespace_declaration',
+            'class_declaration', 'struct_declaration', 'interface_declaration', 'record_declaration',
+        ],
+        callableOwnerBody: ['declaration_list'],
+        reusableDeclaration: ['class_declaration', 'interface_declaration', 'record_declaration'],
+        reusableContainer: ['namespace_declaration', 'file_scoped_namespace_declaration', 'declaration_list'],
+        reusableScope: ['namespace_declaration', 'file_scoped_namespace_declaration'],
+        reusableBlocker: ['ERROR'],
+        bindingContext: ['using_directive', 'extern_alias_directive'],
         block: ['block', 'declaration_list'],
     },
     envReads: (root) => envKeysFrom(root, /GetEnvironmentVariable/, ['invocation_expression']),
@@ -384,6 +491,18 @@ const PHP = {
         ifStatement: ['if_statement'],
         bail: ['return_statement', 'throw_expression', 'break_statement', 'continue_statement'],
         declaration: ['function_definition', 'method_declaration', 'class_declaration'],
+        callable: ['function_definition', 'method_declaration'],
+        callableBody: ['compound_statement'],
+        callableOwner: [
+            'namespace_definition', 'class_declaration', 'interface_declaration', 'trait_declaration', 'enum_declaration',
+        ],
+        callableOwnerBody: ['compound_statement', 'declaration_list'],
+        reusableDeclaration: ['function_definition', 'class_declaration'],
+        reusableContainer: ['namespace_definition', 'compound_statement'],
+        reusableScope: ['namespace_definition'],
+        bindingContext: ['namespace_use_declaration', 'expression_statement'],
+        bindingDeclaration: ['const_declaration'],
+        bindingIdentifier: ['name', 'variable_name'],
         block: ['compound_statement'],
     },
     envReads: (root) => envKeysFrom(root, /getenv|\$_ENV/, ['function_call_expression', 'subscript_expression']),
@@ -399,10 +518,23 @@ const KOTLIN = {
         ifStatement: ['if_expression'],
         bail: ['jump_expression'],
         declaration: ['function_declaration', 'class_declaration', 'object_declaration'],
+        callable: ['function_declaration'],
+        fileScope: ['package_header'],
+        callableBody: ['function_body', 'block', 'statements'],
+        callableOwner: ['class_declaration', 'object_declaration'],
+        callableOwnerBody: ['class_body'],
+        reusableDeclaration: ['function_declaration', 'class_declaration', 'object_declaration'],
+        reusableContainer: ['import_list'],
+        bindingContext: ['import_header'],
+        bindingDeclaration: ['property_declaration', 'type_alias'],
+        bindingIdentifier: ['simple_identifier', 'type_identifier'],
         block: ['statements', 'block'],
     },
     envReads: (root) => envKeysFrom(root, /System\.getenv|getenv/, ['call_expression']),
     swallowedError: catchBased(['catch_block'], undefined, /^(println|print|log|logger|Log)\b/),
+    reusableAcrossFiles(node) {
+        return !/\bprivate\b/.test(declarationHeader(node));
+    },
 };
 /*
  * Swift is deliberately absent.
@@ -427,6 +559,14 @@ const SWIFT_DISABLED = {
         ifStatement: ['if_statement'],
         bail: ['control_transfer_statement'],
         declaration: ['function_declaration', 'class_declaration', 'protocol_declaration'],
+        callable: ['function_declaration'],
+        callableBody: ['function_body', 'statements'],
+        callableOwner: [
+            'class_declaration', 'struct_declaration', 'protocol_declaration',
+            'extension_declaration', 'enum_declaration',
+        ],
+        callableOwnerBody: ['class_body', 'protocol_body', 'enum_class_body'],
+        reusableDeclaration: ['function_declaration', 'class_declaration', 'protocol_declaration'],
         block: ['statements', 'function_body'],
     },
     envReads: (root) => envKeysFrom(root, /ProcessInfo|environment/, ['call_expression', 'subscript_expression']),
@@ -438,11 +578,17 @@ const RUBY = {
     grammar: 'tree-sitter-ruby',
     nodes: {
         ...COMMON_NODES,
-        ifStatement: ['if', 'if_modifier'],
-        ifCondition: 'condition',
-        ifBody: 'consequence',
+        ifStatement: ['if', 'if_modifier', 'unless', 'unless_modifier'],
         bail: ['return', 'break', 'next'],
         declaration: ['method', 'singleton_method', 'class', 'module'],
+        callable: ['method', 'singleton_method'],
+        callableBody: ['body_statement'],
+        callableOwner: ['class', 'module'],
+        callableOwnerBody: ['body_statement'],
+        reusableDeclaration: ['method', 'singleton_method', 'class', 'module'],
+        bindingContext: ['call'],
+        bindingDeclaration: ['assignment'],
+        bindingIdentifier: ['identifier', 'constant'],
         block: ['body_statement', 'do_block', 'block'],
     },
     envReads: (root) => envKeysFrom(root, /ENV/, ['element_reference', 'call']),
@@ -477,6 +623,12 @@ const RUBY = {
         }
         return out;
     },
+    fileConstraints(root) {
+        return root.namedChildren
+            .filter((node) => COMMON_NODES.comment.includes(node.type) && node.startPosition.row <= 1)
+            .map((node) => node.text.trim())
+            .filter((text) => /^#\s*(?:frozen_string_literal|encoding|coding)\s*[:=]/.test(text));
+    },
 };
 void SWIFT_DISABLED;
 const SOLIDITY = {
@@ -489,6 +641,16 @@ const SOLIDITY = {
         // revert and require are how a contract refuses, alongside plain return
         bail: ['return_statement', 'revert_statement', 'break_statement', 'continue_statement'],
         declaration: ['function_definition', 'contract_declaration', 'modifier_definition'],
+        callable: ['function_definition', 'modifier_definition'],
+        callableBody: ['function_body', 'block_statement'],
+        callableOwner: ['contract_declaration'],
+        callableOwnerBody: ['contract_body'],
+        reusableDeclaration: ['function_definition', 'contract_declaration'],
+        bindingContext: ['import_directive', 'pragma_directive'],
+        bindingDeclaration: [
+            'constant_variable_declaration', 'struct_declaration', 'enum_declaration',
+            'user_defined_value_type_definition',
+        ],
         block: ['block_statement', 'function_body', 'contract_body'],
     },
     swallowedError: catchBased(['catch_clause'], 'body', /^(emit|console\.log)/),