@lzehrung/codegraph 2.3.31 → 2.4.0

package/dist/indexer/navigation-local.js

@@ -1,19 +1,108 @@
+import { getCallArgumentCount } from "../languages/callable-arity.js";
 import { fileIdentityKey, normalizePath } from "../util/paths.js";
 import { okGoToResult } from "./navigation-provenance.js";
+import { cppBindingCallableShape, cppSelectCallableBinding } from "./cpp-callables.js";
+import { typescriptCallableCandidatesInContainer, typescriptSelectOverloadCandidate } from "./ts-callables.js";
+import { cScopeName, cTagRole } from "../languages/definitions/c.js";
+import { bindingCoversUse, fileScopeDefinitionCoversUse, isExplicitMethodCall, laterLocalBlocksOuterUse, scopeAllowsUse, scopeIdentifierKey, scopeNodesFor, closestContainingScope, } from "./scope-nodes.js";
 import { buildScopeIndexFromSource } from "./scope.js";
-import { resolveExport, resolveImported } from "./navigation-resolve.js";
-import { SymbolKind } from "./types.js";
+import { cjsRequireValueBinding, resolveExport, resolveImported } from "./navigation-resolve.js";
+import { phpNamedImportRole } from "./import-types.js";
+import { resolvePhpExplicitImport } from "./php-namespace-symbols.js";
+import { AMBIGUOUS_STAR_IMPORT_REASON } from "./ambiguous-resolution.js";
+import { decideStarImportCandidates, effectiveExplicitOrLocalBinding, isExpandedStarBinding, resolveStarImportedDefinition, starImportPrecedence, } from "./star-import-precedence.js";
+import { SymbolKind, } from "./types.js";
+/** Follow a C# name token through generic arguments and qualified-name segments. */
+export function csharpQualifiedNameNode(node) {
+    let qualified = node;
+    while (qualified.parent) {
+        const parent = qualified.parent;
+        if (parent.type === "generic_name") {
+            const name = parent.childForFieldName("name") ?? parent.namedChildren[0];
+            if (name && name.startIndex === qualified.startIndex && name.endIndex === qualified.endIndex) {
+                qualified = parent;
+                continue;
+            }
+        }
+        if ((parent.type === "qualified_name" || parent.type === "alias_qualified_name") &&
+            parent.endIndex === qualified.endIndex) {
+            qualified = parent;
+            continue;
+        }
+        break;
+    }
+    return qualified.type === "qualified_name" || qualified.type === "alias_qualified_name" ? qualified : null;
+}
+/** Preserve the full C# namespace or alias path, excluding generic type arguments. */
+export function csharpLookupName(node, source, fallback) {
+    const qualified = csharpQualifiedNameNode(node);
+    if (!qualified)
+        return fallback;
+    const text = source.slice(qualified.startIndex, qualified.endIndex);
+    if (!text.includes("<"))
+        return text.replace(/\s+/gu, "");
+    const argumentsNodes = [];
+    const collect = (current) => {
+        if (current.type === "generic_name") {
+            const argumentsNode = (current.namedChildren ?? []).find((child) => child.type === "type_argument_list");
+            if (argumentsNode)
+                argumentsNodes.push(argumentsNode);
+            return;
+        }
+        for (const child of current.namedChildren ?? []) {
+            if (child.type === "generic_name" || child.type === "qualified_name" || child.type === "alias_qualified_name") {
+                collect(child);
+            }
+        }
+    };
+    collect(qualified);
+    let result = "";
+    let from = qualified.startIndex;
+    for (const argumentsNode of argumentsNodes) {
+        result += source.slice(from, argumentsNode.startIndex);
+        from = argumentsNode.endIndex;
+    }
+    return (result + source.slice(from, qualified.endIndex)).replace(/\s+/gu, "");
+}
+const FALLBACK_DECLARATION_TYPES = new Set([
+    "function_declaration",
+    "class_declaration",
+    "variable_declarator",
+    "interface_declaration",
+    "type_alias_declaration",
+    "function_definition",
+    "class_definition",
+    "assignment",
+]);
+const FALLBACK_CLASS_TYPES = new Set(["class_declaration", "class_definition"]);
+/** Ordinary JavaScript functions rebind `this`; arrow functions and class methods do not. */
+const DYNAMIC_THIS_FUNCTION_TYPES = new Set([
+    "function_declaration",
+    "function_expression",
+    "function",
+    "generator_function",
+    "generator_function_declaration",
+]);
+/**
+ * The declared name for a position on a declaration's own header (its keywords, name, or the
+ * space between them), and the enclosing class name for a JavaScript/TypeScript `this` whose
+ * value is lexically that class (not inside an ordinary nested function).
+ *
+ * A position inside the body or initializer is a use, not the declaration: `trim` in
+ * `const handle = value?.trim()` must never resolve to `handle`.
+ */
 export function findDeclarationNameNode(sup, currentNode) {
+    if (!currentNode)
+        return null;
+    const isThis = currentNode.type === "this";
     let current = currentNode;
     while (current) {
-        if (current.type === "function_declaration" ||
-            current.type === "class_declaration" ||
-            current.type === "variable_declarator" ||
-            current.type === "interface_declaration" ||
-            current.type === "type_alias_declaration" ||
-            current.type === "function_definition" ||
-            current.type === "class_definition" ||
-            current.type === "assignment") {
+        if (isThis && current !== currentNode && DYNAMIC_THIS_FUNCTION_TYPES.has(current.type))
+            return null;
+        // An object-literal method binds `this` to that object, not to the enclosing class.
+        if (isThis && current.type === "method_definition" && current.parent?.type !== "class_body")
+            return null;
+        if (FALLBACK_DECLARATION_TYPES.has(current.type)) {
             let named = current.childForFieldName("name");
             if (!named && current.type === "assignment") {
                 const left = current.child(0);
@@ -21,7 +110,13 @@ export function findDeclarationNameNode(sup, currentNode) {
                     named = left;
                 }
             }
-            if (named && sup.nodeTypes.identifier.includes(named.type)) {
+            const tail = current.childForFieldName("body") ??
+                current.childForFieldName("value") ??
+                (current.type === "assignment" ? current.childForFieldName("right") : null);
+            const headerEnd = tail ? tail.startIndex : current.endIndex;
+            const onHeader = currentNode === current || currentNode.endIndex <= headerEnd;
+            const ownClass = isThis && FALLBACK_CLASS_TYPES.has(current.type);
+            if (named && sup.nodeTypes.identifier.includes(named.type) && (onHeader || ownClass)) {
                 return named;
             }
         }
@@ -38,37 +133,171 @@ export function getOrBuildScopeIndex(index, file, source, sup, mod, tree) {
     index.scopeCache.set(fileKey, scopeIndex);
     return scopeIndex;
 }
+/** Python function bodies resolve module names when called, after module initialization. */
+function pythonModuleLookupUsesRuntimeBindings(scope, node) {
+    for (let current = scope; current; current = current.parent) {
+        if (current.kind !== "function")
+            continue;
+        const body = current.node.childForFieldName("body");
+        if (!body)
+            return false;
+        return node.startIndex >= body.startIndex && node.endIndex <= body.endIndex;
+    }
+    return false;
+}
+function effectivePythonModuleScopeBinding(binding, useStartIndex, moduleLookupAtRuntime) {
+    let importBinding;
+    let importSource;
+    let localBinding;
+    let latestLocalStart = -1;
+    for (let candidate = binding; candidate; candidate = candidate.earlierSameScope) {
+        const localStart = candidate.def?.start.index;
+        if (localStart !== undefined &&
+            (moduleLookupAtRuntime || localStart <= useStartIndex) &&
+            localStart > latestLocalStart) {
+            localBinding = candidate;
+            latestLocalStart = localStart;
+        }
+        if (!importBinding && candidate.import) {
+            importBinding = candidate.import;
+            importSource = candidate;
+        }
+    }
+    const imports = importBinding ? [importBinding] : [];
+    const effective = effectiveExplicitOrLocalBinding(imports, "python", () => true, localBinding?.def?.start.index, useStartIndex, moduleLookupAtRuntime);
+    if (effective?.kind === "local")
+        return localBinding ?? null;
+    if (effective?.kind === "explicit")
+        return importSource ?? null;
+    return null;
+}
 export function findClosestScopeBinding(scopeIndex, bindingName, currentNode, support) {
-    const normalizedName = support.normalizeIdentifier(bindingName);
-    let currentScope = scopeIndex.allScopes.find((scope) => {
-        const start = scope.node.startIndex;
-        const end = scope.node.endIndex;
-        return currentNode.startIndex >= start && currentNode.endIndex <= end;
-    });
-    if (currentScope) {
-        let best = currentScope;
-        for (const scope of scopeIndex.allScopes) {
-            if (currentNode.startIndex >= scope.node.startIndex &&
-                currentNode.endIndex <= scope.node.endIndex &&
-                scope.node.startIndex >= best.node.startIndex &&
-                scope.node.endIndex <= best.node.endIndex) {
-                best = scope;
-            }
+    if (support.id === "csharp" && bindingName.includes(".")) {
+        const names = bindingName.split(".");
+        const first = names.shift();
+        let owner = findClosestScopeBinding(scopeIndex, first, currentNode, support);
+        for (const name of names) {
+            if (owner?.kind !== "class")
+                return null;
+            const body = owner.node?.parent?.childForFieldName("body");
+            if (!body)
+                return null;
+            const bodyScope = scopeIndex.allScopes.find((scope) => scope.node.id === body.id);
+            owner = bodyScope?.map.get(support.normalizeIdentifier(name)) ?? null;
         }
-        currentScope = best;
+        return owner;
     }
+    const row = scopeNodesFor(support.id);
+    const canonicalName = scopeIdentifierKey(row, bindingName, currentNode, support.normalizeIdentifier);
+    const normalizedName = support.id === "c" && cTagRole(currentNode) ? cScopeName(canonicalName, "tag") : canonicalName;
+    let currentScope = closestContainingScope(scopeIndex, currentNode);
+    const methodCall = isExplicitMethodCall(row, currentNode);
+    const pythonModuleLookupAtRuntime = !!row.moduleBindingsAtFunctionRuntime && pythonModuleLookupUsesRuntimeBindings(currentScope, currentNode);
     while (currentScope) {
-        const binding = currentScope.map.get(normalizedName);
+        if (!scopeAllowsUse(row, currentScope, currentNode)) {
+            currentScope = currentScope.parent;
+            continue;
+        }
+        let binding = currentScope.map.get(normalizedName);
+        if (!pythonModuleLookupAtRuntime || currentScope.kind !== "module" || methodCall) {
+            while (binding &&
+                ((methodCall && binding.kind === "local") ||
+                    ((!pythonModuleLookupAtRuntime || currentScope.kind !== "module") &&
+                        !bindingCoversUse(row, currentScope.kind, binding, currentNode.startIndex)))) {
+                binding = binding.earlierSameScope;
+            }
+        }
+        if (support.id === "python" && currentScope.kind === "module" && binding) {
+            const effectiveBinding = effectivePythonModuleScopeBinding(binding, currentNode.startIndex, pythonModuleLookupAtRuntime);
+            if (effectiveBinding)
+                return effectiveBinding;
+            currentScope = currentScope.parent;
+            continue;
+        }
         if (binding)
             return binding;
+        if (laterLocalBlocksOuterUse(row, currentScope, normalizedName, currentNode.startIndex))
+            return null;
         currentScope = currentScope.parent;
     }
     return null;
 }
-export function findClosestBinding(scopeIndex, file, bindingName, currentNode, support) {
+/** A later C# local makes an earlier use invalid rather than binding to an outer member. */
+export function laterLocalShadowsUse(scopeIndex, bindingName, currentNode, support) {
+    const row = scopeNodesFor(support.id);
+    if (!row.laterLocalBlocksOuterKinds)
+        return false;
+    const canonicalName = scopeIdentifierKey(row, bindingName, currentNode, support.normalizeIdentifier);
+    let scope = closestContainingScope(scopeIndex, currentNode);
+    while (scope) {
+        if (!scopeAllowsUse(row, scope, currentNode)) {
+            scope = scope.parent;
+            continue;
+        }
+        if (laterLocalBlocksOuterUse(row, scope, canonicalName, currentNode.startIndex))
+            return true;
+        let binding = scope.map.get(canonicalName);
+        while (binding && !bindingCoversUse(row, scope.kind, binding, currentNode.startIndex)) {
+            binding = binding.earlierSameScope;
+        }
+        if (binding)
+            return false;
+        scope = scope.parent;
+    }
+    return false;
+}
+function selectTypeScriptOverloadBinding(binding, file, currentNode, source, tree, languageId) {
+    const call = currentNode.parent;
+    if (!call || call.type !== "call_expression")
+        return binding;
+    const start = binding.def.start.index ?? 0;
+    const end = binding.def.end.index ?? start;
+    const candidates = typescriptCallableCandidatesInContainer(binding.sameScopeFunctionBindings ?? [binding], tree, (candidate) => candidate.def, start, end);
+    const selected = typescriptSelectOverloadCandidate({
+        group: candidates,
+        tree,
+        definitionOf: (candidate) => ({
+            file,
+            localName: candidate.name,
+            kind: SymbolKind.Function,
+            range: candidate.def,
+        }),
+        declarationOf: (candidate) => candidate.node?.parent,
+        source,
+        languageId,
+        argumentCount: getCallArgumentCount({ languageId, source, call }),
+    });
+    return selected ?? null;
+}
+export function findClosestBinding(scopeIndex, file, bindingName, currentNode, support, source, tree) {
     const binding = findClosestScopeBinding(scopeIndex, bindingName, currentNode, support);
-    if (!binding?.def)
+    return binding ? definitionForBinding(binding, file, currentNode, support, source, tree) : null;
+}
+/** The definition a scope binding names at a use, choosing C++ and TypeScript overloads by arity. */
+export function definitionForBinding(closest, file, currentNode, support, source, tree) {
+    let binding = closest;
+    if (!binding.def)
         return null;
+    if (support.id === "cpp" && binding.kind === "function" && source) {
+        const collisions = binding.sameScopeFunctionBindings ?? [binding];
+        if (collisions.length > 1 || cppBindingCallableShape(binding)) {
+            const selected = cppSelectCallableBinding(collisions, currentNode, source, file, file);
+            if (!selected?.def)
+                return null;
+            return {
+                file,
+                localName: selected.name,
+                kind: SymbolKind.Function,
+                range: selected.def,
+            };
+        }
+    }
+    if ((support.id === "ts" || support.id === "tsx") && binding.kind === "function" && source && tree) {
+        const selected = selectTypeScriptOverloadBinding(binding, file, currentNode, source, tree, support.id);
+        if (!selected?.def)
+            return null;
+        binding = selected;
+    }
     let kind = SymbolKind.Variable;
     if (binding.kind === "function") {
         kind = SymbolKind.Function;
@@ -79,11 +308,16 @@ export function findClosestBinding(scopeIndex, file, bindingName, currentNode, s
     else if (binding.kind === "type") {
         kind = SymbolKind.TypeAlias;
     }
+    const range = binding.def;
+    if (!range)
+        return null;
+    const tagRole = support.id === "c" && binding.node ? cTagRole(binding.node) : undefined;
     return {
         file,
         localName: binding.name,
         kind,
-        range: binding.def,
+        range,
+        ...(tagRole ? { cTag: tagRole } : {}),
     };
 }
 export function toModuleRef(resolved) {
@@ -91,25 +325,95 @@ export function toModuleRef(resolved) {
         return undefined;
     return typeof resolved === "string" ? resolved : resolved.external;
 }
-export function resolveNamedDefinition(index, mod, file, support, name) {
+function importBindingCoversIndex(imp, index) {
+    const ranges = [];
+    if ((imp.kind === "named" || imp.kind === "default" || imp.kind === "namespace") && imp.localRange) {
+        ranges.push(imp.localRange);
+    }
+    if (imp.kind === "named" && imp.importedRange)
+        ranges.push(imp.importedRange);
+    return ranges.some((range) => {
+        const start = range.start.index;
+        const end = range.end.index;
+        return start !== undefined && end !== undefined && index >= start && index < end;
+    });
+}
+function starImportGoTo(index, imp, def, name) {
+    return okGoToResult(index, def, {
+        via: {
+            ...(toModuleRef(imp.resolved) ? { importedFrom: toModuleRef(imp.resolved) } : {}),
+            exportedName: name,
+        },
+        resolution: "import-star",
+        confidence: "medium",
+    });
+}
+export function resolveNamedDefinition(index, mod, file, support, name, cNamespace, referenceIndex) {
     const normalizedName = support.normalizeIdentifier(name);
     const requiresExplicitReceiver = !support.membersAreImplicitlyInScope;
-    const directExport = requiresExplicitReceiver
+    const directExport = requiresExplicitReceiver && support.id !== "c"
         ? mod.exports.find((entry) => entry.type === "local" &&
             support.normalizeIdentifier(entry.exportedAs) === normalizedName &&
             !entry.target.isMember)
         : undefined;
-    const hit = directExport && directExport.type === "local"
-        ? { kind: "resolved", def: directExport.target }
-        : resolveExport(index, file, name, { allowLocalFallback: support.membersAreImplicitlyInScope });
-    if (hit?.kind === "resolved" && (!requiresExplicitReceiver || !hit.def.isMember)) {
-        return okGoToResult(index, hit.def, {
-            via: { exportedName: name },
-            resolution: "exact",
-            confidence: "high",
+    const suppressCppUnqualifiedLocalExport = support.id === "cpp" && !name.includes("::");
+    let hit = null;
+    const precedence = starImportPrecedence(support.id);
+    const matchesExplicitBinding = (imp) => {
+        if (isExpandedStarBinding(imp, mod.imports))
+            return false;
+        if (imp.kind === "default")
+            return support.normalizeIdentifier(imp.local) === normalizedName;
+        if (imp.kind === "named")
+            return !imp.cNamespace && support.normalizeIdentifier(imp.local) === normalizedName;
+        return imp.kind === "namespace" && support.normalizeIdentifier(imp.localNS) === normalizedName;
+    };
+    // Explicit-beats-star languages: an explicit import, then the compilation unit (Java and
+    // Kotlin same-package peers), then a wildcard. resolveExport's compilation-unit hit must wait
+    // until explicit imports have had a chance to win and must still beat star imports. In Rust a
+    // `use` and a same-named local item are a compile error, so the order changes nothing there.
+    const deferCompilationUnitPeers = precedence === "explicit-beats-star";
+    if (!suppressCppUnqualifiedLocalExport) {
+        if (directExport && directExport.type === "local") {
+            hit = { kind: "resolved", def: directExport.target };
+        }
+        else if (!deferCompilationUnitPeers) {
+            hit = resolveExport(index, file, name, {
+                allowLocalFallback: support.membersAreImplicitlyInScope,
+                ...(cNamespace ? { cNamespace } : {}),
+                ...(support.id === "csharp" && referenceIndex !== undefined ? { referenceIndex } : {}),
+            });
+        }
+    }
+    const row = scopeNodesFor(support.id);
+    const moduleLookupAtRuntime = !!row.moduleBindingsAtFunctionRuntime &&
+        hit?.kind === "resolved" &&
+        referenceIndex !== undefined &&
+        fileIdentityKey(file) === fileIdentityKey(hit.def.file) &&
+        !!index.scopeCache.get(fileIdentityKey(file))?.allScopes.some((scope) => {
+            if (scope.kind !== "function")
+                return false;
+            const body = scope.node.childForFieldName("body");
+            return !!body && referenceIndex >= body.startIndex && referenceIndex < body.endIndex;
         });
+    const effectiveBinding = effectiveExplicitOrLocalBinding(mod.imports, support.id, matchesExplicitBinding, hit?.kind === "resolved" ? hit.def.range.start.index : undefined, referenceIndex, moduleLookupAtRuntime);
+    const effectiveExplicitImport = effectiveBinding?.kind === "explicit" ? effectiveBinding.binding : undefined;
+    if (hit?.kind === "resolved" && (!requiresExplicitReceiver || !hit.def.isMember)) {
+        const sameFileFallback = referenceIndex !== undefined && fileIdentityKey(file) === fileIdentityKey(hit.def.file);
+        if (sameFileFallback &&
+            !fileScopeDefinitionCoversUse(support.id, hit.def.range, referenceIndex, hit.def.kind, moduleLookupAtRuntime)) {
+            return null;
+        }
+        if (support.id !== "python" || effectiveBinding?.kind === "local") {
+            const importedFrom = support.id === "c" && fileIdentityKey(file) !== fileIdentityKey(hit.def.file) ? hit.def.file : undefined;
+            return okGoToResult(index, hit.def, {
+                via: { exportedName: name, ...(importedFrom ? { importedFrom } : {}) },
+                resolution: importedFrom ? "import" : "exact",
+                confidence: "high",
+            });
+        }
     }
-    if (hit?.kind === "namespace") {
+    if (hit?.kind === "namespace" && effectiveBinding?.kind !== "explicit") {
         const targetMod = index.byFile.get(fileIdentityKey(hit.file));
         const firstExport = targetMod?.exports.find((entry) => entry.type === "local");
         if (firstExport) {
@@ -120,11 +424,32 @@ export function resolveNamedDefinition(index, mod, file, support, name) {
             });
         }
     }
+    const starCandidates = [];
+    let lastWinsResult = null;
+    const acceptBinding = (result, imp) => {
+        // A click on the binding's own token names that import, not a later rebinding.
+        if (precedence === "last-wins" && referenceIndex !== undefined && importBindingCoversIndex(imp, referenceIndex)) {
+            return result;
+        }
+        if (precedence === "last-wins") {
+            lastWinsResult = result;
+            return null;
+        }
+        return result;
+    };
     for (const imp of mod.imports) {
+        // Star expansion republishes the same names. Judging those copies as explicit
+        // imports would hide a second star import behind the first expanded binding.
+        if (isExpandedStarBinding(imp, mod.imports))
+            continue;
+        const matchesExplicit = matchesExplicitBinding(imp);
+        if (matchesExplicit && effectiveExplicitImport !== imp)
+            continue;
+        let matched = null;
         if (imp.kind === "default" && support.normalizeIdentifier(imp.local) === normalizedName) {
             const result = resolveImported(index, imp, "default");
             if (result && !("namespace" in result)) {
-                return okGoToResult(index, result, {
+                matched = okGoToResult(index, result, {
                     via: {
                         ...(toModuleRef(imp.resolved) ? { importedFrom: toModuleRef(imp.resolved) } : {}),
                         exportedName: "default",
@@ -135,9 +460,26 @@ export function resolveNamedDefinition(index, mod, file, support, name) {
             }
         }
         else if (imp.kind === "named" && support.normalizeIdentifier(imp.local) === normalizedName) {
-            const result = resolveImported(index, imp, imp.imported);
+            const phpRole = phpNamedImportRole(imp);
+            let result;
+            if (phpRole) {
+                // This role-blind fallback cannot choose between PHP class, function, and constant aliases.
+                const hasPhpRoleCollision = mod.imports.some((candidate) => candidate !== imp &&
+                    candidate.kind === "named" &&
+                    phpNamedImportRole(candidate) !== undefined &&
+                    support.normalizeIdentifier(candidate.local) === normalizedName);
+                if (hasPhpRoleCollision) {
+                    result = null;
+                }
+                else {
+                    result = resolvePhpExplicitImport(index, imp, phpRole);
+                }
+            }
+            else {
+                result = resolveImported(index, imp, imp.imported, cNamespace ? { cNamespace } : undefined);
+            }
             if (result && !("namespace" in result)) {
-                return okGoToResult(index, result, {
+                matched = okGoToResult(index, result, {
                     via: {
                         ...(toModuleRef(imp.resolved) ? { importedFrom: toModuleRef(imp.resolved) } : {}),
                         exportedName: imp.imported,
@@ -148,32 +490,127 @@ export function resolveNamedDefinition(index, mod, file, support, name) {
             }
         }
         else if (imp.kind === "star") {
-            const result = resolveImported(index, imp, name);
+            const def = resolveStarImportedDefinition(index, imp, name, support.id, cNamespace);
+            if (def) {
+                const starResult = starImportGoTo(index, imp, def, name);
+                if (precedence === "last-wins") {
+                    const taken = acceptBinding(starResult, imp);
+                    if (taken)
+                        return taken;
+                }
+                else {
+                    starCandidates.push({ imp, def });
+                }
+            }
+        }
+        else if (imp.kind === "namespace" && support.normalizeIdentifier(imp.localNS) === normalizedName) {
+            const targetFile = typeof imp.resolved === "string" ? normalizePath(imp.resolved) : undefined;
+            if (imp.mechanism === "cjs" && targetFile) {
+                const classValue = cjsRequireValueBinding(index, targetFile);
+                if (classValue) {
+                    matched = okGoToResult(index, classValue, {
+                        via: {
+                            ...(toModuleRef(imp.resolved) ? { importedFrom: toModuleRef(imp.resolved) } : {}),
+                            exportedName: classValue.localName,
+                        },
+                        resolution: "import",
+                        confidence: "high",
+                    });
+                }
+            }
+            if (!matched) {
+                const targetMod = targetFile ? index.byFile.get(fileIdentityKey(targetFile)) : undefined;
+                const firstExport = targetMod?.exports.find((entry) => entry.type === "local");
+                if (firstExport) {
+                    matched = okGoToResult(index, firstExport.target, {
+                        via: {
+                            ...(toModuleRef(imp.resolved) ? { importedFrom: toModuleRef(imp.resolved) } : {}),
+                            exportedName: firstExport.exportedAs,
+                        },
+                        resolution: "namespace",
+                        confidence: "medium",
+                    });
+                }
+            }
+        }
+        if (!matched) {
+            if (matchesExplicit && effectiveExplicitImport === imp) {
+                if (precedence !== "last-wins")
+                    return null;
+                lastWinsResult = null;
+            }
+            continue;
+        }
+        const taken = acceptBinding(matched, imp);
+        if (taken)
+            return taken;
+    }
+    // A local binding name always wins above so a grouped import's own aliases never collide with
+    // each other. An aliased import's source spelling is not itself a bound name anywhere in the
+    // file (Python: `from a import helper as h` binds only `h`; a bare `helper()` elsewhere is
+    // unbound and must stay not_found), so only resolve it when the click falls inside that exact
+    // import statement's own source-name token, never by re-matching the spelling anywhere else.
+    if (referenceIndex !== undefined) {
+        for (const imp of mod.imports) {
+            if (imp.kind !== "named" ||
+                imp.local === imp.imported ||
+                support.normalizeIdentifier(imp.imported) !== normalizedName ||
+                !imp.importedRange ||
+                imp.importedRange.start.index === undefined ||
+                imp.importedRange.end.index === undefined ||
+                referenceIndex < imp.importedRange.start.index ||
+                referenceIndex >= imp.importedRange.end.index) {
+                continue;
+            }
+            const result = resolveImported(index, imp, imp.imported, cNamespace ? { cNamespace } : undefined);
             if (result && !("namespace" in result)) {
                 return okGoToResult(index, result, {
                     via: {
                         ...(toModuleRef(imp.resolved) ? { importedFrom: toModuleRef(imp.resolved) } : {}),
-                        exportedName: name,
+                        exportedName: imp.imported,
                     },
-                    resolution: "import-star",
-                    confidence: "medium",
+                    resolution: "import",
+                    confidence: "high",
                 });
             }
         }
-        else if (imp.kind === "namespace" && support.normalizeIdentifier(imp.localNS) === normalizedName) {
-            const targetFile = typeof imp.resolved === "string" ? normalizePath(imp.resolved) : undefined;
-            const targetMod = targetFile ? index.byFile.get(fileIdentityKey(targetFile)) : undefined;
-            const firstExport = targetMod?.exports.find((entry) => entry.type === "local");
-            if (firstExport) {
-                return okGoToResult(index, firstExport.target, {
-                    via: {
-                        ...(toModuleRef(imp.resolved) ? { importedFrom: toModuleRef(imp.resolved) } : {}),
-                        exportedName: firstExport.exportedAs,
-                    },
-                    resolution: "namespace",
-                    confidence: "medium",
+    }
+    if (precedence === "last-wins") {
+        if (lastWinsResult)
+            return lastWinsResult;
+    }
+    else {
+        if (deferCompilationUnitPeers) {
+            const unitHit = resolveExport(index, file, name, {
+                allowLocalFallback: support.membersAreImplicitlyInScope,
+            });
+            if (unitHit?.kind === "resolved" && (!requiresExplicitReceiver || !unitHit.def.isMember)) {
+                return okGoToResult(index, unitHit.def, {
+                    via: { exportedName: name },
+                    resolution: "exact",
+                    confidence: "high",
                 });
             }
+            if (unitHit?.kind === "namespace") {
+                const targetMod = index.byFile.get(fileIdentityKey(unitHit.file));
+                const firstExport = targetMod?.exports.find((entry) => entry.type === "local");
+                if (firstExport) {
+                    return okGoToResult(index, firstExport.target, {
+                        via: { exportedName: name },
+                        resolution: "namespace",
+                        confidence: "medium",
+                    });
+                }
+            }
+        }
+        if (!starCandidates.length)
+            return null;
+        const decision = decideStarImportCandidates(index, support.id, starCandidates, file);
+        if (decision.status === "ambiguous") {
+            return { status: "not_found", reason: AMBIGUOUS_STAR_IMPORT_REASON };
+        }
+        if (decision.status === "resolved") {
+            return starImportGoTo(index, decision.imp, decision.definition, name);
         }
     }
     return null;