@lzehrung/codegraph 3.0.0 → 3.1.0

package/dist/indexer/imports/import-binding-tables.d.ts

@@ -1,16 +1,20 @@
 import type { LanguageExtensionMap } from "../../languages.js";
+import type { SyntaxNodeLike } from "../../languages/types.js";
+import type { JvmImportDirective } from "../../util/jvm-tree.js";
 import type { Range } from "../../types.js";
 import type { CFamilyIncludeForm, RubyLoadForm } from "../../util/specifiers.js";
-import type { ImportBinding } from "../types.js";
-import type { ImportBindingSink, ImportResolver, ResolvedImportTarget } from "./context.js";
+import type { BuildReport, ImportBinding } from "../types.js";
+import type { ImportBindingSink, ImportDegradedHook, ImportResolver, ResolvedImportTarget } from "./context.js";
+import type { ParsedFileContext } from "../parse-context.js";
 /**
  * Per-language import-binding registry for statement overrides and implicit native-capture
  * mapping. Rows are keyed by language id and live next to `language-specific.ts` because that
  * file is the only dispatch consumer this wave.
  *
  * One row owns the statement handler, the implicit mapper, and the flags those paths used to
- * spell as `languageId === "..."` chains: trivia masking, JVM/C# dot normalization, Rust
- * statement-key offsets, C# `alwaysAliased` range attribution, and Rust's reduced-mode rescan.
+ * spell as `languageId === "..."` chains: trivia masking, Rust statement-key offsets, and Rust's
+ * reduced-mode rescan. C# and the JVM languages bind their directives from syntax-tree nodes
+ * (`applyCsharpImportDirective`, `applyJvmImportDirective`), so their rows name no statement handler.
  * `text-import-extractors.ts` stays the shared discovery source; this table does not re-scan.
  *
  * `tests/import-binding-tables.test.ts` asserts every registered language has a row, that an
@@ -24,6 +28,10 @@ export type LanguageSpecificImportContext = ImportBindingSink & {
     resolveFrom: ImportResolver;
     /** Active extension-to-language mapping, so a resolved file is classified as the language that parses it. */
     languageExtensions?: LanguageExtensionMap;
+    parsedFiles?: ReadonlyMap<string, ParsedFileContext>;
+    report?: BuildReport;
+    /** Reports that this file's imports are incomplete, so the module that holds them is marked parser-degraded. */
+    onDegraded?: ImportDegradedHook;
     getBindings: () => ImportBinding[];
     replaceBindings: (bindings: ImportBinding[]) => void;
 };
@@ -38,17 +46,16 @@ export type ImplicitImportBindingArgs = {
     alias?: string;
     /** UTF-16 range of the captured alias token, when the native alias capture proved it. */
     localRange?: Range;
-    wildcard?: boolean;
     includeForm?: CFamilyIncludeForm;
     rubyLoadForm?: RubyLoadForm;
 };
 export type ApplyStatementImportOverride = (context: LanguageSpecificImportContext, parserStmt: string, typeOnly: boolean, statementStartIndex?: number) => Promise<boolean>;
 export type AppendImplicitImportBinding = (context: LanguageSpecificImportContext, args: ImplicitImportBindingArgs) => void;
 /**
- * How a statement override prepares text before the parser: mask trivia, mask only PHP `use`
- * statements (includes keep string payloads), or leave the trimmed source untouched (Rust).
+ * How a statement override prepares text before the parser: mask only PHP `use` statements
+ * (includes keep string payloads), or leave the trimmed source untouched (Rust).
  */
-export type StatementTriviaMask = true | false | "use-keyword";
+export type StatementTriviaMask = false | "use-keyword";
 export type ImportBindingRow = {
     /** Why the language has no statement override and no implicit mapper. */
     omittedReason?: string;
@@ -56,15 +63,11 @@ export type ImportBindingRow = {
     appendImplicit?: AppendImplicitImportBinding;
     /** Present only with `applyStatement`. */
     maskTrivia?: StatementTriviaMask;
-    /** Collapse whitespace around `.` after masking (C#, Java, Kotlin). */
-    normalizeDots?: true;
     /**
-     * Include the statement start offset in the override de-dupe key (C#, Rust). Required when the
+     * Include the statement start offset in the override de-dupe key (Rust). Required when the
      * same statement text can appear in several scopes and each must keep its own range.
      */
     statementKeyUsesOffset?: true;
-    /** Named-range attribution treats unaliased `local === imported` as two tokens (C#). */
-    alwaysAliased?: true;
     /** Reduced-mode text bindings re-run even when native already produced some (Rust). */
     rescanTextBindings?: true;
     /** Why the language declares no statement override. */
@@ -72,5 +75,17 @@ export type ImportBindingRow = {
     /** Why the language declares no implicit mapper. */
     implicitOmittedReason?: string;
 };
+/**
+ * Binds one C# `using` or `extern alias` directive. The node comes from `collectCsharpImportDirectives`, so the
+ * directive is never found again by its text or offset. C# has no type-only imports.
+ */
+export declare function applyCsharpImportDirective(context: LanguageSpecificImportContext, directive: SyntaxNodeLike): Promise<void>;
+/**
+ * Binds one Java or Kotlin `import`. The directive comes from `collectJvmImportDirectives`, so its ranges are its
+ * nodes' own and it is never found again by its text or offset. Neither language has type-only imports. Every form
+ * resolves `directive.from`, the name its dependency edge resolves too: the type, the owner of a static member, or the
+ * package or type of a wildcard.
+ */
+export declare function applyJvmImportDirective(context: LanguageSpecificImportContext, { from, leaf, isStatic, wildcard, alias }: JvmImportDirective): Promise<void>;
 export declare const IMPORT_BINDING_ROWS: Record<string, ImportBindingRow>;
 //# sourceMappingURL=import-binding-tables.d.ts.map

package/dist/indexer/imports/import-binding-tables.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"import-binding-tables.d.ts","sourceRoot":"","sources":["../../../src/indexer/imports/import-binding-tables.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAO/D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AACjF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAE5F;;;;;;;;;;;;GAYG;AAEH,MAAM,MAAM,6BAA6B,GAAG,iBAAiB,GAAG;IAC9D,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,cAAc,CAAC;IAC5B,6GAA6G;IAC7G,kBAAkB,CAAC,EAAE,oBAAoB,CAAC;IAC1C,WAAW,EAAE,MAAM,aAAa,EAAE,CAAC;IACnC,eAAe,EAAE,CAAC,QAAQ,EAAE,aAAa,EAAE,KAAK,IAAI,CAAC;CACtD,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,oBAAoB,CAAC;IAC/B,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,2EAA2E;IAC3E,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,yFAAyF;IACzF,UAAU,CAAC,EAAE,KAAK,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,WAAW,CAAC,EAAE,kBAAkB,CAAC;IACjC,YAAY,CAAC,EAAE,YAAY,CAAC;CAC7B,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG,CACzC,OAAO,EAAE,6BAA6B,EACtC,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,OAAO,EACjB,mBAAmB,CAAC,EAAE,MAAM,KACzB,OAAO,CAAC,OAAO,CAAC,CAAC;AAEtB,MAAM,MAAM,2BAA2B,GAAG,CACxC,OAAO,EAAE,6BAA6B,EACtC,IAAI,EAAE,yBAAyB,KAC5B,IAAI,CAAC;AAEV;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,IAAI,GAAG,KAAK,GAAG,aAAa,CAAC;AAE/D,MAAM,MAAM,gBAAgB,GAAG;IAC7B,yEAAyE;IACzE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,4BAA4B,CAAC;IAC9C,cAAc,CAAC,EAAE,2BAA2B,CAAC;IAC7C,0CAA0C;IAC1C,UAAU,CAAC,EAAE,mBAAmB,CAAC;IACjC,uEAAuE;IACvE,aAAa,CAAC,EAAE,IAAI,CAAC;IACrB;;;OAGG;IACH,sBAAsB,CAAC,EAAE,IAAI,CAAC;IAC9B,wFAAwF;IACxF,aAAa,CAAC,EAAE,IAAI,CAAC;IACrB,uFAAuF;IACvF,kBAAkB,CAAC,EAAE,IAAI,CAAC;IAC1B,uDAAuD;IACvD,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC,oDAAoD;IACpD,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC,CAAC;AAwmBF,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CA2FhE,CAAC"}
+{"version":3,"file":"import-binding-tables.d.ts","sourceRoot":"","sources":["../../../src/indexer/imports/import-binding-tables.ts"],"names":[],"mappings":"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"}

package/dist/indexer/imports/import-binding-tables.js

@@ -1,20 +1,52 @@
-import { parseCsharpUsingDirective, parseJavaImportStatement, parseKotlinImportStatement, parsePhpImportStatement, parseRustImportStatements, rustImportKeywordOffset, } from "../../languages/import-statement-parsers.js";
-import { CSHARP_IDENTIFIER_SOURCE, normalizeCsharpQualifiedName } from "../../util/identifiers.js";
+import { parsePhpImportStatement, parseRustImportStatements, rustImportKeywordOffset, } from "../../languages/import-statement-parsers.js";
+import { csharpExternAlias, csharpUsingDirective } from "../../util/csharp-tree.js";
+import { isJvmLanguage } from "../../util/syntax-tree.js";
+import { toRange } from "../../util/ast.js";
+import { normalizeCsharpIdentifier, normalizeCsharpQualifiedName } from "../../util/identifiers.js";
 import { isRustCfgTestStatement } from "../../util/rust-test-modules.js";
 import { resolveCsharpDottedTypeImportPath, resolveCsharpNamespaceImportPaths } from "../../util/resolution/csharp.js";
+import { lookupJvmImport } from "../../util/resolution/jvm.js";
 import { extractRustModPathAttribute } from "../../util/resolution/rust.js";
 import { collectLineStartOffsets } from "../../util/lines.js";
 import { attributeNamedBindingRanges, maskImportBindingTrivia, sourceRangeFromOffsets } from "./binding-ranges.js";
-function pushCsharpOverride(context, parsed, typeOnly, fromValue, resolved) {
+function csharpNodeRange(node, source, lineStarts) {
+    let startIndex = node.startIndex;
+    if (startIndex && source[startIndex - 1] === "@")
+        startIndex -= 1;
+    return sourceRangeFromOffsets(lineStarts, startIndex, node.endIndex);
+}
+function csharpAliasTargetLeaf(node) {
+    if (node.type === "identifier" || node.type === "predefined_type")
+        return node;
+    // A generic name is its identifier followed by type arguments; only the identifier names the target.
+    if (node.type === "generic_name")
+        return node.namedChildren.find((child) => child.type === "identifier") ?? null;
+    if (node.type === "qualified_name" || node.type === "alias_qualified_name") {
+        const name = node.childForFieldName("name");
+        if (name)
+            return csharpAliasTargetLeaf(name);
+    }
+    for (let index = node.namedChildren.length - 1; index >= 0; index -= 1) {
+        const leaf = csharpAliasTargetLeaf(node.namedChildren[index]);
+        if (leaf)
+            return leaf;
+    }
+    return null;
+}
+function pushCsharpOverride(context, parsed, directiveStartIndex, typeOnly, fromValue, resolved, localRange, importedRange) {
     if (parsed.alias) {
-        const fromParts = parsed.from.split(".");
-        const imported = fromParts[fromParts.length - 1] ?? parsed.alias;
+        const localStart = localRange?.start.index;
+        const importedStart = importedRange?.start.index;
+        const local = localStart === undefined ? parsed.alias.text : context.source.slice(localStart, parsed.alias.endIndex);
+        const imported = importedStart === undefined ? parsed.leaf.text : context.source.slice(importedStart, parsed.leaf.endIndex);
         context.pushBinding({
             kind: "named",
-            local: parsed.alias,
+            local,
             imported,
             from: fromValue,
             explicitAlias: true,
+            ...(localRange ? { localRange } : {}),
+            ...(importedRange ? { importedRange } : {}),
             resolved,
             typeOnly,
         });
@@ -25,112 +57,129 @@ function pushCsharpOverride(context, parsed, typeOnly, fromValue, resolved) {
         from: fromValue,
         resolved,
         typeOnly,
+        csharpDirectiveStartIndex: directiveStartIndex,
     });
 }
-const CSHARP_EXTERN_ALIAS_PATTERN = new RegExp(String.raw `^extern\s+alias\s+(${CSHARP_IDENTIFIER_SOURCE})\s*;$`, "u");
-function csharpUsingAliasLocalRange(source, statementStartIndex, alias) {
-    if (statementStartIndex === undefined || !alias)
-        return undefined;
-    // Comments and string literals can carry `;` and sit between the alias and `=`
-    // (`using X /* ; */ = P;`), so both the statement boundary and the alias match run over
-    // trivia-masked text. Masking is one-for-one with the raw source (masked units become
-    // spaces, newlines survive), so every match offset is the raw-source offset.
-    const masked = maskImportBindingTrivia(source.slice(statementStartIndex), "csharp");
-    const semicolon = masked.indexOf(";");
-    const window = semicolon < 0 ? masked : masked.slice(0, semicolon + 1);
-    const escaped = alias.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const match = window.match(new RegExp(`\\busing\\s+(${escaped})\\s*=`));
-    if (!match || match.index === undefined)
-        return undefined;
-    const aliasOffset = match[0].lastIndexOf(alias);
-    if (aliasOffset < 0)
-        return undefined;
-    const start = statementStartIndex + match.index + aliasOffset;
-    return sourceRangeFromOffsets(collectLineStartOffsets(source), start, start + alias.length);
-}
-async function applyCsharpStatementOverride(context, normalizedStmt, typeOnly, statementStartIndex) {
-    const externAlias = normalizedStmt.match(CSHARP_EXTERN_ALIAS_PATTERN)?.[1];
+/**
+ * Binds one C# `using` or `extern alias` directive. The node comes from `collectCsharpImportDirectives`, so the
+ * directive is never found again by its text or offset. C# has no type-only imports.
+ */
+export async function applyCsharpImportDirective(context, directive) {
+    const typeOnly = false;
+    const externAlias = csharpExternAlias(directive);
     if (externAlias) {
-        // `extern alias X;` names a compiler-provided alias for an assembly's extern alias. It has no
-        // first-party or package target, so it stays an unresolved namespace binding and produces no
-        // dependency edge: the graph query does not treat it as an import specifier.
+        // An extern alias names a compiler-provided assembly alias, so it remains unresolved and
+        // does not produce a dependency edge: the graph query does not treat it as an import.
         context.pushBinding({ kind: "namespace", localNS: externAlias, from: externAlias });
-        return true;
+        return;
     }
-    const parsed = parseCsharpUsingDirective(normalizedStmt);
-    if (!parsed)
-        return false;
-    // `using static N.T;` imports the static members and nested types of one type. Bind it to the
-    // file that declares `T` only when exactly one file does; otherwise it stays external. A
-    // `global using static` applies to every file of the project, which module-local bindings
-    // cannot express, so it is not bound.
-    if (parsed.isStatic && !/^global\s/u.test(normalizedStmt.trim())) {
-        const typeMatch = await resolveCsharpDottedTypeImportPath(context.projectRoot, parsed.from, context.file, context.languageExtensions);
-        const qualifiedType = normalizeCsharpQualifiedName(parsed.from).replace(/^global::/u, "");
-        if (typeMatch.status === "found" && qualifiedType.includes(".")) {
+    const parsed = csharpUsingDirective(directive);
+    if (!parsed) {
+        const alias = directive.childForFieldName("name");
+        if (alias?.type === "identifier") {
+            const target = directive.namedChildren.find((child) => child !== alias && child.type !== "comment");
+            if (target) {
+                const leaf = csharpAliasTargetLeaf(target) ?? target;
+                const unresolved = {
+                    value: target.text,
+                    leaf,
+                    rawValue: target.text,
+                    alias,
+                    isStatic: false,
+                    isGlobal: false,
+                };
+                const lineStarts = collectLineStartOffsets(context.source);
+                // The binding stays unresolved, so it cannot restore a target token it claims: only the alias
+                // name is a binding token, and every name in the target remains an ordinary reference.
+                pushCsharpOverride(context, unresolved, directive.startIndex, typeOnly, unresolved.value, { external: unresolved.value }, csharpNodeRange(alias, context.source, lineStarts));
+            }
+            return;
+        }
+        return;
+    }
+    const lineStarts = parsed.alias ? collectLineStartOffsets(context.source) : undefined;
+    const localRange = parsed.alias && lineStarts ? csharpNodeRange(parsed.alias, context.source, lineStarts) : undefined;
+    const importedRange = parsed.alias && lineStarts ? csharpNodeRange(parsed.leaf, context.source, lineStarts) : undefined;
+    // Static imports bind to a declaring type only when exactly one file owns that type. A global
+    // static using applies to the whole project, which module-local bindings cannot express.
+    if (parsed.isStatic && !parsed.isGlobal) {
+        const typeMatch = await resolveCsharpDottedTypeImportPath(context.projectRoot, parsed.value, context.file, context.languageExtensions, context.report, context.parsedFiles);
+        // `partial`: a C# file of the project could not be read, so it may declare the type too and the binding stays
+        // external. The module records that, so a later build resolves it again once every file reads.
+        if (typeMatch.status === "partial")
+            context.onDegraded?.("lookup");
+        const qualifiedType = normalizeCsharpQualifiedName(parsed.value).replace(/^global::/u, "");
+        if (typeMatch.status === "found" && !typeMatch.parts && qualifiedType.includes(".")) {
             context.pushBinding({
                 kind: "star",
-                from: parsed.from,
+                from: parsed.value,
                 resolved: typeMatch.file.replace(/\\/g, "/"),
                 typeOnly,
                 staticMembersOf: qualifiedType,
             });
-            return true;
+            return;
         }
+        context.pushBinding({
+            kind: "star",
+            from: parsed.rawValue,
+            resolved: { external: parsed.rawValue },
+            typeOnly,
+        });
+        return;
     }
-    // A target that is itself a declared namespace is a namespace alias, even when the alias is
-    // written in alias form. Resolving it here keeps the local name a namespace so member
-    // navigation can reach the declaring file instead of treating the last segment as a type.
-    // A namespace split across several files has no single target, so it keeps the local alias
-    // as an unresolved namespace rather than claiming one of the declaring files.
-    const namespaceTargets = await resolveCsharpNamespaceImportPaths(context.projectRoot, parsed.from, context.file, context.languageExtensions);
+    // A target declared as a namespace remains a namespace alias, even when written with alias
+    // syntax. Ambiguous namespaces stay unresolved rather than claiming one declaring file.
+    const namespaceTargets = await resolveCsharpNamespaceImportPaths(context.projectRoot, parsed.value, context.file, context.languageExtensions, context.report, context.parsedFiles);
     if (parsed.alias && namespaceTargets.length) {
-        const localRange = csharpUsingAliasLocalRange(context.source, statementStartIndex, parsed.alias);
         context.pushBinding({
             kind: "namespace",
-            localNS: parsed.alias,
-            from: parsed.from,
+            localNS: normalizeCsharpIdentifier(parsed.alias.text),
+            from: parsed.value,
             ...(namespaceTargets.length === 1 ? { resolved: namespaceTargets[0].replace(/\\/g, "/") } : {}),
             typeOnly,
             ...(localRange ? { localRange } : {}),
         });
-        return true;
+        return;
+    }
+    let fromValue = parsed.value;
+    // A plain using names a namespace, which ordinary C# declares across many files. Bind it to a
+    // representative declaring file; namespace-qualified export lookup reaches all files through
+    // the compilation-unit relation. Path-like resolution applies only when no file declares it.
+    let resolved;
+    if (parsed.alias) {
+        resolved = await context.resolveFrom(fromValue);
+    }
+    else if (namespaceTargets.length) {
+        resolved = namespaceTargets[0].replace(/\\/g, "/");
+    }
+    else {
+        resolved = await context.resolveFrom(fromValue);
     }
-    let fromValue = parsed.from;
-    // `using N;` names a namespace, which ordinary C# declares across many files. Bind it to the
-    // first declaring file: lookups through the binding qualify the name with `N`, and
-    // namespace-qualified export lookup reaches every file that declares `N` through the
-    // compilation-unit relation. Path-like resolution applies only when no file declares `N`, and
-    // only to a C# file.
-    let resolved = !parsed.alias && namespaceTargets.length
-        ? namespaceTargets[0].replace(/\\/g, "/")
-        : await context.resolveFrom(fromValue);
     if (parsed.alias) {
-        const fromParts = parsed.from.split(".");
+        const fromParts = parsed.value.split(".");
         if (fromParts.length > 1) {
             const fallbackFrom = fromParts.slice(0, -1).join(".");
             if (fallbackFrom) {
-                // The full path isn't itself a declared namespace (checked above): `using PT = N.Point;`
-                // names a TYPE (`Point`) inside namespace `N`. A namespace that lives in one file can
-                // use that file directly. When several files declare it, the type name is resolved
-                // across all of them (partial parts share one owner). An ambiguous set stays external
-                // instead of keeping a path-like first match such as `N/Point.cs`.
-                const fallbackNamespaceTargets = await resolveCsharpNamespaceImportPaths(context.projectRoot, fallbackFrom, context.file, context.languageExtensions);
-                if (fallbackNamespaceTargets.length > 1) {
-                    const typeMatch = await resolveCsharpDottedTypeImportPath(context.projectRoot, parsed.from, context.file, context.languageExtensions);
+                // A type alias names a type in a namespace. Resolve the type across every namespace file; any
+                // result but one proven declaration stays external instead of selecting a path-like first match
+                // or the namespace's file.
+                const fallbackNamespaceTargets = await resolveCsharpNamespaceImportPaths(context.projectRoot, fallbackFrom, context.file, context.languageExtensions, context.report, context.parsedFiles);
+                const namespaceDeclared = fallbackNamespaceTargets.length > 1 ||
+                    (fallbackNamespaceTargets.length === 1 && typeof resolved !== "string");
+                if (namespaceDeclared) {
+                    const typeMatch = await resolveCsharpDottedTypeImportPath(context.projectRoot, parsed.value, context.file, context.languageExtensions, context.report, context.parsedFiles);
+                    // `partial` leaves the alias external and marks the module, as for a static using.
+                    if (typeMatch.status === "partial")
+                        context.onDegraded?.("lookup");
                     if (typeMatch.status === "found") {
                         fromValue = fallbackFrom;
                         resolved = typeMatch.file;
                     }
                     else {
-                        fromValue = parsed.from;
-                        resolved = { external: parsed.from };
+                        fromValue = parsed.value;
+                        resolved = { external: parsed.value };
                     }
                 }
-                else if (typeof resolved !== "string" && fallbackNamespaceTargets.length === 1) {
-                    fromValue = fallbackFrom;
-                    resolved = fallbackNamespaceTargets[0].replace(/\\/g, "/");
-                }
                 else if (typeof resolved !== "string") {
                     const fallbackResolved = await context.resolveFrom(fallbackFrom);
                     if (typeof fallbackResolved === "string") {
@@ -141,56 +190,57 @@ async function applyCsharpStatementOverride(context, normalizedStmt, typeOnly, s
             }
         }
     }
-    pushCsharpOverride(context, parsed, typeOnly, fromValue, resolved);
-    return true;
+    pushCsharpOverride(context, parsed, directive.startIndex, typeOnly, fromValue, resolved, localRange, importedRange);
 }
-async function applyJavaStatementOverride(context, normalizedStmt, typeOnly) {
-    return await applyJvmStatementOverride(context, normalizedStmt, typeOnly, parseJavaImportStatement, (parsed) => {
-        if (parsed.kind === "named")
-            return parsed.imported;
-        return undefined;
-    });
-}
-async function applyKotlinStatementOverride(context, normalizedStmt, typeOnly) {
-    return await applyJvmStatementOverride(context, normalizedStmt, typeOnly, parseKotlinImportStatement, (parsed) => {
-        if (parsed.kind === "named")
-            return parsed.local;
-        return undefined;
-    });
-}
-async function applyJvmStatementOverride(context, normalizedStmt, typeOnly, parseStatement, localNameFor) {
-    const parsed = parseStatement(normalizedStmt);
-    if (!parsed)
-        return false;
-    return await pushJvmImportBinding(context, parsed, localNameFor(parsed), typeOnly);
-}
-async function pushJvmImportBinding(context, parsed, local, typeOnly) {
-    const resolved = await context.resolveFrom(parsed.from, undefined, parsed.kind === "star" && !parsed.isStatic ? { jvmPackageWildcard: true } : undefined);
-    if (parsed.kind === "star") {
+/**
+ * Binds one Java or Kotlin `import`. The directive comes from `collectJvmImportDirectives`, so its ranges are its
+ * nodes' own and it is never found again by its text or offset. Neither language has type-only imports. Every form
+ * resolves `directive.from`, the name its dependency edge resolves too: the type, the owner of a static member, or the
+ * package or type of a wildcard.
+ */
+export async function applyJvmImportDirective(context, { from, leaf, isStatic, wildcard, alias }) {
+    const packageWildcard = wildcard && !isStatic;
+    const resolved = await context.resolveFrom(from, undefined, packageWildcard ? { jvmPackageWildcard: true } : undefined);
+    // A file that was not read in full may declare what an import names, and a file whose package could not be read may
+    // be one of a package's files. The module records that, so a later build resolves the import again once every file
+    // reads. A resolved import names a file that proves it, except a package wildcard, which names every file of its
+    // package.
+    if (isJvmLanguage(context.languageId)) {
+        const lookupOptions = { languageId: context.languageId, fromFile: context.file };
+        let incomplete = false;
+        if (packageWildcard) {
+            incomplete = (await lookupJvmImport(context.projectRoot, `${from}.*`, lookupOptions)).incomplete;
+        }
+        if (!incomplete && typeof resolved !== "string") {
+            incomplete = (await lookupJvmImport(context.projectRoot, from, lookupOptions)).incomplete;
+        }
+        if (incomplete)
+            context.onDegraded?.("lookup");
+    }
+    const owner = from.slice(from.lastIndexOf(".") + 1);
+    if (wildcard) {
         context.pushBinding({
             kind: "star",
-            from: parsed.from,
+            from,
             resolved,
-            ...(parsed.isStatic
-                ? { jvmStaticWildcardName: parsed.from.slice(parsed.from.lastIndexOf(".") + 1) }
-                : { jvmTypeWildcardName: parsed.from.slice(parsed.from.lastIndexOf(".") + 1) }),
-            typeOnly,
+            ...(isStatic ? { jvmStaticWildcardName: owner } : { jvmTypeWildcardName: owner }),
+            typeOnly: false,
         });
-        return true;
+        return;
     }
+    const importedRange = toRange(leaf);
     context.pushBinding({
         kind: "named",
-        local: local ?? parsed.imported,
-        imported: parsed.imported,
-        from: parsed.from,
-        ...(parsed.isStatic && context.languageId === "java"
-            ? { jvmStaticWildcardName: parsed.from.slice(parsed.from.lastIndexOf(".") + 1) }
-            : {}),
-        ...(parsed.explicitAlias ? { explicitAlias: true } : {}),
+        local: alias?.text ?? leaf.text,
+        imported: leaf.text,
+        from,
+        ...(isStatic ? { jvmStaticWildcardName: owner } : {}),
+        ...(alias ? { explicitAlias: true } : {}),
+        importedRange,
+        localRange: alias ? toRange(alias) : importedRange,
         resolved,
-        typeOnly,
+        typeOnly: false,
     });
-    return true;
 }
 async function applyRustStatementOverride(context, normalizedStmt, typeOnly, statementStartIndex) {
     if (isRustTestOnlyStatement(context, normalizedStmt, statementStartIndex))
@@ -290,7 +340,7 @@ async function applyPhpStatementOverride(context, normalizedStmt, typeOnly) {
     }
     return true;
 }
-function pushNamedImplicitBinding(context, binding, stmtText, stmtStartIndex, source, alwaysAliased) {
+function pushNamedImplicitBinding(context, binding, stmtText, stmtStartIndex, source) {
     if (stmtStartIndex !== undefined && source !== undefined) {
         attributeNamedBindingRanges({
             bindings: [binding],
@@ -298,31 +348,10 @@ function pushNamedImplicitBinding(context, binding, stmtText, stmtStartIndex, so
             text: maskImportBindingTrivia(stmtText, context.languageId),
             textStartIndex: stmtStartIndex,
             source,
-            ...(alwaysAliased !== undefined ? { alwaysAliased } : {}),
         });
     }
     context.pushBinding(binding);
 }
-function appendJavaImplicitBinding(context, { from, resolved, typeOnly, stmtText, stmtStartIndex, source }) {
-    const parts = from.split(".");
-    const last = parts[parts.length - 1];
-    if (last === "*") {
-        context.pushBinding({ kind: "star", from, resolved, typeOnly });
-    }
-    else if (last) {
-        pushNamedImplicitBinding(context, { kind: "named", local: last, imported: last, from, resolved, typeOnly }, stmtText, stmtStartIndex, source, undefined);
-    }
-}
-function appendCsharpImplicitBinding(context, { from, resolved, typeOnly, stmtText, stmtStartIndex, source, alias }) {
-    if (alias) {
-        const fromParts = from.split(".");
-        const imported = fromParts[fromParts.length - 1] ?? alias;
-        pushNamedImplicitBinding(context, { kind: "named", local: alias, imported, from, explicitAlias: true, resolved, typeOnly }, stmtText, stmtStartIndex, source, IMPORT_BINDING_ROWS.csharp.alwaysAliased);
-    }
-    else {
-        context.pushBinding({ kind: "star", from, resolved, typeOnly });
-    }
-}
 function appendRubyImplicitBinding(context, { from, resolved, rubyLoadForm }) {
     context.pushBinding({ kind: "star", from, resolved, ...(rubyLoadForm ? { rubyLoadForm } : {}) });
 }
@@ -355,29 +384,10 @@ function appendRustImplicitBinding(context, { from, resolved, stmtText, stmtStar
             context.pushBinding({ kind: "star", from, resolved });
         }
         else {
-            pushNamedImplicitBinding(context, { kind: "named", local: last, imported: last, from, resolved }, stmtText, stmtStartIndex, source, undefined);
+            pushNamedImplicitBinding(context, { kind: "named", local: last, imported: last, from, resolved }, stmtText, stmtStartIndex, source);
         }
     }
 }
-function appendKotlinImplicitBinding(context, { from, resolved, typeOnly, stmtText, stmtStartIndex, source, alias, wildcard }) {
-    if (wildcard || from.endsWith(".*")) {
-        context.pushBinding({ kind: "star", from, resolved, typeOnly });
-    }
-    else {
-        const parts = from.split(".");
-        const imported = parts[parts.length - 1];
-        if (imported)
-            pushNamedImplicitBinding(context, {
-                kind: "named",
-                local: alias ?? imported,
-                imported,
-                from,
-                ...(alias !== undefined ? { explicitAlias: true } : {}),
-                resolved,
-                typeOnly,
-            }, stmtText, stmtStartIndex, source, undefined);
-    }
-}
 function swiftModuleLocalRange(source, statementStartIndex, statementText, name) {
     if (!source || statementStartIndex === undefined || !name)
         return undefined;
@@ -420,7 +430,7 @@ function appendSwiftImplicitBinding(context, { from, resolved, typeOnly, stmtTex
         context.pushBinding({ kind: "star", from, resolved, typeOnly });
     }
     else {
-        pushNamedImplicitBinding(context, { kind: "named", local: last, imported: last, from, resolved, typeOnly }, stmtText, stmtStartIndex, source, undefined);
+        pushNamedImplicitBinding(context, { kind: "named", local: last, imported: last, from, resolved, typeOnly }, stmtText, stmtStartIndex, source);
     }
 }
 function appendZigImplicitBinding(context, { from, resolved, typeOnly, alias, localRange }) {
@@ -461,13 +471,8 @@ export const IMPORT_BINDING_ROWS = {
     },
     css: { omittedReason: STYLESHEET_OMITTED },
     csharp: {
-        applyStatement: applyCsharpStatementOverride,
-        appendImplicit: appendCsharpImplicitBinding,
-        maskTrivia: true,
-        normalizeDots: true,
-        alwaysAliased: true,
-        // `using X = P;` in two namespace blocks is two scoped aliases, each with its own range.
-        statementKeyUsesOffset: true,
+        statementOmittedReason: "C# using directives are bound from syntax-tree nodes by applyCsharpImportDirective, not from statement text.",
+        implicitOmittedReason: "C# using directives are bound from syntax-tree nodes; no native capture is mapped.",
     },
     go: {
         appendImplicit: appendGoImplicitBinding,
@@ -476,20 +481,16 @@ export const IMPORT_BINDING_ROWS = {
     hbs: { omittedReason: "Handlebars document format; embedded scripts parse as their own language." },
     html: { omittedReason: "Document format; embedded scripts parse as their own language." },
     java: {
-        applyStatement: applyJavaStatementOverride,
-        appendImplicit: appendJavaImplicitBinding,
-        maskTrivia: true,
-        normalizeDots: true,
+        statementOmittedReason: "Java imports are bound from syntax-tree nodes by applyJvmImportDirective, not from statement text.",
+        implicitOmittedReason: "Java imports are bound from syntax-tree nodes; no native capture is mapped.",
     },
     js: {
         statementOmittedReason: ECMASCRIPT_STATEMENT_OMITTED,
         implicitOmittedReason: ECMASCRIPT_IMPLICIT_OMITTED,
     },
     kotlin: {
-        applyStatement: applyKotlinStatementOverride,
-        appendImplicit: appendKotlinImplicitBinding,
-        maskTrivia: true,
-        normalizeDots: true,
+        statementOmittedReason: "Kotlin imports are bound from syntax-tree nodes by applyJvmImportDirective, not from statement text.",
+        implicitOmittedReason: "Kotlin imports are bound from syntax-tree nodes; no native capture is mapped.",
     },
     less: { omittedReason: STYLESHEET_OMITTED },
     markdown: { omittedReason: "Document format; fenced code blocks parse as their own language." },
@@ -516,6 +517,9 @@ export const IMPORT_BINDING_ROWS = {
     },
     scss: { omittedReason: STYLESHEET_OMITTED },
     sql: { omittedReason: "Data language; no import-statement or implicit-binding dispatch." },
+    terraform: {
+        omittedReason: "A module call binds no local names; `module.<name>` resolves in src/terraform/.",
+    },
     svelte: { omittedReason: "Svelte component format; script blocks parse as js/ts and templates as html." },
     swift: {
         appendImplicit: appendSwiftImplicitBinding,