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

package/dist/core/ingestion/languages/rust/range-binding.js

@@ -2,54 +2,84 @@ import { getRustParser } from './query.js';
 import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe, ParseTimeoutError } from '../../../tree-sitter/safe-parse.js';
 import { logger } from '../../../logger.js';
+import { lookupBindingsAt } from '../../scope-resolution/scope/walkers.js';
 /**
- * Populate type bindings for patterns and iterators that the tree-sitter
- * query can't handle (they need runtime type lookup, not just syntax).
- *
- * Covers: for-loop element types, if-let/while-let pattern bindings,
- * match arm patterns, and struct destructuring.
- *
- * Runs in Phase 2 (after propagateImportedReturnTypes) so all cross-file
- * type bindings are available for lookup.
+ * Hold parsed trees for reuse across both prepass loops only when the whole
+ * Rust source fits this budget. Trees are much larger than their source, so a
+ * modest source cap keeps peak held-tree memory bounded; larger repos fall
+ * back to re-parsing per loop (unchanged RSS).
  */
-export function populateRustRangeBindings(parsedFiles, _indexes, ctx) {
+const TREE_REUSE_SOURCE_BUDGET_BYTES = 16 * 1024 * 1024;
+/**
+ * Parse `filePath`'s source once, honoring the caller's `treeCache` and, when
+ * provided, an in-function `store` so the two prepass loops share a single
+ * parse instead of re-parsing every file. Returns null when the source is
+ * missing or parsing times out.
+ */
+function getOrParseTree(parser, filePath, ctx, store) {
+    const cached = (ctx.treeCache?.get(filePath) ?? store?.get(filePath));
+    if (cached !== undefined)
+        return cached;
+    const sourceText = ctx.fileContents.get(filePath);
+    if (sourceText === undefined)
+        return null;
+    let tree;
+    try {
+        tree = parseSourceSafe(parser, sourceText, undefined, {
+            bufferSize: getTreeSitterBufferSize(sourceText),
+        });
+    }
+    catch (err) {
+        if (err instanceof ParseTimeoutError) {
+            logger.warn({ file: filePath }, 'rust range-binding: parse timed out, skipping file');
+            return null;
+        }
+        throw err;
+    }
+    store?.set(filePath, tree);
+    return tree;
+}
+export function populateRustRangeBindings(parsedFiles, indexes, ctx) {
     const parser = getRustParser();
     const allReturnTypes = new Map();
+    const ambiguousReturnTypes = new Set();
     const allFieldTypes = new Map();
+    const ambiguousFieldTypes = new Set();
+    // Per-defining-file, un-collapsed, FULL-generic return/field types. When a
+    // bare name is ambiguous (#2514) but the call site's `use` import pins a
+    // single definition, we resolve that definition's file here and read its
+    // untruncated type so a generic `Vec<Repo>` element type survives (#2514
+    // follow-up: import-disambiguated duplicates resolve like the compiler).
+    const returnTypeByFile = new Map();
+    const fieldTypeByFile = new Map();
+    // Parse each file once and reuse across both loops when the workspace fits
+    // the byte budget; otherwise re-parse per loop to bound RSS (see helper).
+    let totalSourceBytes = 0;
+    for (const parsed of parsedFiles) {
+        totalSourceBytes += ctx.fileContents.get(parsed.filePath)?.length ?? 0;
+    }
+    const treeStore = totalSourceBytes <= TREE_REUSE_SOURCE_BUDGET_BYTES ? new Map() : undefined;
     for (const parsed of parsedFiles) {
-        const sourceText = ctx.fileContents.get(parsed.filePath);
-        if (sourceText === undefined)
+        const tree = getOrParseTree(parser, parsed.filePath, ctx, treeStore);
+        if (tree === null)
             continue;
-        const cachedTree = ctx.treeCache?.get(parsed.filePath);
-        let tree;
-        if (cachedTree !== undefined) {
-            tree = cachedTree;
-        }
-        else {
-            try {
-                tree = parseSourceSafe(parser, sourceText, undefined, {
-                    bufferSize: getTreeSitterBufferSize(sourceText),
-                });
-            }
-            catch (err) {
-                if (err instanceof ParseTimeoutError) {
-                    logger.warn({ file: parsed.filePath }, 'rust range-binding: parse timed out, skipping file');
-                    continue;
-                }
-                throw err;
-            }
-        }
         for (const fn of tree.rootNode.descendantsOfType('function_item')) {
             const nameNode = fn.childForFieldName('name');
             const retType = fn.childForFieldName('return_type');
             if (nameNode !== null && retType !== null) {
                 const name = nameNode.text;
+                // Ambiguity is a latch, not a toggle: once a name has two or more
+                // workspace definitions it stays ambiguous for the rest of the
+                // prepass, regardless of duplicate count or file order (#2514).
                 if (allReturnTypes.has(name)) {
                     allReturnTypes.delete(name);
+                    ambiguousReturnTypes.add(name);
                 }
-                else {
+                else if (!ambiguousReturnTypes.has(name)) {
                     allReturnTypes.set(name, retType.text);
                 }
+                // Full-generic record per defining file for import-disambiguated lookup.
+                recordByFile(returnTypeByFile, parsed.filePath, name, retType.text);
             }
         }
         for (const structNode of tree.rootNode.descendantsOfType('struct_item')) {
@@ -67,47 +97,37 @@ export function populateRustRangeBindings(parsedFiles, _indexes, ctx) {
             }
             if (fields.size > 0) {
                 const name = nameNode.text;
+                // Same ambiguity latch as return types (#2514): a third same-named
+                // struct must not restore a resolvable global field map.
                 if (allFieldTypes.has(name)) {
                     allFieldTypes.delete(name);
+                    ambiguousFieldTypes.add(name);
                 }
-                else {
+                else if (!ambiguousFieldTypes.has(name)) {
                     allFieldTypes.set(name, fields);
                 }
+                // Full-generic record per defining file for import-disambiguated lookup.
+                recordByFile(fieldTypeByFile, parsed.filePath, name, fields);
             }
         }
+        // Publish per-type member bindings for the whole workspace before resolving
+        // assignments. Otherwise an importer processed before its defining file can
+        // miss a field or identity-method type solely because of file order.
+        const scopeMap = new Map(parsed.scopes.map((scope) => [scope.id, scope]));
+        processFieldTypeBindings(tree.rootNode, parsed, scopeMap);
+        processIdentityMethodBindings(parsed);
     }
     for (const parsed of parsedFiles) {
-        const sourceText = ctx.fileContents.get(parsed.filePath);
-        if (sourceText === undefined)
+        const tree = getOrParseTree(parser, parsed.filePath, ctx, treeStore);
+        if (tree === null)
             continue;
-        const cachedTree = ctx.treeCache?.get(parsed.filePath);
-        let tree;
-        if (cachedTree !== undefined) {
-            tree = cachedTree;
-        }
-        else {
-            try {
-                tree = parseSourceSafe(parser, sourceText, undefined, {
-                    bufferSize: getTreeSitterBufferSize(sourceText),
-                });
-            }
-            catch (err) {
-                if (err instanceof ParseTimeoutError) {
-                    logger.warn({ file: parsed.filePath }, 'rust range-binding: parse timed out, skipping file');
-                    continue;
-                }
-                throw err;
-            }
-        }
         const scopeMap = new Map(parsed.scopes.map((s) => [s.id, s]));
         const moduleScope = parsed.scopes.find((s) => s.kind === 'Module');
         if (moduleScope === undefined)
             continue;
-        processFieldTypeBindings(tree.rootNode, parsed, scopeMap);
-        processIdentityMethodBindings(parsed);
-        processForLoops(tree.rootNode, parsed, scopeMap, moduleScope, allReturnTypes);
+        processForLoops(tree.rootNode, parsed, scopeMap, moduleScope, allReturnTypes, indexes, returnTypeByFile);
         processPatternBindings(tree.rootNode, parsed, scopeMap, moduleScope);
-        processStructDestructuring(tree.rootNode, parsed, scopeMap, moduleScope, allFieldTypes);
+        processStructDestructuring(tree.rootNode, parsed, scopeMap, moduleScope, allFieldTypes, indexes, fieldTypeByFile);
         processPendingAssignments(tree.rootNode, parsed, parsedFiles, scopeMap, moduleScope, allReturnTypes);
     }
 }
@@ -154,7 +174,60 @@ function normalizeFieldType(text) {
         t = t.slice(lastColon + 2);
     return t.trim();
 }
-function processForLoops(root, parsed, scopeMap, moduleScope, allReturnTypes) {
+/** Get-or-create the inner map for `file` and record `name -> value`. */
+function recordByFile(byFile, file, name, value) {
+    let inner = byFile.get(file);
+    if (inner === undefined) {
+        inner = new Map();
+        byFile.set(file, inner);
+    }
+    inner.set(name, value);
+}
+/** Final segment of a dot-joined qualified name (`a.make` -> `make`), or the
+ *  bare name when the def carries no qualifier. */
+function simpleName(qualifiedName, bareName) {
+    if (qualifiedName === undefined)
+        return bareName;
+    const dot = qualifiedName.lastIndexOf('.');
+    return dot === -1 ? qualifiedName : qualifiedName.slice(dot + 1);
+}
+/** Distinct `(file, name)` definitions, in first-seen order. */
+function uniqueDefs(defs) {
+    const seen = new Set();
+    const out = [];
+    for (const d of defs) {
+        const key = `${d.file} ${d.name}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(d);
+    }
+    return out;
+}
+/**
+ * Resolve `name` at `moduleScope` to the value recorded in `byFile` for the one
+ * definition visible here, or null when zero or several are visible (which
+ * keeps the #2514 ambiguity latch). Mirrors Rust name resolution: explicit
+ * `use`/re-export imports and local defs shadow `use x::*` globs, so a glob is
+ * consulted only when no explicit binding names `name`, and even then only when
+ * exactly one glob-target file actually defines it.
+ */
+function resolveImportedDef(name, moduleScope, indexes, byFile) {
+    const explicit = uniqueDefs(lookupBindingsAt(moduleScope.id, name, indexes)
+        .filter((r) => r.origin === 'import' || r.origin === 'reexport' || r.origin === 'local')
+        .map((r) => ({ file: r.def.filePath, name: simpleName(r.def.qualifiedName, name) })));
+    const defs = explicit.length > 0
+        ? explicit
+        : uniqueDefs((indexes.imports.get(moduleScope.id) ?? [])
+            .filter((e) => e.kind === 'wildcard-expanded' &&
+            e.targetFile !== null &&
+            byFile.get(e.targetFile)?.has(name) === true)
+            .map((e) => ({ file: e.targetFile, name })));
+    if (defs.length !== 1)
+        return null;
+    return byFile.get(defs[0].file)?.get(defs[0].name) ?? null;
+}
+function processForLoops(root, parsed, scopeMap, moduleScope, allReturnTypes, indexes, returnTypeByFile) {
     for (const forNode of root.descendantsOfType('for_expression')) {
         const patternNode = forNode.childForFieldName('pattern');
         const valueNode = forNode.childForFieldName('value');
@@ -163,7 +236,7 @@ function processForLoops(root, parsed, scopeMap, moduleScope, allReturnTypes) {
         const varName = extractVarName(patternNode);
         if (varName === null)
             continue;
-        const elementType = resolveIterableElementType(valueNode, parsed, scopeMap, moduleScope, allReturnTypes);
+        const elementType = resolveIterableElementType(valueNode, parsed, scopeMap, moduleScope, allReturnTypes, indexes, returnTypeByFile);
         if (elementType === null)
             continue;
         const targetScope = findEnclosingFunctionScope(forNode, scopeMap) ?? moduleScope;
@@ -247,7 +320,7 @@ function processTupleStructPattern(patternNode, contextNode, parsed, scopeMap, m
     const targetScope = findEnclosingFunctionScope(contextNode, scopeMap) ?? moduleScope;
     injectTypeBinding(targetScope, varName, resolvedType);
 }
-function processStructDestructuring(root, parsed, scopeMap, moduleScope, allFieldTypes) {
+function processStructDestructuring(root, parsed, scopeMap, moduleScope, allFieldTypes, indexes, fieldTypeByFile) {
     for (const letNode of root.descendantsOfType('let_declaration')) {
         const patternNode = letNode.childForFieldName('pattern');
         if (patternNode === null || patternNode.type !== 'struct_pattern')
@@ -270,7 +343,13 @@ function processStructDestructuring(root, parsed, scopeMap, moduleScope, allFiel
                 continue;
             let fieldType = lookupFieldType(typeName, fieldName, parsed, scopeMap, moduleScope);
             if (fieldType === null) {
-                fieldType = allFieldTypes?.get(typeName)?.get(fieldName) ?? null;
+                fieldType = allFieldTypes.get(typeName)?.get(fieldName) ?? null;
+            }
+            if (fieldType === null) {
+                // Import-disambiguated duplicate struct (#2514 follow-up): the global
+                // field map is ambiguous, but a `use` import pins one definition.
+                const fields = resolveImportedDef(typeName, moduleScope, indexes, fieldTypeByFile);
+                fieldType = fields?.get(fieldName) ?? null;
             }
             if (fieldType !== null) {
                 injectTypeBinding(targetScope, fieldName, fieldType);
@@ -363,7 +442,7 @@ function processPendingAssignments(root, parsed, allParsedFiles, scopeMap, modul
         }
     }
 }
-function resolveIterableElementType(valueNode, parsed, scopeMap, moduleScope, allReturnTypes) {
+function resolveIterableElementType(valueNode, parsed, scopeMap, moduleScope, allReturnTypes, indexes, returnTypeByFile) {
     let iterableNode = valueNode;
     if (iterableNode.type === 'reference_expression') {
         iterableNode = iterableNode.firstNamedChild ?? iterableNode;
@@ -386,12 +465,19 @@ function resolveIterableElementType(valueNode, parsed, scopeMap, moduleScope, al
             }
         }
         if (func.type === 'identifier') {
-            const crossFileReturn = allReturnTypes?.get(func.text);
+            const crossFileReturn = allReturnTypes.get(func.text);
             if (crossFileReturn !== undefined)
                 return unwrapGeneric(crossFileReturn);
             const rawReturn = lookupRawFunctionReturnType(func.text, valueNode);
             if (rawReturn !== null)
                 return unwrapGeneric(rawReturn);
+            // Import-disambiguated duplicate: the bare-name map is ambiguous (#2514)
+            // but a `use` import pins one definition. Read its FULL return type
+            // here, BEFORE the scope-binding lookup below, because that binding is
+            // generic-truncated (`Vec<Repo>` becomes `Vec`), losing the element.
+            const importedReturn = resolveImportedDef(func.text, moduleScope, indexes, returnTypeByFile);
+            if (importedReturn !== null)
+                return unwrapGeneric(importedReturn);
             const returnType = lookupReturnTypeInScopes(func.text, parsed, scopeMap, moduleScope);
             if (returnType !== null)
                 return unwrapGeneric(returnType);

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

@@ -1,8 +1,10 @@
 import { SupportedLanguages } from '../../../../_shared/index.js';
 import { buildMro, defaultLinearize } from '../../scope-resolution/passes/mro.js';
+import { indexOnlyElementType } from '../../type-extractors/shared.js';
 import { rustProvider } from '../rust.js';
 import { rustArityCompatibility, rustMergeBindings, resolveRustImportTarget } from './index.js';
 import { populateRustOwners } from './method-owners.js';
+import { resolveRustQualifiedFreeCall } from './qualified-call.js';
 import { populateRustRangeBindings } from './range-binding.js';
 import { isClassLike, findClassBindingInScope, resolveAmbiguousInheritanceBaseViaImports, } from '../../scope-resolution/scope/walkers.js';
 import { resolveDefGraphId } from '../../scope-resolution/graph-bridge/ids.js';
@@ -37,7 +39,7 @@ import { generateId } from '../../../../lib/utils.js';
  * set from existing IMPLEMENTS edges so a worker-mode legacy emission (or a
  * re-resolution) is not duplicated.
  */
-function emitRustTraitImplEdges(graph, parsedFiles, nodeLookup, scopes) {
+function emitRustTraitImplEdges(graph, parsedFiles, nodeLookup, scopes, recordTypeArguments) {
     if (scopes === undefined)
         return;
     const emitted = new Set();
@@ -64,6 +66,13 @@ function emitRustTraitImplEdges(graph, parsedFiles, nodeLookup, scopes) {
             const traitGraphId = resolveDefGraphId(traitDef.filePath, traitDef, nodeLookup);
             if (structGraphId === undefined || traitGraphId === undefined)
                 continue;
+            // The instantiation the impl was written with — `impl Validator<String>
+            // for V` (#2912). Recorded against THIS edge's ids, not the pre-pass's:
+            // the pre-pass sources its edge from the enclosing def, and interface
+            // dispatch crosses the corrected one emitted here.
+            if (site.typeArguments !== undefined) {
+                recordTypeArguments?.(structGraphId, traitGraphId, site.typeArguments);
+            }
             const edgeKey = `${structGraphId}->${traitGraphId}`;
             if (emitted.has(edgeKey))
                 continue;
@@ -124,10 +133,20 @@ export const rustScopeResolver = {
     resolveImportTarget: (targetRaw, fromFile, allFilePaths, resolutionConfig) => resolveRustImportTarget(targetRaw, fromFile, allFilePaths, resolutionConfig),
     mergeBindings: (existing, incoming, scopeId) => rustMergeBindings(existing, incoming, scopeId),
     arityCompatibility: (callsite, def) => rustArityCompatibility(def, callsite),
+    resolveQualifiedFreeCall: (site, callerParsed, scopes, workspaceIndex, allFilePaths) => resolveRustQualifiedFreeCall(site, callerParsed, scopes, workspaceIndex, allFilePaths),
     buildMro: (graph, parsedFiles, nodeLookup) => buildRustMro(graph, parsedFiles, nodeLookup),
-    emitHeritageEdges: (graph, parsedFiles, nodeLookup, scopes) => emitRustTraitImplEdges(graph, parsedFiles, nodeLookup, scopes),
+    emitHeritageEdges: (graph, parsedFiles, nodeLookup, scopes, recordTypeArguments) => emitRustTraitImplEdges(graph, parsedFiles, nodeLookup, scopes, recordTypeArguments),
     populateOwners: (parsed) => populateRustOwners(parsed),
     isSuperReceiver: () => false,
+    // Subscript route only — Rust has no property-style collection view; `.iter()`
+    // / `.values()` are method calls the compound resolver's call branch handles.
+    //
+    // Fed the annotation AS WRITTEN (`&Vec<User>`, `HashMap<String, User>`), which
+    // `normalizeRustTypeName` had already collapsed to `User` by the time the fold
+    // saw it. Returning `undefined` is the answer "not a container" and makes the
+    // index step decline rather than fold onto the receiver's own class — an
+    // `Index`-impl type would otherwise take its own members as the element's.
+    elementTypeOf: indexOnlyElementType,
     populateRangeBindings: populateRustRangeBindings,
     fieldFallbackOnMethodLookup: false,
     hoistTypeBindingsToModule: true,

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

@@ -172,6 +172,23 @@ export const rustProvider = defineLanguage({
     emitScopeCaptures: emitRustScopeCaptures,
     cfgVisitor: createRustCfgVisitor(),
     interpretImport: interpretRustImport,
+    // `use` is a compile-time path alias, not a statement that runs. Writing one
+    // inside a function body — `fn f() { use crate::m::X; }`, which is legal —
+    // narrows where the NAME is visible and defers nothing: Rust has no
+    // module-initialization order in the JS/Python sense and permits intra-crate
+    // module cycles outright. `rust/query.ts` captures `(use_declaration)` and
+    // nothing else, so this covers every import form the pipeline sees; the
+    // structural twin is C++'s `using ns::name`, exempt under the same
+    // capability. Without this the central Pass-3 position rule would tag an
+    // fn-local `use` `runsOnlyWhenCalled` and `check --cycles` would drop a
+    // cycle it is part of.
+    //
+    // Deliberately the NARROW claim — position does not defer a Rust import. It
+    // is not a claim that no Rust import can create an initialization
+    // dependency; that is a bigger semantic question (statics, `OnceLock`,
+    // `lazy_static`) which this capability does not reach and should not be read
+    // as settling. See `LanguageProvider.importsExecuteWhereWritten`.
+    importsExecuteWhereWritten: false,
     interpretTypeBinding: interpretRustTypeBinding,
     bindingScopeFor: rustBindingScopeFor,
     importOwningScope: rustImportOwningScope,

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

@@ -35,14 +35,65 @@ import { nodeIfType, nodeToCapture, syntheticCapture, walkNamedTree, } from '../
 import { splitSwiftImport } from './import-decomposer.js';
 import { swiftQualifiedBaseTail } from './base-type.js';
 import { computeSwiftArityMetadata } from './arity-metadata.js';
-import { synthesizeSwiftReceiverBinding } from './receiver-binding.js';
+import { findEnclosingTypeDeclaration, synthesizeSwiftReceiverBinding, } from './receiver-binding.js';
 import { synthesizeSwiftSignatureBindings } from './signature-bindings.js';
 import { getSwiftParser, getSwiftScopeQuery } from './query.js';
+import { preprocessSwiftConditionalDirectives } from './conditional-directive-preprocess.js';
 import { recordCacheHit, recordCacheMiss } from './cache-stats.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';
+/**
+ * Name of the type that lexically owns `node` — the nearest enclosing
+ * `class_declaration` (which in tree-sitter-swift is also how `struct` and
+ * `extension` parse) or `protocol_declaration`.
+ *
+ * Qualifies a method def as `<Type>.<method>` (#2807 follow-up). Swift's
+ * structure phase already keys the graph node that way (`A.run#1`), but the
+ * resolver-side def carried only `run`, and the bridge's every label-scoped key
+ * is built from the def's name — so two classes in one file each declaring
+ * `func run` fell through to the label-agnostic simple key, which is
+ * first-write-wins. The result: EVERY call in both bodies was attributed to
+ * whichever `run` registered first, which collected duplicate edges while its
+ * twin collected none. Renaming one method, or moving it to another file, made
+ * both resolve — which is what identified the collision as name-keyed and
+ * per-file rather than positional.
+ *
+ * An `extension Foo` wraps the extended type in a `user_type`, which may be
+ * qualified (`extension Outer.Inner`) or carry generic arguments
+ * (`extension Set<Int>`), so the trailing `type_identifier` is taken — the
+ * spelling has to match the owner the structure phase used to build the node id.
+ *
+ * Both halves delegate rather than re-derive: `findEnclosingTypeDeclaration`
+ * (receiver-binding.ts) decides what the enclosing type IS, so a method's owner
+ * qualifier and its `self` binding cannot disagree, and `swiftBaseTypeIdentifier`
+ * reads the name STRUCTURALLY. An earlier version split the node text on `<` and
+ * `.`, which only approximates the tree: generic arguments live in a sibling
+ * `type_arguments` node that the walk skips outright.
+ */
+function swiftEnclosingTypeName(node) {
+    const typeNode = findEnclosingTypeDeclaration(node);
+    if (typeNode === null)
+        return null;
+    const nameNode = typeNode.childForFieldName('name');
+    if (nameNode === null)
+        return null;
+    const tail = swiftBaseTypeIdentifier(nameNode)?.text.trim() ?? '';
+    return tail.length > 0 ? tail : null;
+}
 /** Declaration anchors that carry function-like arity metadata. */
 const FUNCTION_DECL_TAGS = ['@declaration.method', '@declaration.constructor'];
+const SWIFT_CALLABLE_CAPTURE_OPTIONS = {
+    functionNodeTypes: new Set(['function_declaration', 'lambda_literal']),
+    callNodeTypes: new Set(['call_expression']),
+    parameterListNodeTypes: new Set(['value_arguments']),
+    parameterNodeTypes: new Set(['parameter']),
+    bindingNodeTypes: new Set(['property_declaration']),
+    assignmentNodeTypes: new Set(['assignment']),
+    identifierNodeTypes: new Set(['simple_identifier', 'type_identifier']),
+    extractFunctionParameters: (node) => node.namedChildren.filter((child) => child !== null && child.type === 'parameter'),
+};
 /** tree-sitter-swift node types that carry arity. */
 const FUNCTION_NODE_TYPES = [
     'function_declaration',
@@ -57,10 +108,16 @@ const RECEIVER_NODE_TYPES = [
 ];
 export function emitSwiftScopeCaptures(sourceText, _filePath, cachedTree) {
     // Reuse the parse phase's cached Tree when available; otherwise parse.
+    // `extractParsedFile` already applies `preprocessSource` on this path, but
+    // this emitter is also called directly (benchmarks, capture goldens, the
+    // scope-capture tripwire), and those callers must see the same program the
+    // pipeline does. The transform is idempotent, so applying it twice is a
+    // no-op; it is length-preserving, so offsets still index `sourceText`.
     let tree = cachedTree;
     if (tree === undefined) {
-        tree = parseSourceSafe(getSwiftParser(), sourceText, undefined, {
-            bufferSize: getTreeSitterBufferSize(sourceText),
+        const parseText = preprocessSwiftConditionalDirectives(sourceText);
+        tree = parseSourceSafe(getSwiftParser(), parseText, undefined, {
+            bufferSize: getTreeSitterBufferSize(parseText),
         });
         recordCacheMiss();
     }
@@ -97,6 +154,12 @@ export function emitSwiftScopeCaptures(sourceText, _filePath, cachedTree) {
                     continue;
                 }
             }
+            // 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); // defensive fallback
             continue;
         }
@@ -144,6 +207,12 @@ export function emitSwiftScopeCaptures(sourceText, _filePath, cachedTree) {
             if (seenReadSpans.has(span))
                 continue;
             seenReadSpans.add(span);
+            // 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;
         }
@@ -191,6 +260,20 @@ export function emitSwiftScopeCaptures(sourceText, _filePath, cachedTree) {
                 grouped['@declaration.name'] = syntheticCapture('@declaration.name', initNode, 'init');
             }
         }
+        // ── Qualify a method/constructor def with its owning type (#2807). ──
+        // Emitted before the `@scope.function` branch below, which pushes and
+        // `continue`s; a Swift `function_declaration` matches both patterns.
+        if (grouped['@declaration.qualified_name'] === undefined) {
+            const ownerTag = FUNCTION_DECL_TAGS.find((t) => grouped[t] !== undefined);
+            const declaredName = grouped['@declaration.name']?.text;
+            const declNode = ownerTag === undefined ? null : nodeMap[ownerTag];
+            if (ownerTag !== undefined && declaredName !== undefined && declNode != null) {
+                const owner = swiftEnclosingTypeName(declNode);
+                if (owner !== null) {
+                    grouped['@declaration.qualified_name'] = syntheticCapture('@declaration.qualified_name', declNode, `${owner}.${declaredName}`);
+                }
+            }
+        }
         // ── @scope.function: arity + receiver + signature bindings. ──────
         if (grouped['@scope.function'] !== undefined) {
             const fnNodeForArity = nodeIfType(nodeMap['@scope.function'] ??
@@ -198,6 +281,12 @@ export function emitSwiftScopeCaptures(sourceText, _filePath, cachedTree) {
                 nodeMap['@declaration.constructor'], ...FUNCTION_NODE_TYPES);
             if (fnNodeForArity !== null)
                 attachArityMetadata(grouped, fnNodeForArity);
+            // 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);
             const recvNode = nodeIfType(nodeMap['@scope.function'], ...RECEIVER_NODE_TYPES);
             if (recvNode !== null) {
@@ -247,6 +336,12 @@ export function emitSwiftScopeCaptures(sourceText, _filePath, cachedTree) {
                 grouped['@reference.arity'] = syntheticCapture('@reference.arity', callNode, String(countCallArguments(callNode)));
             }
         }
+        // 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);
     }
     // ── Emit inheritance references for scope-resolution EXTENDS / IMPLEMENTS ──
@@ -257,6 +352,7 @@ export function emitSwiftScopeCaptures(sourceText, _filePath, cachedTree) {
     // legacy heritage-capture leg (removed in #942), which the worker pipeline
     // drops for registry-primary languages (issue #1951).
     out.push(...synthesizeSwiftInheritanceReferences(tree.rootNode));
+    out.push(...synthesizeCallableFlowCaptures(tree.rootNode, SWIFT_CALLABLE_CAPTURE_OPTIONS));
     return out;
 }
 /**

package/dist/core/ingestion/languages/swift/conditional-directive-preprocess.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Blank nested Swift conditional-compilation directives before parsing.
+ *
+ * tree-sitter-swift 0.7.1 does not admit `directive` as a `class_body` child
+ * (`vendor/tree-sitter-swift/src/node-types.json`), so error recovery can
+ * discard the enclosing declaration. Replacing only the directive text with
+ * spaces preserves `.length`, line endings, and every declaration offset.
+ *
+ * ponytail: delete this file (and the `preprocessSource` wiring in `swift.ts`)
+ * once a vendored tree-sitter-swift release includes upstream PR #583 ("Allow
+ * #if/#elseif/#else/#endif directives inside type bodies"); see also upstream
+ * issue #298 and PR #599. `.github/vendored-grammars.json` has no `"hold"` on
+ * swift, so the bump bot will land that release on its own.
+ *
+ * A directive group is blanked only when **all** of these hold:
+ *
+ *   - it opens at `braceDepth > 0` — nesting, not indentation, is what the
+ *     grammar rejects; top-level directives are valid source-file members and
+ *     are left intact
+ *   - it is not inside a multiline string literal or a block comment — blanking
+ *     a line that carries a block-comment terminator would un-terminate the
+ *     comment and swallow the rest of the file, and blanking inside a literal
+ *     would rewrite program data
+ *   - every branch is brace-balanced. A group that splits a declaration header
+ *     (`#if` … `func f() async {` … `#else` … `func f() {` … `#endif`) leaves
+ *     one unmatched `{` once both branches survive, which re-parents every
+ *     later top-level declaration. Such a group degrades to the pre-fix
+ *     behavior instead.
+ *
+ * Known residuals, all of which degrade to "directive left in place" rather
+ * than to corrupted output: string interpolation is not parsed with full Swift
+ * expression fidelity, so a nested multiline string inside an interpolation can
+ * confuse the scanner; a bare `/…/` regex literal containing `/*` opens a
+ * phantom block comment; and a multiline extended regex literal is treated as
+ * ending at its first line.
+ *
+ * Byte length is *not* preserved when a blanked directive line carries
+ * non-ASCII trailing text (`  #if os(iOS) // 日本語 🔥` is 23 UTF-16 code units
+ * either way, but shrinks from 31 UTF-8 bytes to 23). C++ sidesteps this
+ * because UE macro tokens are ASCII-only; a Swift directive line can carry any
+ * trailing comment. Per the `LanguageProvider.preprocessSource` contract this is
+ * safe only while no consumer slices the original UTF-8 bytes by `startIndex`:
+ * node-tree-sitter reports UTF-16 code-unit indices, and every in-process
+ * consumer slices the JS string, whose `.length` *is* preserved.
+ *
+ * Must stay pure and idempotent — see `LanguageProvider.preprocessSource`.
+ */
+export declare function preprocessSwiftConditionalDirectives(sourceText: string): string;