@lzehrung/codegraph 2.3.28 → 2.3.30

package/dist/indexer/navigation-goto.js

@@ -1,29 +1,33 @@
 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";
-import { CSHARP_IDENTIFIER_SOURCE, JAVA_IDENTIFIER_SOURCE, XID_IDENTIFIER_SOURCE } from "../util/identifiers.js";
+import { getMemberAccessParts, getNavigationExpressionProperty, isMemberAccessNode, isReceiverNameNode, memberAccessTraversalTypes, } from "../util/member-access.js";
+import { declaresMembers, hasStaticMemberDistinction, isKeywordReceiver, nearestMemberContainer, receiverConstructorExpression, supportsReceiverMemberNavigation, unwrapNamedType, } from "../graphs/symbol-graph-detailed/receiver-calls.js";
 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}`;
-const RUST_CONSTANT_SOURCE = String.raw `(?=\p{Lu})${XID_IDENTIFIER_SOURCE}`;
-const IDENTIFIER_BOUNDARY_SOURCE = String.raw `[$_\p{ID_Continue}\u200c\u200d]`;
 export async function resolveMemberAccessDefinition(params) {
     const { index, mod, node, source, sup, resolveLexicalBinding } = params;
     const parent = node.parent;
-    if (!parent || !sup.supportsCrossModuleSymbols || !isMemberAccessNode(sup, parent)) {
+    if (!parent || !sup.supportsCrossModuleSymbols) {
         return null;
     }
-    const memberNode = parent;
+    let memberNode = null;
+    if (isMemberAccessNode(sup, parent)) {
+        memberNode = parent;
+    }
+    else if (parent.parent && isMemberAccessNode(sup, parent.parent)) {
+        memberNode = parent.parent;
+    }
+    if (!memberNode)
+        return null;
     const { object: obj, property: prop } = getMemberAccessParts(sup, memberNode);
     const optionalMemberTypes = memberAccessTraversalTypes(sup);
     const resolveExpression = async (expr) => {
-        const exprIsId = sup.nodeTypes.identifier.includes(expr.type) && !isMemberAccessNode(sup, expr);
-        if (exprIsId || expr.type === "identifier" || expr.type === "type_identifier" || expr.type === "constant") {
+        const exprIsId = isReceiverNameNode(sup, expr.type) && !isMemberAccessNode(sup, expr);
+        if (exprIsId) {
             const lexicalBinding = resolveLexicalBinding?.(expr);
             if (lexicalBinding)
                 return { kind: "resolved", def: lexicalBinding };
@@ -129,11 +133,19 @@ export async function resolveMemberAccessDefinition(params) {
         }
     }
     const receiverName = obj ? sliceText(obj, source) : "";
-    const implicitClassReceiver = (isJsTsLanguage(sup.id) && receiverName === "this") ||
-        (sup.id === "php" && /^(?:\$this|self|static)$/.test(receiverName)) ||
-        (sup.id === "rust" && /^(?:self|Self)$/.test(receiverName));
-    if (obj && prop && node.id === prop.id && (supportsReceiverMemberResolution(sup.id) || implicitClassReceiver)) {
+    const implicitClassReceiver = isKeywordReceiver(sup.id, receiverName);
+    if (obj && prop && node.id === prop.id && (supportsReceiverMemberNavigation(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
@@ -147,7 +159,7 @@ export async function resolveMemberAccessDefinition(params) {
                 });
             }
         }
-        const receiver = await resolveReceiverDefinition(obj, source, sup, resolveExpression);
+        const receiver = await resolveReceiverDefinition(obj, source, sup, resolveExpression, mod);
         if (receiver) {
             const objDef = receiver.def;
             const targetContext = await ensureParsedContext(objDef.file, undefined, index.languageExtensions);
@@ -169,12 +181,12 @@ export async function resolveMemberAccessDefinition(params) {
                 const targetModule = index.byFile.get(fileIdentityKey(objDef.file));
                 if (targetModule) {
                     const normalizeIdentifier = targetContext.sup.normalizeIdentifier;
+                    const memberPredicate = receiver.memberScope === "any"
+                        ? undefined
+                        : (local) => matchesReceiverMemberScope(local, receiver.memberScope, targetContext, container);
                     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);
+                    if (receiver.runtimeTypeOnly || targetContext.sup.id === "java") {
+                        memberDef = findDirectLocalWithinNode(targetModule.locals, member, container, targetContext, normalizeIdentifier, memberPredicate);
                     }
                     else {
                         memberDef = findReceiverMemberDefinition(targetModule.locals, member, objDef, container, targetContext, normalizeIdentifier, receiver.memberScope);
@@ -193,49 +205,47 @@ export async function resolveMemberAccessDefinition(params) {
     return null;
 }
 function findEnclosingClassContainer(node) {
-    let current = node.parent;
-    while (current) {
-        if (current.type === "class_declaration" ||
-            current.type === "abstract_class_declaration" ||
-            current.type === "class_definition" ||
-            current.type === "impl_item") {
-            return current;
-        }
-        current = current.parent;
-    }
-    return null;
+    return nearestMemberContainer(node);
 }
-export function supportsReceiverMemberResolution(languageId) {
-    return (languageId === "csharp" ||
-        languageId === "python" ||
-        languageId === "js" ||
-        languageId === "java" ||
-        languageId === "javascript" ||
-        languageId === "jsx" ||
-        languageId === "rust" ||
-        languageId === "ts" ||
-        languageId === "typescript" ||
-        languageId === "tsx");
+export { supportsReceiverCallEdges, supportsReceiverMemberNavigation, } from "../graphs/symbol-graph-detailed/receiver-calls.js";
+function memberDeclaringLocals(mod, typeName, normalize) {
+    const normalized = normalize(typeName);
+    return mod.locals.filter((local) => normalize(local.localName) === normalized && declaresMembers(local));
 }
-async function resolveReceiverDefinition(obj, source, sup, resolveExpression) {
+async function resolveReceiverDefinition(obj, source, sup, resolveExpression, mod) {
     const constructor = receiverConstructorExpression(obj, source, sup);
     if (constructor) {
+        const typeName = sliceText(constructor, source);
+        const typedLocals = memberDeclaringLocals(mod, typeName, sup.normalizeIdentifier);
+        if (typedLocals.length === 1) {
+            return {
+                def: typedLocals[0],
+                memberScope: hasStaticMemberDistinction(sup.id) ? "instance" : "any",
+            };
+        }
         const result = await resolveExpression(constructor);
-        if (result?.kind === "resolved") {
+        if (result?.kind === "resolved" && declaresMembers(result.def)) {
             return {
                 def: result.def,
-                memberScope: isJsTsLanguage(sup.id) ? "instance" : "any",
+                memberScope: hasStaticMemberDistinction(sup.id) ? "instance" : "any",
+            };
+        }
+        if (typedLocals[0]) {
+            return {
+                def: typedLocals[0],
+                memberScope: hasStaticMemberDistinction(sup.id) ? "instance" : "any",
             };
         }
     }
     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) {
+    if (direct?.kind === "resolved" && declaresMembers(direct.def)) {
+        if (isJsTsLanguage(sup.id) && direct.def.kind === SymbolKind.TypeAlias) {
             return { def: direct.def, memberScope: "any", runtimeTypeOnly: true };
         }
+        const memberScope = hasStaticMemberDistinction(sup.id) ? "static" : "any";
+        return { def: direct.def, memberScope };
+    }
+    if (isJsTsLanguage(sup.id) && isReceiverNameNode(sup, obj.type)) {
         return null;
     }
     if (direct?.kind === "resolved") {
@@ -243,224 +253,6 @@ async function resolveReceiverDefinition(obj, source, sup, resolveExpression) {
     }
     return null;
 }
-/**
- * Resolves the node naming the type a receiver expression was constructed from, or
- * null when no constructor is proven for it. Shared with detailed symbol-graph call
- * extraction so `goto` and resolved `calls` edges accept the same receiver forms.
- */
-export function receiverConstructorExpression(obj, source, sup) {
-    if (obj.type === "new_expression" || obj.type === "object_creation_expression") {
-        return constructorNameNode(obj, sup);
-    }
-    if (sup.id === "ruby" && obj.type === "call") {
-        const rubyConstructor = rubyNewReceiverNameNode(obj, source, sup);
-        if (rubyConstructor)
-            return rubyConstructor;
-    }
-    if (!sup.nodeTypes.identifier.includes(obj.type)) {
-        return null;
-    }
-    const receiverName = sliceText(obj, source);
-    return findVisiblePriorNewConstructor(obj, receiverName, source, sup);
-}
-function constructorNameNode(node, sup) {
-    const constructor = node.childForFieldName("constructor") ?? node.child(0);
-    if (constructor && sup.nodeTypes.identifier.includes(constructor.type)) {
-        return constructor;
-    }
-    for (const child of node.namedChildren) {
-        if (sup.nodeTypes.identifier.includes(child.type) ||
-            child.type === "type_identifier" ||
-            child.type === "constant") {
-            return child;
-        }
-    }
-    return null;
-}
-function rubyNewReceiverNameNode(node, source, sup) {
-    if (!new RegExp(String.raw `^(?:${RUBY_CONSTANT_SOURCE})\.new$`, "u").test(sliceText(node, source)))
-        return null;
-    return (node.namedChildren.find((child) => sup.nodeTypes.identifier.includes(child.type) || child.type === "constant") ??
-        null);
-}
-function rootOf(node) {
-    let current = node;
-    while (current.parent) {
-        current = current.parent;
-    }
-    return current;
-}
-const BINDING_CONTAINER_TYPES = new Set([
-    "program",
-    "compilation_unit",
-    "source_file",
-    "statement_block",
-    "block",
-    "function_declaration",
-    "function_item",
-    "function",
-    "function_expression",
-    "arrow_function",
-    "method_definition",
-    "method_declaration",
-    "method",
-]);
-const BINDING_DECLARATION_TYPES = new Set([
-    "variable_declarator",
-    "let_declaration",
-    "assignment",
-    "formal_parameter",
-    "required_parameter",
-    "optional_parameter",
-]);
-function findVisiblePriorNewConstructor(receiver, receiverName, source, sup) {
-    let current = receiver;
-    while (current) {
-        if (BINDING_CONTAINER_TYPES.has(current.type)) {
-            const constructor = findPriorNewConstructorInContainer(current, receiver, receiverName, source, sup);
-            if (constructor || bindingContainerDeclaresNameBefore(current, receiver, receiverName, source, sup)) {
-                return constructor;
-            }
-        }
-        current = current.parent;
-    }
-    return findPriorNewConstructorInContainer(rootOf(receiver), receiver, receiverName, source, sup);
-}
-function findPriorNewConstructorInContainer(node, receiver, receiverName, source, sup) {
-    let constructor = null;
-    const visit = (current) => {
-        if (current.startIndex >= receiver.startIndex) {
-            return true;
-        }
-        if (current !== node && isSkippableBindingContainer(current, receiver)) {
-            return true;
-        }
-        if (current.type === "variable_declarator") {
-            const name = current.childForFieldName("name") ?? current.child(0);
-            const value = current.childForFieldName("value");
-            if (name &&
-                value &&
-                (value.type === "new_expression" ||
-                    value.type === "object_creation_expression" ||
-                    sup.nodeTypes.identifier.includes(value.type)) &&
-                sup.nodeTypes.identifier.includes(name.type) &&
-                sliceText(name, source) === receiverName) {
-                const candidate = constructorNameNode(value, sup);
-                if (!candidate) {
-                    return true;
-                }
-                if (constructor && sliceText(constructor, source) !== sliceText(candidate, source)) {
-                    constructor = null;
-                    return false;
-                }
-                constructor = candidate;
-            }
-        }
-        if (current.type === "assignment" || current.type === "let_declaration") {
-            const candidate = constructorFromAssignmentLike(current, receiverName, source, sup);
-            if (candidate) {
-                if (constructor && sliceText(constructor, source) !== sliceText(candidate, source)) {
-                    constructor = null;
-                    return false;
-                }
-                constructor = candidate;
-            }
-        }
-        if (current.type === "local_variable_declaration" ||
-            current.type === "local_declaration_statement" ||
-            current.type === "variable_declaration") {
-            const candidate = constructorFromTypedLocalDeclaration(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;
-            }
-        }
-        return true;
-    };
-    visit(node);
-    return constructor;
-}
-function constructorFromTypedLocalDeclaration(node, receiverName, source, sup) {
-    if (sup.id !== "csharp" && sup.id !== "java")
-        return null;
-    const text = sliceText(node, source);
-    const typeNameSource = sup.id === "java" ? JAVA_CONSTANT_SOURCE : CSHARP_CONSTANT_SOURCE;
-    const match = text.match(new RegExp(String.raw `^\s*(${typeNameSource})\s+${escapeRegExp(receiverName)}\s*=\s*new\s+(${typeNameSource})(?![\p{L}\p{Nl}\p{Sc}\p{Pc}\p{Nd}\p{Mn}\p{Mc}\p{Cf}])`, "u"));
-    const typeName = match?.[2] ?? match?.[1];
-    return typeName ? findNamedChildText(node, typeName, source, sup) : null;
-}
-function bindingContainerDeclaresNameBefore(node, receiver, receiverName, source, sup) {
-    const visit = (current) => {
-        if (current.startIndex >= receiver.startIndex) {
-            return false;
-        }
-        if (current !== node && isSkippableBindingContainer(current, receiver)) {
-            return false;
-        }
-        if (BINDING_DECLARATION_TYPES.has(current.type)) {
-            const name = current.childForFieldName("name") ?? current.child(0);
-            if (name && sup.nodeTypes.identifier.includes(name.type) && sliceText(name, source) === receiverName) {
-                return true;
-            }
-        }
-        for (const child of current.namedChildren) {
-            if (visit(child)) {
-                return true;
-            }
-        }
-        return false;
-    };
-    return visit(node);
-}
-function isSkippableBindingContainer(node, receiver) {
-    return BINDING_CONTAINER_TYPES.has(node.type) && !nodeContainsIndex(node, receiver.startIndex);
-}
-function nodeContainsIndex(node, index) {
-    return node.startIndex <= index && node.endIndex >= index;
-}
-function constructorFromAssignmentLike(node, receiverName, source, sup) {
-    const text = sliceText(node, source);
-    if (!new RegExp(String.raw `(?<!${IDENTIFIER_BOUNDARY_SOURCE})${escapeRegExp(receiverName)}(?!${IDENTIFIER_BOUNDARY_SOURCE})`, "u").test(text))
-        return null;
-    if (sup.id === "ruby") {
-        const match = text.match(new RegExp(String.raw `^\s*${escapeRegExp(receiverName)}\s*=\s*(${RUBY_CONSTANT_SOURCE})\.new(?!${IDENTIFIER_BOUNDARY_SOURCE})`, "u"));
-        if (!match?.[1])
-            return null;
-        return findNamedChildText(node, match[1], source, sup);
-    }
-    if (sup.id === "rust") {
-        const match = text.match(new RegExp(String.raw `^\s*(?:let\s+)?${escapeRegExp(receiverName)}\s*=\s*(${RUST_CONSTANT_SOURCE})(?!${IDENTIFIER_BOUNDARY_SOURCE})`, "u"));
-        if (!match?.[1])
-            return null;
-        return findNamedChildText(node, match[1], source, sup);
-    }
-    return null;
-}
-function findNamedChildText(node, name, source, sup) {
-    const isNameNode = (candidate) => (sup.nodeTypes.identifier.includes(candidate.type) ||
-        candidate.type === "type_identifier" ||
-        candidate.type === "constant") &&
-        sliceText(candidate, source) === name;
-    const visit = (current) => {
-        if (isNameNode(current))
-            return current;
-        for (const child of current.namedChildren) {
-            const hit = visit(child);
-            if (hit)
-                return hit;
-        }
-        return null;
-    };
-    return visit(node);
-}
 async function resolveMemberDefinitionForBase(index, baseDef, member) {
     const targetContext = await ensureParsedContext(baseDef.file, undefined, index.languageExtensions);
     const start = baseDef.range.start;
@@ -486,16 +278,20 @@ async function resolveMemberDefinitionForBase(index, baseDef, member) {
 function findReceiverMemberDefinition(locals, member, receiverDef, container, targetContext, normalizeIdentifier, memberScope = "any") {
     const memberPredicate = memberScope === "any"
         ? undefined
-        : (local) => hasStaticModifier(local, targetContext, container) === (memberScope === "static");
+        : (local) => matchesReceiverMemberScope(local, memberScope, targetContext, container);
     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")
-        return undefined;
-    const implNode = findRustImplForType(targetContext.tree.rootNode, receiverDef.localName, targetContext.source);
-    return implNode ? findLocalWithinNode(locals, member, implNode, normalizeIdentifier) : undefined;
+    if (targetContext.sup.id === "rust") {
+        const implNode = findRustImplForType(targetContext.tree.rootNode, receiverDef.localName, targetContext.source);
+        return implNode ? findLocalWithinNode(locals, member, implNode, normalizeIdentifier) : undefined;
+    }
+    if (targetContext.sup.id === "go") {
+        return findGoReceiverMember(locals, member, receiverDef.localName, targetContext, normalizeIdentifier);
+    }
+    return undefined;
 }
 function findLocalWithinNode(locals, member, node, normalizeIdentifier = (name) => name, predicate) {
     const containerStart = node.startIndex;
@@ -512,6 +308,28 @@ function findLocalWithinNode(locals, member, node, normalizeIdentifier = (name)
             (!predicate || predicate(local)));
     });
 }
+function matchesReceiverMemberScope(local, memberScope, targetContext, container) {
+    if (memberScope === "any")
+        return true;
+    return hasStaticModifier(local, targetContext, container) === (memberScope === "static");
+}
+function nodeDeclaresStatic(node, source) {
+    if (node.type === "static" || node.type === "static_modifier")
+        return true;
+    if (node.type === "storage_class_specifier" || node.type === "modifier" || node.type === "property_modifier") {
+        return sliceText(node, source).trim() === "static";
+    }
+    if (node.type === "modifiers") {
+        for (let childIndex = 0;; childIndex += 1) {
+            const child = node.child(childIndex);
+            if (!child)
+                break;
+            if (nodeDeclaresStatic(child, source))
+                return true;
+        }
+    }
+    return false;
+}
 function hasStaticModifier(local, targetContext, container) {
     const position = {
         row: local.range.start.line - 1,
@@ -523,7 +341,7 @@ function hasStaticModifier(local, targetContext, container) {
             const child = current.child(childIndex);
             if (!child)
                 break;
-            if (child.type === "static")
+            if (nodeDeclaresStatic(child, targetContext.source))
                 return true;
         }
         current = current.parent;
@@ -571,7 +389,7 @@ 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.parent === container;
+            const isDirectBody = (current.type === "statement_block" || current.type === "block") && current.parent === container;
             if (!isDeclarationParent &&
                 !isDirectBody &&
                 ((current.type === "class_body" && current.parent !== container) ||
@@ -606,6 +424,318 @@ function findRustImplForType(root, typeName, source) {
     visit(root);
     return found;
 }
+const GO_EMBED_DEPTH = 16;
+function goMethodReceiverTypeName(methodNode, source, sup) {
+    const receiver = methodNode.childForFieldName("receiver");
+    if (!receiver)
+        return null;
+    const parameter = receiver.namedChildren.find((child) => child.type === "parameter_declaration") ?? receiver.namedChildren[0] ?? null;
+    const typeNode = parameter?.childForFieldName("type") ?? null;
+    if (!typeNode)
+        return null;
+    const named = unwrapNamedType(typeNode, sup);
+    return named ? sliceText(named, source) : null;
+}
+function goTypeSpecNamed(root, typeName, source, normalizeIdentifier) {
+    const normalized = normalizeIdentifier(typeName);
+    let found = null;
+    const visit = (node) => {
+        if (node.type === "type_spec") {
+            const name = node.childForFieldName("name");
+            if (name && normalizeIdentifier(sliceText(name, source)) === normalized) {
+                found = node;
+                return false;
+            }
+        }
+        for (const child of node.namedChildren) {
+            if (!visit(child))
+                return false;
+        }
+        return true;
+    };
+    visit(root);
+    return found;
+}
+function goEmbeddedTypeNames(typeName, targetContext, normalizeIdentifier) {
+    const spec = goTypeSpecNamed(targetContext.tree.rootNode, typeName, targetContext.source, normalizeIdentifier);
+    if (!spec)
+        return [];
+    const typeNode = spec.childForFieldName("type");
+    if (!typeNode)
+        return [];
+    const names = [];
+    const visit = (node) => {
+        if (node.type === "field_declaration") {
+            if (node.childForFieldName("name"))
+                return;
+            const fieldType = node.childForFieldName("type");
+            const named = fieldType ? unwrapNamedType(fieldType, targetContext.sup) : null;
+            if (named)
+                names.push(sliceText(named, targetContext.source));
+            return;
+        }
+        for (const child of node.namedChildren)
+            visit(child);
+    };
+    visit(typeNode);
+    return names;
+}
+function goMethodsNamedOnType(locals, member, typeName, targetContext, normalizeIdentifier) {
+    const matches = [];
+    const visit = (node) => {
+        if (node.type === "method_declaration") {
+            const receiverType = goMethodReceiverTypeName(node, targetContext.source, targetContext.sup);
+            if (receiverType && normalizeIdentifier(receiverType) === normalizeIdentifier(typeName)) {
+                const local = findLocalWithinNode(locals, member, node, normalizeIdentifier);
+                if (local && !matches.includes(local))
+                    matches.push(local);
+            }
+            return;
+        }
+        for (const child of node.namedChildren)
+            visit(child);
+    };
+    visit(targetContext.tree.rootNode);
+    return matches;
+}
+function findGoReceiverMember(locals, member, typeName, targetContext, normalizeIdentifier) {
+    const visited = new Set();
+    let level = [typeName];
+    for (let depth = 0; depth < GO_EMBED_DEPTH && level.length; depth += 1) {
+        const matches = [];
+        const next = [];
+        for (const currentType of level) {
+            if (visited.has(currentType))
+                continue;
+            visited.add(currentType);
+            for (const method of goMethodsNamedOnType(locals, member, currentType, targetContext, normalizeIdentifier)) {
+                if (!matches.includes(method))
+                    matches.push(method);
+            }
+            for (const embedded of goEmbeddedTypeNames(currentType, targetContext, normalizeIdentifier)) {
+                if (!visited.has(embedded) && !next.includes(embedded))
+                    next.push(embedded);
+            }
+        }
+        if (matches.length === 1)
+            return matches[0];
+        if (matches.length > 1)
+            return undefined;
+        level = next;
+    }
+    return undefined;
+}
+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, "\\$&");
 }