gitnexus 1.6.10-rc.21 → 1.6.10-rc.211

package/dist/core/ingestion/frameworks/spring/non-http-handlers.js

@@ -0,0 +1,152 @@
+import { resolveCallerGraphId } from '../../scope-resolution/graph-bridge/ids.js';
+import { createSpringAnnotationNameResolver } from './bean-candidates.js';
+import { SPRING_BEAN_ANNOTATION } from './bean-factories.js';
+export const SPRING_NON_HTTP_HANDLER_ENTRY_POINT_MULTIPLIER = 3.0;
+const SPRING_SERVICE_ACTIVATOR_ANNOTATION = 'org.springframework.integration.annotation.ServiceActivator';
+const HANDLER_ANNOTATIONS = new Map([
+    ['org.springframework.scheduling.annotation.Scheduled', 'scheduled'],
+    ['org.springframework.scheduling.annotation.Schedules', 'scheduled'],
+    ['org.springframework.context.event.EventListener', 'event'],
+    ['org.springframework.transaction.event.TransactionalEventListener', 'event'],
+    ['org.springframework.modulith.events.ApplicationModuleListener', 'event'],
+    ['org.springframework.kafka.annotation.KafkaListener', 'message'],
+    ['org.springframework.kafka.annotation.KafkaListeners', 'message'],
+    ['org.springframework.amqp.rabbit.annotation.RabbitListener', 'message'],
+    ['org.springframework.amqp.rabbit.annotation.RabbitListeners', 'message'],
+    ['org.springframework.jms.annotation.JmsListener', 'message'],
+    ['org.springframework.jms.annotation.JmsListeners', 'message'],
+    ['org.springframework.pulsar.annotation.PulsarListener', 'message'],
+    ['org.springframework.pulsar.annotation.PulsarListeners', 'message'],
+    ['io.awspring.cloud.sqs.annotation.SqsListener', 'message'],
+    ['io.awspring.cloud.messaging.listener.annotation.SqsListener', 'message'],
+    ['org.springframework.cloud.aws.messaging.listener.annotation.SqsListener', 'message'],
+    ['org.springframework.cloud.stream.annotation.StreamListener', 'message'],
+    [SPRING_SERVICE_ACTIVATOR_ANNOTATION, 'message'],
+    ['org.springframework.messaging.handler.annotation.MessageMapping', 'message'],
+    ['org.springframework.messaging.simp.annotation.SubscribeMapping', 'message'],
+    ['com.xxl.job.core.handler.annotation.XxlJob', 'xxl-job'],
+]);
+const RECOGNIZED_HANDLER_ANNOTATIONS = new Set(HANDLER_ANNOTATIONS.keys());
+const RESOLVABLE_NON_HTTP_ANNOTATIONS = new Set([
+    ...RECOGNIZED_HANDLER_ANNOTATIONS,
+    SPRING_BEAN_ANNOTATION,
+]);
+function simpleName(name) {
+    const separator = name.lastIndexOf('.');
+    return separator === -1 ? name : name.slice(separator + 1);
+}
+const CAPTURE_RELEVANT_SIMPLE_NAMES = new Set([...RECOGNIZED_HANDLER_ANNOTATIONS].map(simpleName));
+export function hasSpringNonHttpHandlerRelevantAnnotation(annotations) {
+    return annotations.some((annotation) => CAPTURE_RELEVANT_SIMPLE_NAMES.has(simpleName(annotation.name)));
+}
+function exactCallableOwnersByRange(graph) {
+    const owners = new Map();
+    for (const node of graph.iterNodes()) {
+        if ((node.label !== 'Method' && node.label !== 'Function') ||
+            typeof node.properties.filePath !== 'string') {
+            continue;
+        }
+        const key = `${node.properties.filePath}\0${node.properties.startLine}\0${node.properties.endLine}`;
+        owners.set(key, owners.has(key) ? null : node);
+    }
+    return owners;
+}
+function ownerGraphNode(fact, indexes, nodeLookup, graph, getExactOwnerByRange) {
+    const ownerId = resolveCallerGraphId(fact.ownerScopeId, indexes, nodeLookup);
+    if (ownerId !== undefined) {
+        const owner = graph.getNode(ownerId);
+        if (owner?.label === 'Method' || owner?.label === 'Function')
+            return owner;
+    }
+    if (fact.ownerFilePath !== undefined && fact.ownerRange !== undefined) {
+        const fallback = getExactOwnerByRange().get(`${fact.ownerFilePath}\0${fact.ownerRange.startLine - 1}\0${fact.ownerRange.endLine - 1}`);
+        if (fallback !== null && fallback !== undefined)
+            return fallback;
+    }
+    return undefined;
+}
+function handlerReason(kinds) {
+    if (kinds.size !== 1) {
+        return kinds.has('xxl-job') ? 'managed-non-http-handler' : 'spring-non-http-handler';
+    }
+    const kind = kinds.values().next().value;
+    if (kind === 'xxl-job')
+        return 'xxl-job-handler';
+    return `spring-${kind}-handler`;
+}
+/**
+ * Resolve callable annotations after imports and package visibility finalize,
+ * then promote confirmed framework-managed handlers into process entry points.
+ */
+export function createSpringNonHttpHandlerMetadataAttacher(adapter) {
+    return (graph, parsedFiles, nodeLookup, indexes) => {
+        const factsByFile = new Map();
+        for (const parsed of parsedFiles) {
+            const facts = adapter.getFacts(parsed.filePath);
+            if (facts.length > 0)
+                factsByFile.set(parsed.filePath, facts);
+        }
+        if (factsByFile.size === 0)
+            return;
+        const resolveAnnotation = createSpringAnnotationNameResolver(indexes);
+        let exactOwnerByRange;
+        const getExactOwnerByRange = () => (exactOwnerByRange ??= exactCallableOwnersByRange(graph));
+        let classIdByMethod;
+        const ownerClassLabel = (methodId) => {
+            if (classIdByMethod === undefined) {
+                const owners = new Map();
+                for (const relationship of graph.iterRelationshipsByType('HAS_METHOD')) {
+                    owners.set(relationship.targetId, relationship.sourceId);
+                }
+                classIdByMethod = owners;
+            }
+            const classId = classIdByMethod.get(methodId);
+            return classId === undefined ? undefined : graph.getNode(classId)?.label;
+        };
+        for (const parsed of parsedFiles) {
+            const facts = factsByFile.get(parsed.filePath);
+            if (facts === undefined)
+                continue;
+            const incomplete = adapter.isPackageVisibilityIncomplete(parsed.filePath);
+            const resolvedAnnotations = new Map();
+            for (const fact of facts) {
+                const ownerScope = indexes.scopeTree.getScope(fact.ownerScopeId);
+                const resolvedFactAnnotations = new Set();
+                for (const annotation of fact.annotations) {
+                    if (annotation.useSiteTarget !== undefined)
+                        continue;
+                    const enclosingScope = ownerScope?.parent ?? null;
+                    const cacheKey = `${enclosingScope ?? '<root>'}\0${annotation.name}`;
+                    let resolved = resolvedAnnotations.get(cacheKey);
+                    if (!resolvedAnnotations.has(cacheKey)) {
+                        resolved = resolveAnnotation(annotation.name, parsed, enclosingScope, RESOLVABLE_NON_HTTP_ANNOTATIONS, incomplete);
+                        resolvedAnnotations.set(cacheKey, resolved);
+                    }
+                    if (resolved !== undefined)
+                        resolvedFactAnnotations.add(resolved);
+                }
+                const beanFactoryMethod = resolvedFactAnnotations.has(SPRING_BEAN_ANNOTATION);
+                const kinds = new Set();
+                for (const resolved of resolvedFactAnnotations) {
+                    if (beanFactoryMethod && resolved === SPRING_SERVICE_ACTIVATOR_ANNOTATION)
+                        continue;
+                    const kind = HANDLER_ANNOTATIONS.get(resolved);
+                    if (kind !== undefined)
+                        kinds.add(kind);
+                }
+                if (kinds.size === 0)
+                    continue;
+                const owner = ownerGraphNode(fact, indexes, nodeLookup, graph, getExactOwnerByRange);
+                if (owner === undefined || ownerClassLabel(owner.id) === 'Interface')
+                    continue;
+                const currentMultiplier = owner.properties.astFrameworkMultiplier ?? 1.0;
+                owner.properties.astFrameworkMultiplier = Math.max(currentMultiplier, SPRING_NON_HTTP_HANDLER_ENTRY_POINT_MULTIPLIER);
+                if (currentMultiplier < SPRING_NON_HTTP_HANDLER_ENTRY_POINT_MULTIPLIER ||
+                    (currentMultiplier === SPRING_NON_HTTP_HANDLER_ENTRY_POINT_MULTIPLIER &&
+                        owner.properties.astFrameworkReason === undefined)) {
+                    owner.properties.astFrameworkReason = handlerReason(kinds);
+                }
+            }
+        }
+    };
+}

package/dist/core/ingestion/frameworks/spring/resource-injection.d.ts

@@ -0,0 +1,5 @@
+import type { DiInjectionMatch } from '../../di-extractors/index.js';
+export declare const SPRING_RESOURCE_ANNOTATIONS: Set<string>;
+export declare function springResourceDefaultName(siteKind: string, memberName: string, dependencyCount: number): string | null;
+/** Build the conservative name-first Resource match shared by Java and Kotlin. */
+export declare function springResourceInjectionMatch(annotationText: string, defaultName: string, rawDeclaredType: string, location: string): DiInjectionMatch | null;

package/dist/core/ingestion/frameworks/spring/resource-injection.js

@@ -0,0 +1,91 @@
+import { normalizeSpringBeanType, parseSpringAnnotationArguments, parseStaticClassLiteral, parseStaticStringValues, } from './annotation-arguments.js';
+export const SPRING_RESOURCE_ANNOTATIONS = new Set([
+    'jakarta.annotation.Resource',
+    'javax.annotation.Resource',
+]);
+function singleNamedArgument(annotationText, name) {
+    const argumentsList = parseSpringAnnotationArguments(annotationText);
+    if (argumentsList === null || argumentsList.some((argument) => argument.name === undefined)) {
+        return null;
+    }
+    const matches = argumentsList.filter((argument) => argument.name === name);
+    if (matches.length > 1)
+        return null;
+    return matches.length === 0 ? { present: false } : { present: true, value: matches[0].value };
+}
+function staticSingleString(value) {
+    if (value === undefined)
+        return null;
+    const values = parseStaticStringValues(value);
+    return values !== null && values.length === 1 ? values[0] : null;
+}
+function javaBeansDecapitalize(value) {
+    if (value.length === 0)
+        return value;
+    if (value.length > 1 &&
+        value[0] !== value[0].toLowerCase() &&
+        value[1] !== value[1].toLowerCase()) {
+        return value;
+    }
+    return value[0].toLowerCase() + value.slice(1);
+}
+export function springResourceDefaultName(siteKind, memberName, dependencyCount) {
+    if (siteKind !== 'method')
+        return memberName;
+    if (dependencyCount !== 1 || !/^set[A-Z_$]/.test(memberName) || memberName.length <= 3) {
+        return null;
+    }
+    return javaBeansDecapitalize(memberName.slice(3));
+}
+/** Build the conservative name-first Resource match shared by Java and Kotlin. */
+export function springResourceInjectionMatch(annotationText, defaultName, rawDeclaredType, location) {
+    const nameArgument = singleNamedArgument(annotationText, 'name');
+    const typeArgument = singleNamedArgument(annotationText, 'type');
+    const lookupArgument = singleNamedArgument(annotationText, 'lookup');
+    const mappedNameArgument = singleNamedArgument(annotationText, 'mappedName');
+    if (nameArgument === null ||
+        typeArgument === null ||
+        lookupArgument === null ||
+        mappedNameArgument === null) {
+        return null;
+    }
+    for (const runtimeArgument of [lookupArgument, mappedNameArgument]) {
+        if (!runtimeArgument.present)
+            continue;
+        const value = staticSingleString(runtimeArgument.value);
+        if (value === null || value.length > 0)
+            return null;
+    }
+    const declaredType = normalizeSpringBeanType(rawDeclaredType);
+    if (declaredType === null)
+        return null;
+    let targetTypeName = declaredType;
+    if (typeArgument.present) {
+        const override = parseStaticClassLiteral(typeArgument.value ?? '');
+        if (override === null)
+            return null;
+        if (override.length > 0)
+            targetTypeName = override;
+    }
+    let selectedName = defaultName;
+    let explicitName = false;
+    if (nameArgument.present) {
+        const parsedName = staticSingleString(nameArgument.value);
+        if (parsedName === null)
+            return null;
+        if (parsedName.length > 0) {
+            selectedName = parsedName;
+            explicitName = true;
+        }
+    }
+    return {
+        targetTypeName,
+        cardinality: 'single',
+        namedSelection: {
+            name: selectedName,
+            reason: `${explicitName ? 'resource name' : 'default resource name'} "${selectedName}"`,
+            ...(!explicitName && !rawDeclaredType.includes('<') ? { fallbackToType: true } : {}),
+        },
+        reason: `Spring DI: @Resource ${location}: ${targetTypeName}`,
+    };
+}

package/dist/core/ingestion/import-resolvers/configs/csharp.js

@@ -24,7 +24,11 @@ export const csharpNamespaceStrategy = (rawImportPath, _filePath, ctx) => {
         }
         return null;
     }
-    const resolvedFiles = resolveCSharpImportInternal(rawImportPath, csharpConfigs, ctx.normalizedFileList, ctx.allFileList, ctx.index, evidence);
+    const resolvedFiles = resolveCSharpImportInternal(rawImportPath, csharpConfigs, 
+    // The Set, not `ctx.normalizedFileList`/`ctx.allFileList`: the resolver
+    // derives both from it through the same per-pass memo the ctx's own arrays
+    // come from, so this is the identical pair by a shorter route.
+    ctx.allFilePaths, ctx.index, evidence);
     if (resolvedFiles.length > 1) {
         const dirSuffix = resolveCSharpNamespaceDir(rawImportPath, csharpConfigs);
         if (dirSuffix) {

package/dist/core/ingestion/import-resolvers/configs/swift.js

@@ -31,6 +31,19 @@ import { SupportedLanguages } from '../../../../_shared/index.js';
  * stable reference and the index is built once — not once per import. A
  * fresh run produces a fresh array → a fresh index, so cross-run staleness
  * is impossible.
+ *
+ * DELIBERATELY NOT ON `import-resolvers/per-file-set.ts` (#2909 sweep): this is
+ * a TWO-input memo keyed on ONE of them. The index is a function of both
+ * `ctx` (`allFileList` + the index-aligned `normalizedFileList`) and `targets`,
+ * but the key is only `ctx.allFileList`, and `perFileSet`'s `build: (key) => T`
+ * hands the builder nothing but the key. It is sound here only because of an
+ * invariant OUTSIDE the memo — `targets` is `ctx.configs.swiftPackageConfig
+ * .targets`, so it shares `ctx`'s lifetime and cannot vary while
+ * `ctx.allFileList` is fixed — and `perFileSet` has no way to express "and this
+ * other input is pinned by the same lifetime". Re-keying on `ctx` to make
+ * `targets` derivable from the key would change what the cache is keyed on and
+ * force an unreachable null-config arm into the builder, so it is a behaviour
+ * change rather than a consolidation. Leave it hand-rolled.
  */
 const SWIFT_TARGET_INDEX_CACHE = new WeakMap();
 function getSwiftTargetIndex(ctx, targets) {

package/dist/core/ingestion/import-resolvers/csharp.d.ts

@@ -13,8 +13,16 @@ import type { CSharpProjectConfig, CSharpNamespaceEvidence } from '../language-c
  * The final unanchored suffix fallback is gated on `evidence` so BCL usings
  * (e.g. `System.Threading.Tasks`) can't match a coincidentally-named local
  * file (#1881). When `evidence` is omitted the fallback stays permissive.
+ *
+ * Takes the file SET, not the two materialized lists it used to take: both are
+ * derived here from the per-pass `getWorkspaceFileIndex` memo, which is where
+ * every caller already got them. That leaves one key shape for the indexes
+ * below and makes the `normalized`/`all` pairing structural rather than a
+ * contract the caller has to honour. `index` stays a parameter — the parity
+ * harness drives this resolver with and without one, and the no-index legs are
+ * a tested dimension, not a degenerate case.
  */
-export declare function resolveCSharpImportInternal(importPath: string, csharpConfigs: CSharpProjectConfig[], normalizedFileList: string[], allFileList: string[], index?: SuffixIndex, evidence?: CSharpNamespaceEvidence): string[];
+export declare function resolveCSharpImportInternal(importPath: string, csharpConfigs: CSharpProjectConfig[], allFilePaths: ReadonlySet<string>, index?: SuffixIndex, evidence?: CSharpNamespaceEvidence): string[];
 /**
  * Compute the directory suffix for a C# namespace import (for PackageMap).
  * Returns a suffix like "/ProjectDir/Models/" or null if no config matches.

package/dist/core/ingestion/import-resolvers/csharp.js

@@ -4,8 +4,171 @@
  * Strategy lives in configs/csharp.ts.
  * This file contains shared helpers for namespace-based resolution.
  */
+import { perFileSet } from './per-file-set.js';
+import { getWorkspaceFileIndex } from './workspace-file-index.js';
 import { suffixResolve } from './utils.js';
 import { csharpSuffixFallbackAllowed } from '../csharp-namespace-gate.js';
+/**
+ * Memoized on the file SET's identity, the same key every other per-file-set
+ * index in this pipeline uses: the orchestrator builds one Set per pass and
+ * threads it through every import, so this build runs once.
+ *
+ * It used to key on the `normalizedFileList` ARRAY, which was a second key
+ * shape and — more to the point — one no guard could instrument. Copying an
+ * array mints a fresh `WeakMap` key while traversing the SET zero extra times,
+ * so a `[...normalized]` copy at the adapter boundary rebuilt this index once
+ * per `using` while every scan-counting guard stayed green and only the timing
+ * bench noticed (#2911 review). Taking the array from
+ * `getWorkspaceFileIndex(allFilePaths)` inside the builder retires that shape:
+ * the only way to defeat the memo now is to copy the Set, which is exactly what
+ * `CountingSet` counts.
+ *
+ * It also retires a precondition. The cached positions index `normalized` while
+ * the emitted value is read from `all`; both now come from the same
+ * `getWorkspaceFileIndex` object, so the caller can no longer pair a position
+ * list against a differently-ordered array.
+ */
+const getCsharpNamespaceDirIndex = perFileSet((allFilePaths) => {
+    const { normalized: normalizedFileList } = getWorkspaceFileIndex(allFilePaths);
+    const dirsByLastSegment = new Map();
+    const positionsByDir = new Map();
+    const singleSegmentDirs = [];
+    for (let i = 0; i < normalizedFileList.length; i++) {
+        const normalized = normalizedFileList[i];
+        if (!normalized.endsWith('.cs'))
+            continue;
+        const lastSlash = normalized.lastIndexOf('/');
+        // A file with no directory can never match: the needle always ends with
+        // '/', so `indexOf` on a slash-free path is always -1.
+        if (lastSlash < 0)
+            continue;
+        const dir = normalized.slice(0, lastSlash);
+        let positions = positionsByDir.get(dir);
+        if (positions === undefined) {
+            positions = [];
+            positionsByDir.set(dir, positions);
+            const lastSegment = dir.slice(dir.lastIndexOf('/') + 1);
+            if (lastSegment === dir)
+                singleSegmentDirs.push(dir);
+            let dirs = dirsByLastSegment.get(lastSegment);
+            if (dirs === undefined) {
+                dirs = [];
+                dirsByLastSegment.set(lastSegment, dirs);
+            }
+            dirs.push(dir);
+        }
+        positions.push(i);
+    }
+    return { dirsByLastSegment, positionsByDir, singleSegmentDirs };
+});
+/**
+ * Every directory that could satisfy `dirPrefix`, as a superset — the exact
+ * test runs in `matchingDirPositions`.
+ *
+ * When `dirPrefix` contains a '/', its own slash forces a segment boundary in
+ * any matching directory: `H` ending with `…/<lastSeg>/` means `D` ends with
+ * `/<lastSeg>`, so `D`'s last segment IS `lastSeg` and the exact bucket is
+ * complete. Without a '/', `D`'s last segment only has to END with `dirPrefix`
+ * (`SubModels` for `Models`), which no single bucket holds, so the last-segment
+ * KEYS are swept. That is the one term here that is not O(matches), and it is
+ * O(distinct last segments), not O(directories): C# repos reuse `Models`,
+ * `Services`, `Controllers` under every project, so the sweep collapses on the
+ * layouts that actually occur. Measured at 200 000 `.cs` files, 25 000
+ * directories: 456 µs per import when every directory name is unique, 7.9 µs
+ * on a `SrcN/Models` layout. Closing the unique-name case needs a character-
+ * suffix map over the segments, which is the O(files × depth) memory shape
+ * `package-dir-index.ts` cites #2649 to avoid — a design change, not a tune.
+ *
+ * An empty `dirPrefix` would sweep every key and keep every directory, so it is
+ * answered from `singleSegmentDirs` instead: its needle is a bare '/', which
+ * only a slash-free directory can carry as its LAST slash.
+ */
+function* candidateDirs(index, dirPrefix) {
+    if (dirPrefix === '') {
+        yield* index.singleSegmentDirs;
+        return;
+    }
+    const lastSlash = dirPrefix.lastIndexOf('/');
+    if (lastSlash >= 0) {
+        const bucket = index.dirsByLastSegment.get(dirPrefix.slice(lastSlash + 1));
+        if (bucket !== undefined)
+            yield* bucket;
+        return;
+    }
+    for (const [lastSegment, dirs] of index.dirsByLastSegment) {
+        if (!lastSegment.endsWith(dirPrefix))
+            continue;
+        yield* dirs;
+    }
+}
+/** Positions of the `.cs` files in each directory matching `dirPrefix`. */
+function* matchingDirPositions(index, dirPrefix) {
+    for (const dir of candidateDirs(index, dirPrefix)) {
+        // `(dir + '/').endsWith(dirPrefix + '/')` IS `dir.endsWith(dirPrefix)` — the
+        // appended '/' only ever matches itself, so it decides nothing and BOTH
+        // concatenations go. Exhaustively verified, not assumed: 0 disagreements
+        // over every ordered pair of strings up to length 5 over `{a, b, '/'}`
+        // including '' (132 496 pairs). Measured 64.9 ns -> 18.4 ns per candidate
+        // (Node 22.18); the `dir + '/'` was paid once per candidate, on every sweep
+        // of the last-segment keys.
+        //
+        // Still deliberately UNANCHORED (no leading '/'), so `src/SubModels` keeps
+        // answering `Models` — see the derivation above. That is also exactly why
+        // the reduction empties this predicate out while `package-dir-index.ts`
+        // keeps its concatenations: one decorating term per side here, two there,
+        // and only the trailing one cancels.
+        //
+        // `endsWith` subsumes the length guard the `indexOf` form needed: a shorter
+        // `dir` is simply false, where `indexOf` returned -1 and
+        // `haystack.length - needle.length` could also be -1 and report a bogus
+        // match.
+        //
+        // Do NOT "finish the job" with the two-argument overload. `endsWith(search,
+        // endPosition)` measured 8.8-11.8 ns against 9.5-14.9 ns for the
+        // one-argument form across seven call-site shapes (Node 22.18) — a wash —
+        // and `dir.endsWith(dirPrefix, dir.length)` is character-for-character this
+        // same test anyway. There is nothing left here to win.
+        if (!dir.endsWith(dirPrefix))
+            continue;
+        const positions = index.positionsByDir.get(dir);
+        if (positions !== undefined)
+            yield positions;
+    }
+}
+/**
+ * Append every `.cs` file directly inside a directory matching `dirPrefix`, in
+ * `normalizedFileList` order — the order the single-pass scan emitted, which
+ * this function's callers return as the whole edge target list.
+ */
+function pushFilesDirectlyInNamespaceDir(index, dirPrefix, allFileList, results) {
+    // One matching directory is the overwhelmingly common case, and its positions
+    // are already ascending, so the first bucket is held by reference. A second
+    // one promotes it to a real accumulator that is appended to from then on —
+    // never re-spread per directory, which would cost O(files × dirs²) copies in
+    // a monorepo carrying the same namespace directory under many projects.
+    let first = null;
+    let merged = null;
+    for (const positions of matchingDirPositions(index, dirPrefix)) {
+        if (first === null) {
+            first = positions;
+            continue;
+        }
+        if (merged === null)
+            merged = [...first];
+        for (const position of positions)
+            merged.push(position);
+    }
+    if (first === null)
+        return;
+    if (merged === null) {
+        for (const position of first)
+            results.push(allFileList[position]);
+        return;
+    }
+    merged.sort((a, b) => a - b);
+    for (const position of merged)
+        results.push(allFileList[position]);
+}
 /**
  * Resolve a C# using-directive import path to matching .cs files (low-level helper).
  * Tries single-file match first, then directory match for namespace imports.
@@ -13,8 +176,17 @@ import { csharpSuffixFallbackAllowed } from '../csharp-namespace-gate.js';
  * The final unanchored suffix fallback is gated on `evidence` so BCL usings
  * (e.g. `System.Threading.Tasks`) can't match a coincidentally-named local
  * file (#1881). When `evidence` is omitted the fallback stays permissive.
+ *
+ * Takes the file SET, not the two materialized lists it used to take: both are
+ * derived here from the per-pass `getWorkspaceFileIndex` memo, which is where
+ * every caller already got them. That leaves one key shape for the indexes
+ * below and makes the `normalized`/`all` pairing structural rather than a
+ * contract the caller has to honour. `index` stays a parameter — the parity
+ * harness drives this resolver with and without one, and the no-index legs are
+ * a tested dimension, not a degenerate case.
  */
-export function resolveCSharpImportInternal(importPath, csharpConfigs, normalizedFileList, allFileList, index, evidence) {
+export function resolveCSharpImportInternal(importPath, csharpConfigs, allFilePaths, index, evidence) {
+    const { normalized: normalizedFileList, all: allFileList } = getWorkspaceFileIndex(allFilePaths);
     const namespacePath = importPath.replace(/\./g, '/');
     const results = [];
     for (const config of csharpConfigs) {
@@ -51,38 +223,73 @@ export function resolveCSharpImportInternal(importPath, csharpConfigs, normalize
         // 2. Try as directory: all .cs files directly inside (namespace import)
         if (index) {
             const dirFiles = index.getFilesInDir(dirPrefix, '.cs');
+            // `getFilesInDir` already answers "directly inside a directory `D` where
+            // `D === dirPrefix || D.endsWith('/' + dirPrefix)`" — its keys ARE
+            // segment-aligned directory suffixes. So for a non-empty `dirPrefix` the
+            // direct-child re-check this loop used to run cannot reject anything, and
+            // measurement agrees: zero rejections over 12 008 (prefix, candidate)
+            // pairs. It rejected before #2881 only because it asked `indexOf` for the
+            // FIRST `/<dirPrefix>/`, which is the rule that issue removed.
+            //
+            // That widening does not stay inside step 2's own bucket. This step
+            // returns as soon as it pushes anything, so a query it used to answer with
+            // nothing now also SUPPRESSES step 3, whose unanchored match set is a
+            // strict superset: over `SubModels/Models/F1.cs` + `SubModels/F3.cs`,
+            // `using App.Models` answered both through step 3 and now answers only the
+            // first through step 2. The new answer is the more precise one — a
+            // directory literally named `Models` beating a character-suffix hit on
+            // `SubModels` — and it is what this module's step-2-before-step-3 layering
+            // asks for, so it is kept rather than worked around. Pinned absolutely by
+            // the parity test, which is differentially blind to it (its frozen legacy
+            // copy moved in lockstep with this line).
+            //
+            // The empty prefix is the exception and keeps a real filter. `getDirMap`
+            // keys a file under every suffix of its DIRECTORY, so it emits the EMPTY
+            // one exactly when that directory's last component is empty: a leading '/'
+            // on a root-level file, or a doubled slash immediately before the file
+            // name. Probed against `getDirMap`'s own key emission:
+            //
+            //   src/X.cs   -> ['src:.cs']                        no empty key
+            //   /X.cs      -> [':.cs']                           empty key
+            //   a//X.cs    -> [':.cs', 'a/:.cs']                 empty key
+            //   /a/b/X.cs  -> ['b:.cs', 'a/b:.cs', '/a/b:.cs']   no empty key
+            //
+            // So the `''` bucket is not "one directory deep" on its own — `a//X.cs`
+            // sits in it two components down — while step 3 answers that same query
+            // from `singleSegmentDirs`, which is. Filtering on `D` holding no slash is
+            // what rejects `a//X.cs` and keeps steps 2 and 3 in agreement.
             for (const f of dirFiles) {
-                const normalized = f.replace(/\\/g, '/');
-                // Check it's a direct child by finding the dirPrefix and ensuring no deeper slashes
-                const prefixIdx = normalized.indexOf(dirPrefix + '/');
-                if (prefixIdx < 0)
-                    continue;
-                const afterDir = normalized.substring(prefixIdx + dirPrefix.length + 1);
-                if (!afterDir.includes('/')) {
-                    results.push(f);
-                }
-            }
-            if (results.length > 0)
-                return results;
-        }
-        // 3. Linear scan fallback for directory matching
-        if (results.length === 0) {
-            const dirTrail = dirPrefix + '/';
-            for (let i = 0; i < normalizedFileList.length; i++) {
-                const normalized = normalizedFileList[i];
-                if (!normalized.endsWith('.cs'))
-                    continue;
-                const prefixIdx = normalized.indexOf(dirTrail);
-                if (prefixIdx < 0)
-                    continue;
-                const afterDir = normalized.substring(prefixIdx + dirTrail.length);
-                if (!afterDir.includes('/')) {
-                    results.push(allFileList[i]);
+                if (dirPrefix === '') {
+                    const normalized = f.replace(/\\/g, '/');
+                    const lastSlash = normalized.lastIndexOf('/');
+                    if (lastSlash < 0 || normalized.slice(0, lastSlash).includes('/'))
+                        continue;
                 }
+                results.push(f);
             }
             if (results.length > 0)
                 return results;
         }
+        // 3. Directory matching, UNANCHORED.
+        //
+        // Not redundant with step 2, and not skippable when `index` is present:
+        // `getFilesInDir` is keyed on SEGMENT suffixes of a directory, while this
+        // leg's predicate is an unanchored ends-with one, so it additionally
+        // answers `Models` with `src/SubModels/` and `src/Models` with
+        // `vendor/mysrc/Models/`. It is also the only leg that answers an empty
+        // `dirPrefix` — the `relative = ''` branch above (the import IS the root
+        // namespace) with no `projectDir` to stand in for it — because
+        // `buildSuffixIndex` emits an empty directory suffix only for a path that
+        // BEGINS with '/', so over repo-relative paths `getFilesInDir('', '.cs')`
+        // is always empty. See `CsharpNamespaceDirIndex` above for the index that
+        // replaced the per-import Θ(files) scan this used to be (#2902).
+        //
+        // `results` is provably empty here: step 2 returns as soon as it pushes
+        // anything, and so does this leg, so every iteration of the config loop
+        // starts empty.
+        pushFilesDirectlyInNamespaceDir(getCsharpNamespaceDirIndex(allFilePaths), dirPrefix, allFileList, results);
+        if (results.length > 0)
+            return results;
     }
     // Fallback: suffix matching without namespace stripping (single file).
     // Gated on in-repo declared-namespace evidence (#1881).

package/dist/core/ingestion/import-resolvers/go.d.ts

@@ -3,6 +3,16 @@
  *
  * Strategy lives in configs/go.ts.
  * This file contains the shared helpers used by the strategy.
+ *
+ * **Reachability, as of #2929:** nothing in production calls either export
+ * today. The only path in is `configs/go.ts` → `createImportResolver` →
+ * the `importResolver` field on Go's `LanguageProvider`, and that field is
+ * read at exactly two lines — `import-target-adapter.ts:74-75` — whose two
+ * exports (`buildImportTargetWorkspace`,
+ * `resolveImportTargetAcrossLanguages`) have no importer anywhere but their
+ * own unit test. So this is a live-looking but currently unwired leg; the
+ * tests in `test/unit/import-resolvers/go-package-resolve.test.ts` are the
+ * only thing watching it.
  */
 import type { GoModuleConfig } from '../language-config.js';
 /**
@@ -14,4 +24,4 @@ export declare function resolveGoPackageDir(importPath: string, goModule: GoModu
  * Resolve a Go internal package import to all .go files in the package directory.
  * Returns an array of file paths.
  */
-export declare function resolveGoPackage(importPath: string, goModule: GoModuleConfig, normalizedFileList: string[], allFileList: string[]): string[];
+export declare function resolveGoPackage(importPath: string, goModule: GoModuleConfig, normalizedFileList: readonly string[], allFileList: readonly string[]): string[];