@lzehrung/codegraph 2.3.27 → 2.3.29

package/dist/indexer/navigation-goto.js

@@ -1,4 +1,5 @@
 import { isJsTsLanguage } from "../languages/js-family.js";
+import { isPythonReceiverAttributeAssignmentName } from "../languages/definitions/python.js";
 import { sliceText } from "../util/ast.js";
 import { fileIdentityKey } from "../util/paths.js";
 import { getMemberAccessParts, getNavigationExpressionProperty, isMemberAccessNode, memberAccessTraversalTypes, } from "../util/member-access.js";
@@ -6,6 +7,7 @@ import { CSHARP_IDENTIFIER_SOURCE, JAVA_IDENTIFIER_SOURCE, XID_IDENTIFIER_SOURCE
 import { ensureParsedContext } from "./parse-context.js";
 import { okGoToResult } from "./navigation-provenance.js";
 import { resolveExport, resolveImported } from "./navigation-resolve.js";
+import { SymbolKind, } from "./types.js";
 const RUBY_CONSTANT_SOURCE = String.raw `(?=\p{Lu})${XID_IDENTIFIER_SOURCE}`;
 const CSHARP_CONSTANT_SOURCE = String.raw `(?=@?\p{Lu})${CSHARP_IDENTIFIER_SOURCE}`;
 const JAVA_CONSTANT_SOURCE = String.raw `(?=\p{Lu})${JAVA_IDENTIFIER_SOURCE}`;
@@ -133,6 +135,16 @@ export async function resolveMemberAccessDefinition(params) {
         (sup.id === "rust" && /^(?:self|Self)$/.test(receiverName));
     if (obj && prop && node.id === prop.id && (supportsReceiverMemberResolution(sup.id) || implicitClassReceiver)) {
         const member = sliceText(prop, source);
+        if (sup.id === "python") {
+            const memberDef = await resolvePythonReceiverMember(index, mod, node, obj, member, source, sup, resolveExpression);
+            if (!memberDef)
+                return null;
+            return okGoToResult(index, memberDef, {
+                via: { exportedName: member },
+                resolution: "member-access",
+                confidence: "medium",
+            });
+        }
         if (!sup.membersAreImplicitlyInScope && implicitClassReceiver) {
             const classContainer = findEnclosingClassContainer(node);
             const memberDef = classContainer
@@ -146,8 +158,9 @@ export async function resolveMemberAccessDefinition(params) {
                 });
             }
         }
-        const objDef = await resolveReceiverDefinition(obj, source, sup, resolveExpression);
-        if (objDef) {
+        const receiver = await resolveReceiverDefinition(obj, source, sup, resolveExpression);
+        if (receiver) {
+            const objDef = receiver.def;
             const targetContext = await ensureParsedContext(objDef.file, undefined, index.languageExtensions);
             const start = objDef.range.start;
             const targetPosition = {
@@ -156,13 +169,27 @@ export async function resolveMemberAccessDefinition(params) {
             };
             const nameNode = targetContext.tree.rootNode.descendantForPosition(targetPosition, targetPosition);
             const container = nameNode.parent;
+            if (receiver.runtimeTypeOnly &&
+                container &&
+                container.type !== "enum_declaration" &&
+                container.type !== "internal_module" &&
+                container.type !== "module") {
+                return null;
+            }
             if (container) {
                 const targetModule = index.byFile.get(fileIdentityKey(objDef.file));
                 if (targetModule) {
                     const normalizeIdentifier = targetContext.sup.normalizeIdentifier;
-                    const memberDef = targetContext.sup.id === "java"
-                        ? findDirectLocalWithinNode(targetModule.locals, member, container, targetContext, normalizeIdentifier)
-                        : findReceiverMemberDefinition(targetModule.locals, member, objDef, container, targetContext, normalizeIdentifier);
+                    let memberDef;
+                    if (receiver.runtimeTypeOnly) {
+                        memberDef = findDirectLocalWithinNode(targetModule.locals, member, container, targetContext, normalizeIdentifier);
+                    }
+                    else if (targetContext.sup.id === "java") {
+                        memberDef = findDirectLocalWithinNode(targetModule.locals, member, container, targetContext, normalizeIdentifier);
+                    }
+                    else {
+                        memberDef = findReceiverMemberDefinition(targetModule.locals, member, objDef, container, targetContext, normalizeIdentifier, receiver.memberScope);
+                    }
                     if (memberDef) {
                         return okGoToResult(index, memberDef, {
                             via: { exportedName: member },
@@ -206,17 +233,24 @@ async function resolveReceiverDefinition(obj, source, sup, resolveExpression) {
     if (constructor) {
         const result = await resolveExpression(constructor);
         if (result?.kind === "resolved") {
-            return result.def;
+            return {
+                def: result.def,
+                memberScope: isJsTsLanguage(sup.id) ? "instance" : "any",
+            };
         }
     }
-    if (isJsTsLanguage(sup.id)) {
-        if (sup.nodeTypes.identifier.includes(obj.type)) {
-            return null;
+    const direct = await resolveExpression(obj);
+    if (isJsTsLanguage(sup.id) && sup.nodeTypes.identifier.includes(obj.type)) {
+        if (direct?.kind === "resolved" && direct.def.kind === SymbolKind.Class) {
+            return { def: direct.def, memberScope: "static" };
         }
+        if (direct?.kind === "resolved" && direct.def.kind === SymbolKind.TypeAlias) {
+            return { def: direct.def, memberScope: "any", runtimeTypeOnly: true };
+        }
+        return null;
     }
-    const direct = await resolveExpression(obj);
     if (direct?.kind === "resolved") {
-        return direct.def;
+        return { def: direct.def, memberScope: "any" };
     }
     return null;
 }
@@ -275,6 +309,7 @@ const BINDING_CONTAINER_TYPES = new Set([
     "block",
     "function_declaration",
     "function_item",
+    "function_definition",
     "function",
     "function_expression",
     "arrow_function",
@@ -289,6 +324,9 @@ const BINDING_DECLARATION_TYPES = new Set([
     "formal_parameter",
     "required_parameter",
     "optional_parameter",
+    "parameter_declaration",
+    "short_var_declaration",
+    "var_spec",
 ]);
 function findVisiblePriorNewConstructor(receiver, receiverName, source, sup) {
     let current = receiver;
@@ -355,6 +393,16 @@ function findPriorNewConstructorInContainer(node, receiver, receiverName, source
                 constructor = candidate;
             }
         }
+        if (sup.id === "go" && (current.type === "short_var_declaration" || current.type === "var_spec")) {
+            const candidate = constructorFromGoBinding(current, receiverName, source, sup);
+            if (candidate) {
+                if (constructor && sliceText(constructor, source) !== sliceText(candidate, source)) {
+                    constructor = null;
+                    return false;
+                }
+                constructor = candidate;
+            }
+        }
         for (const child of current.namedChildren) {
             if (!visit(child)) {
                 return false;
@@ -383,6 +431,8 @@ function bindingContainerDeclaresNameBefore(node, receiver, receiverName, source
             return false;
         }
         if (BINDING_DECLARATION_TYPES.has(current.type)) {
+            if (goBindingDeclaresName(current, receiverName, source, sup))
+                return true;
             const name = current.childForFieldName("name") ?? current.child(0);
             if (name && sup.nodeTypes.identifier.includes(name.type) && sliceText(name, source) === receiverName) {
                 return true;
@@ -419,8 +469,88 @@ function constructorFromAssignmentLike(node, receiverName, source, sup) {
             return null;
         return findNamedChildText(node, match[1], source, sup);
     }
+    if (sup.id === "python") {
+        return pythonConstructorFromAssignment(node, receiverName, source, sup);
+    }
     return null;
 }
+function goBindingNameNodes(node) {
+    if (node.type === "short_var_declaration") {
+        const left = node.childForFieldName("left");
+        return (left?.namedChildren ?? []).filter((child) => child.type === "identifier");
+    }
+    if (node.type === "var_spec") {
+        return (node.namedChildren ?? []).filter((child) => child.type === "identifier");
+    }
+    return [];
+}
+function goBindingDeclaresName(node, receiverName, source, sup) {
+    if (sup.id !== "go")
+        return false;
+    return goBindingNameNodes(node).some((name) => sliceText(name, source) === receiverName);
+}
+function constructorFromGoBinding(node, receiverName, source, sup) {
+    if (!goBindingDeclaresName(node, receiverName, source, sup))
+        return null;
+    if (node.type === "short_var_declaration") {
+        const left = node.childForFieldName("left");
+        const right = node.childForFieldName("right");
+        if (!left || !right)
+            return null;
+        const names = (left.namedChildren ?? []).filter((child) => child.type === "identifier");
+        const values = right.namedChildren ?? [];
+        const index = names.findIndex((name) => sliceText(name, source) === receiverName);
+        if (index < 0)
+            return null;
+        const value = values[index] ?? null;
+        return value ? goCompositeLiteralTypeName(value, source) : null;
+    }
+    if (node.type !== "var_spec")
+        return null;
+    const value = node.childForFieldName("value");
+    if (value) {
+        const first = value.type === "expression_list" ? (value.namedChildren[0] ?? null) : value;
+        const fromValue = first ? goCompositeLiteralTypeName(first, source) : null;
+        if (fromValue)
+            return fromValue;
+    }
+    const typeNode = node.childForFieldName("type");
+    return typeNode ? unwrapGoConstructorType(typeNode) : null;
+}
+function goCompositeLiteralTypeName(expr, source) {
+    let current = expr;
+    if (current.type === "unary_expression") {
+        const operand = current.childForFieldName("operand");
+        if (!operand)
+            return null;
+        const operator = current.childForFieldName("operator");
+        let isAddr = sliceText(current, source).startsWith("&");
+        if (operator)
+            isAddr = sliceText(operator, source) === "&";
+        if (!isAddr)
+            return null;
+        current = operand;
+    }
+    if (current.type !== "composite_literal")
+        return null;
+    const typeNode = current.childForFieldName("type");
+    return typeNode ? unwrapGoConstructorType(typeNode) : null;
+}
+function unwrapGoConstructorType(node) {
+    let current = node;
+    while (current) {
+        if (current.type === "parenthesized_type" || current.type === "pointer_type") {
+            current = current.namedChildren[0] ?? null;
+            continue;
+        }
+        if (current.type === "generic_type") {
+            current = current.childForFieldName("type") ?? current.namedChildren[0] ?? null;
+            continue;
+        }
+        break;
+    }
+    return current?.type === "type_identifier" ? current : null;
+}
 function findNamedChildText(node, name, source, sup) {
     const isNameNode = (candidate) => (sup.nodeTypes.identifier.includes(candidate.type) ||
         candidate.type === "type_identifier" ||
@@ -460,8 +590,13 @@ async function resolveMemberDefinitionForBase(index, baseDef, member) {
         return undefined;
     return findReceiverMemberDefinition(targetModule.locals, member, baseDef, container, targetContext, normalizeIdentifier);
 }
-function findReceiverMemberDefinition(locals, member, receiverDef, container, targetContext, normalizeIdentifier) {
-    const containerHit = findLocalWithinNode(locals, member, container, normalizeIdentifier);
+function findReceiverMemberDefinition(locals, member, receiverDef, container, targetContext, normalizeIdentifier, memberScope = "any") {
+    const memberPredicate = memberScope === "any"
+        ? undefined
+        : (local) => hasStaticModifier(local, targetContext, container) === (memberScope === "static");
+    const containerHit = memberScope === "any"
+        ? findLocalWithinNode(locals, member, container, normalizeIdentifier)
+        : findDirectLocalWithinNode(locals, member, container, targetContext, normalizeIdentifier, memberPredicate);
     if (containerHit)
         return containerHit;
     if (targetContext.sup.id !== "rust")
@@ -469,7 +604,7 @@ function findReceiverMemberDefinition(locals, member, receiverDef, container, ta
     const implNode = findRustImplForType(targetContext.tree.rootNode, receiverDef.localName, targetContext.source);
     return implNode ? findLocalWithinNode(locals, member, implNode, normalizeIdentifier) : undefined;
 }
-function findLocalWithinNode(locals, member, node, normalizeIdentifier = (name) => name) {
+function findLocalWithinNode(locals, member, node, normalizeIdentifier = (name) => name, predicate) {
     const containerStart = node.startIndex;
     const containerEnd = node.endIndex;
     const normalizedMember = normalizeIdentifier(member);
@@ -480,9 +615,28 @@ function findLocalWithinNode(locals, member, node, normalizeIdentifier = (name)
             startIndex !== undefined &&
             endIndex !== undefined &&
             startIndex >= containerStart &&
-            endIndex <= containerEnd);
+            endIndex <= containerEnd &&
+            (!predicate || predicate(local)));
     });
 }
+function hasStaticModifier(local, targetContext, container) {
+    const position = {
+        row: local.range.start.line - 1,
+        column: local.range.start.column - 1,
+    };
+    let current = targetContext.tree.rootNode.descendantForPosition(position, position);
+    while (current && current !== container) {
+        for (let childIndex = 0;; childIndex += 1) {
+            const child = current.child(childIndex);
+            if (!child)
+                break;
+            if (child.type === "static")
+                return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}
 const NESTED_MEMBER_LOCAL_CONTAINERS = new Set([
     "block",
     "class",
@@ -502,7 +656,7 @@ const NESTED_MEMBER_LOCAL_CONTAINERS = new Set([
     "module",
     "statement_block",
 ]);
-function findDirectLocalWithinNode(locals, member, container, targetContext, normalizeIdentifier) {
+function findDirectLocalWithinNode(locals, member, container, targetContext, normalizeIdentifier, predicate) {
     const containerStart = container.startIndex;
     const containerEnd = container.endIndex;
     const normalizedMember = normalizeIdentifier(member);
@@ -524,7 +678,9 @@ function findDirectLocalWithinNode(locals, member, container, targetContext, nor
         let current = targetContext.tree.rootNode.descendantForPosition(position, position).parent;
         let isDeclarationParent = true;
         while (current && current !== container) {
+            const isDirectBody = (current.type === "statement_block" || current.type === "block") && current.parent === container;
             if (!isDeclarationParent &&
+                !isDirectBody &&
                 ((current.type === "class_body" && current.parent !== container) ||
                     NESTED_MEMBER_LOCAL_CONTAINERS.has(current.type))) {
                 current = null;
@@ -533,7 +689,7 @@ function findDirectLocalWithinNode(locals, member, container, targetContext, nor
             isDeclarationParent = false;
             current = current.parent;
         }
-        if (current)
+        if (current && (!predicate || predicate(local)))
             return local;
     }
     return undefined;
@@ -557,6 +713,230 @@ function findRustImplForType(root, typeName, source) {
     visit(root);
     return found;
 }
+function pythonConstructorFromAssignment(node, receiverName, source, sup) {
+    const left = node.childForFieldName("left");
+    if (!left || !sup.nodeTypes.identifier.includes(left.type) || sliceText(left, source) !== receiverName) {
+        return null;
+    }
+    const right = node.childForFieldName("right");
+    if (!right || right.type !== "call")
+        return null;
+    const callee = right.childForFieldName("function") ?? right.namedChildren[0] ?? null;
+    if (!callee || !sup.nodeTypes.identifier.includes(callee.type))
+        return null;
+    return callee;
+}
+const PYTHON_SUPERTYPE_DEPTH = 16;
+function pythonClassKey(def) {
+    const start = def.range.start;
+    return `${fileIdentityKey(def.file)}:${start.index ?? `${start.line}:${start.column}`}`;
+}
+async function resolvePythonReceiverMember(index, mod, node, obj, member, source, sup, resolveExpression) {
+    const classRef = await pythonReceiverClassRef(index, mod, node, obj, source, sup, resolveExpression);
+    if (!classRef)
+        return undefined;
+    return lookupPythonClassMember(index, classRef, member);
+}
+async function pythonReceiverClassRef(index, mod, node, obj, source, sup, resolveExpression) {
+    const receiverName = sliceText(obj, source);
+    if (receiverName === "self" || receiverName === "cls") {
+        const container = findEnclosingClassContainer(node);
+        if (!container)
+            return null;
+        const nameNode = container.childForFieldName("name");
+        if (!nameNode)
+            return null;
+        const className = sliceText(nameNode, source);
+        const def = mod.locals.find((local) => {
+            const startIndex = local.range.start.index;
+            const endIndex = local.range.end.index;
+            return (local.kind === SymbolKind.Class &&
+                local.localName === className &&
+                startIndex !== undefined &&
+                endIndex !== undefined &&
+                startIndex >= container.startIndex &&
+                endIndex <= container.endIndex);
+        });
+        if (!def)
+            return null;
+        return pythonClassRefFromDef(index, def);
+    }
+    let classDef;
+    const constructor = receiverConstructorExpression(obj, source, sup);
+    if (constructor) {
+        const result = await resolveExpression(constructor);
+        if (result?.kind === "resolved" && result.def.kind === SymbolKind.Class) {
+            classDef = result.def;
+        }
+    }
+    if (!classDef) {
+        const direct = await resolveExpression(obj);
+        if (direct?.kind === "resolved" && direct.def.kind === SymbolKind.Class) {
+            classDef = direct.def;
+        }
+    }
+    if (!classDef)
+        return null;
+    return pythonClassRefFromDef(index, classDef);
+}
+async function pythonClassRefFromDef(index, def) {
+    const module = index.byFile.get(fileIdentityKey(def.file));
+    if (!module)
+        return null;
+    const context = await ensureParsedContext(def.file, undefined, index.languageExtensions);
+    const start = def.range.start;
+    const position = {
+        row: start.line - 1,
+        column: start.column - 1,
+    };
+    let current = context.tree.rootNode.descendantForPosition(position, position);
+    while (current && current.type !== "class_definition") {
+        current = current.parent;
+    }
+    if (!current)
+        return null;
+    return { def, container: current, context, module };
+}
+function pythonMembersOnClass(classRef, member) {
+    const normalizeIdentifier = classRef.context.sup.normalizeIdentifier;
+    const direct = findDirectLocalWithinNode(classRef.module.locals, member, classRef.container, classRef.context, normalizeIdentifier);
+    if (direct)
+        return [direct];
+    const attribute = findPythonInstanceAttributeWithinClass(classRef.module.locals, member, classRef.container, classRef.context, normalizeIdentifier);
+    return attribute ? [attribute] : [];
+}
+function findPythonInstanceAttributeWithinClass(locals, member, container, targetContext, normalizeIdentifier) {
+    const containerStart = container.startIndex;
+    const containerEnd = container.endIndex;
+    const normalizedMember = normalizeIdentifier(member);
+    for (const local of locals) {
+        const startIndex = local.range.start.index;
+        const endIndex = local.range.end.index;
+        if (normalizeIdentifier(local.localName) !== normalizedMember ||
+            startIndex === undefined ||
+            endIndex === undefined ||
+            startIndex < containerStart ||
+            endIndex > containerEnd) {
+            continue;
+        }
+        const start = local.range.start;
+        const position = {
+            row: start.line - 1,
+            column: start.column - 1,
+        };
+        const nameNode = targetContext.tree.rootNode.descendantForPosition(position, position);
+        if (isPythonReceiverAttributeAssignmentName(nameNode))
+            return local;
+    }
+    return undefined;
+}
+function pythonBaseIdentifierNodes(classNode) {
+    const bases = classNode.childForFieldName("superclasses") ??
+        (classNode.namedChildren ?? []).find((child) => child.type === "argument_list");
+    if (!bases)
+        return [];
+    const names = [];
+    const visit = (node) => {
+        if (node.type === "keyword_argument" || node.type === "dictionary_splat" || node.type === "list_splat") {
+            return;
+        }
+        if (node.type === "identifier") {
+            names.push(node);
+            return;
+        }
+        if (node.type === "subscript") {
+            const value = node.childForFieldName("value");
+            if (value)
+                visit(value);
+            return;
+        }
+        for (const child of node.namedChildren)
+            visit(child);
+    };
+    visit(bases);
+    return names;
+}
+function resolvePythonNamedClass(index, mod, name) {
+    const classes = mod.locals.filter((local) => local.kind === SymbolKind.Class && local.localName === name);
+    const topLevel = classes.filter((local) => !local.isMember);
+    const candidates = topLevel.length ? topLevel : classes;
+    if (candidates.length === 1)
+        return candidates[0];
+    if (candidates.length > 1)
+        return undefined;
+    for (const imp of mod.imports) {
+        if (imp.kind === "named" && imp.local === name) {
+            const result = resolveImported(index, imp, imp.imported);
+            if (result && !("namespace" in result) && result.kind === SymbolKind.Class)
+                return result;
+        }
+        if (imp.kind === "star") {
+            const result = resolveImported(index, imp, name);
+            if (result && !("namespace" in result) && result.kind === SymbolKind.Class)
+                return result;
+        }
+    }
+    const exported = resolveExport(index, mod.file, name, { preferredKind: SymbolKind.Class, allowLocalFallback: false });
+    if (exported?.kind === "resolved" && exported.def.kind === SymbolKind.Class)
+        return exported.def;
+    return undefined;
+}
+async function pythonBaseClassRefs(index, classRef) {
+    const names = pythonBaseIdentifierNodes(classRef.container);
+    const refs = [];
+    const seen = new Set();
+    for (const nameNode of names) {
+        const def = resolvePythonNamedClass(index, classRef.module, sliceText(nameNode, classRef.context.source));
+        if (!def)
+            continue;
+        const key = pythonClassKey(def);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const ref = await pythonClassRefFromDef(index, def);
+        if (ref)
+            refs.push(ref);
+    }
+    return refs;
+}
+async function lookupPythonClassMember(index, start, member) {
+    const own = pythonMembersOnClass(start, member);
+    if (own.length === 1)
+        return own[0];
+    if (own.length > 1)
+        return undefined;
+    let level = await pythonBaseClassRefs(index, start);
+    const visited = new Set([pythonClassKey(start.def), ...level.map((base) => pythonClassKey(base.def))]);
+    for (let depth = 0; depth < PYTHON_SUPERTYPE_DEPTH && level.length; depth += 1) {
+        const matches = [];
+        const seenMatch = new Set();
+        for (const base of level) {
+            for (const hit of pythonMembersOnClass(base, member)) {
+                const key = pythonClassKey(hit);
+                if (seenMatch.has(key))
+                    continue;
+                seenMatch.add(key);
+                matches.push(hit);
+            }
+        }
+        if (matches.length === 1)
+            return matches[0];
+        if (matches.length > 1)
+            return undefined;
+        const next = [];
+        for (const base of level) {
+            for (const parent of await pythonBaseClassRefs(index, base)) {
+                const key = pythonClassKey(parent.def);
+                if (visited.has(key))
+                    continue;
+                visited.add(key);
+                next.push(parent);
+            }
+        }
+        level = next;
+    }
+    return undefined;
+}
 function escapeRegExp(value) {
     return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }