gitnexus 1.6.13-rc.52 → 1.6.13-rc.54

package/dist/_shared/scope-resolution/types.d.ts

@@ -595,7 +595,7 @@ export interface TypeRef {
     readonly declaredSpelling?: string;
     /** Anchor for resolving `rawName` — the scope where the annotation/inference was written. */
     readonly declaredAtScope: ScopeId;
-    readonly source: 'annotation' | 'parameter-annotation' | 'return-annotation' | 'self' | 'assignment-inferred' | 'constructor-inferred' | 'receiver-propagated';
+    readonly source: 'annotation' | 'parameter-annotation' | 'return-annotation' | 'self' | 'decorator-unknown' | 'assignment-inferred' | 'constructor-inferred' | 'receiver-propagated';
     /** Reserved for V2+: generic type arguments (`List<User>` → `[TypeRef('User')]`). V1 ignores. */
     readonly typeArgs?: readonly TypeRef[];
 }

package/dist/_shared/scope-resolution/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/scope-resolution/types.ts"],"names":[],"mappings":"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"}

package/dist/core/ingestion/languages/python/builtin-descriptors.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Decide whether a method decorator names one of Python's builtin descriptor
+ * types, following CPython's evaluation of the decorator expression.
+ *
+ * A decorator in a class body is evaluated with LOAD_NAME: the class
+ * namespace first, then module globals, then builtins, each as bound at the
+ * moment the `def` statement runs. Aliases, dotted names and decorator calls
+ * have no known descriptor contract without import resolution, so only bare
+ * spellings qualify.
+ */
+import type { SyntaxNode } from '../../utils/ast-helpers.js';
+declare const BUILTIN_DESCRIPTOR_NAMES: readonly ['classmethod', 'staticmethod', 'property'];
+export type BuiltinDescriptor = (typeof BUILTIN_DESCRIPTOR_NAMES)[number];
+/** Decorator expressions, outermost first. Tree-sitter keeps a trailing
+ *  comment inside the decorator node, so read the expression child only. */
+export declare function decoratorNames(fnNode: SyntaxNode): string[];
+/** Does `expression` denote a builtin descriptor type (or `kind`) at `fnNode`? */
+export declare function isBuiltinDescriptor(fnNode: SyntaxNode, expression: string, kind?: BuiltinDescriptor): boolean;
+export {};

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

@@ -0,0 +1,314 @@
+/**
+ * Decide whether a method decorator names one of Python's builtin descriptor
+ * types, following CPython's evaluation of the decorator expression.
+ *
+ * A decorator in a class body is evaluated with LOAD_NAME: the class
+ * namespace first, then module globals, then builtins, each as bound at the
+ * moment the `def` statement runs. Aliases, dotted names and decorator calls
+ * have no known descriptor contract without import resolution, so only bare
+ * spellings qualify.
+ */
+const BUILTIN_DESCRIPTOR_NAMES = ['classmethod', 'staticmethod', 'property'];
+const BUILTIN_DESCRIPTORS = new Set(BUILTIN_DESCRIPTOR_NAMES);
+/** Decorator expressions, outermost first. Tree-sitter keeps a trailing
+ *  comment inside the decorator node, so read the expression child only. */
+export function decoratorNames(fnNode) {
+    const parent = fnNode.parent;
+    if (parent === null || parent.type !== 'decorated_definition')
+        return [];
+    const names = [];
+    for (const child of parent.namedChildren) {
+        if (child.type !== 'decorator')
+            continue;
+        // An empty name matches nothing, so a malformed decorator stays unknown.
+        names.push(child.namedChildren.find((part) => part.type !== 'comment')?.text ?? '');
+    }
+    return names;
+}
+/** Does `expression` denote a builtin descriptor type (or `kind`) at `fnNode`? */
+export function isBuiltinDescriptor(fnNode, expression, kind) {
+    if (kind === undefined ? !BUILTIN_DESCRIPTORS.has(expression) : expression !== kind)
+        return false;
+    // Decorators are evaluated as the `def` statement runs, so its wrapper is the
+    // use site. No statement can rebind the name between stacked decorators.
+    const use = fnNode.parent?.type === 'decorated_definition' ? fnNode.parent : fnNode;
+    return lookupName(descriptorBindings(fnNode).get(expression) ?? [], use) !== 'shadow';
+}
+const FUNCTION_SCOPES = new Set(['function_definition', 'lambda']);
+const COMPREHENSIONS = new Set([
+    'list_comprehension',
+    'set_comprehension',
+    'dictionary_comprehension',
+    'generator_expression',
+]);
+const TARGET_WRAPPERS = new Set([
+    'pattern_list',
+    'tuple_pattern',
+    'list_pattern',
+    'list_splat_pattern',
+    'dictionary_splat_pattern',
+    'as_pattern_target',
+    'expression_list',
+    'parenthesized_expression',
+]);
+/** Simple statements whose effect always happens once execution reaches them. */
+const SIMPLE_STATEMENTS = new Set([
+    'expression_statement',
+    'import_statement',
+    'import_from_statement',
+    'delete_statement',
+]);
+/** Is `node` the `field` child of its parent? */
+function isField(node, field) {
+    return node.parent?.childForFieldName(field)?.id === node.id;
+}
+/** Does `statement` import from the `builtins` module? */
+function importsFromBuiltins(statement) {
+    return statement?.childForFieldName('module_name')?.text === 'builtins';
+}
+/**
+ * The binding this identifier performs, following the binding constructs of
+ * Language Reference 4.2.1, or `null` for a plain read.
+ */
+function bindingOf(identifier) {
+    let node = identifier;
+    let parent = node.parent;
+    while (parent !== null && TARGET_WRAPPERS.has(parent.type)) {
+        node = parent;
+        parent = node.parent;
+    }
+    if (parent === null)
+        return null;
+    const shadow = { node: identifier, effect: 'shadow' };
+    switch (parent.type) {
+        case 'assignment':
+        case 'augmented_assignment':
+        case 'for_statement':
+        case 'for_in_clause':
+            return isField(node, 'left') ? shadow : null;
+        case 'named_expression':
+        case 'function_definition':
+        case 'class_definition':
+        case 'default_parameter':
+        case 'typed_default_parameter':
+            return isField(node, 'name') ? shadow : null;
+        case 'as_pattern':
+            return isField(node, 'alias') ? shadow : null;
+        case 'aliased_import': {
+            if (!isField(node, 'alias'))
+                return null;
+            // `from builtins import staticmethod as staticmethod` binds the builtin.
+            const source = parent.childForFieldName('name')?.text;
+            return importsFromBuiltins(parent.parent) && source === identifier.text
+                ? { node: identifier, effect: 'builtin' }
+                : shadow;
+        }
+        case 'typed_parameter':
+            return node.type === 'identifier' ? shadow : null;
+        case 'parameters':
+        case 'lambda_parameters':
+            return shadow;
+        case 'delete_statement':
+            return { node: identifier, effect: 'unbind' };
+        case 'type':
+            return parent.parent?.type === 'type_parameter' ||
+                (parent.parent?.type === 'type_alias_statement' && isField(parent, 'left'))
+                ? shadow
+                : null;
+        case 'dotted_name': {
+            const owner = parent.parent;
+            // `import a.b` binds `a`; `case name:` captures a single name.
+            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;
+        }
+        default:
+            return null;
+    }
+}
+const bindingsByTree = new WeakMap();
+/** Every binding of a builtin descriptor name in the file, in source order. */
+function descriptorBindings(node) {
+    const tree = node.tree;
+    const cached = bindingsByTree.get(tree);
+    if (cached !== undefined)
+        return cached;
+    // `global x` / `nonlocal x` bind nothing themselves; they redirect the
+    // declaring scope's own bindings of `x` to an outer namespace.
+    const redirected = new Map();
+    for (const statement of tree.rootNode.descendantsOfType([
+        'global_statement',
+        'nonlocal_statement',
+    ])) {
+        const scope = scopeOf(statement)?.id;
+        const kind = statement.type === 'global_statement' ? 'global' : 'nonlocal';
+        for (const name of statement.namedChildren)
+            redirected.set(`${name.text}@${scope}`, kind);
+    }
+    const bindings = new Map();
+    const add = (name, binding) => {
+        const list = bindings.get(name);
+        if (list === undefined)
+            bindings.set(name, [binding]);
+        else
+            list.push(binding);
+    };
+    for (const found of tree.rootNode.descendantsOfType(['identifier', 'wildcard_import'])) {
+        if (found.type === 'wildcard_import') {
+            // `from m import *` binds every public name m defines. Unless m is
+            // `builtins`, whether that includes a descriptor name is unknown here.
+            const effect = importsFromBuiltins(found.parent) ? 'builtin' : 'shadow';
+            for (const name of BUILTIN_DESCRIPTORS)
+                add(name, { node: found, effect, redirect: null });
+            continue;
+        }
+        if (!BUILTIN_DESCRIPTORS.has(found.text))
+            continue;
+        const binding = bindingOf(found);
+        if (binding === null)
+            continue;
+        const redirect = redirected.get(`${found.text}@${scopeOf(found)?.id}`) ?? null;
+        add(found.text, { ...binding, redirect });
+    }
+    bindingsByTree.set(tree, bindings);
+    return bindings;
+}
+/**
+ * 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
+ * comprehensions, as PEP 572 binds it in the enclosing scope.
+ */
+function scopeOf(node) {
+    const skipComprehensions = node.parent?.type === 'named_expression';
+    let child = node;
+    for (let parent = node.parent; parent !== null; child = parent, parent = parent.parent) {
+        if (FUNCTION_SCOPES.has(parent.type)) {
+            if (isField(child, 'body') || isField(child, 'parameters'))
+                return parent;
+        }
+        else if (parent.type === 'class_definition') {
+            if (isField(child, 'body'))
+                return parent;
+        }
+        else if (COMPREHENSIONS.has(parent.type) && !skipComprehensions) {
+            return parent;
+        }
+    }
+    return null;
+}
+/** The statement containing `node` that sits directly in `body`. */
+function statementIn(node, body) {
+    let current = node;
+    while (current.parent !== null && current.parent.id !== body.id)
+        current = current.parent;
+    return current.parent === null ? null : current;
+}
+/** Can `binding` run before `use` in the same scope, including an earlier
+ *  iteration of an enclosing loop? */
+function mayRunBefore(binding, use, scope) {
+    if (binding.startIndex < use.startIndex)
+        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) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * What a module, class or function namespace holds for the name when
+ * execution reaches `use`. A `shadow` that may have run wins. A restoring
+ * effect (`builtin`, `unbind`) counts only when it is a simple statement
+ * directly in the scope body that runs before `use`, so it runs exactly once
+ * in order.
+ */
+function namespaceState(bindings, scope, use) {
+    const body = scope === null ? null : scope.childForFieldName('body');
+    let state = 'unbind';
+    for (const binding of bindings) {
+        if (binding.redirect !== null || scopeOf(binding.node)?.id !== scope?.id)
+            continue;
+        if (!mayRunBefore(binding.node, use, scope))
+            continue;
+        if (binding.effect === 'shadow') {
+            state = 'shadow';
+            continue;
+        }
+        const statement = statementIn(binding.node, body ?? binding.node.tree.rootNode);
+        const ordered = binding.node.startIndex < use.startIndex;
+        if (ordered && statement !== null && SIMPLE_STATEMENTS.has(statement.type)) {
+            state = binding.effect;
+        }
+    }
+    return state;
+}
+/**
+ * Resolve the decorator name at `use` as a class body does (Language
+ * Reference 4.2.2): the class namespace first, then the innermost enclosing
+ * function that binds the name, then module globals, then builtins.
+ */
+function lookupName(bindings, use) {
+    // Enclosing scopes, innermost first, ending with the module (`null`).
+    const chain = [];
+    for (let scope = scopeOf(use); scope !== null; scope = scopeOf(scope))
+        chain.push(scope);
+    chain.push(null);
+    const classScope = chain[0]?.type === 'class_definition' ? chain[0] : null;
+    if (classScope !== null) {
+        const state = namespaceState(bindings, classScope, use);
+        if (state !== 'unbind')
+            return state;
+    }
+    const functions = chain.filter((scope) => scope !== null && FUNCTION_SCOPES.has(scope.type));
+    for (const fn of functions) {
+        const owned = bindings.some((binding) => binding.redirect === null && scopeOf(binding.node)?.id === fn.id);
+        if (!owned)
+            continue;
+        // 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';
+    }
+    // A class body inside a function runs whenever that function is called,
+    // which can be any time after its top-level statement starts. Module state
+    // is therefore read at that statement, and any later module override may
+    // also have run first.
+    const deferred = functions.length > 0;
+    const moduleUse = deferred ? (statementIn(use, use.tree.rootNode) ?? use) : use;
+    for (const binding of bindings) {
+        if (binding.effect !== 'shadow')
+            continue;
+        // A nested function can rebind an enclosing function's cell whenever it
+        // 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)
+                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.
+            const top = statementIn(binding.node, binding.node.tree.rootNode);
+            if (deferred || (top !== null && mayRunBefore(top, use, null)))
+                return 'shadow';
+        }
+    }
+    if (deferred) {
+        const laterOverride = bindings.some((binding) => binding.effect === 'shadow' &&
+            binding.redirect === null &&
+            scopeOf(binding.node) === null &&
+            binding.node.startIndex > moduleUse.startIndex);
+        if (laterOverride)
+            return 'shadow';
+    }
+    return namespaceState(bindings, null, moduleUse);
+}

package/dist/core/ingestion/languages/python/index.d.ts

@@ -43,13 +43,11 @@
  *      and emit a single edge rather than branching. `List[T]` /
  *      `Dict[K, V]` strip the outer generic for receiver typing (see
  *      `interpret.ts`).
- *   5. **Decorators that rewrite signatures** — `@dataclass`,
- *      `@property`, `@classmethod`, `@staticmethod` are recognized
- *      by `receiver-binding.ts`. Arbitrary decorators (e.g.
- *      `functools.wraps`, custom retry wrappers) preserve the wrapped
- *      function's declared signature; a decorator that returns a
- *      different callable is followed only through the declared
- *      return type.
+ *   5. **Decorators that rewrite signatures** — Known descriptor
+ *      spellings (`@property`, `@classmethod`, `@staticmethod`) are
+ *      recognized by `receiver-binding.ts`. Unknown decorator expressions
+ *      leave implicit receiver binding unresolved. Calls through wrappers
+ *      are followed only through their declared return type.
  *   6. **`typing.TYPE_CHECKING`-guarded imports** — treated like any
  *      other `import` for reference resolution. We do not distinguish
  *      runtime-visible from type-checker-only imports; this is

package/dist/core/ingestion/languages/python/index.js

@@ -43,13 +43,11 @@
  *      and emit a single edge rather than branching. `List[T]` /
  *      `Dict[K, V]` strip the outer generic for receiver typing (see
  *      `interpret.ts`).
- *   5. **Decorators that rewrite signatures** — `@dataclass`,
- *      `@property`, `@classmethod`, `@staticmethod` are recognized
- *      by `receiver-binding.ts`. Arbitrary decorators (e.g.
- *      `functools.wraps`, custom retry wrappers) preserve the wrapped
- *      function's declared signature; a decorator that returns a
- *      different callable is followed only through the declared
- *      return type.
+ *   5. **Decorators that rewrite signatures** — Known descriptor
+ *      spellings (`@property`, `@classmethod`, `@staticmethod`) are
+ *      recognized by `receiver-binding.ts`. Unknown decorator expressions
+ *      leave implicit receiver binding unresolved. Calls through wrappers
+ *      are followed only through their declared return type.
  *   6. **`typing.TYPE_CHECKING`-guarded imports** — treated like any
  *      other `import` for reference resolution. We do not distinguish
  *      runtime-visible from type-checker-only imports; this is

package/dist/core/ingestion/languages/python/interpret.js

@@ -124,7 +124,9 @@ export function interpretPythonTypeBinding(captures) {
     // the variable-annotation and constructor-inferred forms from the
     // classic parameter annotation.
     let source = 'parameter-annotation';
-    if (captures['@type-binding.self'] !== undefined)
+    if (captures['@type-binding.uncertain-receiver'] !== undefined)
+        source = 'decorator-unknown';
+    else if (captures['@type-binding.self'] !== undefined)
         source = 'self';
     // `cls` is a self-like receiver; share the source label so downstream
     // `Registry.lookup` Step 2 treats them identically.

package/dist/core/ingestion/languages/python/receiver-binding.d.ts

@@ -13,6 +13,13 @@ import type { CaptureMatch } from '../../../../_shared/index.js';
 import { type SyntaxNode } from '../../utils/ast-helpers.js';
 /** Static-like descriptors do not inject an instance on attribute access. */
 export declare function isPythonStaticLikeMethod(fnNode: SyntaxNode): boolean;
+/**
+ * Can the method's parameter list prove its call shape? Only a plain function
+ * or one builtin `staticmethod` / `classmethod` wrapper qualifies. Any other
+ * decorator may replace the callable, and a descriptor stack can make it
+ * uncallable: `staticmethod(classmethod(f))` yields a classmethod object.
+ */
+export declare function hasPythonProvenCallShape(fnNode: SyntaxNode): boolean;
 export interface PythonBoundReceiver {
     readonly kind: 'instance' | 'class';
     readonly parameter: SyntaxNode;
@@ -34,6 +41,11 @@ export declare function classifyPythonBoundReceiver(fnNode: SyntaxNode): PythonB
  * The caller is responsible for guaranteeing `fnNode.type ===
  * 'function_definition'`.
  */
+/**
+ * The first parameter of a class method under an unrecognized decorator.
+ * Python may still bind it implicitly, but its receiver kind is unproven.
+ */
+export declare function classifyPythonUncertainReceiver(fnNode: SyntaxNode): PythonBoundReceiver | null;
 export declare function synthesizeReceiverTypeBinding(fnNode: SyntaxNode): CaptureMatch | null;
 /**
  * Synthesize class-scope field bindings for the common Python constructor

package/dist/core/ingestion/languages/python/receiver-binding.js

@@ -10,6 +10,7 @@
  * awareness that Python's runtime depends on.
  */
 import { nodeToCapture, syntheticCapture } from '../../utils/ast-helpers.js';
+import { decoratorNames, isBuiltinDescriptor } from './builtin-descriptors.js';
 /** Walk up to the enclosing `class_definition`, ignoring the immediate
  *  `decorated_definition` wrapper. Returns `null` when the function is
  *  free, lambda-bodied, or nested inside another function. */
@@ -27,26 +28,76 @@ function findEnclosingClassDefinition(node) {
 function classDefinitionName(classNode) {
     return classNode.childForFieldName('name')?.text ?? null;
 }
-/** Does the function carry a `@<decoratorName>` decorator? Matches both
- *  bare `@classmethod` and module-qualified `@functools.classmethod`. */
-function hasDecorator(fnNode, decoratorName) {
-    const parent = fnNode.parent;
-    if (parent === null || parent.type !== 'decorated_definition')
+/** Accept a local `@property` accessor chain, skipping only plain unrelated
+ * methods. Other intervening class-suite statements may rebind the descriptor,
+ * including tuple assignment or control flow. */
+function isLocalPropertyAccessor(fnNode, expression) {
+    const methodName = fnNode.childForFieldName('name')?.text;
+    if (methodName === undefined ||
+        !['getter', 'setter', 'deleter'].some((kind) => expression === `${methodName}.${kind}`))
         return false;
-    for (let i = 0; i < parent.namedChildCount; i++) {
-        const child = parent.namedChild(i);
-        if (child === null || child.type !== 'decorator')
+    const wrapper = fnNode.parent;
+    const classBody = findEnclosingClassDefinition(fnNode)?.childForFieldName('body');
+    if (wrapper?.type !== 'decorated_definition' || classBody === null || classBody === undefined) {
+        return false;
+    }
+    let wrapperIndex = -1;
+    for (let i = 0; i < classBody.namedChildCount; i++) {
+        const sibling = classBody.namedChild(i);
+        if (sibling?.id === wrapper.id) {
+            wrapperIndex = i;
+            break;
+        }
+    }
+    for (let i = wrapperIndex - 1; i >= 0; i--) {
+        const sibling = classBody.namedChild(i);
+        if (sibling?.type === 'function_definition' &&
+            sibling.childForFieldName('name')?.text !== methodName) {
+            // A plain function definition binds only its own name in the class suite.
             continue;
-        const text = child.text.replace(/^@/, '').split('(')[0].trim();
-        const tail = text.split('.').pop();
-        if (tail === decoratorName)
+        }
+        if (sibling?.type !== 'decorated_definition')
+            return false;
+        let candidate = null;
+        for (let j = 0; j < sibling.namedChildCount; j++) {
+            const child = sibling.namedChild(j);
+            if (child?.type === 'function_definition')
+                candidate = child;
+        }
+        if (candidate?.childForFieldName('name')?.text !== methodName)
+            return false;
+        const [decorator, ...rest] = decoratorNames(candidate);
+        if (decorator === undefined || rest.length > 0)
+            return false;
+        if (isBuiltinDescriptor(candidate, decorator, 'property'))
             return true;
+        if (!['getter', 'setter', 'deleter'].some((kind) => decorator === `${methodName}.${kind}`)) {
+            return false;
+        }
     }
     return false;
 }
 /** Static-like descriptors do not inject an instance on attribute access. */
 export function isPythonStaticLikeMethod(fnNode) {
-    return (fnNode.childForFieldName('name')?.text === '__new__' || hasDecorator(fnNode, 'staticmethod'));
+    return (fnNode.childForFieldName('name')?.text === '__new__' ||
+        decoratorNames(fnNode).some((name) => isBuiltinDescriptor(fnNode, name, 'staticmethod')));
+}
+/**
+ * Can the method's parameter list prove its call shape? Only a plain function
+ * or one builtin `staticmethod` / `classmethod` wrapper qualifies. Any other
+ * decorator may replace the callable, and a descriptor stack can make it
+ * uncallable: `staticmethod(classmethod(f))` yields a classmethod object.
+ */
+export function hasPythonProvenCallShape(fnNode) {
+    const [decorator, ...rest] = decoratorNames(fnNode);
+    if (decorator === undefined)
+        return true;
+    return (rest.length === 0 &&
+        (isBuiltinDescriptor(fnNode, decorator, 'staticmethod') ||
+            isBuiltinDescriptor(fnNode, decorator, 'classmethod')));
+}
+function isKnownReceiverDecorator(fnNode, expression) {
+    return isBuiltinDescriptor(fnNode, expression) || isLocalPropertyAccessor(fnNode, expression);
 }
 function firstBoundReceiverParameter(parameters) {
     for (let i = 0; i < parameters.namedChildCount; i++) {
@@ -86,12 +137,17 @@ function firstParameterName(param) {
  */
 export function classifyPythonBoundReceiver(fnNode) {
     const enclosingClass = findEnclosingClassDefinition(fnNode);
-    if (enclosingClass === null || isPythonStaticLikeMethod(fnNode))
+    if (enclosingClass === null)
         return null;
+    const decorators = decoratorNames(fnNode);
+    if (isPythonStaticLikeMethod(fnNode) ||
+        decorators.some((name) => !isKnownReceiverDecorator(fnNode, name))) {
+        // Python evaluates decorators as expressions. An unrecognized one may
+        // replace the function with a class/static descriptor, so its first
+        // parameter is not proven to receive an instance.
+        return null;
+    }
     const functionName = fnNode.childForFieldName('name')?.text;
-    // Python applies these descriptor kinds implicitly even without decorators.
-    // __new__ is static-like (its class argument is explicit), while
-    // __init_subclass__ and __class_getitem__ receive the class implicitly.
     const params = fnNode.childForFieldName('parameters');
     if (params === null)
         return null;
@@ -103,7 +159,9 @@ export function classifyPythonBoundReceiver(fnNode) {
     if (name === null || className === null)
         return null;
     return {
-        kind: hasDecorator(fnNode, 'classmethod') ||
+        // Python makes __init_subclass__ and __class_getitem__ implicit
+        // classmethods, so they receive the class even without a decorator.
+        kind: decorators.includes('classmethod') ||
             functionName === '__init_subclass__' ||
             functionName === '__class_getitem__'
             ? 'class'
@@ -142,10 +200,45 @@ function classifyPythonExplicitNewReceiver(fnNode) {
  * The caller is responsible for guaranteeing `fnNode.type ===
  * 'function_definition'`.
  */
+/**
+ * The first parameter of a class method under an unrecognized decorator.
+ * Python may still bind it implicitly, but its receiver kind is unproven.
+ */
+export function classifyPythonUncertainReceiver(fnNode) {
+    const decorators = decoratorNames(fnNode);
+    // Python applies decorators bottom-up. An outer built-in staticmethod
+    // guarantees no implicit receiver even when an inner decorator is opaque.
+    // The first parameter remains explicit and can keep its annotation.
+    const outermost = decorators[0];
+    if (outermost !== undefined && isBuiltinDescriptor(fnNode, outermost, 'staticmethod')) {
+        return null;
+    }
+    if (decorators.every((name) => isKnownReceiverDecorator(fnNode, name)))
+        return null;
+    const enclosingClass = findEnclosingClassDefinition(fnNode);
+    const parameters = fnNode.childForFieldName('parameters');
+    const parameter = parameters === null ? null : firstBoundReceiverParameter(parameters);
+    const name = parameter === null ? null : firstParameterName(parameter);
+    const className = enclosingClass === null ? null : classDefinitionName(enclosingClass);
+    if (parameter === null || name === null || className === null)
+        return null;
+    return { kind: 'instance', parameter, name, className };
+}
 export function synthesizeReceiverTypeBinding(fnNode) {
     const receiver = classifyPythonBoundReceiver(fnNode) ?? classifyPythonExplicitNewReceiver(fnNode);
-    if (receiver === null)
-        return null;
+    if (receiver === null) {
+        // Keep an uncertain receiver anchored to its enclosing class so the
+        // resolver can report the missing member without treating it as `self`.
+        const uncertain = classifyPythonUncertainReceiver(fnNode);
+        if (uncertain === null)
+            return null;
+        const { parameter: first, name, className } = uncertain;
+        return {
+            '@type-binding.uncertain-receiver': nodeToCapture('@type-binding.uncertain-receiver', first),
+            '@type-binding.name': syntheticCapture('@type-binding.name', first, name),
+            '@type-binding.type': syntheticCapture('@type-binding.type', first, className),
+        };
+    }
     // Receiver convention: instance methods get `self`, classmethods get `cls`.
     // The capture tag records the descriptor kind; the variable may use any
     // spelling.
@@ -241,8 +334,6 @@ export function synthesizeConstructorFieldTypeBindings(fnNode) {
         return [];
     if (findEnclosingClassDefinition(fnNode) === null)
         return [];
-    if (hasDecorator(fnNode, 'staticmethod') || hasDecorator(fnNode, 'classmethod'))
-        return [];
     const receiver = synthesizeReceiverTypeBinding(fnNode);
     const receiverName = receiver?.['@type-binding.self']?.text;
     if (receiverName === undefined)

package/dist/core/ingestion/languages/python/scope-resolver.js

@@ -50,6 +50,7 @@ const pythonScopeResolver = {
     // A free call naming a class constructs it: `Service(db).do_work()` (#2708).
     constructionSyntax: { bare: true },
     language: SupportedLanguages.Python,
+    suppressReceiverLookup: (typeRef) => typeRef.source === 'decorator-unknown',
     languageProvider: pythonProvider,
     importEdgeReason: 'python-scope: import',
     resolveImportTarget: (targetRaw, fromFile, allFilePaths, _resolutionConfig, context) => {

package/dist/core/ingestion/languages/python/subtype-dispatch.js

@@ -1,5 +1,5 @@
 import { definitionIdPosition } from '../../scope-resolution/utils/definition-id.js';
-import { classifyPythonBoundReceiver, isPythonStaticLikeMethod } from './receiver-binding.js';
+import { classifyPythonBoundReceiver, hasPythonProvenCallShape, isPythonStaticLikeMethod, } from './receiver-binding.js';
 const simplePositionalCallsByFile = new Map();
 const positionalCapacitiesByFile = new Map();
 const positionKey = (line, column) => `${line}:${column}`;
@@ -87,19 +87,10 @@ function positionalCapacity(fnNode) {
 }
 /** Record a method's exact fixed positional capacity when the AST proves it. */
 export function recordPythonSubtypeMethodShape(filePath, fnNode, mapLine) {
-    // An unknown decorator may replace the function or mark it abstract.
-    // Positional shape alone cannot prove a concrete subtype dispatch target.
-    // The two built-in descriptor decorators are handled by receiver binding.
-    const wrapper = fnNode.parent;
-    if (wrapper?.type === 'decorated_definition' &&
-        wrapper.namedChildren.some((child) => {
-            if (child.type !== 'decorator')
-                return false;
-            const name = child.firstNamedChild?.text;
-            return name !== 'staticmethod' && name !== 'classmethod';
-        })) {
+    // An unknown decorator may replace the function or mark it abstract, so
+    // its parameter list cannot prove a concrete subtype dispatch target.
+    if (!hasPythonProvenCallShape(fnNode))
         return;
-    }
     const capacity = positionalCapacity(fnNode);
     if (capacity === undefined)
         return;

package/dist/core/ingestion/method-extractors/configs/python.js

@@ -2,7 +2,7 @@
 // Verified against tree-sitter-python 0.23.4
 import { SupportedLanguages } from '../../../../_shared/index.js';
 import { hasKeyword } from '../../field-extractors/configs/helpers.js';
-import { classifyPythonBoundReceiver } from '../../languages/python/receiver-binding.js';
+import { classifyPythonBoundReceiver, classifyPythonUncertainReceiver, isPythonStaticLikeMethod, } from '../../languages/python/receiver-binding.js';
 import { extractSimpleTypeName } from '../../type-extractors/shared.js';
 // ---------------------------------------------------------------------------
 // Python helpers
@@ -92,7 +92,10 @@ function extractPythonParameters(node) {
         return [];
     const params = [];
     let isFirst = true;
-    const boundReceiverId = classifyPythonBoundReceiver(funcNode)?.parameter.id;
+    // An opaque decorator leaves the receiver kind unproven, not the slot: keep
+    // stripping it so arity matches ordinary bound calls.
+    const boundReceiverId = (classifyPythonBoundReceiver(funcNode) ??
+        (isPythonStaticLikeMethod(funcNode) ? null : classifyPythonUncertainReceiver(funcNode)))?.parameter.id;
     for (let i = 0; i < paramList.namedChildCount; i++) {
         const param = paramList.namedChild(i);
         if (!param)

package/dist/core/ingestion/scope-extractor.js

@@ -1009,6 +1009,11 @@ function followChainedRef(start, draftById) {
  */
 function typeBindingStrength(source) {
     switch (source) {
+        // A method decorator may change what the first parameter receives. An
+        // annotation describes intent, not descriptor binding, so it cannot
+        // override this uncertainty for that parameter.
+        case 'decorator-unknown':
+            return 4;
         case 'annotation':
             return 3;
         case 'parameter-annotation':

package/dist/core/ingestion/scope-resolution/contract/scope-resolver.d.ts

@@ -1235,6 +1235,10 @@ export interface ScopeResolver {
      * return undefined to retain the shared behavior.
      */
     readonly resolveReceiverMember?: (ownerDef: SymbolDefinition, memberName: string, callsite: Callsite, scopes: ScopeResolutionIndexes, model: SemanticModel) => ReceiverMemberResolution | undefined;
+    /** Suppress all receiver dispatch when a captured type cannot prove its
+     * runtime binding. Runs before compound and simple receiver lookup; the
+     * caller records a receiver-unresolved outcome. */
+    readonly suppressReceiverLookup?: (typeRef: TypeRef) => boolean;
     /**
      * Enable the receiver-bound Case 0.5 fallback for explicit `this`
      * receivers (`this->m()` / `this.m()`) that resolves against the

package/dist/core/ingestion/scope-resolution/passes/receiver-bound-calls.d.ts

@@ -72,7 +72,7 @@ import { type HeritageTypeArguments } from '../utils/generic-instantiation.js';
 import type { ResolutionOutcomeRecorder } from '../resolution-outcome.js';
 import type { ReceiverOrigin } from '../resolution-outcome.js';
 import type { DecodedReceiverChain } from '../../utils/receiver-chain-codec.js';
-type ReceiverBoundProviderSubset = Pick<ScopeResolver, 'isSuperReceiver' | 'isSuperReceiverInContext' | 'fieldFallbackOnMethodLookup' | 'collapseMemberCallsByCallerTarget' | 'elementTypeOf' | 'hoistTypeBindingsToModule' | 'stripReceiverCastExpressions' | 'constructionSyntax' | 'stripTypePreservingDecoration' | 'resolveQualifiedReceiverMember' | 'namespaceReceiverPaths' | 'resolveReceiverMember' | 'resolveThisViaEnclosingClass' | 'resolveMissingReceiverMembersFromSubtypes' | 'missingReceiverSubtypeCandidateCompatibility' | 'arityCompatibility' | 'conversionRankFn' | 'conversionOnlyArgTypePrefixes' | 'constraintCompatibility' | 'isStaticOnly' | 'normalizeTypeArgument' | 'markConstructionSites' | 'namespaceExportsIncludeImportedNames' | 'resolveNamespaceChains'>;
+type ReceiverBoundProviderSubset = Pick<ScopeResolver, 'isSuperReceiver' | 'isSuperReceiverInContext' | 'fieldFallbackOnMethodLookup' | 'collapseMemberCallsByCallerTarget' | 'elementTypeOf' | 'hoistTypeBindingsToModule' | 'stripReceiverCastExpressions' | 'constructionSyntax' | 'stripTypePreservingDecoration' | 'resolveQualifiedReceiverMember' | 'namespaceReceiverPaths' | 'resolveReceiverMember' | 'suppressReceiverLookup' | 'resolveThisViaEnclosingClass' | 'resolveMissingReceiverMembersFromSubtypes' | 'missingReceiverSubtypeCandidateCompatibility' | 'arityCompatibility' | 'conversionRankFn' | 'conversionOnlyArgTypePrefixes' | 'constraintCompatibility' | 'isStaticOnly' | 'normalizeTypeArgument' | 'markConstructionSites' | 'namespaceExportsIncludeImportedNames' | 'resolveNamespaceChains'>;
 /**
  * Is this dropped receiver rooted inside the analyzed program?
  *

package/dist/core/ingestion/scope-resolution/passes/receiver-bound-calls.js

@@ -849,6 +849,27 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
             const receiverName = site.explicitReceiver.name;
             const memberName = site.name;
             const siteKey = `${parsed.filePath}:${site.atRange.startLine}:${site.atRange.startCol}`;
+            if (provider.suppressReceiverLookup !== undefined) {
+                const baseName = decodeReceiverChain(site.receiverChain)?.baseReceiverName ??
+                    receiverName.split(/[.([\s]/, 1)[0];
+                const baseTypeRef = baseName === undefined
+                    ? undefined
+                    : findReceiverTypeBinding(site.inScope, baseName, scopes);
+                if (baseTypeRef !== undefined && provider.suppressReceiverLookup(baseTypeRef)) {
+                    options.recordResolutionOutcome?.({
+                        kind: 'suppressed',
+                        reason: 'receiver-unresolved',
+                        candidateIds: [],
+                        phase: 'receiver-bound-calls',
+                        filePath: parsed.filePath,
+                        name: site.name,
+                        range: site.atRange,
+                        siteKind: site.kind,
+                    });
+                    handledSites.add(siteKey);
+                    continue;
+                }
+            }
             // ── owned-but-unbound receiver ───────────────────────────────
             // The language declared this scope REBINDS the receiver and gave
             // it no type — a JS/TS ordinary `function`, whose `this` comes
@@ -1871,9 +1892,7 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                                 if (picked === undefined) {
                                     // This runtime subtype has no proven binding. Preserve
                                     // partial coverage even when a sibling supplies a target.
-                                    if (!incompleteInheritanceSubtypeIds.has(subtype.nodeId)) {
-                                        missingMemberSubtypeIds.add(subtype.nodeId);
-                                    }
+                                    missingMemberSubtypeIds.add(subtype.nodeId);
                                     continue;
                                 }
                                 subtypeTargets.set(picked.nodeId, picked);

package/dist/storage/parse-cache.js

@@ -800,7 +800,14 @@ import { copyV8CacheIfPresent, tryLoadV8Cache, writeV8CacheFile } from './v8-sid
 // would retain that capacity and could emit a false concrete call target.
 // v119 (#3396): Python subtype method capacities now omit receiverless ordinary
 // methods. Warm v118 ParsedFiles would replay a false compatible target.
-const SCHEMA_BUMP = 119;
+// v120 (#3394): decorated Python method receiver bindings now distinguish
+// unproven decorators from instance receivers. Warm v119 ParsedFiles would
+// replay a fabricated `self` binding or lack the uncertainty marker entirely.
+// v121 (#3399 follow-up): Python decorator identity now ignores trailing
+// 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;
 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.52",
+  "version": "1.6.13-rc.54",
   "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",