cgraphx 2.0.1 → 2.0.3

package/dist/core/code/engine/core/ingestion/languages/swift/conditional-directive-preprocess.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preprocessSwiftConditionalDirectives = preprocessSwiftConditionalDirectives;
+/**
+ * A conditional-compilation directive occupying a whole line.
+ *
+ * `[^\S\r\n]` (horizontal whitespace) rather than `[ \t]` so NBSP /
+ * ideographic-space indentation and a leading BOM are recognized too. Leading
+ * whitespace is *not* required: nesting is decided from the scanner's brace
+ * depth, not from indentation (a column-0 `#if` inside a class body is exactly
+ * the shape that loses its enclosing declaration).
+ */
+const SWIFT_CONDITIONAL_DIRECTIVE_RE = /^[^\S\r\n]*#(if|elseif|else|endif)\b[^\r\n]*$/;
+/**
+ * Cheap whole-file precondition, mirroring `stripUeMacros`'s `HAS_UE_HINT`.
+ * Derived from the line pattern so the two can never drift apart.
+ */
+const HAS_CONDITIONAL_DIRECTIVE_HINT = new RegExp(SWIFT_CONDITIONAL_DIRECTIVE_RE.source, 'm');
+function hasTripleQuoteAt(line, index) {
+    return line.startsWith('"""', index);
+}
+/**
+ * Length of the multiline terminator at `index`, or 0.
+ *
+ * A plain `"""` string always closes at `"""`, whatever follows it — an
+ * adjacent `#` is the next token, not part of the delimiter. A raw `#"""`
+ * string closes at `"""` followed by *at least* its own pound count.
+ */
+function matchingMultilineCloseLength(line, index, poundCount) {
+    if (!hasTripleQuoteAt(line, index))
+        return 0;
+    if (poundCount === 0)
+        return 3;
+    return line.startsWith('#'.repeat(poundCount), index + 3) ? 3 + poundCount : 0;
+}
+function skipRegularString(line, startIndex, rawPoundCount) {
+    const endPounds = '#'.repeat(rawPoundCount);
+    let index = startIndex + (rawPoundCount > 0 ? rawPoundCount + 1 : 1);
+    while (index < line.length) {
+        if (line[index] === '"') {
+            if (rawPoundCount === 0)
+                return index + 1;
+            if (line.startsWith(endPounds, index + 1))
+                return index + 1 + rawPoundCount;
+        }
+        if (rawPoundCount === 0 && line[index] === '\\')
+            index++;
+        index++;
+    }
+    return line.length;
+}
+/**
+ * Skip an extended regex literal (`#/…/#`), whose body may legally contain
+ * `/*` — which would otherwise open a block comment that never closes.
+ * `slashIndex` points at the `/` that follows the opening pound run.
+ */
+function skipExtendedRegexLiteral(line, slashIndex, poundCount) {
+    const closePounds = '#'.repeat(poundCount);
+    let index = slashIndex + 1;
+    while (index < line.length) {
+        if (line[index] === '\\') {
+            index += 2;
+            continue;
+        }
+        if (line[index] === '/' && line.startsWith(closePounds, index + 1)) {
+            return index + 1 + poundCount;
+        }
+        index++;
+    }
+    return line.length;
+}
+function scanSwiftLine(line, state) {
+    let index = 0;
+    while (index < line.length) {
+        if (state.blockCommentDepth > 0) {
+            if (line.startsWith('/*', index)) {
+                state.blockCommentDepth++;
+                index += 2;
+            }
+            else if (line.startsWith('*/', index)) {
+                state.blockCommentDepth--;
+                index += 2;
+            }
+            else {
+                index++;
+            }
+            continue;
+        }
+        if (state.multilineStringPounds !== null) {
+            const closeLength = matchingMultilineCloseLength(line, index, state.multilineStringPounds);
+            if (closeLength > 0) {
+                state.multilineStringPounds = null;
+                index += closeLength;
+                continue;
+            }
+            // Non-raw multiline strings honour backslash escapes, so `\"""` is string
+            // data and not a terminator. Raw strings escape with `\#`, so a bare
+            // backslash there is literal.
+            index += state.multilineStringPounds === 0 && line[index] === '\\' ? 2 : 1;
+            continue;
+        }
+        if (line.startsWith('//', index))
+            return;
+        if (line.startsWith('/*', index)) {
+            state.blockCommentDepth = 1;
+            index += 2;
+            continue;
+        }
+        if (line[index] === '#') {
+            // Count the pound run exactly once and always advance past it, so a long
+            // run of bare `#` stays linear instead of being re-walked per character.
+            let poundCount = 1;
+            while (line[index + poundCount] === '#')
+                poundCount++;
+            const afterPounds = index + poundCount;
+            if (hasTripleQuoteAt(line, afterPounds)) {
+                state.multilineStringPounds = poundCount;
+                index = afterPounds + 3;
+            }
+            else if (line[afterPounds] === '"') {
+                index = skipRegularString(line, index, poundCount);
+            }
+            else if (line[afterPounds] === '/') {
+                index = skipExtendedRegexLiteral(line, afterPounds, poundCount);
+            }
+            else {
+                index = afterPounds;
+            }
+            continue;
+        }
+        if (hasTripleQuoteAt(line, index)) {
+            state.multilineStringPounds = 0;
+            index += 3;
+            continue;
+        }
+        if (line[index] === '"') {
+            index = skipRegularString(line, index, 0);
+            continue;
+        }
+        if (line[index] === '{')
+            state.braceDepth++;
+        else if (line[index] === '}')
+            state.braceDepth--;
+        index++;
+    }
+}
+/**
+ * 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`.
+ */
+function preprocessSwiftConditionalDirectives(sourceText) {
+    if (!HAS_CONDITIONAL_DIRECTIVE_HINT.test(sourceText))
+        return sourceText;
+    // Alternating [line, terminator, line, terminator, …, line]; joining it back
+    // reproduces the input byte for byte, including bare-`\r` endings.
+    const parts = sourceText.split(/(\r\n|\n|\r)/);
+    const state = {
+        blockCommentDepth: 0,
+        multilineStringPounds: null,
+        braceDepth: 0,
+    };
+    const openGroups = [];
+    let blankedAny = false;
+    for (let index = 0; index < parts.length; index += 2) {
+        const text = parts[index];
+        const insideLiteralOrComment = state.multilineStringPounds !== null || state.blockCommentDepth > 0;
+        const match = insideLiteralOrComment ? null : SWIFT_CONDITIONAL_DIRECTIVE_RE.exec(text);
+        const braceDepthAtStart = state.braceDepth;
+        scanSwiftLine(text, state);
+        const braceDelta = state.braceDepth - braceDepthAtStart;
+        const openGroup = openGroups[openGroups.length - 1];
+        if (match === null) {
+            if (openGroup !== undefined)
+                openGroup.currentBranchDelta += braceDelta;
+            continue;
+        }
+        // Directive lines are blanked as a unit, so their own braces (if any) never
+        // reach the parser and must not count toward a branch's balance.
+        if (match[1] === 'if') {
+            openGroups.push({
+                braceDepthAtStart,
+                directiveLines: [index],
+                totalDelta: 0,
+                allBranchesBalanced: true,
+                currentBranchDelta: 0,
+            });
+            continue;
+        }
+        // A `#else`/`#endif` with no open `#if` is malformed source — leave it be.
+        if (openGroup === undefined)
+            continue;
+        openGroup.directiveLines.push(index);
+        openGroup.totalDelta += openGroup.currentBranchDelta;
+        openGroup.allBranchesBalanced &&= openGroup.currentBranchDelta === 0;
+        openGroup.currentBranchDelta = 0;
+        if (match[1] !== 'endif')
+            continue;
+        openGroups.pop();
+        const parentGroup = openGroups[openGroups.length - 1];
+        // Every branch survives preprocessing, so the enclosing branch sees the sum
+        // — not one branch's delta.
+        if (parentGroup !== undefined)
+            parentGroup.currentBranchDelta += openGroup.totalDelta;
+        if (openGroup.braceDepthAtStart > 0 && openGroup.allBranchesBalanced) {
+            // Safe to mutate in place: every line of this group has already been
+            // scanned, and the decision never reopens.
+            for (const line of openGroup.directiveLines)
+                parts[line] = ' '.repeat(parts[line].length);
+            blankedAny = true;
+        }
+    }
+    return blankedAny ? parts.join('') : sourceText;
+}

package/dist/core/code/engine/core/ingestion/languages/swift/implicit-imports.js

@@ -0,0 +1,60 @@
+"use strict";
+/**
+ * Swift same-module implicit IMPORTS-edge emission for the
+ * `emitImplicitImportEdges` hook.
+ *
+ * Swift gives every file in a module (an SPM target) visibility of every
+ * other file's top-level declarations WITHOUT any `import` statement
+ * (whole-module visibility). The legacy DAG models this with File→File
+ * IMPORTS edges via `wireSwiftImplicitImports`; under registry-primary
+ * that wirer's `addImportEdge` is gated off, and the scope-resolution
+ * import pipeline (`emitImportEdges`) only materializes edges from
+ * finalized `ImportEdge`s — of which there are none here, because there
+ * is no syntactic `import`. This hook emits the missing edges directly.
+ *
+ * Module identity: Swift has no in-source `package X` marker. Module
+ * membership is the SPM target *subtree* (`Sources/<Target>/…`), threaded
+ * in via the SPM target map (`resolutionConfig` → `coerceSwiftTargets`)
+ * and grouped by `groupSwiftFilesBySpmTarget` — replicating legacy
+ * `groupSwiftFilesByTarget`. With no scanned source dir the map is null
+ * and all files form one `__default__` module (single-Xcode-project
+ * assumption). Every pair of distinct `.swift` files in the same module
+ * gets a directed IMPORTS edge in both directions (whole-module
+ * visibility is symmetric).
+ *
+ * Node identity + edge construction mirror the generic `emitImportEdges`
+ * convention (`graph-bridge/imports-to-edges.ts`): `generateId('File', path)`
+ * for endpoints and `generateId('IMPORTS', key)` for the relationship id,
+ * deduped by `(sourceFile -> targetFile)`. Re-invocation idempotency comes
+ * from `graph.addRelationship` id-dedup (the same `IMPORTS` id is produced
+ * for a given ordered pair), so no local `seen` set is needed.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitSwiftImplicitImportEdges = emitSwiftImplicitImportEdges;
+const utils_js_1 = require("../../../../lib/utils.js");
+const target_grouping_js_1 = require("./target-grouping.js");
+function emitSwiftImplicitImportEdges(graph, parsedFiles, _nodeLookup, resolutionConfig) {
+    // Group files by SPM target subtree (the module). No-source-dir → all
+    // files in one `__default__` bucket.
+    const targets = (0, target_grouping_js_1.coerceSwiftTargets)(resolutionConfig);
+    const filesByTarget = (0, target_grouping_js_1.groupSwiftFilesBySpmTarget)(parsedFiles, (parsed) => parsed.filePath, targets);
+    for (const [, group] of filesByTarget) {
+        if (group.length < 2)
+            continue; // no siblings to import
+        for (const source of group) {
+            for (const target of group) {
+                if (source.filePath === target.filePath)
+                    continue; // no self-import
+                const dedupKey = `${source.filePath}->${target.filePath}`;
+                graph.addRelationship({
+                    id: (0, utils_js_1.generateId)('IMPORTS', dedupKey),
+                    sourceId: (0, utils_js_1.generateId)('File', source.filePath),
+                    targetId: (0, utils_js_1.generateId)('File', target.filePath),
+                    type: 'IMPORTS',
+                    confidence: 1.0,
+                    reason: 'swift-scope: implicit module visibility',
+                });
+            }
+        }
+    }
+}

package/dist/core/code/engine/core/ingestion/languages/swift/import-decomposer.js

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * Decompose a Swift `import_declaration` into a `CaptureMatch` carrying
+ * the synthesized markers `@import.kind` / `@import.source` /
+ * `@import.name` / `@import.testable` that `interpretSwiftImport`
+ * consumes.
+ *
+ * Swift imports are whole-module (no named members), so this is 1:1 —
+ * one `import` produces exactly one import. The split layer exposes the
+ * module name and the `@testable` flag without pushing raw-text parsing
+ * into `interpret.ts`.
+ *
+ *   import Foundation        → kind=namespace, source=Foundation
+ *   import Foo.Bar           → kind=namespace, source=Foo (SPM target),
+ *                              name=Foo.Bar (full path, for reference)
+ *   @testable import MyApp   → kind=namespace, source=MyApp, testable=1
+ *
+ * Verified against tree-sitter-swift 0.7.1:
+ *   (import_declaration
+ *     (modifiers (attribute (user_type (type_identifier))))?   ; @testable / @_exported
+ *     (identifier (simple_identifier)+))                        ; one per dotted segment
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitSwiftImport = splitSwiftImport;
+const ast_helpers_js_1 = require("../../utils/ast-helpers.js");
+function splitSwiftImport(stmtNode) {
+    if (stmtNode.type !== 'import_declaration')
+        return null;
+    const spec = parseSwiftImport(stmtNode);
+    if (spec === null)
+        return null;
+    return buildImportMatch(stmtNode, spec);
+}
+function parseSwiftImport(node) {
+    let testable = false;
+    let identifierNode = null;
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child === null)
+            continue;
+        if (child.type === 'modifiers') {
+            // Any attribute whose text mentions `testable` flips the flag.
+            if (/\btestable\b/.test(child.text))
+                testable = true;
+        }
+        else if (child.type === 'identifier') {
+            identifierNode = child;
+        }
+    }
+    if (identifierNode === null)
+        return null;
+    // The module path is one or more simple_identifier children, one per
+    // dotted segment. The SPM target is the FIRST segment.
+    const segments = [];
+    for (let i = 0; i < identifierNode.namedChildCount; i++) {
+        const seg = identifierNode.namedChild(i);
+        if (seg !== null && seg.type === 'simple_identifier')
+            segments.push(seg.text);
+    }
+    if (segments.length === 0) {
+        // Fall back to the raw identifier text (e.g. a grammar shape we didn't
+        // anticipate). Split on `.` to recover the target segment.
+        const raw = identifierNode.text.trim();
+        if (raw === '')
+            return null;
+        const parts = raw.split('.');
+        return { source: parts[0], fullPath: raw, testable, atNode: node };
+    }
+    return {
+        source: segments[0],
+        fullPath: segments.join('.'),
+        testable,
+        atNode: node,
+    };
+}
+function buildImportMatch(stmtNode, spec) {
+    const m = {
+        '@import.statement': (0, ast_helpers_js_1.nodeToCapture)('@import.statement', stmtNode),
+        '@import.kind': (0, ast_helpers_js_1.syntheticCapture)('@import.kind', spec.atNode, 'namespace'),
+        '@import.source': (0, ast_helpers_js_1.syntheticCapture)('@import.source', spec.atNode, spec.source),
+        '@import.name': (0, ast_helpers_js_1.syntheticCapture)('@import.name', spec.atNode, spec.fullPath),
+    };
+    if (spec.testable) {
+        m['@import.testable'] = (0, ast_helpers_js_1.syntheticCapture)('@import.testable', spec.atNode, '1');
+    }
+    return m;
+}

package/dist/core/code/engine/core/ingestion/languages/swift/import-target.js

@@ -0,0 +1,84 @@
+"use strict";
+/**
+ * `resolveImportTarget` adapter for the Swift `ScopeResolver`.
+ *
+ * Swift's `import ModuleName` brings in a whole SPM target / framework
+ * module. The scope-resolution contract passes only `allFilePaths` (no
+ * `SwiftPackageConfig`), so we resolve a module name to the `.swift`
+ * files under a directory segment named after the module — the SPM
+ * convention `Sources/<Module>/*.swift` (and the common
+ * `<Module>/*.swift` layout). This needs no manifest parsing.
+ *
+ * Same-module (intra-target) visibility — the bulk of Swift cross-file
+ * resolution, which needs NO `import` statement — is handled separately
+ * by `populateSwiftTargetSiblings` (see `target-siblings.ts`). This
+ * adapter only resolves EXPLICIT `import` statements (cross-module).
+ *
+ * Returns all matching files (one ImportEdge per file, like Go's
+ * package resolver) so every exported symbol in the module materializes
+ * a binding. Returns `null` for external frameworks (Foundation, UIKit,
+ * …) that have no in-repo directory.
+ *
+ * Performance: the directory→files grouping is memoized on the stable
+ * `allFilePaths` Set identity (the same Set is threaded to every import
+ * in a run), so it is built once per run — NOT once per import. Mirrors
+ * Python's `getPythonFileIndex` WeakMap pattern (PR #1918).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSwiftImportTarget = resolveSwiftImportTarget;
+const SWIFT_MODULE_INDEX_CACHE = new WeakMap();
+function getSwiftModuleIndex(allFilePaths) {
+    const cached = SWIFT_MODULE_INDEX_CACHE.get(allFilePaths);
+    if (cached !== undefined)
+        return cached;
+    const byModule = new Map();
+    for (const raw of allFilePaths) {
+        const norm = raw.replace(/\\/g, '/');
+        if (!norm.endsWith('.swift'))
+            continue;
+        // Each interior directory segment is a candidate module name. A file
+        // `Sources/Models/User.swift` is attributed to module `Sources` and
+        // module `Models`; an `import Models` then resolves to it.
+        const segments = norm.split('/');
+        // Drop the filename (last segment); the rest are directory segments.
+        for (let i = 0; i < segments.length - 1; i++) {
+            const seg = segments[i];
+            if (seg === '')
+                continue;
+            let bucket = byModule.get(seg);
+            if (bucket === undefined) {
+                bucket = [];
+                byModule.set(seg, bucket);
+            }
+            bucket.push(raw);
+        }
+    }
+    const index = { byModule };
+    SWIFT_MODULE_INDEX_CACHE.set(allFilePaths, index);
+    return index;
+}
+function resolveSwiftImportTarget(parsedImport, workspaceIndex) {
+    const ctx = workspaceIndex;
+    // Duck-type the set (PR #1918 P2: don't `instanceof Set`).
+    const allFilePaths = ctx?.allFilePaths;
+    if (ctx === undefined ||
+        typeof ctx.fromFile !== 'string' ||
+        typeof allFilePaths?.has !== 'function' ||
+        typeof allFilePaths?.[Symbol.iterator] !== 'function') {
+        return null;
+    }
+    // Swift import target is the SPM module name (first dotted segment).
+    const targetRaw = parsedImport.targetRaw;
+    if (targetRaw === null || targetRaw === '')
+        return null;
+    const moduleName = targetRaw.split('.')[0];
+    if (moduleName === '')
+        return null;
+    const index = getSwiftModuleIndex(ctx.allFilePaths);
+    const files = index.byModule.get(moduleName);
+    if (files === undefined || files.length === 0)
+        return null; // external framework
+    // Exclude the importer itself (a file under `Foo/` importing `Foo`).
+    const out = files.filter((f) => f !== ctx.fromFile);
+    return out.length > 0 ? out : null;
+}

package/dist/core/code/engine/core/ingestion/languages/swift/index.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * Swift scope-resolution hooks (RFC #909 Ring 3, issue #937 — the final
+ * per-language migration).
+ *
+ * Public API barrel. Consumers import from this file rather than the
+ * individual modules.
+ *
+ * Module layout (each file is a single concern):
+ *
+ *   - `query.ts`             — tree-sitter query + lazy parser/query singletons
+ *   - `captures.ts`          — `emitSwiftScopeCaptures` orchestrator
+ *   - `import-decomposer.ts` — each `import` → ParsedImport-shaped captures
+ *   - `interpret.ts`         — capture-match → `ParsedImport` / `ParsedTypeBinding`
+ *   - `simple-hooks.ts`      — small/no-op hooks made explicit
+ *   - `receiver-binding.ts`  — synthesize `self` / `super` type-bindings
+ *   - `merge-bindings.ts`    — Swift import-vs-local precedence
+ *   - `arity.ts`             — Swift arity compatibility (count-primary)
+ *   - `arity-metadata.ts`    — synthesize arity metadata from declarations
+ *   - `import-target.ts`     — `(ParsedImport, WorkspaceIndex) → file path` adapter
+ *   - `target-grouping.ts`   — group same-module files by SPM target subtree
+ *   - `target-siblings.ts`   — same-SPM-target implicit cross-file visibility
+ *   - `implicit-imports.ts`  — same-SPM-target File→File IMPORTS edges
+ *   - `sibling-type-bindings.ts` — mirror sibling return-type typeBindings
+ *   - `scope-resolver.ts`    — `ScopeResolver` registered in `SCOPE_RESOLVERS`
+ *   - `cache-stats.ts`       — PROF_SCOPE_RESOLUTION cache hit/miss counters
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swiftReceiverBinding = exports.swiftImportOwningScope = exports.swiftBindingScopeFor = exports.mirrorSwiftSiblingTypeBindings = exports.emitSwiftImplicitImportEdges = exports.populateSwiftTargetSiblings = exports.coerceSwiftTargets = exports.groupSwiftFilesBySpmTarget = exports.resolveSwiftImportTarget = exports.swiftArityCompatibility = exports.swiftMergeBindings = exports.interpretSwiftTypeBinding = exports.interpretSwiftImport = exports.resetSwiftCaptureCacheStats = exports.getSwiftCaptureCacheStats = exports.emitSwiftScopeCaptures = void 0;
+var captures_js_1 = require("./captures.js");
+Object.defineProperty(exports, "emitSwiftScopeCaptures", { enumerable: true, get: function () { return captures_js_1.emitSwiftScopeCaptures; } });
+var cache_stats_js_1 = require("./cache-stats.js");
+Object.defineProperty(exports, "getSwiftCaptureCacheStats", { enumerable: true, get: function () { return cache_stats_js_1.getSwiftCaptureCacheStats; } });
+Object.defineProperty(exports, "resetSwiftCaptureCacheStats", { enumerable: true, get: function () { return cache_stats_js_1.resetSwiftCaptureCacheStats; } });
+var interpret_js_1 = require("./interpret.js");
+Object.defineProperty(exports, "interpretSwiftImport", { enumerable: true, get: function () { return interpret_js_1.interpretSwiftImport; } });
+Object.defineProperty(exports, "interpretSwiftTypeBinding", { enumerable: true, get: function () { return interpret_js_1.interpretSwiftTypeBinding; } });
+var merge_bindings_js_1 = require("./merge-bindings.js");
+Object.defineProperty(exports, "swiftMergeBindings", { enumerable: true, get: function () { return merge_bindings_js_1.swiftMergeBindings; } });
+var arity_js_1 = require("./arity.js");
+Object.defineProperty(exports, "swiftArityCompatibility", { enumerable: true, get: function () { return arity_js_1.swiftArityCompatibility; } });
+var import_target_js_1 = require("./import-target.js");
+Object.defineProperty(exports, "resolveSwiftImportTarget", { enumerable: true, get: function () { return import_target_js_1.resolveSwiftImportTarget; } });
+var target_grouping_js_1 = require("./target-grouping.js");
+Object.defineProperty(exports, "groupSwiftFilesBySpmTarget", { enumerable: true, get: function () { return target_grouping_js_1.groupSwiftFilesBySpmTarget; } });
+Object.defineProperty(exports, "coerceSwiftTargets", { enumerable: true, get: function () { return target_grouping_js_1.coerceSwiftTargets; } });
+var target_siblings_js_1 = require("./target-siblings.js");
+Object.defineProperty(exports, "populateSwiftTargetSiblings", { enumerable: true, get: function () { return target_siblings_js_1.populateSwiftTargetSiblings; } });
+var implicit_imports_js_1 = require("./implicit-imports.js");
+Object.defineProperty(exports, "emitSwiftImplicitImportEdges", { enumerable: true, get: function () { return implicit_imports_js_1.emitSwiftImplicitImportEdges; } });
+var sibling_type_bindings_js_1 = require("./sibling-type-bindings.js");
+Object.defineProperty(exports, "mirrorSwiftSiblingTypeBindings", { enumerable: true, get: function () { return sibling_type_bindings_js_1.mirrorSwiftSiblingTypeBindings; } });
+var simple_hooks_js_1 = require("./simple-hooks.js");
+Object.defineProperty(exports, "swiftBindingScopeFor", { enumerable: true, get: function () { return simple_hooks_js_1.swiftBindingScopeFor; } });
+Object.defineProperty(exports, "swiftImportOwningScope", { enumerable: true, get: function () { return simple_hooks_js_1.swiftImportOwningScope; } });
+Object.defineProperty(exports, "swiftReceiverBinding", { enumerable: true, get: function () { return simple_hooks_js_1.swiftReceiverBinding; } });

package/dist/core/code/engine/core/ingestion/languages/swift/interpret.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * Capture-match → semantic-shape interpreters for Swift.
+ *
+ *   - `interpretSwiftImport`      → `ParsedImport`
+ *   - `interpretSwiftTypeBinding`  → `ParsedTypeBinding`
+ *
+ * Import matches arrive pre-decomposed by `emitSwiftScopeCaptures` (one
+ * import per match, with synthesized `@import.kind/source/name` markers
+ * and an optional `@import.testable` flag). Type-binding matches arrive
+ * from the raw query captures — each `@type-binding.*` anchor carries
+ * `@type-binding.name` + `@type-binding.type`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interpretSwiftImport = interpretSwiftImport;
+exports.interpretSwiftTypeBinding = interpretSwiftTypeBinding;
+// ─── interpretImport ──────────────────────────────────────────────────────
+function interpretSwiftImport(captures) {
+    const sourceCap = captures['@import.source'];
+    if (sourceCap === undefined)
+        return null;
+    // Swift imports are whole-module (wildcard semantics): `import Foundation`
+    // brings the entire module into scope, no named members. The SPM target
+    // (first dotted segment) is the resolution target; the full path is kept
+    // as importedName for reference. `@testable` resolves identically to a
+    // plain import (same module is visible in test scope).
+    const source = sourceCap.text;
+    const fullPath = captures['@import.name']?.text ?? source;
+    return {
+        kind: 'namespace',
+        localName: source,
+        importedName: fullPath,
+        targetRaw: source,
+    };
+}
+// ─── interpretTypeBinding ─────────────────────────────────────────────────
+function interpretSwiftTypeBinding(captures) {
+    const nameCap = captures['@type-binding.name'];
+    const typeCap = captures['@type-binding.type'];
+    if (nameCap === undefined || typeCap === undefined)
+        return null;
+    // Normalize so receiver-typed resolution treats these identically:
+    //   `User?` / `User!`           → User   (optional / IUO)
+    //   `[User]`                    → User   (array sugar)
+    //   `Array<User>` / `Optional<User>` → User (single-arg generic)
+    //   `Foundation.URL`            → URL    (qualifier)
+    const rawType = stripQualifier(stripGeneric(stripArraySugar(stripOptional(typeCap.text.trim()))));
+    let source = 'parameter-annotation';
+    if (captures['@type-binding.self'] !== undefined)
+        source = 'self';
+    else if (captures['@type-binding.constructor'] !== undefined)
+        source = 'constructor-inferred';
+    else if (captures['@type-binding.annotation'] !== undefined)
+        source = 'annotation';
+    else if (captures['@type-binding.alias'] !== undefined)
+        source = 'assignment-inferred';
+    else if (captures['@type-binding.return'] !== undefined)
+        source = 'return-annotation';
+    return { boundName: nameCap.text, rawTypeName: rawType, source };
+}
+/** `User?` / `User!` → `User`. */
+function stripOptional(text) {
+    if (text.endsWith('?') || text.endsWith('!'))
+        return text.slice(0, -1).trim();
+    return text;
+}
+/** `[User]` → `User` (array sugar). `[K: V]` (dictionary) is left alone —
+ *  element semantics aren't unambiguous. */
+function stripArraySugar(text) {
+    if (text.startsWith('[') && text.endsWith(']') && !text.includes(':')) {
+        return text.slice(1, -1).trim();
+    }
+    return text;
+}
+/**
+ * Unwrap a single-arg generic collection wrapper — `Array<User>`,
+ * `Optional<User>`, `Set<User>` — to its element type. Mirrors C#'s
+ * `stripGeneric`. Multi-arg generics (`Dictionary<K, V>`,
+ * `Result<T, E>`) are left alone.
+ */
+function stripGeneric(text) {
+    const single = text.match(/^(?:[A-Za-z_][A-Za-z0-9_.]*\.)?(?:Array|Optional|Set|ContiguousArray|ArraySlice)<([^,<>]+)>$/);
+    if (single !== null)
+        return single[1].trim();
+    return text;
+}
+/** `Foundation.URL` → `URL`. */
+function stripQualifier(text) {
+    const lastDot = text.lastIndexOf('.');
+    if (lastDot === -1)
+        return text;
+    return text.slice(lastDot + 1);
+}