gitnexus 1.6.13-rc.55 → 1.6.13-rc.56

package/dist/core/ingestion/languages/python/builtin-descriptors.js

@@ -80,6 +80,8 @@ function bindingOf(identifier) {
     if (parent === null)
         return null;
     const shadow = { node: identifier, effect: 'shadow' };
+    if (inCasePattern(identifier))
+        return isCaseCapture(identifier) ? shadow : null;
     switch (parent.type) {
         case 'assignment':
         case 'augmented_assignment':
@@ -117,11 +119,9 @@ function bindingOf(identifier) {
                 : null;
         case 'dotted_name': {
             const owner = parent.parent;
-            // `import a.b` binds `a`; `case name:` captures a single name.
+            // `import a.b` binds `a`.
             if (owner?.type === 'import_statement')
                 return parent.firstNamedChild?.id === node.id ? shadow : null;
-            if (owner?.type === 'case_pattern')
-                return parent.namedChildCount === 1 ? shadow : null;
             if (owner?.type !== 'import_from_statement' || !isField(parent, 'name'))
                 return null;
             return importsFromBuiltins(owner) ? { node: identifier, effect: 'builtin' } : shadow;
@@ -174,9 +174,145 @@ function descriptorBindings(node) {
         const redirect = redirected.get(`${found.text}@${scopeOf(found)?.id}`) ?? null;
         add(found.text, { ...binding, redirect });
     }
+    addHelperCalls(tree.rootNode, bindings, redirected);
     bindingsByTree.set(tree, bindings);
     return bindings;
 }
+/**
+ * A bare module-level call to a same-file helper that always restores a
+ * descriptor name through `global` runs that restore at the call. Record it
+ * there as a module binding, so the call's position orders it.
+ */
+function addHelperCalls(root, bindings, redirected) {
+    // Helper function name -> its `def` and, per descriptor name, the restore
+    // its call performs.
+    const helpers = new Map();
+    for (const [name, list] of bindings) {
+        const byHelper = new Map();
+        for (const binding of list) {
+            if (binding.redirect !== 'global')
+                continue;
+            const fn = scopeOf(binding.node);
+            if (fn === null)
+                continue;
+            const entry = byHelper.get(fn.id);
+            if (entry === undefined)
+                byHelper.set(fn.id, { fn, globals: [binding] });
+            else
+                entry.globals.push(binding);
+        }
+        for (const { fn, globals } of byHelper.values()) {
+            const effect = restoreOnCall(fn, globals);
+            const helper = fn.childForFieldName('name')?.text;
+            if (effect === null || helper === undefined)
+                continue;
+            const entry = helpers.get(helper) ?? { fn, restores: new Map() };
+            entry.restores.set(name, effect);
+            helpers.set(helper, entry);
+        }
+    }
+    if (helpers.size === 0)
+        return;
+    // A call only denotes the helper when its `def` is the name's one module
+    // binding. A local of the same name elsewhere cannot rebind it.
+    if (root.descendantsOfType('wildcard_import').length > 0)
+        return;
+    const bindingCounts = new Map();
+    for (const found of root.descendantsOfType('identifier')) {
+        if (!helpers.has(found.text) || bindingOf(found) === null)
+            continue;
+        const scope = scopeOf(found);
+        if (scope !== null && redirected.get(`${found.text}@${scope.id}`) !== 'global')
+            continue;
+        bindingCounts.set(found.text, (bindingCounts.get(found.text) ?? 0) + 1);
+    }
+    for (const [helper, count] of bindingCounts)
+        if (count > 1)
+            helpers.delete(helper);
+    const touched = new Set();
+    for (const statement of root.namedChildren) {
+        // Only a call that is the whole statement surely runs when reached.
+        if (statement.type !== 'expression_statement' || statement.namedChildCount !== 1)
+            continue;
+        const call = statement.firstNamedChild;
+        const callee = call?.type === 'call' ? call.childForFieldName('function') : null;
+        const helper = callee?.type === 'identifier' ? helpers.get(callee.text) : undefined;
+        // The call reaches the helper only once its `def` statement has run, and
+        // an argument-free call binds only when every parameter is optional.
+        if (helper === undefined || statement.startIndex < helper.fn.endIndex)
+            continue;
+        if ((call?.childForFieldName('arguments')?.namedChildCount ?? 0) > 0)
+            continue;
+        for (const [name, effect] of helper.restores) {
+            const list = bindings.get(name);
+            if (list === undefined)
+                continue;
+            list.push({ node: callee, effect, redirect: null });
+            touched.add(list);
+        }
+    }
+    for (const list of touched)
+        list.sort((a, b) => a.node.startIndex - b.node.startIndex);
+}
+/**
+ * Does this name in a case pattern capture? Value patterns (`a.b`), class
+ * names and keyword keys are reads. Every other name is a capture.
+ */
+function isCaseCapture(identifier) {
+    const parent = identifier.parent;
+    if (parent?.type === 'keyword_pattern')
+        return parent.firstNamedChild?.id !== identifier.id;
+    if (parent?.type !== 'dotted_name')
+        return true;
+    if (parent.namedChildCount > 1)
+        return false;
+    return !(parent.parent?.type === 'class_pattern' && parent.parent.firstNamedChild?.id === parent.id);
+}
+/** Is `node` inside a `match` case pattern? */
+function inCasePattern(node) {
+    for (let parent = node.parent; parent !== null; parent = parent.parent) {
+        if (parent.type === 'case_pattern')
+            return true;
+    }
+    return false;
+}
+/**
+ * The restore a call to `fn` always performs on a module global, or `null`.
+ * `fn` must be a plain module-level `def` whose body runs on call (not a
+ * generator or coroutine), and every `global` binding of the name in it must
+ * be a restore in a simple statement that no earlier `return` can skip.
+ */
+function restoreOnCall(fn, globals) {
+    if (fn.type !== 'function_definition' || fn.parent?.type !== 'module')
+        return null;
+    if (fn.children.some((child) => child.type === 'async'))
+        return null;
+    const required = fn
+        .childForFieldName('parameters')
+        ?.namedChildren.some((param) => param.type === 'identifier' ||
+        (param.type === 'typed_parameter' && param.firstNamedChild?.type === 'identifier'));
+    if (required === true)
+        return null;
+    const body = fn.childForFieldName('body');
+    // `globals` is in source order, so the last restore is the one that sticks.
+    const first = globals[0];
+    const last = globals[globals.length - 1];
+    if (body === null || first === undefined || last === undefined)
+        return null;
+    for (const binding of globals) {
+        const statement = statementIn(binding.node, body);
+        if (binding.effect === 'shadow' ||
+            statement === null ||
+            !SIMPLE_STATEMENTS.has(statement.type)) {
+            return null;
+        }
+    }
+    const escapes = body
+        .descendantsOfType(['yield', 'return_statement'])
+        .some((node) => scopeOf(node)?.id === fn.id &&
+        (node.type === 'yield' || node.startIndex < first.node.startIndex));
+    return escapes ? null : last.effect;
+}
 /**
  * The scope that owns names bound at `node`: a function or lambda body, a
  * class body, a comprehension, or the module (`null`). A walrus target skips
@@ -207,6 +343,10 @@ function statementIn(node, body) {
         current = current.parent;
     return current.parent === null ? null : current;
 }
+/** Does `outer` span `node`? */
+function contains(outer, node) {
+    return node.startIndex >= outer.startIndex && node.endIndex <= outer.endIndex;
+}
 /** Can `binding` run before `use` in the same scope, including an earlier
  *  iteration of an enclosing loop? */
 function mayRunBefore(binding, use, scope) {
@@ -214,8 +354,7 @@ function mayRunBefore(binding, use, scope) {
         return true;
     for (let loop = use.parent; loop !== null && loop.id !== scope?.id; loop = loop.parent) {
         if ((loop.type === 'for_statement' || loop.type === 'while_statement') &&
-            binding.startIndex >= loop.startIndex &&
-            binding.endIndex <= loop.endIndex) {
+            contains(loop, binding)) {
             return true;
         }
     }
@@ -270,6 +409,13 @@ function lookupName(bindings, use) {
         const owned = bindings.some((binding) => binding.redirect === null && scopeOf(binding.node)?.id === fn.id);
         if (!owned)
             continue;
+        // A nested function can rebind this cell whenever it is called; that
+        // order is not modelled, so assume it ran.
+        const rebound = bindings.some((binding) => binding.effect === 'shadow' &&
+            binding.redirect === 'nonlocal' &&
+            contains(fn, binding.node));
+        if (rebound)
+            return 'shadow';
         // Any binding makes the name local to this function, so the class body
         // reads that cell. An unbound cell raises NameError, not the builtin.
         return namespaceState(bindings, fn, use) === 'builtin' ? 'builtin' : 'shadow';
@@ -287,16 +433,14 @@ function lookupName(bindings, use) {
         // is called; that order is not modelled, so assume it ran.
         if (binding.redirect === 'nonlocal') {
             const outer = functions[functions.length - 1];
-            const inside = outer !== undefined &&
-                binding.node.startIndex >= outer.startIndex &&
-                binding.node.endIndex <= outer.endIndex;
-            if (inside)
+            if (outer !== undefined && contains(outer, binding.node))
                 return 'shadow';
         }
         if (binding.redirect === 'global') {
             // The function can only be called once the top-level statement that
-            // defines it has run. Whether a call happens is unknown, so a restoring
-            // `global` delete is ignored and a rebinding one is assumed.
+            // defines it has run. Whether a call happens is unknown, so a rebinding
+            // one is assumed. A restore counts only at a proven call site (see
+            // `addHelperCalls`).
             const top = statementIn(binding.node, binding.node.tree.rootNode);
             if (deferred || (top !== null && mayRunBefore(top, use, null)))
                 return 'shadow';

package/dist/storage/parse-cache.js

@@ -807,7 +807,10 @@ import { copyV8CacheIfPresent, tryLoadV8Cache, writeV8CacheFile } from './v8-sid
 // comments, honors rebinding of builtin descriptor names visible where the
 // decorator is evaluated, and withholds subtype capacity from descriptor
 // stacks. Warm v120 captures carry the old verdicts.
-const SCHEMA_BUMP = 121;
+// v122 (#3414): Python decorator identity models restoring helper calls and
+// treats match-pattern captures and nested nonlocal rebinds as shadowing.
+// Warm v121 captures carry the old verdicts.
+const SCHEMA_BUMP = 122;
 const GITNEXUS_PKG_VERSION = (() => {
     try {
         // package.json sits at gitnexus/package.json — two levels up from

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.13-rc.55",
+  "version": "1.6.13-rc.56",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",