cgraphx 2.0.1 → 2.0.3

package/dist/core/code/engine/core/ingestion/languages/go/captures.js

@@ -0,0 +1,492 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitGoScopeCaptures = emitGoScopeCaptures;
+const ast_helpers_js_1 = require("../../utils/ast-helpers.js");
+const query_js_1 = require("./query.js");
+const cache_stats_js_1 = require("./cache-stats.js");
+const arity_metadata_js_1 = require("./arity-metadata.js");
+const import_decomposer_js_1 = require("./import-decomposer.js");
+const receiver_binding_js_1 = require("./receiver-binding.js");
+const type_binding_js_1 = require("./type-binding.js");
+const constants_js_1 = require("../../constants.js");
+const safe_parse_js_1 = require("../../../tree-sitter/safe-parse.js");
+const callable_flow_captures_js_1 = require("../../utils/callable-flow-captures.js");
+const receiver_chain_captures_js_1 = require("../../utils/receiver-chain-captures.js");
+/** Range for a capture that marks no source span. */
+const ZERO_RANGE = Object.freeze({ startLine: 0, startCol: 0, endLine: 0, endCol: 0 });
+/**
+ * The callee-position marker, allocated once for the whole process.
+ *
+ * This capture is a PRESENCE FLAG, not a payload: `scope-extractor.ts` reads it
+ * only as `match['@reference.callee-position'] !== undefined`, and the tag is
+ * listed in `KNOWN_SUB_TAGS`, so `anchorCaptureFor` never considers its range
+ * when picking a reference anchor. Nothing else in the pipeline touches it.
+ * (Its range used to duplicate `@reference.read`'s exactly, and that capture is
+ * still emitted, so the one place that scans every capture's range — the
+ * synthetic Module-scope span in `scope-extractor.ts` — sees the same maximum.)
+ *
+ * Minting it per site from the read node was therefore pure cost, and not a
+ * cheap one: `node.text` is an `input.substring` behind N-API index marshals,
+ * and `startPosition` / `endPosition` are two more round-trips each. A frozen
+ * singleton carries exactly the same information — its presence — for free.
+ */
+const CALLEE_POSITION_MARKER = Object.freeze({
+    name: '@reference.callee-position',
+    range: ZERO_RANGE,
+    text: '',
+});
+/**
+ * Presence-only marker for an embedded field written as `*T` rather than `T`.
+ *
+ * Go's method-set rules treat the two forms differently — `S{T}` promotes only
+ * the value-receiver methods of `T` into `MS(S)`, while `S{*T}` promotes both
+ * value- and pointer-receiver ones (go.dev/ref/spec#Struct_types). Structural
+ * interface detection cannot give an exact answer without knowing which was
+ * written, so the spelling is recorded here and interpreted downstream.
+ */
+const EMBEDDED_POINTER_MARKER = Object.freeze({
+    name: '@reference.embedded-pointer',
+    range: ZERO_RANGE,
+    text: '',
+});
+const GO_CALLABLE_CAPTURE_OPTIONS = {
+    functionNodeTypes: new Set(['function_declaration', 'method_declaration', 'func_literal']),
+    callNodeTypes: new Set(['call_expression']),
+    parameterListNodeTypes: new Set(['parameter_list', 'argument_list']),
+    parameterNodeTypes: new Set(['parameter_declaration', 'variadic_parameter_declaration']),
+    bindingNodeTypes: new Set(['short_var_declaration', 'var_spec']),
+    assignmentNodeTypes: new Set(['assignment_statement']),
+    identifierNodeTypes: new Set(['identifier', 'field_identifier', 'package_identifier']),
+    // Multi-value forms (`a, b := f, g`) pair LHS/RHS expression_list entries
+    // positionally — the shared field fallback cross-wired first-LHS with
+    // last-RHS and synthesized a garbage comma-joined qualified name (#2522
+    // review). A length mismatch (multi-return call RHS) recognizes the node
+    // but emits nothing.
+    extractAssignment: (node) => {
+        if (node.type !== 'short_var_declaration' && node.type !== 'assignment_statement') {
+            return undefined;
+        }
+        const left = node.childForFieldName('left');
+        const right = node.childForFieldName('right');
+        if (left === null || right === null)
+            return undefined;
+        if (left.type !== 'expression_list' || right.type !== 'expression_list')
+            return undefined;
+        const destinations = left.namedChildren.filter((child) => child !== null);
+        const sources = right.namedChildren.filter((child) => child !== null);
+        if (destinations.length <= 1 && sources.length <= 1)
+            return undefined;
+        if (destinations.length !== sources.length)
+            return [];
+        return destinations.map((destination, index) => ({ destination, source: sources[index] }));
+    },
+};
+/**
+ * Is this `selector_expression` in CALLEE position — the `function` child of an
+ * enclosing `call_expression` — rather than free-standing?
+ *
+ * `h.dep.Work` in `h.dep.Work()` is in callee position; `f := h.dep.Work` (a
+ * method value, or a func-typed field value) is not.
+ *
+ * Callee position alone does NOT make the selector a non-read. Go dispatches
+ * `h.dep.Work()` through a func-typed struct field just as readily as through a
+ * method, and this predicate cannot tell the two apart — `call_expression` has
+ * the same shape either way, and the tail's declaration may live in another
+ * package. See {@link emitGoScopeCaptures} for what is done with the answer.
+ */
+function isCalleeOfMemberCall(node) {
+    const parent = node.parent;
+    if (parent === null || parent.type !== 'call_expression')
+        return false;
+    return parent.childForFieldName('function')?.id === node.id;
+}
+function emitGoScopeCaptures(sourceText, _filePath, cachedTree) {
+    let tree = cachedTree;
+    if (tree === undefined) {
+        tree = (0, safe_parse_js_1.parseSourceSafe)((0, query_js_1.getGoParser)(), sourceText, undefined, {
+            bufferSize: (0, constants_js_1.getTreeSitterBufferSize)(sourceText),
+        });
+        (0, cache_stats_js_1.recordGoCacheMiss)();
+    }
+    else {
+        (0, cache_stats_js_1.recordGoCacheHit)();
+    }
+    const rawMatches = (0, query_js_1.getGoScopeQuery)().matches(tree.rootNode);
+    const out = [];
+    for (const m of rawMatches) {
+        const grouped = {};
+        // Parallel tag -> captured SyntaxNode map. The tree-sitter query already
+        // hands us the matched node as `c.node`; keeping it here lets us derive the
+        // anchor/relative node by walking LOCALLY (parent chain / own subtree)
+        // instead of re-walking from tree.rootNode (the O(matches x rootChildren)
+        // hotpath that made #1848's 250-struct DAO file take ~10s). The captured
+        // node either IS the node the old findNodeAtRange re-derived, or is a close
+        // relative reachable by a bounded local walk.
+        const nodeMap = {};
+        for (const c of m.captures) {
+            const tag = '@' + c.name;
+            if (tag.startsWith('@_'))
+                continue; // skip anonymous captures
+            grouped[tag] = (0, ast_helpers_js_1.nodeToCapture)(tag, c.node);
+            nodeMap[tag] = c.node;
+        }
+        if (Object.keys(grouped).length === 0)
+            continue;
+        if (grouped['@import.statement'] !== undefined) {
+            // The captured node is the `import_spec`; the original code preferred its
+            // enclosing `import_declaration` ONLY when that ancestor shares the exact
+            // same range (which never happens — the declaration always includes the
+            // `import` keyword prefix — so it falls back to the import_spec itself).
+            // Replicate that exactly via a local ancestor walk, never from root.
+            const importNode = resolveImportNode(nodeMap['@import.statement']);
+            if (importNode !== null) {
+                out.push(...(0, import_decomposer_js_1.splitGoImportStatement)(importNode));
+                continue;
+            }
+        }
+        if (grouped['@scope.function'] !== undefined) {
+            // @scope.function captures function_declaration | method_declaration |
+            // func_literal. The original looked for a function_declaration or
+            // method_declaration at the captured range; the captured node IS that
+            // node for the first two, and a func_literal never coincides in range
+            // with either, so the lookup yields null for func_literal.
+            const scopeNode = nodeMap['@scope.function'];
+            const fnNode = scopeNode.type === 'function_declaration' || scopeNode.type === 'method_declaration'
+                ? scopeNode
+                : null;
+            if (fnNode !== null) {
+                const receiver = (0, receiver_binding_js_1.synthesizeGoReceiverBinding)(fnNode);
+                if (receiver !== null)
+                    out.push(receiver);
+            }
+        }
+        if (isRawMultiAssignTypeBinding(nodeMap))
+            continue;
+        normalizeGenericConstructorCapture(nodeMap, grouped);
+        const declAnchorNode = nodeMap['@declaration.function'] ?? nodeMap['@declaration.method'];
+        if (declAnchorNode !== undefined) {
+            // @declaration.function / @declaration.method are captured directly on
+            // the function_declaration / method_declaration node.
+            const fnNode = declAnchorNode.type === 'function_declaration' ||
+                declAnchorNode.type === 'method_declaration' ||
+                declAnchorNode.type === 'method_elem'
+                ? declAnchorNode
+                : null;
+            if (fnNode !== null) {
+                const arity = (0, arity_metadata_js_1.computeGoDeclarationArity)(fnNode);
+                if (arity.parameterCount !== undefined) {
+                    grouped['@declaration.parameter-count'] = (0, ast_helpers_js_1.syntheticCapture)('@declaration.parameter-count', fnNode, String(arity.parameterCount));
+                }
+                if (arity.requiredParameterCount !== undefined) {
+                    grouped['@declaration.required-parameter-count'] = (0, ast_helpers_js_1.syntheticCapture)('@declaration.required-parameter-count', fnNode, String(arity.requiredParameterCount));
+                }
+                if (arity.parameterTypes !== undefined) {
+                    grouped['@declaration.parameter-types'] = (0, ast_helpers_js_1.syntheticCapture)('@declaration.parameter-types', fnNode, JSON.stringify(arity.parameterTypes));
+                }
+                if (arity.returnType !== undefined) {
+                    grouped['@declaration.return-type'] = (0, ast_helpers_js_1.syntheticCapture)('@declaration.return-type', fnNode, arity.returnType);
+                }
+            }
+            // Structural receiver chain for a call whose receiver is itself an
+            // expression, so resolution can type it by folding over structure
+            // instead of re-parsing the receiver's source text. Self-gating: a
+            // non-call match, an absent receiver, or a chain with no nameable base
+            // all leave `grouped` untouched.
+            (0, receiver_chain_captures_js_1.synthesizeReceiverChainCapture)(grouped, nodeMap['@reference.receiver']);
+            out.push(grouped);
+            continue;
+        }
+        // @reference.call.free / .member are captured on the call_expression;
+        // @reference.call.constructor on the composite_literal. The captured node
+        // IS the node the old findNodeAtRange re-derived for each, so use it.
+        const callNode = nodeMap['@reference.call.free'] ??
+            nodeMap['@reference.call.member'] ??
+            nodeMap['@reference.call.constructor'];
+        if (callNode !== undefined && grouped['@reference.arity'] === undefined) {
+            if (callNode.type === 'call_expression' || callNode.type === 'composite_literal') {
+                grouped['@reference.arity'] = (0, ast_helpers_js_1.syntheticCapture)('@reference.arity', callNode, String((0, arity_metadata_js_1.computeGoCallArity)(callNode)));
+            }
+        }
+        // Mark — do NOT drop — the read site on a member call's callee.
+        //
+        // The `@reference.read` pattern matches every `selector_expression`, so
+        // `h.dep.Work()` yields THREE sites: the call on `Work`, a read on the inner
+        // `h.dep` (the genuine field read), and a read on the OUTER `h.dep.Work`.
+        //
+        // That third site is a phantom ONLY when `Work` is a method: it then
+        // resolves through `findOwnedMember` (which prefers methods over fields) and
+        // emits an ACCESSES edge to the METHOD duplicating the CALLS edge at the
+        // same position — `v.impl.DoWork()` emitting both `CALLS -> DoWork` and
+        // `ACCESSES -> DoWork`.
+        //
+        // When `Work` is a FUNC-TYPED STRUCT FIELD (`Work func() error` — callback
+        // structs, hook structs, hand-rolled mocks) the very same syntax is a
+        // genuine field read followed by an indirect call through the value it
+        // holds, and that read is the field's only ACCESSES evidence. Dropping the
+        // site here deleted it (#2782 review).
+        //
+        // Method-vs-field is not knowable at capture: `call_expression` has the same
+        // shape either way and the tail's declaration may live in another package.
+        // So the capture layer records the POSITION and edge emission — which knows
+        // the resolved target's kind — decides. See `ReferenceSite.inCalleePosition`
+        // and `tryEmitEdge`.
+        const readNode = nodeMap['@reference.read'];
+        if (readNode !== undefined && isCalleeOfMemberCall(readNode)) {
+            grouped['@reference.callee-position'] = CALLEE_POSITION_MARKER;
+        }
+        // Structural receiver chain for a call whose receiver is itself an
+        // expression, so resolution can type it by folding over structure
+        // instead of re-parsing the receiver's source text. Self-gating: a
+        // non-call match, an absent receiver, or a chain with no nameable base
+        // all leave `grouped` untouched.
+        (0, receiver_chain_captures_js_1.synthesizeReceiverChainCapture)(grouped, nodeMap['@reference.receiver']);
+        out.push(grouped);
+    }
+    // Layer on type-binding synthesis (new/make/qualified composite literal)
+    const synthesized = (0, type_binding_js_1.synthesizeGoTypeBindings)(tree.rootNode);
+    out.push(...synthesized);
+    // Synthesize typeBindings for struct fields so compound receiver
+    // resolution (`user.Address.Save()`) can walk field types.
+    for (const match of out) {
+        if (match['@declaration.field'] === undefined)
+            continue;
+        const nameCap = match['@declaration.name'];
+        const typeCap = match['@declaration.field-type'];
+        if (nameCap === undefined || typeCap === undefined)
+            continue;
+        // Create a synthetic @type-binding.field match using the field
+        // name and its declared type from the @declaration.field-type capture.
+        // This lands in the Class scope's typeBindings (via pass4 positioning).
+        out.push({
+            '@type-binding.field': typeCap,
+            '@type-binding.name': nameCap,
+            '@type-binding.type': {
+                name: '@type-binding.type',
+                text: typeCap.text,
+                range: { ...typeCap.range },
+            },
+        });
+    }
+    out.push(...synthesizeGoInheritanceReferences(tree.rootNode));
+    out.push(...(0, callable_flow_captures_js_1.synthesizeCallableFlowCaptures)(tree.rootNode, GO_CALLABLE_CAPTURE_OPTIONS));
+    return out;
+}
+/**
+ * Synthesize `@reference.inherits` captures for Go struct embedding so the
+ * registry-primary scope-resolution path emits inheritance edges (mirrors C#
+ * `synthesizeCsharpInheritanceReferences` / C++ `emitCppInheritanceCaptures`).
+ * Without this, Go embedding edges came only from the legacy heritage-capture
+ * leg (removed in #942), which is dropped for registry-primary languages in the
+ * worker pipeline (issue #1951).
+ *
+ * Scope EXACTLY matches the legacy Go heritage query + its `shouldSkipExtends`
+ * hook (`heritage-extractors/configs/go.ts`), whose supertype alternation is
+ * `[(type_identifier) (qualified_type) (generic_type)]` (see `goHeritageShapes`)
+ * matched against BOTH struct embedding and interface-in-interface embedding:
+ *
+ *   struct:    (struct_type (field_declaration_list
+ *                (field_declaration type: <base>)))   — anonymous (no `name`) field
+ *   interface: (interface_type (type_elem <base>))    — single-element type_elem
+ *
+ * i.e. an embedded (anonymous) field inside a struct, or an embedded type inside
+ * an interface. Named struct fields (`Breed string`) are skipped because their
+ * `field_declaration` carries a `name` field; multi-operand interface type-sets
+ * (`int | float64`) are skipped because their `type_elem` has >1 named child —
+ * both matching the legacy `shouldSkipExtends` filter.
+ *
+ * The base shapes covered (issue #1951 — these were previously DROPPED by the
+ * registry-primary synth, so production silently omitted their edges even though
+ * the legacy heritage leg, config-driven since #1940, captured them):
+ *   - bare `type_identifier`  (`Base`)                       → the node itself
+ *   - `qualified_type`        (`pkg.Base`)                    → `name:` tail
+ *   - `generic_type`          (`Box[T]`)                      → `type:` base
+ *   - pointer embeds          (`*Base`, `*pkg.Base`, …)       → the `*` is an
+ *     unnamed token, so `field_declaration.type` already points at the inner
+ *     shape above; no `pointer_type` unwrap is needed in this grammar version.
+ *
+ * The captured `@reference.name` is reduced to its bare simple identifier so the
+ * V1 simple-name `findClassBindingInScope` contract keeps holding — `pkg.Base`
+ * → `Base`, `Box[T]` → `Box`. {@link goEmbedBaseNameNode} returns the node whose
+ * `.text` EQUALS `normalizeSupertypeName(base)` for every shape (verified by
+ * real-parse), so this synth stays at parity with the legacy leg's reduction.
+ * For a bare `type_identifier` it returns the same node, keeping the simple-base
+ * path byte-identical.
+ *
+ * The EXTENDS-vs-IMPLEMENTS split is decided downstream from the resolved
+ * target's symbol kind (`preEmitInheritanceEdges`): an embedded struct resolves
+ * to EXTENDS, an embedded interface to IMPLEMENTS.
+ */
+function synthesizeGoInheritanceReferences(root) {
+    const out = [];
+    (0, ast_helpers_js_1.walkNamedTree)(root, (node) => {
+        if (node.type !== 'type_declaration')
+            return;
+        for (const spec of node.namedChildren) {
+            if (spec.type !== 'type_spec')
+                continue;
+            const typeNode = spec.childForFieldName('type');
+            if (typeNode === null)
+                continue;
+            if (typeNode.type === 'struct_type') {
+                const fieldList = findNamedChildOfType(typeNode, 'field_declaration_list');
+                if (fieldList === null)
+                    continue;
+                for (const field of fieldList.namedChildren) {
+                    if (field.type !== 'field_declaration')
+                        continue;
+                    // Embedded (anonymous) field: no `name` field. Named fields are
+                    // skipped (legacy `shouldSkipExtends`).
+                    if (field.childForFieldName('name') !== null)
+                        continue;
+                    // `field.type` is the embedded base — bare/qualified/generic, with any
+                    // `*` pointer marker as an unnamed sibling token (already unwrapped).
+                    // That token is the ONLY record of `*T` versus `T`, and the two have
+                    // different method sets, so read it off the field text before it is
+                    // lost. An embedded field has no name, so a leading `*` can only be
+                    // the pointer marker.
+                    const embeddedAsPointer = field.text.trimStart().startsWith('*');
+                    emitGoEmbedInheritance(field.childForFieldName('type'), out, embeddedAsPointer);
+                }
+            }
+            else if (typeNode.type === 'interface_type') {
+                for (const elem of typeNode.namedChildren) {
+                    // Only `type_elem` (an embedded type); `method_elem` is a method, not
+                    // an embed. Multi-operand type-sets (`int | float64`) parse as a
+                    // `type_elem` with >1 named child — skip them (legacy
+                    // `shouldSkipExtends`); a single-element `type_elem` is the embed.
+                    if (elem.type !== 'type_elem' || elem.namedChildCount !== 1)
+                        continue;
+                    // An interface embed is never a pointer form.
+                    emitGoEmbedInheritance(elem.namedChild(0), out, false);
+                }
+            }
+        }
+    });
+    return out;
+}
+/**
+ * Emit one `@reference.inherits` / `@reference.name` match for a Go embed base
+ * node, reducing the name to its bare simple identifier. No-ops when `baseNode`
+ * is null or not one of the embed shapes.
+ */
+function emitGoEmbedInheritance(baseNode, out, embeddedAsPointer) {
+    if (baseNode === null)
+        return;
+    const nameNode = goEmbedBaseNameNode(baseNode);
+    if (nameNode === null)
+        return;
+    out.push({
+        '@reference.inherits': (0, ast_helpers_js_1.nodeToCapture)('@reference.inherits', baseNode),
+        '@reference.name': (0, ast_helpers_js_1.nodeToCapture)('@reference.name', nameNode),
+        // Added ONLY for the pointer form, so a value embed's capture set is
+        // byte-identical to what it was before this marker existed.
+        ...(embeddedAsPointer ? { '@reference.embedded-pointer': EMBEDDED_POINTER_MARKER } : {}),
+    });
+}
+/**
+ * Reduce a Go embed base node to its trailing bare `type_identifier`, matching
+ * the node shapes the legacy heritage query accepted (`goHeritageShapes`) and
+ * the reduction `normalizeSupertypeName` performs (verified by real-parse to
+ * yield an identical `.text` for each shape):
+ *   - `type_identifier`                          → the node itself (`Base`)
+ *   - `qualified_type` name: (type_identifier)   → the trailing `name:` id
+ *                                                  (`pkg.Base` → `Base`)
+ *   - `generic_type` type: <any of the above>    → recurse into `type:`
+ *                                                  (`Box[T]` → `Box`)
+ * Any other node type returns null (no edge), keeping this emitter at parity
+ * with the legacy leg.
+ */
+function goEmbedBaseNameNode(node) {
+    if (node.type === 'type_identifier')
+        return node;
+    if (node.type === 'qualified_type') {
+        const name = node.childForFieldName('name');
+        return name !== null ? goEmbedBaseNameNode(name) : null;
+    }
+    if (node.type === 'generic_type') {
+        const inner = node.childForFieldName('type');
+        return inner !== null ? goEmbedBaseNameNode(inner) : null;
+    }
+    return null;
+}
+/** First named child of `node` matching `type`, else null. */
+function findNamedChildOfType(node, type) {
+    for (const child of node.namedChildren) {
+        if (child.type === type)
+            return child;
+    }
+    return null;
+}
+/**
+ * Resolve the node passed to `splitGoImportStatement` for an @import.statement
+ * match. The capture is on the `import_spec`; the original preferred an
+ * `import_declaration` at the SAME range, else the import_spec. An
+ * import_declaration always includes the `import` keyword and so never shares
+ * the spec's exact range — the only candidate is an ancestor, and it can only
+ * match when ranges coincide. Walk the parent chain (bounded, local) for an
+ * import_declaration whose range equals the spec's; otherwise return the spec.
+ */
+function resolveImportNode(importSpec) {
+    let current = importSpec.parent;
+    while (current !== null) {
+        if (current.type === 'import_declaration') {
+            if (nodeRangeEquals(current, importSpec))
+                return current;
+            break;
+        }
+        // import_spec is nested at most under import_declaration ->
+        // import_spec_list -> import_spec; stop once we leave the import subtree.
+        if (current.type !== 'import_spec_list')
+            break;
+        current = current.parent;
+    }
+    return importSpec;
+}
+/** True iff two nodes occupy the exact same source range. */
+function nodeRangeEquals(a, b) {
+    return (a.startPosition.row === b.startPosition.row &&
+        a.startPosition.column === b.startPosition.column &&
+        a.endPosition.row === b.endPosition.row &&
+        a.endPosition.column === b.endPosition.column);
+}
+function normalizeGenericConstructorCapture(nodeMap, grouped) {
+    const typeNode = grouped['@type-binding.constructor'] !== undefined ? nodeMap['@type-binding.type'] : undefined;
+    if (typeNode !== undefined && typeNode.type === 'generic_type') {
+        const base = typeNode.childForFieldName('type');
+        if (base !== null) {
+            grouped['@type-binding.type'] = (0, ast_helpers_js_1.syntheticCapture)('@type-binding.type', base, (0, type_binding_js_1.extractSimpleTypeNameText)(base));
+        }
+    }
+    const referenceNode = grouped['@reference.call.constructor'] !== undefined ? nodeMap['@reference.name'] : undefined;
+    if (referenceNode !== undefined && referenceNode.type === 'generic_type') {
+        const base = referenceNode.childForFieldName('type');
+        if (base !== null) {
+            grouped['@reference.name'] = (0, ast_helpers_js_1.syntheticCapture)('@reference.name', base, (0, type_binding_js_1.extractSimpleTypeNameText)(base));
+        }
+    }
+}
+function isRawMultiAssignTypeBinding(nodeMap) {
+    const anchor = nodeMap['@type-binding.constructor'] ??
+        nodeMap['@type-binding.call-return'] ??
+        nodeMap['@type-binding.assertion'];
+    if (anchor === undefined)
+        return false;
+    // These tags are captured directly ON the short_var_declaration, so the
+    // captured node IS what the original findNodeAtRange(root, range,
+    // 'short_var_declaration') re-derived. The var_declaration (var-form)
+    // variants — @type-binding.assertion (`var x = e.(T)`) and
+    // @type-binding.call-return (`var x = Func()`) — anchor on a var_declaration
+    // instead; the old range+type lookup found no short_var_declaration at that
+    // range and returned null -> false, which this type guard reproduces exactly.
+    if (anchor.type !== 'short_var_declaration')
+        return false;
+    const node = anchor;
+    const lhs = node.childForFieldName('left');
+    const rhs = node.childForFieldName('right');
+    if (lhs === null)
+        return false;
+    if (rhs === null)
+        return false;
+    return (lhs.namedChildren.filter((c) => c.type === 'identifier').length >= 2 &&
+        rhs.namedChildren.length >= 2);
+}

package/dist/core/code/engine/core/ingestion/languages/go/expand-wildcards.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandGoDotImports = expandGoDotImports;
+exports.expandGoWildcardNames = expandGoWildcardNames;
+/**
+ * Expand Go dot imports (`import . "pkg"`) into binding augmentations.
+ *
+ * Go dot imports are treated as wildcard imports in the scope model.
+ * The shared `expandsWildcardTo` hook defaults to returning `[]` for Go
+ * because it can't easily access the target module's exported defs
+ * (it only receives a `ScopeId`). Instead we post-process wildcard
+ * import edges and augment bindings with the target file's exported
+ * (uppercase) defs — the same augmentation channel used by
+ * `populateGoPackageSiblings` for same-package cross-file visibility.
+ */
+function expandGoDotImports(parsedFiles, indexes) {
+    const augmentations = indexes.bindingAugmentations;
+    for (const parsed of parsedFiles) {
+        const moduleEdges = indexes.imports.get(parsed.moduleScope);
+        if (moduleEdges === undefined)
+            continue;
+        const wildcardTargets = [];
+        for (const edge of moduleEdges) {
+            // Go dot imports start as `kind: 'wildcard'`; finalize materializes
+            // them as `wildcard-expanded` import edges.
+            if (edge.kind !== 'wildcard-expanded' && edge.kind !== 'dynamic-resolved') {
+                continue;
+            }
+            if (edge.targetFile === null)
+                continue;
+            if (!wildcardTargets.includes(edge.targetFile))
+                wildcardTargets.push(edge.targetFile);
+        }
+        if (wildcardTargets.length === 0)
+            continue;
+        for (const targetFile of wildcardTargets) {
+            const targetModule = indexes.moduleScopes.byFilePath.get(targetFile);
+            if (targetModule === undefined)
+                continue;
+            // Walk target module's local bindings — these are the exported symbols.
+            const targetBindings = indexes.bindings.get(targetModule);
+            if (targetBindings === undefined)
+                continue;
+            for (const [name, refs] of targetBindings) {
+                if (name.length === 0)
+                    continue;
+                // V1: ASCII-only export check; Unicode uppercase identifiers (e.g. Ñame)
+                // are not recognized as exported. Conforms to Go community convention.
+                const first = name[0];
+                if (first < 'A' || first > 'Z')
+                    continue;
+                // Check if the importer already has this name.
+                const importerBindings = indexes.bindings.get(parsed.moduleScope);
+                if (importerBindings?.has(name))
+                    continue;
+                let augBucket = augmentations.get(parsed.moduleScope);
+                if (augBucket === undefined) {
+                    augBucket = new Map();
+                    augmentations.set(parsed.moduleScope, augBucket);
+                }
+                let entries = augBucket.get(name);
+                if (entries === undefined) {
+                    entries = [];
+                    augBucket.set(name, entries);
+                }
+                for (const ref of refs) {
+                    if (ref.origin !== 'local')
+                        continue;
+                    if (entries.some((e) => e.def.nodeId === ref.def.nodeId))
+                        continue;
+                    entries.push({ def: ref.def, origin: 'wildcard' });
+                }
+            }
+        }
+    }
+}
+function expandGoWildcardNames(targetModuleScope, parsedFiles) {
+    const target = parsedFiles.find((parsed) => parsed.moduleScope === targetModuleScope);
+    if (target === undefined)
+        return [];
+    const names = [];
+    for (const def of target.localDefs) {
+        const name = simpleName(def);
+        if (name === '')
+            continue;
+        // V1: ASCII-only export check; see expandGoDotImports for full note.
+        const first = name[0];
+        if (first < 'A' || first > 'Z')
+            continue;
+        if (!names.includes(name))
+            names.push(name);
+    }
+    return names;
+}
+function simpleName(def) {
+    return def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
+}