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

package/dist/core/ingestion/languages/go/generic-type-parameters.js

@@ -0,0 +1,140 @@
+/**
+ * Stamp every generic interface in `parsedFiles` with its type-parameter names,
+ * read out of the declaration's own source text.
+ *
+ * WHY SOURCE TEXT AND NOT A CAPTURE. The tree has the list right there
+ * (`type_spec` carries a `type_parameters` field), and capturing it would be two
+ * lines. But captures run inside the PARSE WORKER, whose script is resolved from
+ * the compiled `dist/` build, and their output is additionally memoized by the
+ * parse cache and the durable ParsedFile store — so a capture-side change is
+ * invisible until a rebuild AND a cache-version bump, and silently wrong in
+ * between. Everything here runs on the main thread from data the pipeline
+ * already materialized, so it is correct on the first run and needs neither.
+ *
+ * The scan is exact rather than a grep over the file: an interface declaration
+ * owns a `Class` scope whose range spans exactly its `type_spec`
+ * (`Repo[T any] interface{ … }`), so the text is sliced by that range and the
+ * type parameters are, by grammar, whatever sits between the brackets that
+ * IMMEDIATELY follow the name. Comments and strings elsewhere in the file cannot
+ * reach it.
+ */
+export function stampGoInterfaceTypeParameters(parsedFiles, fileContents) {
+    for (const parsed of parsedFiles) {
+        // Deferred so a file with no interface declaration never indexes its lines.
+        let lines;
+        for (const scope of parsed.scopes) {
+            if (scope.kind !== 'Class')
+                continue;
+            const iface = scope.ownedDefs.find((def) => def.type === 'Interface');
+            if (iface?.qualifiedName === undefined)
+                continue;
+            if (lines === undefined) {
+                const source = fileContents.get(parsed.filePath);
+                if (source === undefined)
+                    break;
+                lines = { source, starts: buildLineStarts(source) };
+            }
+            const declaration = sliceRange(lines.source, lines.starts, scope.range);
+            if (declaration === undefined)
+                continue;
+            const names = goTypeParameterNames(declaration, simpleGoName(iface.qualifiedName));
+            if (names === undefined)
+                continue;
+            iface.goTypeParameters = names;
+        }
+    }
+}
+/** Read back a stamp, rejecting anything whose shape does not match — the
+ *  sidecar is optional and a hand-built fixture def carries none. */
+export function readGoTypeParameters(def) {
+    const names = def.goTypeParameters;
+    if (!Array.isArray(names) || names.length === 0)
+        return undefined;
+    return names.every((name) => typeof name === 'string') ? names : undefined;
+}
+/**
+ * The declared type-parameter names of `Name[…] interface{…}`, in source order,
+ * or `undefined` when the declaration is not generic.
+ *
+ * Go spec, Type parameter declarations: the list is comma-separated and one
+ * entry may declare SEVERAL names sharing one constraint — `[K, V any]` declares
+ * `K` and `V`, and `[S ~[]E, E any]` declares `S` and `E`. Each entry therefore
+ * contributes exactly its FIRST token as a name; anything after it is the
+ * constraint, which is not needed here (satisfaction of a constraint is a
+ * separate question from implementation of an interface, and constraints are
+ * never harvested as instantiations — see `interface-impls.ts`).
+ */
+function goTypeParameterNames(declaration, interfaceName) {
+    if (!declaration.startsWith(interfaceName))
+        return undefined;
+    if (declaration[interfaceName.length] !== '[')
+        return undefined;
+    const close = matchingGoDelimiter(declaration, interfaceName.length);
+    if (close === -1)
+        return undefined;
+    const names = [];
+    for (const entry of splitTopLevelGoList(declaration.slice(interfaceName.length + 1, close))) {
+        const name = /^[A-Za-z_][A-Za-z0-9_]*/.exec(entry)?.[0];
+        if (name === undefined)
+            return undefined;
+        names.push(name);
+    }
+    return names.length === 0 ? undefined : names;
+}
+/** Index of the delimiter closing the one at `open`, or -1 when unbalanced.
+ *  Tracks `[]`, `{}` and `()` together so an `interface{ M(a, b int) }`
+ *  constraint cannot end the list early. */
+export function matchingGoDelimiter(text, open) {
+    let depth = 0;
+    for (let i = open; i < text.length; i += 1) {
+        const ch = text[i];
+        if (ch === '[' || ch === '{' || ch === '(')
+            depth += 1;
+        else if (ch === ']' || ch === '}' || ch === ')') {
+            depth -= 1;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return -1;
+}
+/** Split on commas that are not nested inside brackets, braces or parens. */
+export function splitTopLevelGoList(text) {
+    const parts = [];
+    let depth = 0;
+    let start = 0;
+    for (let i = 0; i < text.length; i += 1) {
+        const ch = text[i];
+        if (ch === '[' || ch === '{' || ch === '(')
+            depth += 1;
+        else if (ch === ']' || ch === '}' || ch === ')')
+            depth -= 1;
+        else if (ch === ',' && depth === 0) {
+            parts.push(text.slice(start, i));
+            start = i + 1;
+        }
+    }
+    parts.push(text.slice(start));
+    return parts.map((part) => part.trim()).filter((part) => part.length > 0);
+}
+function simpleGoName(qualifiedName) {
+    const dot = qualifiedName.lastIndexOf('.');
+    return dot === -1 ? qualifiedName : qualifiedName.slice(dot + 1);
+}
+/** Offsets at which each 1-based line begins. */
+function buildLineStarts(source) {
+    const starts = [0, 0];
+    for (let i = 0; i < source.length; i += 1) {
+        if (source[i] === '\n')
+            starts.push(i + 1);
+    }
+    return starts;
+}
+/** `Range` is 1-based on lines and 0-based on columns (`syntheticCapture`). */
+function sliceRange(source, lineStarts, range) {
+    const start = lineStarts[range.startLine];
+    const end = lineStarts[range.endLine];
+    if (start === undefined || end === undefined)
+        return undefined;
+    return source.slice(start + range.startCol, end + range.endCol);
+}

package/dist/core/ingestion/languages/go/import-target.d.ts

@@ -1,4 +1,3 @@
-import type { GoModuleConfig } from '../../language-config.js';
 /**
  * Resolve a Go import path to ALL .go files in the matching package directory.
  *
@@ -8,14 +7,8 @@ import type { GoModuleConfig } from '../../language-config.js';
  * IMPORTS edge fanout AND binding materialization for every exported symbol in
  * the package.
  *
- * Strategy (first match wins):
- *   1. go.mod-based: strip module prefix, match package directory
- *   2. Non-go.mod / GOPATH: progressively shorter directory suffixes
+ * Strategy:
+ *   1. With go.mod: resolve only imports owned by that module
+ *   2. Without go.mod / GOPATH: progressively shorter directory suffixes
  */
 export declare function resolveGoImportTarget(targetRaw: string, _fromFile: string, allFilePaths: ReadonlySet<string>, resolutionConfig?: unknown): string | readonly string[] | null;
-/** Preserved for backward compat. */
-export interface GoResolveContext {
-    readonly fromFile: string;
-    readonly allFilePaths: ReadonlySet<string>;
-    readonly goModule?: GoModuleConfig;
-}

package/dist/core/ingestion/languages/go/import-target.js

@@ -1,3 +1,5 @@
+import { buildPackageDirIndex, filesDirectlyInPkgDir, sortedRootFiles, } from '../../import-resolvers/package-dir-index.js';
+import { perFileSet } from '../../import-resolvers/per-file-set.js';
 /**
  * Resolve a Go import path to ALL .go files in the matching package directory.
  *
@@ -7,23 +9,28 @@
  * IMPORTS edge fanout AND binding materialization for every exported symbol in
  * the package.
  *
- * Strategy (first match wins):
- *   1. go.mod-based: strip module prefix, match package directory
- *   2. Non-go.mod / GOPATH: progressively shorter directory suffixes
+ * Strategy:
+ *   1. With go.mod: resolve only imports owned by that module
+ *   2. Without go.mod / GOPATH: progressively shorter directory suffixes
  */
 export function resolveGoImportTarget(targetRaw, _fromFile, allFilePaths, resolutionConfig) {
     if (!targetRaw)
         return null;
     const goModule = resolutionConfig;
-    // 1) go.mod-based: strip module prefix, match directory
-    if (goModule != null &&
-        (targetRaw === goModule.modulePath || targetRaw.startsWith(`${goModule.modulePath}/`))) {
+    // 1) go.mod is authoritative: only this module's exact path or subpackages
+    //    can name files in the workspace. Standard-library and third-party
+    //    imports must not fall through to the suffix matcher below.
+    if (goModule != null) {
+        const ownedByModule = targetRaw === goModule.modulePath || targetRaw.startsWith(`${goModule.modulePath}/`);
+        if (!ownedByModule)
+            return null;
         const relativePkg = targetRaw === goModule.modulePath ? '' : targetRaw.slice(goModule.modulePath.length + 1); // e.g. "internal/models"
         const files = relativePkg === ''
             ? findRootPackageFiles(allFilePaths)
             : findAllFilesInPkgDir(allFilePaths, relativePkg);
         if (files.length > 0)
             return files;
+        return null;
     }
     // 2) Non-go.mod / GOPATH: progressively shorter directory suffixes.
     //    "github.com/xxx/yyy/pkg" → try "github.com/xxx/yyy/pkg/" → "xxx/yyy/pkg/" → "yyy/pkg/"
@@ -37,31 +44,28 @@ export function resolveGoImportTarget(targetRaw, _fromFile, allFilePaths, resolu
     }
     return null;
 }
+/** Go packages exclude `_test.go` files: they are a separate package. */
+function isGoPackageFile(normalized) {
+    return normalized.endsWith('.go') && !normalized.endsWith('_test.go');
+}
+/**
+ * Package index over the file set, memoized on the Set's identity (#2877).
+ *
+ * Every leg above used to walk all of `allFilePaths`, and the GOPATH fallback
+ * walks once per path segment — so without go.mod a single unresolved stdlib or
+ * third-party import ran the whole cascade before returning null and cost
+ * several full workspace scans, making resolution O(imports × files).
+ *
+ * The orchestrator hands the same Set to every import in a pass, so the index
+ * is built once per run. `resolveGoImportTarget` must therefore never copy the
+ * Set before this point — see `import-resolvers/workspace-file-index.ts`.
+ */
+const getGoPackageIndex = perFileSet((allFilePaths) => buildPackageDirIndex(allFilePaths, isGoPackageFile));
 function findRootPackageFiles(allFilePaths) {
-    const result = [];
-    for (const raw of allFilePaths) {
-        const normalized = raw.replace(/\\/g, '/');
-        if (normalized.includes('/'))
-            continue;
-        if (!normalized.endsWith('.go') || normalized.endsWith('_test.go'))
-            continue;
-        result.push(raw);
-    }
-    return result.sort();
+    return sortedRootFiles(getGoPackageIndex(allFilePaths));
 }
 function findAllFilesInPkgDir(allFilePaths, pkgPath) {
-    const pkgDir = '/' + pkgPath + '/';
-    const result = [];
-    for (const raw of allFilePaths) {
-        const normalized = '/' + raw.replace(/\\/g, '/');
-        if (!normalized.includes(pkgDir))
-            continue;
-        if (!normalized.endsWith('.go') || normalized.endsWith('_test.go'))
-            continue;
-        // Ensure file is directly in the package directory (not a subdirectory)
-        const afterPkg = normalized.substring(normalized.indexOf(pkgDir) + pkgDir.length);
-        if (!afterPkg.includes('/'))
-            result.push(raw);
-    }
-    return result;
+    // Deliberately UNSORTED, unlike the root leg: the previous single-pass scan
+    // emitted in Set-iteration order and `filesDirectlyInPkgDir` reproduces it.
+    return filesDirectlyInPkgDir(getGoPackageIndex(allFilePaths), pkgPath);
 }

package/dist/core/ingestion/languages/go/index.d.ts

@@ -10,7 +10,7 @@ export { synthesizeGoTypeBindings } from './type-binding.js';
 export { goArityCompatibility } from './arity.js';
 export { goMergeBindings } from './merge-bindings.js';
 export { goBindingScopeFor, goImportOwningScope, goReceiverBinding } from './simple-hooks.js';
-export { resolveGoImportTarget, type GoResolveContext } from './import-target.js';
+export { resolveGoImportTarget } from './import-target.js';
 export { populateGoPackageSiblings } from './package-siblings.js';
 export { populateGoRangeBindings } from './range-binding.js';
 export { detectGoInterfaceImplementations } from './interface-impls.js';

package/dist/core/ingestion/languages/go/interface-impls.d.ts

@@ -1,4 +1,12 @@
 import type { ParsedFile } from '../../../../_shared/index.js';
+import type { StructuralImplementationResult } from '../../scope-resolution/contract/scope-resolver.js';
 import type { SemanticModel } from '../../model/semantic-model.js';
 import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
-export declare function detectGoInterfaceImplementations(parsedFiles: readonly ParsedFile[], _indexes: ScopeResolutionIndexes, _model: SemanticModel): Map<string, string[]>;
+/** Which method set satisfied an interface. `value` implies pointer too. */
+export type GoReceiverForm = 'value' | 'pointer';
+/** One structural implementor plus the form in which it implements. */
+export type GoStructuralImplementor = {
+    readonly structDefId: string;
+    readonly receiverForm: GoReceiverForm;
+};
+export declare function detectGoInterfaceImplementations(parsedFiles: readonly ParsedFile[], _indexes: ScopeResolutionIndexes, _model: SemanticModel): StructuralImplementationResult;