cgraphx 2.0.2 → 2.0.3

package/dist/core/code/engine/core/ingestion/languages/swift/merge-bindings.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * Swift shadowing precedence for the `mergeBindings` hook.
+ *
+ * Tier ranking (lower wins in shadowing):
+ *
+ *   - 0: `local` — a type member, method, local var, or parameter
+ *        declared in this scope.
+ *   - 1: `import` / `namespace` / `reexport` — names brought in by an
+ *        `import ModuleName` (whole-module, including `@testable`).
+ *   - 2: `wildcard` — reserved; Swift's whole-module import already
+ *        behaves like a namespace tier, so this is rarely populated.
+ *
+ * Swift resolves an ambiguity between two imported modules by requiring
+ * an explicit `Module.Symbol` qualifier; for receiver-typed dispatch we
+ * treat all imports as one tier. Locals always shadow imports.
+ *
+ * Within a surviving tier we de-dup by `DefId`, last-write-wins.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swiftMergeBindings = swiftMergeBindings;
+const TIER_LOCAL = 0;
+const TIER_IMPORT = 1;
+const TIER_WILDCARD = 2;
+const TIER_UNKNOWN = 3;
+function tierOf(b) {
+    switch (b.origin) {
+        case 'local':
+            return TIER_LOCAL;
+        case 'reexport':
+        case 'import':
+        case 'namespace':
+            return TIER_IMPORT;
+        case 'wildcard':
+            return TIER_WILDCARD;
+        default:
+            return TIER_UNKNOWN;
+    }
+}
+function swiftMergeBindings(bindings) {
+    if (bindings.length === 0)
+        return bindings;
+    let bestTier = Number.POSITIVE_INFINITY;
+    for (const b of bindings)
+        bestTier = Math.min(bestTier, tierOf(b));
+    const survivors = bindings.filter((b) => tierOf(b) === bestTier);
+    const seen = new Map();
+    for (const b of survivors)
+        seen.set(b.def.nodeId, b);
+    return [...seen.values()];
+}

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

@@ -0,0 +1,226 @@
+"use strict";
+/**
+ * Tree-sitter query for Swift scope captures (RFC §5.1).
+ *
+ * Captures the structural skeleton the generic scope-resolution
+ * pipeline consumes: scopes (module/class/function), declarations
+ * (class-likes, methods, init, properties), imports, type bindings
+ * (parameter annotations, property/field annotations, constructor
+ * inference, receiver self), and references (call sites, member calls).
+ *
+ * Swift specifics that shape this query (all verified against
+ * tree-sitter-swift 0.7.1 live s-expressions):
+ *
+ *   - `class`, `struct`, AND `extension` all parse to a single node
+ *     type `class_declaration`. They are distinguished by the `name:`
+ *     field node type: class/struct name is a bare `(type_identifier)`,
+ *     while an extension's name field wraps the extended type in a
+ *     `(user_type (type_identifier))`. The capture below grabs all
+ *     three under `@scope.class` + `@declaration.class`; the captures
+ *     orchestrator (`captures.ts`) re-tags extensions via the
+ *     user_type discriminator so extension members hoist onto the
+ *     extended type.
+ *   - `protocol_declaration` is its own node; its bodyless method
+ *     requirements are `protocol_function_declaration` (NOT
+ *     `function_declaration`).
+ *   - `init_declaration` has no `name:` field — identity is the `init`
+ *     keyword. The captures layer synthesizes its `@declaration.name`.
+ *   - Inside a `parameter`, BOTH the label and the type use the field
+ *     name `name:` — disambiguate by child node type (simple_identifier
+ *     = label, user_type = type). Parameter type bindings are therefore
+ *     synthesized in `captures.ts`, not matched here.
+ *   - A labeled call argument wraps its label in a dedicated
+ *     `value_argument_label` node.
+ *   - `self` is its own node `self_expression`; a `self.member()` call
+ *     is `call_expression > navigation_expression(target: self_expression,
+ *     suffix: navigation_suffix > simple_identifier)`.
+ *   - `import_declaration` carries the module path as an `(identifier
+ *     (simple_identifier)+)` — one `simple_identifier` per dotted
+ *     segment. `@testable` and other attributes surface as a leading
+ *     `(modifiers (attribute (user_type (type_identifier))))`.
+ *
+ * Exposes lazy `Parser` and `Query` singletons so callers don't pay
+ * tree-sitter init cost per file.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSwiftParser = getSwiftParser;
+exports.getSwiftScopeQuery = getSwiftScopeQuery;
+const tree_sitter_1 = __importDefault(require("tree-sitter"));
+const index_js_1 = require("../../../../../shared/index.js");
+// `tree-sitter-swift` is an optional/vendored grammar that may be absent on a
+// default install. It is loaded lazily + guarded via parser-loader rather than
+// statically imported: this module is pulled onto the main thread eagerly by
+// the scope-resolution registry and the language-provider index, so a top-level
+// `import Swift from 'tree-sitter-swift'` would throw ERR_MODULE_NOT_FOUND at
+// module-load and crash `analyze` even for repos with no Swift files (#2091,
+// #2093). The grammar is only ever needed inside the lazy getters below.
+const parser_loader_js_1 = require("../../../tree-sitter/parser-loader.js");
+const SWIFT_SCOPE_QUERY = `
+;; ── Scopes ──────────────────────────────────────────────────────────
+(source_file) @scope.module
+
+;; class / struct / extension all parse to class_declaration; the
+;; captures orchestrator splits extensions out via the user_type
+;; name discriminator.
+(class_declaration) @scope.class
+(protocol_declaration) @scope.class
+
+(function_declaration) @scope.function
+(protocol_function_declaration) @scope.function
+(init_declaration) @scope.function
+(deinit_declaration) @scope.function
+
+;; ── Declarations — types ────────────────────────────────────────────
+;; class / struct: name is a bare type_identifier.
+(class_declaration
+  name: (type_identifier) @declaration.name) @declaration.class
+
+;; extension: name is (user_type (type_identifier)). Captured separately
+;; so captures.ts can re-tag it as an extension of the wrapped type.
+(class_declaration
+  name: (user_type) @declaration.name) @declaration.extension
+
+(protocol_declaration
+  name: (type_identifier) @declaration.name) @declaration.interface
+
+;; ── Declarations — methods / init / properties ──────────────────────
+(function_declaration
+  name: (simple_identifier) @declaration.name) @declaration.method
+
+(protocol_function_declaration
+  name: (simple_identifier) @declaration.name) @declaration.method
+
+;; init has no name field — captures.ts synthesizes @declaration.name = "init".
+(init_declaration) @declaration.constructor
+
+(property_declaration
+  name: (pattern
+    bound_identifier: (simple_identifier) @declaration.name)) @declaration.property
+
+;; ── Imports ─────────────────────────────────────────────────────────
+;; Single anchor per import; the captures layer decomposes the module
+;; path (and detects @testable) into @import.kind/source/name markers.
+(import_declaration) @import.statement
+
+;; ── Type bindings — property annotations: \`var owner: Owner\` ─────────
+(property_declaration
+  name: (pattern
+    bound_identifier: (simple_identifier) @type-binding.name)
+  (type_annotation
+    (user_type (type_identifier) @type-binding.type))) @type-binding.annotation
+
+;; Optional property annotations: \`var owner: Owner?\` (#2807). The pattern
+;; above requires the \`user_type\` to be a DIRECT child of the annotation;
+;; an optional inserts an \`optional_type\` level between them, so an optional
+;; field was never typed at all and \`self.owner!.method()\` could not resolve
+;; its receiver. Declaring a field optional and assigning it later is the
+;; idiomatic Swift way to express a field that has no value at init time, so
+;; this is the common shape, not an edge case.
+;;
+;; The INNER \`type_identifier\` is captured, so the binding is \`Owner\` with no
+;; reliance on \`stripOptional\` reducing a \`Owner?\` spelling.
+(property_declaration
+  name: (pattern
+    bound_identifier: (simple_identifier) @type-binding.name)
+  (type_annotation
+    (optional_type
+      (user_type (type_identifier) @type-binding.type)))) @type-binding.annotation
+
+;; ── Type bindings — stored / local-var constructor inference:
+;; \`let p = Product(...)\` (constructor) and \`let u = getUser()\`
+;; (free-call result; chain-follow resolves getUser → its return type).
+;; property_declaration is the node for both class-level stored
+;; properties AND let/var inside a function body. ───────────────────
+(property_declaration
+  name: (pattern
+    bound_identifier: (simple_identifier) @type-binding.name)
+  value: (call_expression
+    (simple_identifier) @type-binding.type)) @type-binding.constructor
+
+;; \`let u = await fetchUser()\` — unwrap the await wrapper to the call.
+(property_declaration
+  name: (pattern
+    bound_identifier: (simple_identifier) @type-binding.name)
+  value: (await_expression
+    (call_expression
+      (simple_identifier) @type-binding.type))) @type-binding.constructor
+
+;; \`let r = try parseRepo()\` — unwrap the try wrapper to the call.
+(property_declaration
+  name: (pattern
+    bound_identifier: (simple_identifier) @type-binding.name)
+  value: (try_expression
+    (call_expression
+      (simple_identifier) @type-binding.type))) @type-binding.constructor
+
+;; ── Optional binding anchors: if-let / guard-let. In tree-sitter-swift
+;; 0.7.1 these are if_statement / guard_statement with a flat shape — a
+;; \`bound_identifier:\` field for the name plus separate \`condition:\`
+;; children (one of which is the bound value expression). A static .scm
+;; pattern can't pair the name with the value across those sibling
+;; condition fields, so we only ANCHOR the statement here and synthesize
+;; the @type-binding.constructor in captures.ts (synthesizeOptionalBinding)
+;; by walking the node. (A nonexistent if_let_binding node type would throw
+;; TSQueryErrorNodeType and break the WHOLE query — do not reintroduce it.)
+(if_statement
+  bound_identifier: (simple_identifier)) @optional.binding
+(guard_statement
+  bound_identifier: (simple_identifier)) @optional.binding
+
+;; NOTE: parameter-type bindings (\`func f(u: User)\`) and function
+;; return-type bindings (\`func getUser() -> User\`) are NOT matched by
+;; tree-sitter patterns here. Swift's grammar reuses the SAME \`name:\`
+;; field for the function name, each parameter's label, AND the return
+;; type, so a two-\`name:\`-field query cross-assigns and produces garbage
+;; bindings (\`save: save\`). They are synthesized in code instead —
+;; \`captures.ts\` reads the function node via
+;; \`swiftMethodConfig.extractParameters\` / \`extractReturnType\`, which
+;; handle the grammar correctly. (Mirrors how receiver + arity are
+;; synthesized rather than queried.)
+
+;; ── References — field reads: \`u.address\` (member access that is NOT a
+;; call callee or assignment LHS). Emit-side filtering in captures.ts
+;; drops call targets and write LHS so only genuine reads emit ACCESSES.
+(navigation_expression
+  target: (_) @reference.receiver
+  suffix: (navigation_suffix
+    suffix: (simple_identifier) @reference.name)) @reference.read.member
+
+;; ── References — free calls: \`foo(...)\` ─────────────────────────────
+(call_expression
+  (simple_identifier) @reference.name) @reference.call.free
+
+;; ── References — member / method calls: \`obj.method(...)\` ───────────
+;; navigation_expression carries the receiver (target:) and the member
+;; (suffix > navigation_suffix > simple_identifier). \`self\` is a
+;; self_expression; other receivers are simple_identifier / nested
+;; navigation_expression — capture the whole target as @reference.receiver.
+(call_expression
+  (navigation_expression
+    target: (_) @reference.receiver
+    suffix: (navigation_suffix
+      suffix: (simple_identifier) @reference.name))) @reference.call.member
+
+;; ── References — constructor calls handled via @reference.call.free
+;; (a Swift \`Foo(...)\` is a call_expression with a simple_identifier
+;; callee; pickConstructorOrClass in free-call fallback targets the
+;; type's Constructor). No separate object_creation node in Swift.
+`;
+let _parser = null;
+let _query = null;
+function getSwiftParser() {
+    if (_parser === null) {
+        _parser = new tree_sitter_1.default();
+        _parser.setLanguage((0, parser_loader_js_1.getLanguageGrammar)(index_js_1.SupportedLanguages.Swift));
+    }
+    return _parser;
+}
+function getSwiftScopeQuery() {
+    if (_query === null) {
+        _query = new tree_sitter_1.default.Query((0, parser_loader_js_1.getLanguageGrammar)(index_js_1.SupportedLanguages.Swift), SWIFT_SCOPE_QUERY);
+    }
+    return _query;
+}

package/dist/core/code/engine/core/ingestion/languages/swift/receiver-binding.js

@@ -0,0 +1,169 @@
+"use strict";
+/**
+ * Synthesize `@type-binding.self` captures for Swift instance methods —
+ * one for `self` (always on non-static methods inside a type body) and
+ * optionally one for `super` (only on class methods when the enclosing
+ * class declares a superclass).
+ *
+ * Mirrors `languages/csharp/receiver-binding.ts`. tree-sitter can't
+ * express "the implicit receiver of a non-static member of a
+ * class/struct/extension/protocol" via a static `.scm` pattern because
+ * the receiver isn't a parameter — it's implicit. Synthesis in code is
+ * the same approach C#/Python use for `this`/`self`.
+ *
+ * Swift AST facts (tree-sitter-swift 0.7.1, verified):
+ *   - class / struct / extension all parse to `class_declaration`. For
+ *     class/struct the `name:` field is `(type_identifier)`; for an
+ *     extension it is `(user_type (type_identifier))` wrapping the
+ *     EXTENDED type — so `self` in an extension binds to the extended
+ *     type, which is exactly what we want for method dispatch.
+ *   - `protocol_declaration` has a `(type_identifier)` name.
+ *   - the method body is the `body:` field (`function_body`); a bodyless
+ *     `protocol_function_declaration` has no function scope to anchor to.
+ *   - a superclass / conformance is an `(inheritance_specifier
+ *     inherits_from: (user_type (type_identifier)))` child of the
+ *     class_declaration.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findEnclosingTypeDeclaration = findEnclosingTypeDeclaration;
+exports.synthesizeSwiftReceiverBinding = synthesizeSwiftReceiverBinding;
+const ast_helpers_js_1 = require("../../utils/ast-helpers.js");
+const base_type_js_1 = require("./base-type.js");
+const swift_js_1 = require("../../method-extractors/configs/swift.js");
+const TYPE_DECL_NODE_TYPES = new Set(['class_declaration', 'protocol_declaration']);
+const FUNCTION_NODE_TYPES = new Set([
+    'function_declaration',
+    'init_declaration',
+    'deinit_declaration',
+]);
+/** Walk up to the enclosing type declaration (class/struct/extension/
+ *  protocol). Nested local functions still see `self` from the enclosing
+ *  type, so don't stop at function-like nodes.
+ *
+ *  Exported so `swiftEnclosingTypeName` (captures.ts) asks the same question
+ *  the same way — the two must agree on what "the enclosing type" is or a
+ *  method's owner qualifier and its `self` binding name different types. */
+function findEnclosingTypeDeclaration(node) {
+    let cur = node.parent;
+    while (cur !== null) {
+        if (TYPE_DECL_NODE_TYPES.has(cur.type))
+            return cur;
+        cur = cur.parent;
+    }
+    return null;
+}
+/** Bare type name of the enclosing type. class/struct → type_identifier
+ *  text; extension → the wrapped user_type's identifier text; protocol →
+ *  type_identifier text. */
+function enclosingTypeName(typeNode) {
+    const nameNode = typeNode.childForFieldName('name');
+    if (nameNode === null)
+        return null;
+    if (nameNode.type === 'user_type') {
+        // extension Foo { } → name is (user_type (type_identifier)).
+        // extension Foo.Bar { } → (user_type (type_identifier Foo)
+        // (type_identifier Bar)); the extended type — and therefore `self` —
+        // is the TRAILING identifier `Bar` (lastNamedChild), not `Foo`. For a
+        // single identifier first === last, so this is unchanged.
+        const inner = nameNode.lastNamedChild;
+        return inner?.text ?? nameNode.text;
+    }
+    return nameNode.text;
+}
+/** Is this declaration a `class` (vs `struct`/`extension`)? Only classes
+ *  have a meaningful `super`. Detected by the leading keyword token —
+ *  class/struct/extension share the `class_declaration` node type. */
+function isClassKeyword(typeNode) {
+    for (let i = 0; i < typeNode.childCount; i++) {
+        const child = typeNode.child(i);
+        if (child !== null && !child.isNamed) {
+            const t = child.text.trim();
+            if (t === 'class')
+                return true;
+            if (t === 'struct' || t === 'extension' || t === 'enum' || t === 'actor')
+                return false;
+        }
+    }
+    return false;
+}
+/** First inherited type (superclass or first protocol) as raw text, or
+ *  null. For a class the first `inheritance_specifier` is conventionally
+ *  the superclass — `super.x()` only compiles when that is true. For a
+ *  `user_type` base the name is its trailing `type_identifier` segment (see
+ *  `swiftQualifiedBaseTail`), falling back to the raw node text when there is
+ *  no `type_identifier` child. */
+function firstInheritedType(typeNode) {
+    for (let i = 0; i < typeNode.namedChildCount; i++) {
+        const child = typeNode.namedChild(i);
+        if (child === null || child.type !== 'inheritance_specifier')
+            continue;
+        const inheritsFrom = child.childForFieldName('inherits_from') ?? child.firstNamedChild;
+        if (inheritsFrom === null)
+            return null;
+        if (inheritsFrom.type === 'user_type') {
+            return (0, base_type_js_1.swiftQualifiedBaseTail)(inheritsFrom)?.text ?? inheritsFrom.text;
+        }
+        return inheritsFrom.text;
+    }
+    return null;
+}
+/** A Swift type method (`static func` OR `class func`) has no `self`
+ *  instance receiver. Delegate to `swiftMethodConfig.isStatic`, which is
+ *  the single source of truth: `static func` emits the modifier under a
+ *  `modifiers > property_modifier` wrapper, but `class func` emits a BARE
+ *  anonymous `class` token directly under `function_declaration` (verified,
+ *  tree-sitter-swift 0.7.1). `swiftMethodConfig.isStatic` covers both via
+ *  `hasKeyword(node, 'static'|'class')` (scans direct children) and
+ *  `hasModifier(...)` — so reusing it avoids re-deriving the same scan and
+ *  fixes the prior `modifiers`-only check that missed `class func`. */
+function isStaticMethod(fnNode) {
+    return swift_js_1.swiftMethodConfig.isStatic(fnNode);
+}
+/**
+ * Build zero, one, or two `@type-binding.self` matches for `fnNode`:
+ *  - `null`/`[]` if the function is free (no enclosing type), static, or
+ *    the enclosing type has no resolvable name, or the function is
+ *    bodyless (no scope to anchor to).
+ *  - one match (`self`) for instance methods of a class/struct/extension/
+ *    protocol.
+ *  - two matches (`self` + `super`) only when the function lives in a
+ *    `class` (keyword) declaration with a declared superclass.
+ *
+ * Caller must guarantee `FUNCTION_NODE_TYPES.has(fnNode.type)`.
+ */
+function synthesizeSwiftReceiverBinding(fnNode) {
+    if (!FUNCTION_NODE_TYPES.has(fnNode.type))
+        return [];
+    if (isStaticMethod(fnNode))
+        return [];
+    const enclosingType = findEnclosingTypeDeclaration(fnNode);
+    if (enclosingType === null)
+        return [];
+    const enclosingName = enclosingTypeName(enclosingType);
+    if (enclosingName === null)
+        return [];
+    // Anchor inside the function scope. `body:` is the function_body; its
+    // range is guaranteed inside the function scope (unlike the method's
+    // start position, which maps to the enclosing type scope via
+    // positionIndex). Bodyless declarations have no function scope.
+    const anchorNode = fnNode.childForFieldName('body');
+    if (anchorNode === null)
+        return [];
+    const out = [buildReceiverMatch(anchorNode, 'self', enclosingName)];
+    // `super` only for class methods with a declared superclass.
+    if (isClassKeyword(enclosingType)) {
+        const superType = firstInheritedType(enclosingType);
+        if (superType !== null) {
+            out.push(buildReceiverMatch(anchorNode, 'super', superType));
+        }
+    }
+    return out;
+}
+function buildReceiverMatch(anchorNode, name, typeText) {
+    const m = {
+        '@type-binding.self': (0, ast_helpers_js_1.nodeToCapture)('@type-binding.self', anchorNode),
+        '@type-binding.name': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.name', anchorNode, name),
+        '@type-binding.type': (0, ast_helpers_js_1.syntheticCapture)('@type-binding.type', anchorNode, typeText),
+    };
+    return m;
+}

package/dist/core/code/engine/core/ingestion/languages/swift/scope-resolver.js

@@ -0,0 +1,192 @@
+"use strict";
+/**
+ * Swift `ScopeResolver` registered in `SCOPE_RESOLVERS` and consumed by
+ * the generic `runScopeResolution` orchestrator (RFC #909 Ring 3,
+ * issue #937 — the final per-language migration).
+ *
+ * Closest reference: C# (`csharpScopeResolver`) — both are OOP with
+ * classes, structs, interfaces/protocols, and explicit instance
+ * receivers. MRO follows Kotlin's shape (single superclass + multiple
+ * protocol conformance).
+ *
+ * ## Swift specifics
+ *
+ *   - **Extensions** add members to an existing type. `emitSwiftScopeCaptures`
+ *     re-keys an `extension Foo { … }` to a `class_declaration`-style def
+ *     named `Foo`, so its members land on `Foo`'s scope and the shared
+ *     `populateClassOwnedMembers` stamps them with `Foo`'s ownerId — the
+ *     same mechanism C# uses for `partial class`. No separate hoist pass.
+ *   - **Labeled arguments** narrow by ARITY only (count-primary, labels
+ *     soft) — see `arity.ts`. Label-precise dispatch is deferred to the
+ *     type-binding layer.
+ *   - **Same-module visibility**: every file in an SPM target sees its
+ *     siblings' top-level defs without an `import`. Modeled via
+ *     `populateSwiftTargetSiblings`, grouped by the SPM target *subtree*
+ *     (`Sources/<Target>/…`) via `groupSwiftFilesBySpmTarget` fed from the
+ *     `loadResolutionConfig` SPM map, mirroring Go's package siblings. With
+ *     no scanned source dir (no `Sources/`/`Package/Sources/`/`src/`) the
+ *     map is null and all files form one `__default__` module.
+ *   - **`super`** is the superclass receiver (`super.method()`); plain
+ *     `self` is the instance receiver. Both synthesized in
+ *     `receiver-binding.ts`.
+ *
+ * ## Known limitations (conscious migration trade-offs; parity gate flags
+ * anything that matters in the corpus)
+ *
+ *   1. **Protocol associated types / generic constraints** (`extension
+ *      Array where Element: Equatable`) are not narrowed — the `Self`
+ *      type of a protocol method resolves to the protocol, not the
+ *      conforming type.
+ *   2. **Cross-module `import` resolution** is still directory-segment
+ *      based (`import Foo` → files under a `Foo/` dir); explicit imports do
+ *      not yet consult the SPM target map (follow-up, tracked under #1935).
+ *      Same-target visibility (the common case) IS SPM-target-subtree
+ *      accurate — handled by sibling augmentation grouped via
+ *      `groupSwiftFilesBySpmTarget`, not by explicit imports.
+ *   3. **Operator / subscript overloads** dispatch by name only.
+ *   4. **`@_exported import` re-exports** are treated as plain imports.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swiftScopeResolver = void 0;
+const index_js_1 = require("../../../../../shared/index.js");
+const language_config_js_1 = require("../../language-config.js");
+const mro_js_1 = require("../../scope-resolution/passes/mro.js");
+const walkers_js_1 = require("../../scope-resolution/scope/walkers.js");
+const ids_js_1 = require("../../scope-resolution/graph-bridge/ids.js");
+const swift_js_1 = require("../swift.js");
+const index_js_2 = require("./index.js");
+const ZERO_RANGE = { startLine: 0, startCol: 0, endLine: 0, endCol: 0 };
+const swiftScopeResolver = {
+    language: index_js_1.SupportedLanguages.Swift,
+    languageProvider: swift_js_1.swiftProvider,
+    importEdgeReason: 'swift-scope: import',
+    // Load the SPM target map (Sources/<Target>/ subtree mapping) once per
+    // workspace pass. Threaded through the orchestrator as `resolutionConfig`
+    // and consumed by the three same-module grouping hooks
+    // (`emitImplicitImportEdges`, `populateNamespaceSiblings`,
+    // `mirrorNamespaceTypeBindings`) via `coerceSwiftTargets` so they group by
+    // the SPM target subtree, not the immediate directory. Mirrors
+    // `goScopeResolver`'s `loadGoModulePath`.
+    loadResolutionConfig: (repoPath) => (0, language_config_js_1.loadSwiftPackageConfig)(repoPath),
+    resolveImportTarget: (targetRaw, fromFile, allFilePaths) => {
+        const ws = { fromFile, allFilePaths };
+        return (0, index_js_2.resolveSwiftImportTarget)((0, index_js_2.interpretSwiftImport)({
+            '@import.source': { name: '@import.source', text: targetRaw, range: ZERO_RANGE },
+        }) ?? { kind: 'namespace', localName: targetRaw, importedName: targetRaw, targetRaw }, ws);
+    },
+    // Swift shadowing: local declarations hide imports.
+    mergeBindings: (existing, incoming) => [...(0, index_js_2.swiftMergeBindings)([...existing, ...incoming])],
+    // Adapter: swiftArityCompatibility uses (def, callsite); contract is (callsite, def).
+    arityCompatibility: (callsite, def) => (0, index_js_2.swiftArityCompatibility)(def, callsite),
+    buildMro: (graph, parsedFiles, nodeLookup) => buildSwiftMro(graph, parsedFiles, nodeLookup),
+    // Methods/properties/init are owned by their enclosing class/struct/
+    // extension(→extended type)/protocol. Extension members hoist for free
+    // because captures.ts re-keys the extension to a Class def named after
+    // the extended type.
+    populateOwners: (parsed) => (0, walkers_js_1.populateClassOwnedMembers)(parsed),
+    // `super.method()` dispatches through the superclass chain.
+    isSuperReceiver: (text) => text.trim() === 'super',
+    // Whole-module same-target visibility without `import`.
+    populateNamespaceSiblings: index_js_2.populateSwiftTargetSiblings,
+    // Same-target File→File IMPORTS edges (no syntactic `import`). The
+    // generic finalized-ImportEdge pipeline has nothing to emit here, so
+    // these whole-module-visibility edges are emitted directly.
+    emitImplicitImportEdges: index_js_2.emitSwiftImplicitImportEdges,
+    // Mirror sibling files' return-type typeBindings into each file's
+    // module scope so cross-file chains (`let u = siblingFn(); u.m()`)
+    // resolve. Whole-module visibility has no import edge for
+    // `propagateImportedReturnTypes` to follow, so this directory-sibling
+    // mirror feeds it (mirrors Go's namespace-typeBinding mirror).
+    mirrorNamespaceTypeBindings: index_js_2.mirrorSwiftSiblingTypeBindings,
+    // Swift is statically typed — type info is reliable; the field-fallback
+    // heuristic over-connects, so keep it off. Return-type propagation on.
+    fieldFallbackOnMethodLookup: false,
+    propagatesReturnTypesAcrossImports: true,
+    // Swift has no `new` keyword: `UserService()` is a bare call that
+    // resolves to the type's Constructor/Class. With whole-module sibling
+    // visibility, the callee is reachable workspace-wide, so allow the
+    // global free-call fallback (as Python/Go/Ruby/COBOL do for the same
+    // no-`new` constructor + cross-file free-call shape).
+    allowGlobalFreeCallFallback: true,
+    // Swift's call graph models `Type(...)` as a reference to the type
+    // itself, not its `init` — both the legacy DAG and this test suite link
+    // `Foo()` to the Class node even when an explicit `init` exists.
+    constructorCallTargetsClass: true,
+};
+exports.swiftScopeResolver = swiftScopeResolver;
+/**
+ * Swift MRO — `defaultLinearize` (EXTENDS-only superclass chain) extended
+ * with protocol ancestors discovered via `IMPLEMENTS` edges. Protocols
+ * with default method implementations (via protocol extensions) are
+ * inherited by conforming types without an explicit `override`; the
+ * generic EXTENDS-only MRO would miss them because the conformer has no
+ * EXTENDS link to the protocol.
+ *
+ * Mirrors `buildKotlinMro`: append protocols after the superclass chain
+ * (Swift requires an explicit implementation on ambiguity, so first-seen
+ * ordering approximates method lookup). Transitive protocol inheritance
+ * (`protocol A: B`) is closed via BFS.
+ */
+function buildSwiftMro(graph, parsedFiles, nodeLookup) {
+    const mro = (0, mro_js_1.buildMro)(graph, parsedFiles, nodeLookup, mro_js_1.defaultLinearize);
+    const defIdByGraphId = new Map();
+    for (const parsed of parsedFiles) {
+        for (const def of parsed.localDefs) {
+            if (!(0, walkers_js_1.isClassLike)(def.type))
+                continue;
+            const graphId = (0, ids_js_1.resolveDefGraphId)(parsed.filePath, def, nodeLookup);
+            if (graphId !== undefined)
+                defIdByGraphId.set(graphId, def.nodeId);
+        }
+    }
+    const directImpls = new Map();
+    for (const rel of graph.iterRelationshipsByType('IMPLEMENTS')) {
+        const source = defIdByGraphId.get(rel.sourceId);
+        const target = defIdByGraphId.get(rel.targetId);
+        if (source === undefined || target === undefined)
+            continue;
+        let list = directImpls.get(source);
+        if (list === undefined) {
+            list = [];
+            directImpls.set(source, list);
+        }
+        if (!list.includes(target))
+            list.push(target);
+    }
+    for (const [classDefId, extendsMro] of mro) {
+        const ancestorChain = [classDefId, ...extendsMro];
+        const seeds = [];
+        for (const ancestorId of ancestorChain) {
+            for (const ifaceId of directImpls.get(ancestorId) ?? [])
+                seeds.push(ifaceId);
+        }
+        if (seeds.length === 0)
+            continue;
+        const protocols = closeProtocols(seeds, directImpls);
+        mro.set(classDefId, [...extendsMro, ...protocols.filter((i) => !extendsMro.includes(i))]);
+    }
+    // Types that only conform to protocols (no superclass) still need an MRO.
+    for (const [classDefId, ifaces] of directImpls) {
+        if (mro.has(classDefId))
+            continue;
+        mro.set(classDefId, closeProtocols([...ifaces], directImpls));
+    }
+    return mro;
+}
+function closeProtocols(seeds, directImpls) {
+    const out = [];
+    const seen = new Set();
+    const queue = [...seeds];
+    while (queue.length > 0) {
+        const cur = queue.shift();
+        if (seen.has(cur))
+            continue;
+        seen.add(cur);
+        out.push(cur);
+        for (const next of directImpls.get(cur) ?? []) {
+            if (!seen.has(next))
+                queue.push(next);
+        }
+    }
+    return out;
+}