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

package/dist/core/ingestion/languages/dart/extension-type-preprocess.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Rewrites Dart 3.3 `extension type Name(Type value)` headers into ordinary
+ * extension headers before tree-sitter sees the source. The vendored grammar
+ * currently recovers these declarations through an ERROR subtree, while the
+ * existing Dart ingestion path already handles `extension Name on Type`.
+ */
+export declare function preprocessDartExtensionTypes(sourceText: string): string;

package/dist/core/ingestion/languages/dart/extension-type-preprocess.js

@@ -0,0 +1,30 @@
+const DART_EXTENSION_TYPE_HEADER = /\b(extension)([ \t]+type[ \t]+(?:const[ \t]+)?)([A-Za-z_$][A-Za-z0-9_$]*)([ \t]*<[^()\r\n]*>)?([ \t]*)\(([^()\r\n]*)\)/g;
+function representationType(representation) {
+    const trimmed = representation.trim();
+    const match = /^(.*\S)\s+[A-Za-z_$][A-Za-z0-9_$]*$/.exec(trimmed);
+    const typeName = match?.[1]?.trim();
+    return typeName && typeName.length > 0 ? typeName : null;
+}
+/**
+ * Rewrites Dart 3.3 `extension type Name(Type value)` headers into ordinary
+ * extension headers before tree-sitter sees the source. The vendored grammar
+ * currently recovers these declarations through an ERROR subtree, while the
+ * existing Dart ingestion path already handles `extension Name on Type`.
+ */
+export function preprocessDartExtensionTypes(sourceText) {
+    return sourceText.replace(DART_EXTENSION_TYPE_HEADER, (match, extensionKeyword, extensionTypeGap, name, typeParameters, beforeRepresentation, representation) => {
+        const typeName = representationType(representation);
+        if (typeName === null)
+            return match;
+        const representationSpanLength = beforeRepresentation.length + representation.length + 2;
+        const rewrittenRepresentation = ` on ${typeName}`;
+        if (rewrittenRepresentation.length > representationSpanLength)
+            return match;
+        return (extensionKeyword +
+            ' '.repeat(extensionTypeGap.length) +
+            name +
+            (typeParameters ?? '') +
+            rewrittenRepresentation +
+            ' '.repeat(representationSpanLength - rewrittenRepresentation.length));
+    });
+}

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

@@ -12,7 +12,34 @@
  * The `ScopeResolver` hook signature is `(targetRaw, fromFile, allFilePaths)`;
  * `targetRaw` arrives already quote-stripped from `interpretDartImport`.
  */
+import { perFileSet } from '../../import-resolvers/per-file-set.js';
 import { DART_HERITAGE_PREFIX } from './interpret.js';
+const getDartFileIndex = perFileSet((allFilePaths) => {
+    const byBasename = new Map();
+    for (const fp of allFilePaths) {
+        const base = fp.slice(fp.lastIndexOf('/') + 1);
+        let bucket = byBasename.get(base);
+        if (bucket === undefined) {
+            bucket = [];
+            byBasename.set(base, bucket);
+        }
+        bucket.push(fp);
+    }
+    return { byBasename };
+});
+/** First file (in Set-iteration order) that IS `candidate` or ends with
+ *  `/<candidate>` — the exact predicate of the scans this replaces. */
+function findByPathSuffix(allFilePaths, candidate) {
+    const bucket = getDartFileIndex(allFilePaths).byBasename.get(candidate.slice(candidate.lastIndexOf('/') + 1));
+    if (bucket === undefined)
+        return null;
+    const suffix = '/' + candidate;
+    for (const fp of bucket) {
+        if (fp === candidate || fp.endsWith(suffix))
+            return fp;
+    }
+    return null;
+}
 /** Resolve a relative path against the importer's directory, normalizing
  *  `.`/`..` segments, then confirm it exists in the workspace file set. */
 function resolveRelative(rel, fromFile, allFilePaths) {
@@ -31,11 +58,7 @@ function resolveRelative(rel, fromFile, allFilePaths) {
     if (allFilePaths.has(target))
         return target;
     // Suffix fallback for absolute/rooted workspace paths.
-    for (const fp of allFilePaths) {
-        if (fp === target || fp.endsWith('/' + target))
-            return fp;
-    }
-    return null;
+    return findByPathSuffix(allFilePaths, target);
 }
 export function resolveDartImportTarget(targetRaw, fromFile, allFilePaths) {
     if (targetRaw.startsWith(DART_HERITAGE_PREFIX))
@@ -52,11 +75,11 @@ export function resolveDartImportTarget(targetRaw, fromFile, allFilePaths) {
         if (slash === -1)
             return null;
         const relPath = targetRaw.slice(slash + 1);
+        // Candidate priority is load-bearing: `lib/<rel>` before bare `<rel>`.
         for (const candidate of [`lib/${relPath}`, relPath]) {
-            for (const fp of allFilePaths) {
-                if (fp === candidate || fp.endsWith('/' + candidate))
-                    return fp;
-            }
+            const hit = findByPathSuffix(allFilePaths, candidate);
+            if (hit !== null)
+                return hit;
         }
         return null; // external package
     }

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

@@ -19,7 +19,7 @@
  *   - `scope-resolver.ts`    — `ScopeResolver` registered in `SCOPE_RESOLVERS`
  *   - `cache-stats.ts`       — PROF_SCOPE_RESOLUTION cache hit/miss counters
  */
-export { emitDartScopeCaptures } from './captures.js';
+export { emitDartScopeCaptures, dartScopeOwnsReceivers } from './captures.js';
 export { getDartCaptureCacheStats, resetDartCaptureCacheStats } from './cache-stats.js';
 export { interpretDartImport, interpretDartTypeBinding, normalizeDartType, DART_HERITAGE_PREFIX, } from './interpret.js';
 export { dartMergeBindings } from './merge-bindings.js';

package/dist/core/ingestion/languages/dart/index.js

@@ -19,7 +19,7 @@
  *   - `scope-resolver.ts`    — `ScopeResolver` registered in `SCOPE_RESOLVERS`
  *   - `cache-stats.ts`       — PROF_SCOPE_RESOLUTION cache hit/miss counters
  */
-export { emitDartScopeCaptures } from './captures.js';
+export { emitDartScopeCaptures, dartScopeOwnsReceivers } from './captures.js';
 export { getDartCaptureCacheStats, resetDartCaptureCacheStats } from './cache-stats.js';
 export { interpretDartImport, interpretDartTypeBinding, normalizeDartType, DART_HERITAGE_PREFIX, } from './interpret.js';
 export { dartMergeBindings } from './merge-bindings.js';

package/dist/core/ingestion/languages/dart/query.js

@@ -40,7 +40,15 @@ const DART_SCOPE_QUERY = `
 (enum_declaration) @scope.class
 
 ; ── Declarations — types ─────────────────────────────────────────────────────
-(class_definition name: (identifier) @declaration.name) @declaration.class
+; The type-parameter list is matched as an UNNAMED optional child: the Dart
+; grammar hangs \`type_parameters\` off \`class_definition\` without a field name.
+; Recording it is what lets instantiation-aware interface dispatch tell a type
+; VARIABLE (\`class Box<T> implements Validator<T>\`) from a concrete argument
+; (\`class V implements Validator<String>\`) — see #2912; absent parameters are
+; indistinguishable from a language that captures none, and read as unknown.
+(class_definition
+  name: (identifier) @declaration.name
+  (type_parameters)? @declaration.type-parameters) @declaration.class
 (mixin_declaration (identifier) @declaration.name) @declaration.trait
 (extension_declaration name: (identifier) @declaration.name) @declaration.class
 (enum_declaration name: (identifier) @declaration.name) @declaration.enum
@@ -90,6 +98,43 @@ const DART_SCOPE_QUERY = `
   (function_signature
     name: (identifier) @declaration.name) @declaration.function)
 
+; ── Declarations — closure bound to a local ──────────────────────────────────
+;
+; var handler = (int x) => target(x);   /   var blk = (int y) { ... };
+;
+; Anchor discipline (same contract as javascript/query.ts): @declaration.function
+; sits on the INNER function_expression, NOT on the local_variable_declaration
+; wrapper. Dart is the one language that declares NO @scope.function in this
+; file — its function scopes are SYNTHESIZED in captures.ts from
+; declNode + findFunctionBody(declNode). So this rule deliberately does not add
+; a @scope.function of its own: doing that would collide with the synthesized
+; one at identical range, and duplicate scope ids make buildScopeTree throw,
+; which drops the whole file. Instead findFunctionBody now understands a
+; closure's child function_expression_body, so the existing synthesis produces
+; exactly one scope, anchored on the same node as the declaration (#2699 S4).
+;; THREE binding shapes, not one. Dart wraps only the FIRST local declarator in
+;; initialized_variable_definition; a top-level var and every later declarator
+;; are initialized_identifier, and a top-level final/const is
+;; static_final_declaration. Matching only the first shape left idiomatic
+;; top-level closures and the g of "var f = ..., g = ..." with no declaration
+;; capture, so findFunctionBody never synthesized their scope and they could
+;; never be call SOURCES.
+;;
+;; This mirrors DART_CALLABLE_CAPTURE_OPTIONS.bindingNodeTypes in captures.ts,
+;; which already listed all three for callable-flow. The two lists must stay in
+;; step; dart-closure-binding-shapes.test.ts pins that.
+(initialized_variable_definition
+  (identifier) @declaration.name
+  (function_expression) @declaration.function)
+
+(initialized_identifier
+  (identifier) @declaration.name
+  (function_expression) @declaration.function)
+
+(static_final_declaration
+  (identifier) @declaration.name
+  (function_expression) @declaration.function)
+
 ; ── Declarations — methods (inside class/mixin/extension bodies) ─────────────
 (method_signature
   (function_signature
@@ -124,6 +169,58 @@ const DART_SCOPE_QUERY = `
     (initialized_identifier
       . (identifier) @declaration.name))) @declaration.property
 
+; Inference-typed fields — \`var b = Outer();\`, \`final b = Outer();\`,
+; \`late final b = Outer();\`, \`static var b = Outer();\` (#2807). The two
+; patterns above require a written type, so a field whose type comes from its
+; initializer produced NO property declaration at all — no Property node, and
+; nothing for captures.ts to hang a type binding on, so \`b.inner()\` could not
+; resolve its receiver while the annotated twin resolved fine.
+;
+; Dart spells the keyword as \`inferred_type\` for \`var\` and \`final_builtin\`
+; for \`final\` / \`late final\`; both are class fields and both are idiomatic,
+; so covering only one would leave the more common Dart style broken.
+(declaration
+  (inferred_type)
+  (initialized_identifier_list
+    (initialized_identifier
+      . (identifier) @declaration.name))) @declaration.property
+(declaration
+  (final_builtin)
+  (initialized_identifier_list
+    (initialized_identifier
+      . (identifier) @declaration.name))) @declaration.property
+
+; ── Declarations — closure bindings (#2693) ──────────────────────────────────
+; \`var f = (x) => x;\` binds a callable. Without a declaration the binding has
+; no SymbolDefinition, so callable-value-flow has nothing to attach its seed to
+; and \`f()\` stays unresolved even though the graph emits a Function node for it.
+;
+; Restricted to a function_expression value on purpose: declaring every Dart
+; variable would mint defs repo-wide for no resolution benefit. The top-level
+; rule is anchored under (program) — the same disambiguation the graph-node
+; query uses — so class-body fields, which reuse initialized_identifier_list
+; and are already @declaration.property, are never matched twice.
+(program
+  (initialized_identifier_list
+    (initialized_identifier
+      (identifier) @declaration.name
+      (function_expression))) @declaration.variable)
+(program
+  (static_final_declaration_list
+    (static_final_declaration
+      (identifier) @declaration.name
+      (function_expression))) @declaration.variable)
+(initialized_variable_definition
+  name: (identifier) @declaration.name
+  value: (function_expression)) @declaration.variable
+; Second and later declarators of \`var f = .., g = ..;\` are nested
+; initialized_identifier children of the same initialized_variable_definition,
+; which the field-based rule above only reaches for the first name.
+(initialized_variable_definition
+  (initialized_identifier
+    (identifier) @declaration.name
+    (function_expression)) @declaration.variable)
+
 ; ── Imports / re-exports ─────────────────────────────────────────────────────
 (import_or_export
   (library_import

package/dist/core/ingestion/languages/dart/scope-resolver.js

@@ -33,6 +33,7 @@ import { generateId } from '../../../../lib/utils.js';
 import { dartProvider } from '../dart.js';
 import { dartArityCompatibility, dartMergeBindings, resolveDartImportTarget } from './index.js';
 import { decodeMarker } from '../../utils/heritage-marker.js';
+import { typeApplicationArguments } from '../../utils/template-arguments.js';
 import { expandDartWildcardNames } from './expand-wildcards.js';
 /**
  * Resolve a class simple name to a graph id with FILE AFFINITY: prefer a
@@ -60,7 +61,7 @@ function pickClassByName(name, preferredFile, defsByName) {
  * which keeps cross-file same-name classes from collapsing (mirror of Ruby's
  * `emitRubyMixinEdges`, with the #1951-style file-affinity hardening).
  */
-function emitDartHeritageEdges(graph, parsedFiles, nodeLookup) {
+function emitDartHeritageEdges(graph, parsedFiles, nodeLookup, recordTypeArguments) {
     const defsByName = new Map();
     for (const parsed of parsedFiles) {
         for (const def of parsed.localDefs) {
@@ -97,11 +98,21 @@ function emitDartHeritageEdges(graph, parsedFiles, nodeLookup) {
             const parts = decoded.fields;
             if (parts.length < 3)
                 continue;
-            const [kind, baseName, childName] = parts;
+            const [kind, baseName, childName, rawTypeArguments] = parts;
             const childId = pickClassByName(childName, parsed.filePath, defsByName);
             const baseId = pickClassByName(baseName, parsed.filePath, defsByName);
             if (childId === undefined || baseId === undefined || childId === baseId)
                 continue;
+            // The instantiation this clause was written with — `implements
+            // Validator<String>` (#2912). Recorded before the dedup below, since the
+            // FIRST writer wins on both sides and an edge deduped here still needs
+            // its arguments. A marker from a pre-#2912 cache has no fourth field,
+            // which reads as unknown.
+            if (rawTypeArguments !== undefined) {
+                const typeArguments = typeApplicationArguments(rawTypeArguments);
+                if (typeArguments !== undefined)
+                    recordTypeArguments?.(childId, baseId, typeArguments);
+            }
             const key = `${childId}->${baseId}:${kind}`;
             if (emitted.has(key))
                 continue;
@@ -183,7 +194,7 @@ export const dartScopeResolver = {
     isSuperReceiver: (text) => text.trim() === 'super',
     // `implements` / `with` IMPLEMENTS edges (extends rides the generic
     // inherits pre-pass; these need an explicit, kind-independent edge type).
-    emitHeritageEdges: (graph, parsedFiles, nodeLookup) => emitDartHeritageEdges(graph, parsedFiles, nodeLookup),
+    emitHeritageEdges: (graph, parsedFiles, nodeLookup, _scopes, recordTypeArguments) => emitDartHeritageEdges(graph, parsedFiles, nodeLookup, recordTypeArguments),
     // Dart is statically typed — the field-fallback heuristic over-connects.
     fieldFallbackOnMethodLookup: false,
     propagatesReturnTypesAcrossImports: true,

package/dist/core/ingestion/languages/dart/simple-hooks.js

@@ -14,6 +14,7 @@
  *   - `dartReceiverBinding` — the implicit `this`/`super` receiver of a
  *     Function scope.
  */
+import { walkToScope } from '../../utils/scope-tree-walk.js';
 export function dartBindingScopeFor(decl, innermost, tree) {
     // (1) Return-type bindings hoist to the Module scope.
     if (decl['@type-binding.return'] !== undefined) {
@@ -28,6 +29,14 @@ export function dartBindingScopeFor(decl, innermost, tree) {
             return cur.id;
         return null;
     }
+    // (1b) A field typed from a constructor assigned to it (`r = Outer();` in a
+    // constructor body) must live on the CLASS scope — the assignment sits inside
+    // the constructor's own Function scope, where `typeOfMemberOnClass` never
+    // looks (#2807). Gated on the dedicated marker, never on
+    // `@type-binding.constructor` at large, which also fires for genuine locals.
+    if (decl['@type-binding.dart-field'] !== undefined) {
+        return walkToScope(innermost, tree, 'Class');
+    }
     // (2) Function/method/constructor names are visible in the enclosing scope.
     if (decl['@declaration.function'] !== undefined ||
         decl['@declaration.method'] !== undefined ||

package/dist/core/ingestion/languages/dart.js

@@ -27,8 +27,9 @@ import { createVariableExtractor } from '../variable-extractors/generic.js';
 import { dartVariableConfig } from '../variable-extractors/configs/dart.js';
 import { createCallExtractor } from '../call-extractors/generic.js';
 import { dartCallConfig } from '../call-extractors/configs/dart.js';
-import { emitDartScopeCaptures, interpretDartImport, interpretDartTypeBinding, dartBindingScopeFor, dartImportOwningScope, dartReceiverBinding, dartMergeBindings, dartArityCompatibility, } from './dart/index.js';
+import { emitDartScopeCaptures, dartScopeOwnsReceivers, interpretDartImport, interpretDartTypeBinding, dartBindingScopeFor, dartImportOwningScope, dartReceiverBinding, dartMergeBindings, dartArityCompatibility, } from './dart/index.js';
 import { DART_BUILT_INS } from './dart/built-ins.js';
+import { preprocessDartExtensionTypes } from './dart/extension-type-preprocess.js';
 /**
  * Resolve the enclosing function from a `function_body` node by looking at its
  * previous sibling.  In Dart's tree-sitter grammar, function_signature and
@@ -100,6 +101,7 @@ export const dartProvider = defineLanguage({
         },
     ],
     treeSitterQueries: DART_QUERIES,
+    preprocessSource: preprocessDartExtensionTypes,
     typeConfig: dartConfig,
     exportChecker: dartExportChecker,
     importResolver: createImportResolver(dartImportConfig),
@@ -117,6 +119,11 @@ export const dartProvider = defineLanguage({
     // emit-side `ScopeResolver` lives in `dart/scope-resolver.ts`; the same
     // function references flow through both interfaces.
     emitScopeCaptures: emitDartScopeCaptures,
+    // Dart's `ownsReceivers` masks FIELD NAMES a member body rebinds, not `this`
+    // (which Dart binds lexically in every closure form, so there is nothing to
+    // own). See `dartShadowedFieldsCapture` in `dart/captures.ts` for why the
+    // read side needs the mask and what it deliberately does not cover.
+    scopeOwnsReceivers: dartScopeOwnsReceivers,
     cfgVisitor: createDartCfgVisitor(),
     interpretImport: interpretDartImport,
     interpretTypeBinding: interpretDartTypeBinding,

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

@@ -7,6 +7,96 @@ import { synthesizeGoReceiverBinding } from './receiver-binding.js';
 import { synthesizeGoTypeBindings, extractSimpleTypeNameText } from './type-binding.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
+import { synthesizeCallableFlowCaptures } from '../../utils/callable-flow-captures.js';
+import { synthesizeReceiverChainCapture } from '../../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;
+}
 export function emitGoScopeCaptures(sourceText, _filePath, cachedTree) {
     let tree = cachedTree;
     if (tree === undefined) {
@@ -94,6 +184,12 @@ export function emitGoScopeCaptures(sourceText, _filePath, cachedTree) {
                     grouped['@declaration.return-type'] = 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.
+            synthesizeReceiverChainCapture(grouped, nodeMap['@reference.receiver']);
             out.push(grouped);
             continue;
         }
@@ -108,6 +204,39 @@ export function emitGoScopeCaptures(sourceText, _filePath, cachedTree) {
                 grouped['@reference.arity'] = syntheticCapture('@reference.arity', callNode, String(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.
+        synthesizeReceiverChainCapture(grouped, nodeMap['@reference.receiver']);
         out.push(grouped);
     }
     // Layer on type-binding synthesis (new/make/qualified composite literal)
@@ -136,6 +265,7 @@ export function emitGoScopeCaptures(sourceText, _filePath, cachedTree) {
         });
     }
     out.push(...synthesizeGoInheritanceReferences(tree.rootNode));
+    out.push(...synthesizeCallableFlowCaptures(tree.rootNode, GO_CALLABLE_CAPTURE_OPTIONS));
     return out;
 }
 /**
@@ -207,7 +337,12 @@ function synthesizeGoInheritanceReferences(root) {
                         continue;
                     // `field.type` is the embedded base — bare/qualified/generic, with any
                     // `*` pointer marker as an unnamed sibling token (already unwrapped).
-                    emitGoEmbedInheritance(field.childForFieldName('type'), out);
+                    // 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') {
@@ -218,7 +353,8 @@ function synthesizeGoInheritanceReferences(root) {
                     // `shouldSkipExtends`); a single-element `type_elem` is the embed.
                     if (elem.type !== 'type_elem' || elem.namedChildCount !== 1)
                         continue;
-                    emitGoEmbedInheritance(elem.namedChild(0), out);
+                    // An interface embed is never a pointer form.
+                    emitGoEmbedInheritance(elem.namedChild(0), out, false);
                 }
             }
         }
@@ -230,7 +366,7 @@ function synthesizeGoInheritanceReferences(root) {
  * 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) {
+function emitGoEmbedInheritance(baseNode, out, embeddedAsPointer) {
     if (baseNode === null)
         return;
     const nameNode = goEmbedBaseNameNode(baseNode);
@@ -239,6 +375,9 @@ function emitGoEmbedInheritance(baseNode, out) {
     out.push({
         '@reference.inherits': nodeToCapture('@reference.inherits', baseNode),
         '@reference.name': 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 } : {}),
     });
 }
 /**

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

@@ -0,0 +1,31 @@
+import type { ParsedFile, SymbolDefinition } from '../../../../_shared/index.js';
+/**
+ * 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 declare function stampGoInterfaceTypeParameters(parsedFiles: readonly ParsedFile[], fileContents: ReadonlyMap<string, string>): void;
+/** Read back a stamp, rejecting anything whose shape does not match — the
+ *  sidecar is optional and a hand-built fixture def carries none. */
+export declare function readGoTypeParameters(def: SymbolDefinition): readonly string[] | undefined;
+/** 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 declare function matchingGoDelimiter(text: string, open: number): number;
+/** Split on commas that are not nested inside brackets, braces or parens. */
+export declare function splitTopLevelGoList(text: string): string[];