@lzehrung/codegraph 2.3.31 → 3.0.0

package/dist/indexer/navigation-resolve.js

@@ -1,29 +1,19 @@
-import fs from "node:fs";
 import path from "node:path";
 import { supportForFileWithoutHeaderSample } from "../languages.js";
-import { languageHasDeclarationVisibility } from "./declaration-visibility.js";
-import { GO_IDENTIFIER_SOURCE, JAVA_IDENTIFIER_SOURCE, KOTLIN_IDENTIFIER_SOURCE } from "../util/identifiers.js";
+import { isJvmPackageSymbolVisible, languageHasDeclarationVisibility } from "./declaration-visibility.js";
+import { isJvmStaticWildcardMember, isJvmTypeWildcardMember, jvmWildcardTypeOwner } from "./expand-star-imports.js";
+import { foldPhpIdentifierCase, normalizeCsharpIdentifier, normalizeCsharpQualifiedName } from "../util/identifiers.js";
 import { fileIdentityKey, normalizePath } from "../util/paths.js";
+import { getCompilationUnitPeers, IMPLICIT_UNIT_LANGUAGES, isUnitBareNameVisible } from "./compilation-units.js";
+import { phpNamedImportRole } from "./import-types.js";
+import { resolvePythonSubmoduleExact } from "../util/resolution/python.js";
+import { PHP_CLASS_LIKE_KINDS } from "./php-namespace-symbols.js";
+import { coalesceEquivalentCsharpPartialExports } from "./shared-owner-identity.js";
 import { SymbolKind, } from "./types.js";
-const GO_PACKAGE_PATTERN = new RegExp(String.raw `^\s*package\s+(${GO_IDENTIFIER_SOURCE})`, "mu");
-const JAVA_PACKAGE_NAME_PATTERN = new RegExp(String.raw `^\s*package\s+(${JAVA_IDENTIFIER_SOURCE}(?:\.${JAVA_IDENTIFIER_SOURCE})*)\s*;`, "mu");
-const KOTLIN_PACKAGE_NAME_PATTERN = new RegExp(String.raw `^\s*package\s+(${KOTLIN_IDENTIFIER_SOURCE}(?:\.${KOTLIN_IDENTIFIER_SOURCE})*)`, "mu");
-/**
- * Files that can carry the package declaration each lookup language searches for. Java and Kotlin
- * stay one group because they share a JVM package namespace and each pattern already accepts the
- * other's declaration; every other language is skipped instead of read for a keyword it never uses.
- */
-const PACKAGE_DECLARING_LANGUAGE_IDS = {
-    go: new Set(["go"]),
-    java: new Set(["java", "kotlin"]),
-    kotlin: new Set(["java", "kotlin"]),
-};
 function cacheKey(file, canonicalName) {
     return `${fileIdentityKey(file)}::canonical::${canonicalName}`;
 }
 const moduleNameLookups = new WeakMap();
-const packageDirectoryLookups = new WeakMap();
-const packageNameCaches = new WeakMap();
 function moduleFor(index, file) {
     return index.byFile.get(fileIdentityKey(file));
 }
@@ -123,175 +113,191 @@ function sameResolvedExport(index, left, right) {
     }
     return false;
 }
-function packageNameCacheFor(index) {
-    let caches = packageNameCaches.get(index);
-    if (!caches) {
-        caches = { go: new Map(), jvm: new Map() };
-        packageNameCaches.set(index, caches);
-    }
-    return caches;
-}
 /**
- * Source to read a package declaration from: the text the index already parsed when it retained
- * one, and otherwise the file itself. Reusing the retained text keeps the package name consistent
- * with the symbols resolved from that same snapshot.
+ * Unique same-compilation-unit match for a bare name. Go, the JVM languages, C#, and Swift can
+ * name top-level declarations of their package, namespace, or module without an import;
+ * candidates come from the same proven unit relation used for reference-candidate discovery
+ * (`getCompilationUnitPeers`), never from a project-wide name scan. A name matching more than
+ * one unit declaration is ambiguous and stays unresolved, except proven-equivalent C# `partial`
+ * type parts, which collapse to one representative before uniqueness is judged. Members are
+ * excluded because they resolve through receiver/owner identity rather than as bare unit names.
  */
-function packageDeclarationSource(index, filePath, fileKey) {
-    const retained = index.parsed?.get(fileKey)?.source;
-    if (retained !== undefined)
-        return retained;
-    try {
-        return fs.readFileSync(filePath, "utf8");
-    }
-    catch {
+function resolveImplicitUnitExport(index, file, exportedName, matchesOptions, namespace, useIndex, qualification) {
+    // Only the implicit compilation-unit languages have bare-name unit visibility. C and C++
+    // keep their include-scope tag precedence and PHP its case-folded namespaces; the unit
+    // lookup must not preempt those established fallbacks.
+    const languageId = supportForFileWithoutHeaderSample(file, index.languageExtensions)?.id;
+    if (!languageId || !IMPLICIT_UNIT_LANGUAGES[languageId])
         return null;
-    }
-}
-function readGoPackageName(index, filePath) {
-    const cache = packageNameCacheFor(index).go;
-    const key = fileIdentityKey(filePath);
-    const cached = cache.get(key);
-    if (cached !== undefined)
-        return cached;
-    const source = packageDeclarationSource(index, filePath, key);
-    if (source === null) {
-        cache.set(key, null);
-        return null;
-    }
-    const packageName = GO_PACKAGE_PATTERN.exec(source)?.[1] ?? null;
-    cache.set(key, packageName);
-    return packageName;
-}
-function resolveGoPackageExport(index, file, exportedName) {
-    if (supportForFileWithoutHeaderSample(file, index.languageExtensions)?.id !== "go")
-        return null;
-    const directory = packageDirectoryLookup(index, "go").get(fileIdentityKey(path.dirname(file)));
-    if (!directory)
-        return null;
-    const sourcePackage = readGoPackageName(index, file);
-    const candidates = sourcePackage ? (directory.byName.get(sourcePackage) ?? []) : directory.all;
     const matches = [];
-    for (const moduleEntry of candidates) {
-        const names = moduleNameLookup(index, moduleEntry.file);
+    const peers = getCompilationUnitPeers(index, file, languageId === "csharp" && qualification !== undefined ? { csharpQualifiedName: true } : undefined);
+    for (const peerFile of peers.files) {
+        const names = moduleNameLookup(index, peerFile);
         if (!names)
             continue;
         for (const target of names.localExports.get(names.normalizeIdentifier(exportedName)) ?? []) {
+            if (target.isMember || !matchesOptions(target, namespace))
+                continue;
+            if (!isUnitBareNameVisible({
+                index,
+                declarationFile: target.file,
+                declaration: target.range,
+                useFile: file,
+                ...(useIndex !== undefined ? { useIndex } : {}),
+                ...(qualification !== undefined ? { qualification } : {}),
+            })) {
+                continue;
+            }
             if (!matches.some((candidate) => sameSymbolDef(index, candidate, target))) {
                 matches.push(target);
             }
         }
     }
-    return matches.length === 1 ? (matches[0] ?? null) : null;
+    const unique = languageId === "csharp" ? coalesceEquivalentCsharpPartialExports(index, matches) : matches;
+    return unique.length === 1 ? (unique[0] ?? null) : null;
 }
-function readPackageNameForLanguage(index, filePath, languageId) {
-    const cache = packageNameCacheFor(index).jvm;
-    const fileKey = fileIdentityKey(filePath);
-    const key = `${languageId}::${fileKey}`;
-    const cached = cache.get(key);
-    if (cached !== undefined)
-        return cached;
-    const source = packageDeclarationSource(index, filePath, fileKey);
-    if (source === null) {
-        cache.set(key, null);
-        return null;
-    }
-    const pattern = languageId === "kotlin" ? KOTLIN_PACKAGE_NAME_PATTERN : JAVA_PACKAGE_NAME_PATTERN;
-    const packageName = pattern.exec(source)?.[1] ?? null;
-    cache.set(key, packageName);
-    return packageName;
-}
-function packageDirectoryLookup(index, languageId) {
-    let byLanguage = packageDirectoryLookups.get(index);
-    if (!byLanguage) {
-        byLanguage = new Map();
-        packageDirectoryLookups.set(index, byLanguage);
-    }
-    const cached = byLanguage.get(languageId);
-    if (cached)
-        return cached;
-    const directories = new Map();
-    for (const moduleEntry of index.byFile.values()) {
-        const directoryKey = fileIdentityKey(path.dirname(moduleEntry.file));
-        let directory = directories.get(directoryKey);
-        if (!directory) {
-            directory = { all: [], byName: new Map() };
-            directories.set(directoryKey, directory);
-        }
-        directory.all.push(moduleEntry);
-        const moduleLanguageId = supportForFileWithoutHeaderSample(moduleEntry.file, index.languageExtensions)?.id;
-        if (!moduleLanguageId || !PACKAGE_DECLARING_LANGUAGE_IDS[languageId].has(moduleLanguageId))
-            continue;
-        const packageName = languageId === "go"
-            ? readGoPackageName(index, moduleEntry.file)
-            : readPackageNameForLanguage(index, moduleEntry.file, languageId);
-        if (!packageName)
-            continue;
-        const entries = directory.byName.get(packageName) ?? [];
-        entries.push(moduleEntry);
-        directory.byName.set(packageName, entries);
-    }
-    byLanguage.set(languageId, directories);
-    return directories;
-}
-function resolveSiblingPackageExport(index, targetFile, exportedName, languageId) {
-    const packageName = readPackageNameForLanguage(index, targetFile, languageId);
-    if (!packageName)
-        return null;
-    const directory = packageDirectoryLookup(index, languageId).get(fileIdentityKey(path.dirname(targetFile)));
-    if (!directory)
+/**
+ * Same-package Java/Kotlin export that the bare-name unit scan does not answer (a member, for
+ * example). Peers come from `getCompilationUnitPeers`, so Java and Kotlin share one package
+ * rule. An incomplete set (an unreadable peer, or the same package outside this directory)
+ * is not a proven unique answer.
+ */
+function resolveSiblingPackageExport(index, targetFile, exportedName) {
+    const peers = getCompilationUnitPeers(index, targetFile);
+    if (!peers.complete)
         return null;
     const targetFileKey = fileIdentityKey(targetFile);
     const matches = [];
-    for (const moduleEntry of directory.byName.get(packageName) ?? []) {
-        if (fileIdentityKey(moduleEntry.file) === targetFileKey)
+    for (const peerFile of peers.files) {
+        if (fileIdentityKey(peerFile) === targetFileKey)
             continue;
-        const hit = resolveExport(index, moduleEntry.file, exportedName);
+        const hit = resolveExport(index, peerFile, exportedName);
         if (hit && !matches.some((candidate) => sameResolvedExport(index, candidate, hit))) {
             matches.push(hit);
         }
     }
     return matches.length === 1 ? (matches[0] ?? null) : null;
 }
-function resolvePythonSubmodule(targetFile, exportedName) {
-    let baseDir;
-    try {
-        const targetStat = fs.statSync(targetFile);
-        if (targetStat.isDirectory()) {
-            baseDir = targetFile;
-        }
-        else if (path.basename(targetFile) === "__init__.py" || path.basename(targetFile) === "__init__.pyi") {
-            baseDir = path.dirname(targetFile);
-        }
-        else {
-            return null;
-        }
-    }
-    catch {
+function declaresMemberKind(def) {
+    return def.kind === SymbolKind.Class || def.kind === SymbolKind.Interface || def.kind === SymbolKind.TypeAlias;
+}
+/**
+ * One function from an overload set, or null when the count is not accepted by exactly one.
+ * Only indexed `callable.arity` is consulted: a missing arity does not accept, and a count
+ * two overloads both accept stays unresolved.
+ */
+function selectFunctionOverloadByArity(candidates, argumentCount) {
+    if (candidates.length < 2 || candidates.some((candidate) => candidate.kind !== SymbolKind.Function))
         return null;
+    const accepting = candidates.filter((candidate) => {
+        const arity = candidate.callable?.arity;
+        return !!arity && argumentCount >= arity.minArgs && (arity.maxArgs === null || argumentCount <= arity.maxArgs);
+    });
+    return accepting.length === 1 ? (accepting[0] ?? null) : null;
+}
+/**
+ * `def` is one function of a Java or Kotlin overload set exported as `exportedName`.
+ * A call chooses among them by argument count; the import itself names the whole set, so
+ * reference search must still treat the import as able to reach each overload.
+ */
+export function javaKotlinFunctionOverloadIncludes(index, file, exportedName, def) {
+    if (def.kind !== SymbolKind.Function)
+        return false;
+    const languageId = supportForFileWithoutHeaderSample(file, index.languageExtensions)?.id;
+    if (languageId !== "java" && languageId !== "kotlin")
+        return false;
+    const moduleEntry = moduleFor(index, file);
+    if (!moduleEntry)
+        return false;
+    const names = moduleNameLookup(index, moduleEntry.file);
+    if (!names)
+        return false;
+    const exported = names.localExports.get(names.normalizeIdentifier(exportedName)) ?? [];
+    if (exported.length < 2 || exported.some((candidate) => candidate.kind !== SymbolKind.Function))
+        return false;
+    return exported.some((candidate) => sameSymbolDef(index, candidate, def));
+}
+/**
+ * A default-export wrapper keeps `SymbolKind.Default` so the export name stays `default`.
+ * Member lookup needs the class, interface, or type alias that wrapper was copied from.
+ */
+export function memberContainerForDefinition(index, def) {
+    if (declaresMemberKind(def))
+        return def;
+    if (def.kind !== SymbolKind.Default)
+        return undefined;
+    const moduleEntry = index.byFile.get(fileIdentityKey(def.file));
+    if (!moduleEntry)
+        return undefined;
+    const sameRange = moduleEntry.locals.filter((local) => declaresMemberKind(local) &&
+        local.range.start.line === def.range.start.line &&
+        local.range.start.column === def.range.start.column);
+    if (sameRange.length === 1)
+        return sameRange[0];
+}
+/** The export entry that proves a direct CommonJS or TypeScript module value, whatever its public name. */
+export function directModuleValueEntry(moduleEntry) {
+    return moduleEntry.exports.find((entry) => entry.type === "local" && (entry.mechanism === "cjs-module-value" || entry.mechanism === "ts-export-assignment"));
+}
+/**
+ * `require()` and `import x = require()` return a proven direct `module.exports = X` or
+ * TypeScript `export = X` value. A default export accompanied by named exports instead returns
+ * a namespace object, including non-local and star re-exports.
+ */
+export function cjsRequireValueBinding(index, targetFile) {
+    const moduleEntry = index.byFile.get(fileIdentityKey(targetFile));
+    const directValue = moduleEntry && directModuleValueEntry(moduleEntry);
+    if (directValue)
+        return memberContainerForDefinition(index, directValue.target) ?? directValue.target;
+    const resolved = resolveExport(index, targetFile, "default");
+    if (resolved?.kind !== "resolved")
+        return undefined;
+    const hasNamedExport = moduleEntry?.exports.some((entry) => {
+        if (entry.type === "exportStar")
+            return !entry.typeOnly;
+        if (entry.type === "local")
+            return entry.exportedAs !== "default" && !entry.target.isMember;
+        return entry.exportedAs !== "default" && !entry.typeOnly;
+    });
+    if (hasNamedExport)
+        return undefined;
+    return memberContainerForDefinition(index, resolved.def) ?? resolved.def;
+}
+const fileEdgeTargetsCache = new WeakMap();
+/** First resolved file target per importer and raw specifier; rebuilt when the edge list changes. */
+function fileEdgeTargetsFor(index) {
+    const edges = index.graph.edges;
+    const cached = fileEdgeTargetsCache.get(index);
+    if (cached && cached.edges === edges && cached.length === edges.length)
+        return cached.targets;
+    const targets = new Map();
+    for (const edge of edges) {
+        if (edge.to.type !== "file")
+            continue;
+        const key = `${fileIdentityKey(edge.from)}\0${edge.raw}`;
+        if (!targets.has(key))
+            targets.set(key, edge.to.path);
     }
-    const moduleFile = path.join(baseDir, `${exportedName}.py`);
-    const stubModuleFile = path.join(baseDir, `${exportedName}.pyi`);
-    const packageInit = path.join(baseDir, exportedName, "__init__.py");
-    const stubPackageInit = path.join(baseDir, exportedName, "__init__.pyi");
-    const namespacePackage = path.join(baseDir, exportedName);
-    for (const candidate of [moduleFile, stubModuleFile, packageInit, stubPackageInit, namespacePackage]) {
-        try {
-            const candidateStat = fs.statSync(candidate);
-            if (candidate === namespacePackage ? candidateStat.isDirectory() : candidateStat.isFile()) {
-                return normalizePath(candidate);
-            }
-        }
-        catch {
-            // The next candidate can still be a real submodule.
-        }
-    }
-    return null;
+    fileEdgeTargetsCache.set(index, { edges, length: edges.length, targets });
+    return targets;
+}
+/**
+ * A member of the module a `typeof import("spec")` receiver holds, resolved through the file
+ * dependency edge the index recorded for that specifier.
+ */
+export function resolveImportTypeMember(index, fromFile, specifier, member) {
+    const target = fileEdgeTargetsFor(index).get(`${fileIdentityKey(fromFile)}\0${specifier}`);
+    if (!target)
+        return null;
+    const hit = resolveExport(index, target, member);
+    return hit?.kind === "resolved" ? hit.def : null;
 }
 export function resolveExport(index, file, exportedName, opts) {
     const visited = new Set();
-    const matchesPreferredKind = (def) => !opts?.preferredKind || def.kind === opts.preferredKind;
+    const matchesOptions = (def, namespace) => (!opts?.preferredKind || def.kind === opts.preferredKind) &&
+        (namespace === undefined || (def.cTag ? "tag" : "ordinary") === namespace);
     const allowLocalFallback = opts?.allowLocalFallback ?? true;
-    function resolveFromFile(fileInner, name) {
+    function resolveFromFile(fileInner, name, namespace = opts?.cNamespace) {
         const moduleEntry = moduleFor(index, fileInner);
         if (!moduleEntry)
             return null;
@@ -299,29 +305,82 @@ export function resolveExport(index, file, exportedName, opts) {
         if (!names)
             return null;
         const normalizedFile = normalizePath(moduleEntry.file);
-        const canonicalName = names.normalizeIdentifier(name);
-        const key = opts?.preferredKind
-            ? `${cacheKey(normalizedFile, canonicalName)}::${opts.preferredKind}::${allowLocalFallback ? "local" : "export"}`
-            : `${cacheKey(normalizedFile, canonicalName)}::${allowLocalFallback ? "local" : "export"}`;
+        const referenceIndex = fileIdentityKey(fileInner) === fileIdentityKey(file) ? opts?.referenceIndex : undefined;
+        const languageId = supportForFileWithoutHeaderSample(normalizedFile, index.languageExtensions)?.id;
+        const csharpFile = languageId === "csharp";
+        // A dotted name is a namespace path even when the caller has no source position
+        // (`using PT = N.Inner.Point` resolves through the bound file, not a use site).
+        // A bare name still needs a source position before namespace visibility applies.
+        const filtersUseNamespace = csharpFile && (referenceIndex !== undefined || name.includes(".") || name.startsWith("global::"));
+        const separator = filtersUseNamespace ? name.lastIndexOf(".") : -1;
+        let qualification;
+        let unqualifiedName = name;
+        if (separator >= 0) {
+            // `@P.Target` and `P.Target` name the same namespace path.
+            qualification = normalizeCsharpQualifiedName(name.slice(0, separator));
+            unqualifiedName = name.slice(separator + 1);
+        }
+        else if (filtersUseNamespace && name.startsWith("global::")) {
+            qualification = "global::";
+            unqualifiedName = name.slice("global::".length);
+        }
+        const canonicalName = names.normalizeIdentifier(unqualifiedName);
+        const argumentCountKey = opts?.argumentCount === undefined ? "" : String(opts.argumentCount);
+        const key = `${cacheKey(normalizedFile, names.normalizeIdentifier(name))}::${opts?.preferredKind ?? ""}::${namespace ?? ""}::${allowLocalFallback ? "local" : "export"}::${referenceIndex ?? ""}::${argumentCountKey}`;
         if (index.exportCache.has(key))
             return index.exportCache.get(key);
-        const cycleKey = cacheKey(normalizedFile, canonicalName);
+        const cycleKey = `${cacheKey(normalizedFile, canonicalName)}::${namespace ?? ""}`;
         if (visited.has(cycleKey))
             return null;
         visited.add(cycleKey);
-        const goPackageExport = resolveGoPackageExport(index, normalizedFile, canonicalName);
-        if (goPackageExport && matchesPreferredKind(goPackageExport)) {
-            const result = { kind: "resolved", def: goPackageExport };
+        const implicitUnitExport = resolveImplicitUnitExport(index, normalizedFile, canonicalName, matchesOptions, namespace, referenceIndex, qualification);
+        if (implicitUnitExport) {
+            const result = { kind: "resolved", def: implicitUnitExport };
             index.exportCache.set(key, result);
             return result;
         }
         const localCandidates = [];
         for (const target of names.localExports.get(canonicalName) ?? []) {
-            if (matchesPreferredKind(target) &&
+            if (matchesOptions(target, namespace) &&
+                // Nested types resolve through their owner, not as bare namespace names.
+                (!filtersUseNamespace ||
+                    (!target.isMember &&
+                        isUnitBareNameVisible({
+                            index,
+                            declarationFile: target.file,
+                            declaration: target.range,
+                            useFile: file,
+                            ...(referenceIndex !== undefined ? { useIndex: referenceIndex } : {}),
+                            ...(qualification !== undefined ? { qualification } : {}),
+                        }))) &&
                 !localCandidates.some((candidate) => sameSymbolDef(index, candidate, target))) {
                 localCandidates.push(target);
             }
         }
+        // A bodyless C tag use can introduce an incomplete tag, but must reuse a tag
+        // already brought into scope by an include. Do not let that use hide its header.
+        if (namespace &&
+            (!localCandidates.length ||
+                localCandidates.every((candidate) => candidate.cTag === "reference" || candidate.cTag === "forward"))) {
+            const included = [];
+            for (const imp of moduleEntry.imports) {
+                if (typeof imp.resolved !== "string")
+                    continue;
+                if (imp.kind !== "star" && !(imp.kind === "named" && imp.local === name))
+                    continue;
+                if (imp.kind === "named" && (imp.cNamespace ?? "ordinary") !== namespace)
+                    continue;
+                const downstream = resolveFromFile(imp.resolved, imp.kind === "named" ? imp.imported : name, namespace);
+                if (downstream && !included.some((candidate) => sameResolvedExport(index, candidate, downstream))) {
+                    included.push(downstream);
+                }
+            }
+            if (included.length) {
+                const result = included.length === 1 ? included[0] : null;
+                index.exportCache.set(key, result);
+                return result;
+            }
+        }
         if (localCandidates.length === 1) {
             const target = localCandidates[0];
             const result = { kind: "resolved", def: target };
@@ -329,6 +388,16 @@ export function resolveExport(index, file, exportedName, opts) {
             return result;
         }
         if (localCandidates.length) {
+            // Several same-named functions are an overload set, not a failed lookup. Java static
+            // imports and Kotlin package imports both land here; arity picks the unique acceptor.
+            const selected = opts?.argumentCount !== undefined && (languageId === "java" || languageId === "kotlin")
+                ? selectFunctionOverloadByArity(localCandidates, opts.argumentCount)
+                : null;
+            if (selected) {
+                const result = { kind: "resolved", def: selected };
+                index.exportCache.set(key, result);
+                return result;
+            }
             index.exportCache.set(key, null);
             return null;
         }
@@ -348,8 +417,9 @@ export function resolveExport(index, file, exportedName, opts) {
         }
         const reexportCandidates = [];
         for (const entry of names.reexports.get(canonicalName) ?? []) {
-            const downstream = resolveFromFile(entry.fromModule, entry.sourceSpecifier || canonicalName) ??
-                resolveFromFile(entry.fromModule, canonicalName);
+            const downstream = resolveFromFile(entry.fromModule, entry.sourceSpecifier || canonicalName, namespace) ??
+                // A qualified using target cannot fall back to an unrelated bare export.
+                (entry.sourceSpecifier.includes("::") ? null : resolveFromFile(entry.fromModule, canonicalName, namespace));
             if (downstream && !reexportCandidates.some((candidate) => sameResolvedExport(index, candidate, downstream))) {
                 reexportCandidates.push(downstream);
             }
@@ -367,7 +437,7 @@ export function resolveExport(index, file, exportedName, opts) {
         for (const entry of moduleEntry.exports) {
             if (entry.type !== "exportStar")
                 continue;
-            const downstream = resolveFromFile(entry.fromModule, canonicalName);
+            const downstream = resolveFromFile(entry.fromModule, canonicalName, namespace);
             if (downstream && !starCandidates.some((candidate) => sameResolvedExport(index, candidate, downstream))) {
                 starCandidates.push(downstream);
             }
@@ -382,21 +452,44 @@ export function resolveExport(index, file, exportedName, opts) {
             return null;
         }
         const localFallbackCandidates = [];
-        if (allowLocalFallback && !shouldSkipVisibilityLocalFallback(index, moduleEntry)) {
+        // C# lexical bindings have already been checked. Only namespace-level types
+        // can remain visible from another region without a shared lexical scope.
+        if (allowLocalFallback && (filtersUseNamespace || !shouldSkipVisibilityLocalFallback(index, moduleEntry))) {
             for (const local of names.locals.get(canonicalName) ?? []) {
-                if (matchesPreferredKind(local) &&
+                if (filtersUseNamespace &&
+                    (local.isMember ||
+                        (local.kind !== SymbolKind.Class &&
+                            local.kind !== SymbolKind.Interface &&
+                            local.kind !== SymbolKind.TypeAlias) ||
+                        !isUnitBareNameVisible({
+                            index,
+                            declarationFile: local.file,
+                            declaration: local.range,
+                            useFile: file,
+                            ...(referenceIndex !== undefined ? { useIndex: referenceIndex } : {}),
+                            ...(qualification !== undefined ? { qualification } : {}),
+                        }))) {
+                    continue;
+                }
+                if (matchesOptions(local, namespace) &&
                     !localFallbackCandidates.some((candidate) => sameSymbolDef(index, candidate, local))) {
                     localFallbackCandidates.push(local);
                 }
             }
         }
-        if (localFallbackCandidates.length === 1) {
-            const local = localFallbackCandidates[0];
+        // Hidden same-file C# types are omitted from exports, so equivalent internal
+        // `partial` parts both land here. Collapse them with the same shared-owner
+        // identity used for exported candidates before uniqueness is judged.
+        const uniqueLocalFallback = filtersUseNamespace
+            ? coalesceEquivalentCsharpPartialExports(index, localFallbackCandidates)
+            : localFallbackCandidates;
+        if (uniqueLocalFallback.length === 1) {
+            const local = uniqueLocalFallback[0];
             const result = { kind: "resolved", def: local };
             index.exportCache.set(key, result);
             return result;
         }
-        if (localFallbackCandidates.length) {
+        if (uniqueLocalFallback.length) {
             index.exportCache.set(key, null);
             return null;
         }
@@ -405,6 +498,63 @@ export function resolveExport(index, file, exportedName, opts) {
     }
     return resolveFromFile(file, exportedName);
 }
+function resolvePhpCaseInsensitiveExport(index, targetFile, exportedName, preferredKind) {
+    const exactExport = resolveExport(index, targetFile, exportedName, { preferredKind, allowLocalFallback: false });
+    if (exactExport)
+        return exactExport;
+    const moduleEntry = moduleFor(index, targetFile);
+    if (!moduleEntry)
+        return null;
+    const foldedName = foldPhpIdentifierCase(exportedName);
+    const resolveUnique = (sourceSpellings, allowLocalFallback) => {
+        const matches = [];
+        for (const sourceSpelling of sourceSpellings) {
+            const hit = resolveExport(index, targetFile, sourceSpelling, { preferredKind, allowLocalFallback });
+            if (hit && !matches.some((candidate) => sameResolvedExport(index, candidate, hit))) {
+                matches.push(hit);
+            }
+        }
+        return matches.length === 1 ? matches[0] : null;
+    };
+    const exportSpellings = new Set();
+    for (const entry of moduleEntry.exports) {
+        if (entry.type === "local" &&
+            entry.target.kind === preferredKind &&
+            foldPhpIdentifierCase(entry.exportedAs) === foldedName) {
+            exportSpellings.add(entry.exportedAs);
+        }
+    }
+    if (exportSpellings.size)
+        return resolveUnique(exportSpellings, false);
+    const exactLocal = resolveExport(index, targetFile, exportedName, { preferredKind });
+    if (exactLocal)
+        return exactLocal;
+    const localSpellings = new Set();
+    for (const local of moduleEntry.locals) {
+        if (local.kind === preferredKind && foldPhpIdentifierCase(local.localName) === foldedName) {
+            localSpellings.add(local.localName);
+        }
+    }
+    return resolveUnique(localSpellings, true);
+}
+/** Resolves a PHP symbol through its separate class, function, or constant import namespace. */
+export function resolvePhpExportByImportType(index, targetFile, exportedName, importType) {
+    if (importType === "class") {
+        for (const preferredKind of PHP_CLASS_LIKE_KINDS) {
+            const hit = resolvePhpCaseInsensitiveExport(index, targetFile, exportedName, preferredKind);
+            if (hit)
+                return hit;
+        }
+        return null;
+    }
+    if (importType === "function") {
+        return resolvePhpCaseInsensitiveExport(index, targetFile, exportedName, SymbolKind.Function);
+    }
+    if (importType === "const") {
+        return resolveExport(index, targetFile, exportedName, { preferredKind: SymbolKind.Variable });
+    }
+    return resolveExport(index, targetFile, exportedName);
+}
 function collectExportedNames(index, file, includeLocalFallback, names, visited) {
     const fileKey = fileIdentityKey(file);
     if (visited.has(fileKey))
@@ -439,41 +589,297 @@ export function resolveModuleExports(index, file, opts) {
     }
     return resolved;
 }
-export function resolveImported(index, imp, exportedName) {
+/**
+ * Qualified name a C# using-alias binds. `from` is either the namespace (`N.Inner`
+ * for `using PT = N.Inner.Point`) or the full dotted type when an earlier resolver
+ * already kept it (`Utils.UtilsClass`). A bare imported name must not be searched on
+ * its own: compilation-unit lookup would accept a same-named type in another namespace.
+ */
+function csharpNamedImportLookupName(from, exportedName) {
+    if (!exportedName || exportedName.includes(".") || exportedName.startsWith("global::"))
+        return exportedName;
+    const normalizedFrom = from.trim();
+    if (!normalizedFrom)
+        return exportedName;
+    const parts = normalizedFrom.split(".").filter(Boolean);
+    const tail = parts[parts.length - 1];
+    if (!tail)
+        return exportedName;
+    if (normalizeCsharpIdentifier(tail) === normalizeCsharpIdentifier(exportedName))
+        return normalizedFrom;
+    return `${normalizedFrom}.${exportedName}`;
+}
+/**
+ * The name a C# binding looks up. A named binding qualifies with its alias target. A `using N;`
+ * star binding qualifies with `N`: its resolved file is one of the files that declare `N`, and
+ * the qualified lookup reaches exactly the types of `N` in every declaring file, not types of
+ * other namespaces the bound file also declares.
+ */
+function csharpImportLookupName(imp, exportedName) {
+    if (imp.kind === "named")
+        return csharpNamedImportLookupName(imp.from, exportedName);
+    if (imp.kind !== "star" || imp.staticMembersOf)
+        return exportedName;
+    if (!exportedName || exportedName.includes(".") || exportedName.startsWith("global::"))
+        return exportedName;
+    const namespaceName = imp.from.trim();
+    return namespaceName ? `${namespaceName}.${exportedName}` : exportedName;
+}
+const csharpNamespaceImportDirectoryFiles = new WeakMap();
+/**
+ * For each C# `using N;` binding, one declaring file per directory. The file graph links each
+ * directive to every file that declares `N` within the importer's own project, so the set is
+ * kept per binding: two importers in different projects never share one. A qualified lookup from
+ * one file reaches the rest of its directory, so one file per directory covers every declaration
+ * of `N`. Built once per index.
+ */
+function csharpNamespaceImportDirectories(index) {
+    const cached = csharpNamespaceImportDirectoryFiles.get(index);
+    if (cached)
+        return cached;
+    const edgesByImporter = new Map();
+    for (const edge of index.graph.edges) {
+        if (edge.to.type !== "file")
+            continue;
+        if (supportForFileWithoutHeaderSample(edge.to.path, index.languageExtensions)?.id !== "csharp")
+            continue;
+        const importerKey = fileIdentityKey(edge.from);
+        let byRaw = edgesByImporter.get(importerKey);
+        if (!byRaw)
+            edgesByImporter.set(importerKey, (byRaw = new Map()));
+        const raw = normalizeCsharpQualifiedName(edge.raw);
+        let byDirectory = byRaw.get(raw);
+        if (!byDirectory)
+            byRaw.set(raw, (byDirectory = new Map()));
+        const directoryKey = fileIdentityKey(path.posix.dirname(normalizePath(edge.to.path)));
+        if (!byDirectory.has(directoryKey))
+            byDirectory.set(directoryKey, edge.to.path);
+    }
+    const result = new Map();
+    for (const mod of index.byFile.values()) {
+        for (const imp of mod.imports) {
+            if (imp.kind !== "star" || imp.staticMembersOf || typeof imp.resolved !== "string")
+                continue;
+            if (supportForFileWithoutHeaderSample(imp.resolved, index.languageExtensions)?.id !== "csharp")
+                continue;
+            const files = new Map([
+                [fileIdentityKey(path.posix.dirname(normalizePath(imp.resolved))), imp.resolved],
+            ]);
+            const targets = edgesByImporter.get(fileIdentityKey(mod.file))?.get(normalizeCsharpQualifiedName(imp.from));
+            for (const [directoryKey, file] of targets ?? [])
+                if (!files.has(directoryKey))
+                    files.set(directoryKey, file);
+            result.set(imp, [...files.values()]);
+        }
+    }
+    csharpNamespaceImportDirectoryFiles.set(index, result);
+    return result;
+}
+/**
+ * A name imported by C# `using N;`, looked up as `N.Name` from one declaring file per
+ * directory. Distinct declarations (other than parts of one partial type) are ambiguous. Only
+ * exported types count: local fallback would expose an `internal` type the exports omit, for
+ * both the bare name and the qualified `N.Name` form.
+ */
+function resolveCsharpNamespaceImport(index, imp, boundFile, lookupName, opts) {
+    // A binding that is not one of the index's own (a copy) falls back to the bound file's directory.
+    const files = csharpNamespaceImportDirectories(index).get(imp) ?? [boundFile];
+    const matches = [];
+    let namespaceHit;
+    for (const file of files) {
+        const hit = resolveExport(index, file, lookupName, { ...opts, allowLocalFallback: false });
+        if (hit?.kind === "namespace")
+            namespaceHit ??= hit.file;
+        if (hit?.kind !== "resolved" || matches.some((candidate) => sameSymbolDef(index, candidate, hit.def)))
+            continue;
+        matches.push(hit.def);
+    }
+    const unique = coalesceEquivalentCsharpPartialExports(index, matches);
+    if (unique.length === 1)
+        return unique[0];
+    if (unique.length)
+        return null;
+    return namespaceHit ? { namespace: namespaceHit } : null;
+}
+/**
+ * A C# namespace-qualified type name (`N.Type`) used in `mod`. Qualified export lookup from the
+ * use file covers its own directory; a `using N;` in the file also reaches every other directory
+ * that declares `N`, as the unqualified name does.
+ */
+export function resolveCsharpQualifiedName(index, mod, qualifiedName, referenceIndex) {
+    const direct = resolveExport(index, mod.file, qualifiedName, { referenceIndex });
+    if (direct)
+        return direct;
+    const separator = qualifiedName.lastIndexOf(".");
+    if (separator <= 0)
+        return null;
+    const namespaceName = normalizeCsharpQualifiedName(qualifiedName.slice(0, separator)).replace(/^global::/u, "");
+    const typeName = qualifiedName.slice(separator + 1);
+    for (const imp of mod.imports) {
+        if (imp.kind !== "star" || imp.staticMembersOf || typeof imp.resolved !== "string")
+            continue;
+        if (normalizeCsharpQualifiedName(imp.from).replace(/^global::/u, "") !== namespaceName)
+            continue;
+        const hit = resolveImported(index, imp, typeName);
+        if (!hit)
+            return null;
+        return "namespace" in hit ? { kind: "namespace", file: hit.namespace } : { kind: "resolved", def: hit };
+    }
+    return null;
+}
+/** Select from the entire wildcard package before any representative file can win. */
+function resolveJvmPackageExport(index, files, name, argumentCount, importerLanguageId, samePackage) {
+    const candidates = [];
+    for (const file of files) {
+        const targetLanguage = supportForFileWithoutHeaderSample(file, index.languageExtensions)?.id;
+        if (targetLanguage !== "java" && targetLanguage !== "kotlin")
+            continue;
+        const names = moduleNameLookup(index, file);
+        if (!names)
+            continue;
+        for (const target of names.localExports.get(names.normalizeIdentifier(name)) ?? []) {
+            if (target.isMember ||
+                !isJvmPackageSymbolVisible(target, targetLanguage, importerLanguageId ?? targetLanguage, !!samePackage) ||
+                candidates.some((candidate) => sameSymbolDef(index, candidate, target)))
+                continue;
+            candidates.push(target);
+        }
+    }
+    if (candidates.length === 1)
+        return candidates[0];
+    return argumentCount === undefined ? null : selectFunctionOverloadByArity(candidates, argumentCount);
+}
+/** Whether a Java named static import can expose this exact direct member. */
+export function javaStaticNamedImportIncludes(index, imp, def) {
+    if (imp.kind !== "named" || !imp.jvmStaticWildcardName)
+        return false;
+    const targetFile = typeof imp.resolved === "string" ? imp.resolved : undefined;
+    if (!targetFile || fileIdentityKey(targetFile) !== fileIdentityKey(def.file))
+        return false;
+    const target = moduleFor(index, targetFile);
+    if (!target)
+        return false;
+    const owner = jvmWildcardTypeOwner(target, imp.jvmStaticWildcardName, "java");
+    if (!owner || owner.range.start.index === undefined || (owner.javaPackagePrivate && !imp.jvmSamePackage))
+        return false;
+    if (!isJvmStaticWildcardMember(def, owner.range.start.index) || (def.javaPackagePrivate && !imp.jvmSamePackage))
+        return false;
+    const names = moduleNameLookup(index, targetFile);
+    if (!names || names.normalizeIdentifier(imp.imported) !== names.normalizeIdentifier(def.localName))
+        return false;
+    return (names.localExports
+        .get(names.normalizeIdentifier(imp.imported))
+        ?.some((candidate) => sameSymbolDef(index, candidate, def)) ?? false);
+}
+export function resolveImported(index, imp, exportedName, opts) {
     const targetFile = typeof imp.resolved === "string" ? imp.resolved : undefined;
     if (!targetFile)
         return null;
-    let preferredKind;
-    if (imp.kind === "named") {
-        if (imp.phpImportType === "function") {
-            preferredKind = SymbolKind.Function;
+    if (imp.kind === "star" && imp.jvmPackageFiles) {
+        return resolveJvmPackageExport(index, imp.jvmPackageFiles, exportedName, opts?.argumentCount, imp.jvmPackageLanguageId, imp.jvmSamePackage);
+    }
+    if ((imp.kind === "star" && (imp.jvmTypeWildcardName || imp.jvmStaticWildcardName)) ||
+        (imp.kind === "named" && (imp.jvmTypeOwnerStartIndex !== undefined || imp.jvmStaticWildcardName !== undefined))) {
+        const target = moduleFor(index, targetFile);
+        if (!target)
+            return null;
+        const targetLanguageId = supportForFileWithoutHeaderSample(targetFile, index.languageExtensions)?.id;
+        let ownerStartIndex;
+        if (imp.kind === "star" || imp.jvmTypeOwnerStartIndex === undefined) {
+            const ownerName = imp.kind === "star" ? (imp.jvmTypeWildcardName ?? imp.jvmStaticWildcardName) : imp.jvmStaticWildcardName;
+            const owner = ownerName && jvmWildcardTypeOwner(target, ownerName, targetLanguageId);
+            if (!owner || (owner.javaPackagePrivate && !imp.jvmSamePackage))
+                return null;
+            ownerStartIndex = owner.range.start.index;
+        }
+        else {
+            ownerStartIndex = imp.jvmTypeOwnerStartIndex;
         }
-        else if (imp.phpImportType === "class") {
-            preferredKind = SymbolKind.Class;
+        if (ownerStartIndex === undefined)
+            return null;
+        const names = moduleNameLookup(index, targetFile);
+        if (!names)
+            return null;
+        let match;
+        let overloads;
+        for (const candidate of names.localExports.get(names.normalizeIdentifier(exportedName)) ?? []) {
+            if ((imp.jvmStaticWildcardName
+                ? !isJvmStaticWildcardMember(candidate, ownerStartIndex)
+                : !isJvmTypeWildcardMember(candidate, ownerStartIndex, targetLanguageId)) ||
+                (candidate.javaPackagePrivate && !imp.jvmSamePackage))
+                continue;
+            if (match && !sameSymbolDef(index, candidate, match)) {
+                if (imp.kind !== "named" || !imp.jvmStaticWildcardName || opts?.argumentCount === undefined)
+                    return null;
+                if (!overloads)
+                    overloads = [match];
+                overloads.push(candidate);
+            }
+            else {
+                match = candidate;
+            }
         }
-        else if (imp.phpImportType === "const") {
-            preferredKind = SymbolKind.Variable;
+        if (overloads && opts?.argumentCount !== undefined)
+            return selectFunctionOverloadByArity(overloads, opts.argumentCount);
+        if (match && imp.kind === "named" && imp.jvmStaticWildcardName && opts?.argumentCount !== undefined) {
+            const arity = match.callable?.arity;
+            if (arity &&
+                (opts.argumentCount < arity.minArgs || (arity.maxArgs !== null && opts.argumentCount > arity.maxArgs)))
+                return null;
         }
+        return match ?? null;
     }
-    const hit = resolveExport(index, targetFile, exportedName, {
-        ...(preferredKind ? { preferredKind } : {}),
-    });
-    if (hit?.kind === "resolved")
+    const namespace = opts?.cNamespace ?? (imp.kind === "named" ? imp.cNamespace : undefined);
+    if (opts?.cNamespace && imp.kind === "named" && (imp.cNamespace ?? "ordinary") !== opts.cNamespace)
+        return null;
+    const phpRole = phpNamedImportRole(imp);
+    // A C# `using PT = N.Inner.Point` stores the namespace in `from` and the type in
+    // `imported`. A bare `Point` lookup is an implicit compilation-unit search, so a peer
+    // `N.Point` is the only bare-visible match when this file also declares outer `N`.
+    // The alias names one namespace, and that qualified name is what every consumer resolves.
+    const support = supportForFileWithoutHeaderSample(targetFile, index.languageExtensions);
+    const lookupName = support?.id === "csharp" ? csharpImportLookupName(imp, exportedName) : exportedName;
+    if (support?.id === "csharp" && imp.kind === "star" && !imp.staticMembersOf) {
+        return resolveCsharpNamespaceImport(index, imp, targetFile, lookupName, {
+            ...opts,
+            ...(namespace ? { cNamespace: namespace } : {}),
+        });
+    }
+    const hit = phpRole
+        ? resolvePhpExportByImportType(index, targetFile, exportedName, phpRole)
+        : resolveExport(index, targetFile, lookupName, {
+            ...opts,
+            ...(namespace ? { cNamespace: namespace } : {}),
+        });
+    if (hit?.kind === "resolved") {
+        if (imp.kind === "named" && hit.def.javaPackagePrivate && !imp.jvmSamePackage)
+            return null;
         return hit.def;
+    }
     if (hit?.kind === "namespace")
         return { namespace: hit.file };
+    if (imp.kind === "default" && exportedName === "default") {
+        const moduleEntry = moduleFor(index, targetFile);
+        const directValue = moduleEntry && directModuleValueEntry(moduleEntry);
+        if (directValue)
+            return directValue.target;
+    }
     // Only Java, Kotlin, and Python matter below, so a `.h` target never needs its sample read.
-    const support = supportForFileWithoutHeaderSample(targetFile, index.languageExtensions);
     if (support?.id === "java" || support?.id === "kotlin") {
-        const siblingHit = resolveSiblingPackageExport(index, targetFile, exportedName, support.id);
-        if (siblingHit?.kind === "resolved")
+        const siblingHit = resolveSiblingPackageExport(index, targetFile, exportedName);
+        if (siblingHit?.kind === "resolved") {
+            if (imp.kind === "named" && siblingHit.def.javaPackagePrivate && !imp.jvmSamePackage)
+                return null;
             return siblingHit.def;
+        }
         if (siblingHit?.kind === "namespace") {
             return { namespace: siblingHit.file };
         }
     }
-    if (support?.id === "python") {
-        const submodule = resolvePythonSubmodule(targetFile, exportedName);
+    // A named `from pkg import child` may load child as a submodule. A plain
+    // namespace import of pkg cannot gain child solely because child.py exists.
+    if (support?.id === "python" && imp.kind === "named" && imp.mechanism === "python") {
+        const submodule = resolvePythonSubmoduleExact(targetFile, exportedName);
         if (submodule)
             return { namespace: submodule };
     }