cgraphx 2.0.1 → 2.0.3

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

@@ -0,0 +1,68 @@
+"use strict";
+/**
+ * Swift same-module return-type typeBinding mirroring for the
+ * `mirrorNamespaceTypeBindings` hook.
+ *
+ * Swift gives every file in a module (an SPM target) visibility of every
+ * sibling's top-level declarations without a syntactic `import`. For a
+ * chained call like
+ *
+ *   App.swift:    let user = getUser(); user.save()   // user → getUser → ?
+ *   Models.swift: func getUser() -> User { … }        // getUser → User
+ *
+ * to resolve `user.save()` cross-file, App.swift's scope chain must be
+ * able to follow `getUser → User`. The function return-type binding
+ * (`getUser → User`) lives on Models.swift's module scope, so we mirror
+ * sibling module-scope typeBindings into the importer's module scope —
+ * the same trick Go uses (`mirrorGoNamespaceTypeBindings`), but Swift has
+ * no namespace-import edges, so 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`;
+ * no-source-dir → all files form one `__default__` module).
+ *
+ * Runs after `populateNamespaceSiblings` and before
+ * `propagateImportedReturnTypes`, so the SCC-ordered propagation pass
+ * sees the mirrored bindings and chains `user → getUser → User` to the
+ * terminal class. Each mirrored binding is chain-followed inside its
+ * source module first so we mirror the terminal type, not an intermediate
+ * intra-module reference. `Scope.typeBindings` is mutated via the
+ * sanctioned non-frozen Map cast (Contract Invariant I6).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mirrorSwiftSiblingTypeBindings = mirrorSwiftSiblingTypeBindings;
+const imported_return_types_js_1 = require("../../scope-resolution/passes/imported-return-types.js");
+const target_grouping_js_1 = require("./target-grouping.js");
+function mirrorSwiftSiblingTypeBindings(parsedFiles, indexes, workspaceIndex, resolutionConfig) {
+    const moduleScopeByFile = workspaceIndex.moduleScopeByFile;
+    // 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 mirror from
+        const files = group.map((parsed) => parsed.filePath);
+        for (const importerFile of files) {
+            const importerModule = moduleScopeByFile.get(importerFile);
+            if (importerModule === undefined)
+                continue;
+            for (const sourceFile of files) {
+                if (sourceFile === importerFile)
+                    continue;
+                const sourceModule = moduleScopeByFile.get(sourceFile);
+                if (sourceModule === undefined)
+                    continue;
+                for (const [name, ref] of sourceModule.typeBindings) {
+                    if (name.length === 0)
+                        continue;
+                    // A local annotation on the importer must win over a sibling's.
+                    if (importerModule.typeBindings.has(name))
+                        continue;
+                    const terminal = (0, imported_return_types_js_1.followChainPostFinalize)(ref, sourceModule.id, indexes);
+                    importerModule.typeBindings.set(name, terminal);
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * Synthesize parameter-type and function return-type `@type-binding.*`
+ * captures for a Swift function-like node.
+ *
+ * Why synthesized rather than queried: Swift's tree-sitter grammar reuses
+ * the field name `name:` for the function name, each parameter's label,
+ * each parameter's type, AND the function's return type. A tree-sitter
+ * query with two `name:` fields cross-assigns those captures and produces
+ * garbage bindings (e.g. `save: save`). Reading the node via the existing
+ * `swiftMethodConfig.extractParameters` / `extractReturnType` extractors
+ * — which already handle the grammar correctly for the legacy parse path
+ * — yields the right name→type pairs. This mirrors how receiver and arity
+ * metadata are synthesized in `captures.ts` instead of queried.
+ *
+ *   - **Parameter bindings** anchor inside the function body so the
+ *     binding lands in the Function scope: `func f(u: User) { u.save() }`
+ *     → `u: User` visible in f's body.
+ *   - **Return-type binding** anchors at the function node and carries
+ *     `@type-binding.return`, which `swiftBindingScopeFor` hoists to the
+ *     Module scope so `propagateImportedReturnTypes` mirrors it across
+ *     files and callers see `let u = getUser(); u.save()`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.synthesizeSwiftSignatureBindings = synthesizeSwiftSignatureBindings;
+const ast_helpers_js_1 = require("../../utils/ast-helpers.js");
+const swift_js_1 = require("../../method-extractors/configs/swift.js");
+const NAMED_FUNCTION_NODE_TYPES = new Set([
+    'function_declaration',
+    'protocol_function_declaration',
+]);
+function synthesizeSwiftSignatureBindings(fnNode) {
+    const out = [];
+    // ── Parameter bindings (anchor in the body for Function-scope landing) ──
+    const params = swift_js_1.swiftMethodConfig.extractParameters?.(fnNode) ?? [];
+    if (params.length > 0) {
+        const bodyNode = fnNode.childForFieldName('body');
+        // Anchor params inside the body when present; for bodyless protocol
+        // requirements there is no Function scope to bind locals into, so skip.
+        if (bodyNode !== null) {
+            for (const p of params) {
+                if (p.type === null || p.name === '')
+                    continue;
+                out.push(buildBindingMatch(bodyNode, '@type-binding.parameter', p.name, p.type));
+            }
+        }
+    }
+    // ── Return-type binding (function name → return type, hoisted to Module) ──
+    // Only named functions have a name to bind; init/deinit have no return.
+    if (NAMED_FUNCTION_NODE_TYPES.has(fnNode.type)) {
+        const funcName = swift_js_1.swiftMethodConfig.extractName?.(fnNode);
+        const returnType = swift_js_1.swiftMethodConfig.extractReturnType?.(fnNode);
+        if (funcName !== undefined &&
+            funcName !== '' &&
+            returnType !== undefined &&
+            returnType !== '') {
+            out.push(buildBindingMatch(fnNode, '@type-binding.return', funcName, returnType));
+        }
+    }
+    return out;
+}
+function buildBindingMatch(anchorNode, sourceTag, name, typeText) {
+    const m = {
+        [sourceTag]: (0, ast_helpers_js_1.nodeToCapture)(sourceTag, 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/simple-hooks.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * Trivial / no-op-ish hooks for the Swift provider. Kept together
+ * because each is a few lines and they share a theme: they make the
+ * provider's choice explicit rather than relying on "absence == default"
+ * so reviewers don't have to re-derive the analysis.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swiftBindingScopeFor = swiftBindingScopeFor;
+exports.swiftImportOwningScope = swiftImportOwningScope;
+exports.swiftReceiverBinding = swiftReceiverBinding;
+// ─── bindingScopeFor ──────────────────────────────────────────────────────
+/** Swift uses the central extractor's "innermost enclosing scope" default
+ *  for most declarations: class-body declarations attach to the Class
+ *  scope, function-body locals to the Function scope.
+ *
+ *  Exception: **function return-type bindings** (`@type-binding.return`)
+ *  must hoist to the Module scope. The default auto-hoist promotes only
+ *  one level (Function → its parent). For top-level functions the parent
+ *  is already the Module so the default works, but for methods declared
+ *  inside a class/struct/extension the parent is the Class — the return
+ *  binding would get stuck there, invisible to:
+ *    - chain-follow's parent-chain walk (`let u = getUser(); u.save()`);
+ *    - cross-file `propagateImportedReturnTypes`, which reads only
+ *      `sourceModule.typeBindings`.
+ *  Walking to Module restores both. Mirrors `csharpBindingScopeFor`. */
+function swiftBindingScopeFor(decl, innermost, tree) {
+    if (decl['@type-binding.return'] !== undefined) {
+        let cur = innermost;
+        while (cur !== undefined && cur.kind !== 'Module') {
+            const parentId = cur.parent ?? null;
+            if (parentId === null)
+                break;
+            cur = tree.getScope(parentId);
+        }
+        if (cur !== undefined && cur.kind === 'Module')
+            return cur.id;
+    }
+    return null;
+}
+// ─── importOwningScope ────────────────────────────────────────────────────
+/** Swift imports only appear at file (module) scope and bring a whole
+ *  module into view there. Attach the import to the Module scope; for any
+ *  other innermost scope delegate to the default (returns null). */
+function swiftImportOwningScope(_imp, innermost, _tree) {
+    if (innermost.kind === 'Module')
+        return innermost.id;
+    return null;
+}
+// ─── receiverBinding ──────────────────────────────────────────────────────
+/** Look up `self` (or `super`) in the function scope's type bindings.
+ *
+ *  `self` / `super` are synthesized as type bindings on instance methods
+ *  during capture emission (`receiver-binding.ts`) — `self` for every
+ *  method inside a class/struct/extension/protocol body, and `super`
+ *  additionally for methods of a class with a declared superclass. This
+ *  hook returns a non-null `TypeRef` for instance-method bodies.
+ *
+ *  Returns `null` for static methods (no `self` synthesized), free
+ *  functions (no enclosing type), and non-Function scopes. */
+function swiftReceiverBinding(functionScope) {
+    if (functionScope.kind !== 'Function')
+        return null;
+    return functionScope.typeBindings.get('self') ?? functionScope.typeBindings.get('super') ?? null;
+}

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

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * Swift SPM-target file grouping for the registry-primary same-module
+ * hooks (`implicit-imports.ts`, `target-siblings.ts`,
+ * `sibling-type-bindings.ts`).
+ *
+ * A Swift module is an SPM *target* — a directory *subtree*
+ * (`Sources/<Target>/…`), not a single immediate directory. Grouping by
+ * the immediate containing directory (the prior `containingDir` proxy)
+ * drops cross-directory same-module edges and can mis-resolve a
+ * constructor call to a wrong same-simple-named type in another target.
+ *
+ * This module duplicates the legacy `groupSwiftFilesByTarget`
+ * (`languages/swift.ts`) semantics **verbatim** so the registry-primary
+ * path matches legacy SPM-subtree grouping without touching the legacy
+ * pipeline (hard constraint: legacy stays byte-identical). The SPM target
+ * map is threaded in via the `resolutionConfig` channel
+ * (`loadSwiftPackageConfig` → `resolutionConfig` → these hooks); see
+ * `scope-resolver.ts` and `scope-resolution/pipeline/run.ts`.
+ *
+ * NOTE: This intentionally differs from the import-config module's
+ * leading-`startsWith` (`import-resolvers/configs/swift.ts`): that module
+ * fans a file out to EVERY matching target (a nested file can belong to
+ * multiple configured target dirs there), whereas legacy module grouping
+ * assigns each file to the FIRST matching target only (legacy `break`s) —
+ * one bucket per file. Do not copy the import-config behavior here.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupSwiftFilesBySpmTarget = groupSwiftFilesBySpmTarget;
+exports.coerceSwiftTargets = coerceSwiftTargets;
+const DEFAULT_TARGET = '__default__';
+/**
+ * Group `items` by SPM target subtree, replicating legacy
+ * `groupSwiftFilesByTarget` semantics exactly:
+ *
+ *   - `targets` null/empty (no scanned source dir found) → ALL items go to
+ *     a single `__default__` bucket (single-Xcode-project assumption).
+ *   - Otherwise: a file matches a target when its normalized path either
+ *     starts with `<targetDir>/` (`indexOf === 0`) OR contains it at a `/`
+ *     boundary (`norm[idx - 1] === '/'`). Each file is assigned to the
+ *     FIRST matching target only (one bucket per file, no fan-out).
+ *   - Files matching no target fall into the `__default__` bucket.
+ *
+ * `targets` is `name → directory` (the `SwiftPackageConfig.targets` map).
+ */
+function groupSwiftFilesBySpmTarget(items, getPath, targets) {
+    // No SPM config -> single target (common for Xcode projects).
+    if (targets === null || targets.size === 0) {
+        return new Map([[DEFAULT_TARGET, [...items]]]);
+    }
+    // Pre-convert target dirs to normalized prefix format once.
+    const targetPrefixes = [...targets.entries()].map(([name, dir]) => ({
+        name,
+        prefix: dir.replace(/\\/g, '/') + '/',
+    }));
+    const groups = new Map();
+    const defaultGroup = [];
+    for (const item of items) {
+        const rawPath = getPath(item);
+        const normalized = rawPath.includes('\\') ? rawPath.replace(/\\/g, '/') : rawPath;
+        let assigned = false;
+        for (const { name, prefix } of targetPrefixes) {
+            const idx = normalized.indexOf(prefix);
+            if (idx === 0 || (idx > 0 && normalized[idx - 1] === '/')) {
+                let group = groups.get(name);
+                if (group === undefined) {
+                    group = [];
+                    groups.set(name, group);
+                }
+                group.push(item);
+                assigned = true;
+                break; // FIRST match only — one bucket per file, no fan-out.
+            }
+        }
+        if (!assigned)
+            defaultGroup.push(item);
+    }
+    if (defaultGroup.length > 0)
+        groups.set(DEFAULT_TARGET, defaultGroup);
+    return groups;
+}
+/**
+ * Duck-type the opaque `resolutionConfig` (loaded by
+ * `loadSwiftPackageConfig` and threaded through the orchestrator) into the
+ * SPM `targets` map, or `null` when no Swift package config is present.
+ *
+ * Uses structural duck-typing (no `instanceof`) because the value crosses
+ * the `unknown`-typed `resolutionConfig` channel and may be `null`,
+ * `undefined`, or a config object whose `targets` is a `Map<string,string>`.
+ */
+function coerceSwiftTargets(resolutionConfig) {
+    const config = resolutionConfig;
+    if (config != null && config.targets instanceof Map) {
+        return config.targets;
+    }
+    return null;
+}

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

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * Swift same-module (SPM target) implicit visibility for the
+ * `populateNamespaceSiblings` hook.
+ *
+ * Swift gives every file in a module access to every other file's
+ * top-level declarations WITHOUT any `import` statement (whole-module
+ * visibility). This is the Swift analogue of Go's same-package sibling
+ * visibility — `populateGoPackageSiblings` is the template.
+ *
+ * Module identity: Swift has no in-source `package X` marker. The SPM
+ * target is a directory subtree (`Sources/<Target>/…`). Module membership
+ * is threaded in via the SPM target map (`ctx.resolutionConfig` →
+ * `coerceSwiftTargets`) and grouped by `groupSwiftFilesBySpmTarget`,
+ * replicating legacy `wireSwiftImplicitImports`'s `groupSwiftFilesByTarget`:
+ * files are grouped by SPM target subtree when a package config is present,
+ * else ALL Swift files form one module (`__default__`,
+ * single-Xcode-project assumption). Every `.swift` file in the same target
+ * sees its siblings' top-level defs.
+ *
+ * Bindings are added through the append-only `bindingAugmentations`
+ * channel (Contract Invariant I8) with `origin: 'namespace'`, exactly
+ * like the Go implementation — `indexes.bindings` is frozen post-
+ * finalize and must not be mutated.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.populateSwiftTargetSiblings = populateSwiftTargetSiblings;
+const target_grouping_js_1 = require("./target-grouping.js");
+function populateSwiftTargetSiblings(parsedFiles, indexes, ctx) {
+    // 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)(ctx.resolutionConfig);
+    const filesByTarget = (0, target_grouping_js_1.groupSwiftFilesBySpmTarget)(parsedFiles, (parsed) => parsed.filePath, targets);
+    const augmentations = indexes.bindingAugmentations;
+    for (const [, group] of filesByTarget) {
+        if (group.length < 2)
+            continue; // no siblings to share
+        const siblings = group.map((parsed) => ({
+            filePath: parsed.filePath,
+            defs: [...parsed.localDefs],
+        }));
+        for (const target of siblings) {
+            for (const receiver of siblings) {
+                if (receiver.filePath === target.filePath)
+                    continue; // no self-reference
+                const receiverModule = indexes.moduleScopes.byFilePath.get(receiver.filePath);
+                if (receiverModule === undefined)
+                    continue;
+                for (const def of target.defs) {
+                    const name = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
+                    if (name === '')
+                        continue;
+                    const bucket = getAugmentationBucket(augmentations, receiverModule, name);
+                    if (bucket.some((b) => b.def.nodeId === def.nodeId))
+                        continue;
+                    bucket.push({ def, origin: 'namespace' });
+                }
+            }
+        }
+    }
+}
+function getAugmentationBucket(augmentations, scopeId, name) {
+    let scopeBindings = augmentations.get(scopeId);
+    if (scopeBindings === undefined) {
+        scopeBindings = new Map();
+        augmentations.set(scopeId, scopeBindings);
+    }
+    let bucketArr = scopeBindings.get(name);
+    if (bucketArr === undefined) {
+        bucketArr = [];
+        scopeBindings.set(name, bucketArr);
+    }
+    return bucketArr;
+}

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

@@ -0,0 +1,246 @@
+"use strict";
+/**
+ * Swift Language Provider
+ *
+ * Assembles all Swift-specific ingestion capabilities into a single
+ * LanguageProvider, following the Strategy pattern used by the pipeline.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swiftProvider = void 0;
+const index_js_1 = require("../../../../shared/index.js");
+const generic_js_1 = require("../class-extractors/generic.js");
+const swift_js_1 = require("../class-extractors/configs/swift.js");
+const language_provider_js_1 = require("../language-provider.js");
+const swift_js_2 = require("../type-extractors/swift.js");
+const export_detection_js_1 = require("../export-detection.js");
+const resolver_factory_js_1 = require("../import-resolvers/resolver-factory.js");
+const swift_js_3 = require("../import-resolvers/configs/swift.js");
+const tree_sitter_queries_js_1 = require("../tree-sitter-queries.js");
+const ast_helpers_js_1 = require("../utils/ast-helpers.js");
+const generic_js_2 = require("../field-extractors/generic.js");
+const swift_js_4 = require("../field-extractors/configs/swift.js");
+const generic_js_3 = require("../method-extractors/generic.js");
+const swift_js_5 = require("../method-extractors/configs/swift.js");
+const generic_js_4 = require("../variable-extractors/generic.js");
+const swift_js_6 = require("../variable-extractors/configs/swift.js");
+const generic_js_5 = require("../call-extractors/generic.js");
+const swift_js_7 = require("../call-extractors/configs/swift.js");
+const swift_js_8 = require("../cfg/visitors/swift.js");
+const index_js_2 = require("./swift/index.js");
+const conditional_directive_preprocess_js_1 = require("./swift/conditional-directive-preprocess.js");
+/** Swift init/deinit declarations have special names and Constructor label. */
+const swiftExtractFunctionName = (node) => {
+    if (node.type === 'init_declaration')
+        return { funcName: 'init', label: 'Constructor' };
+    if (node.type === 'deinit_declaration')
+        return { funcName: 'deinit', label: 'Constructor' };
+    return null; // fall through to generic
+};
+const orderSwiftSameNameTypeCandidates = ({ callSiteFilePath, candidates, }) => {
+    if (!callSiteFilePath.endsWith('.swift'))
+        return null;
+    if (candidates.length <= 1)
+        return null;
+    if (!candidates.every((c) => c.type === candidates[0].type))
+        return null;
+    if (candidates[0].type !== 'Class' && candidates[0].type !== 'Struct')
+        return null;
+    if (!candidates.every((c) => c.filePath.endsWith('.swift')))
+        return null;
+    return [...candidates].sort((a, b) => a.filePath.length - b.filePath.length || a.filePath.localeCompare(b.filePath));
+};
+const BUILT_INS = new Set([
+    'print',
+    'debugPrint',
+    'dump',
+    'fatalError',
+    'precondition',
+    'preconditionFailure',
+    'assert',
+    'assertionFailure',
+    'NSLog',
+    'abs',
+    'min',
+    'max',
+    'zip',
+    'stride',
+    'sequence',
+    'repeatElement',
+    'swap',
+    'withUnsafePointer',
+    'withUnsafeMutablePointer',
+    'withUnsafeBytes',
+    'autoreleasepool',
+    'unsafeBitCast',
+    'unsafeDowncast',
+    'numericCast',
+    'type',
+    'MemoryLayout',
+    'map',
+    'flatMap',
+    'compactMap',
+    'filter',
+    'reduce',
+    'forEach',
+    'contains',
+    'first',
+    'last',
+    'prefix',
+    'suffix',
+    'dropFirst',
+    'dropLast',
+    'sorted',
+    'reversed',
+    'enumerated',
+    'joined',
+    'split',
+    'append',
+    'insert',
+    'remove',
+    'removeAll',
+    'removeFirst',
+    'removeLast',
+    'isEmpty',
+    'count',
+    'index',
+    'startIndex',
+    'endIndex',
+    'addSubview',
+    'removeFromSuperview',
+    'layoutSubviews',
+    'setNeedsLayout',
+    'layoutIfNeeded',
+    'setNeedsDisplay',
+    'invalidateIntrinsicContentSize',
+    'addTarget',
+    'removeTarget',
+    'addGestureRecognizer',
+    'addConstraint',
+    'addConstraints',
+    'removeConstraint',
+    'removeConstraints',
+    'NSLocalizedString',
+    'Bundle',
+    'reloadData',
+    'reloadSections',
+    'reloadRows',
+    'performBatchUpdates',
+    'register',
+    'dequeueReusableCell',
+    'dequeueReusableSupplementaryView',
+    'beginUpdates',
+    'endUpdates',
+    'insertRows',
+    'deleteRows',
+    'insertSections',
+    'deleteSections',
+    'present',
+    'dismiss',
+    'pushViewController',
+    'popViewController',
+    'popToRootViewController',
+    'performSegue',
+    'prepare',
+    'DispatchQueue',
+    'async',
+    'sync',
+    'asyncAfter',
+    'Task',
+    'withCheckedContinuation',
+    'withCheckedThrowingContinuation',
+    'sink',
+    'store',
+    'assign',
+    'receive',
+    'subscribe',
+    'addObserver',
+    'removeObserver',
+    'post',
+    'NotificationCenter',
+]);
+exports.swiftProvider = (0, language_provider_js_1.defineLanguage)({
+    id: index_js_1.SupportedLanguages.Swift,
+    extensions: ['.swift'],
+    preprocessSource: conditional_directive_preprocess_js_1.preprocessSwiftConditionalDirectives,
+    entryPointPatterns: [
+        /^viewDidLoad$/,
+        /^viewWillAppear$/,
+        /^viewDidAppear$/,
+        /^viewWillDisappear$/,
+        /^viewDidDisappear$/,
+        /^application\(/,
+        /^scene\(/,
+        /^body$/,
+        /Coordinator$/,
+        /^sceneDidBecomeActive$/,
+        /^sceneWillResignActive$/,
+        /^didFinishLaunchingWithOptions$/,
+        /ViewController$/,
+        /^configure[A-Z]/,
+        /^setup[A-Z]/,
+        /^makeBody$/,
+    ],
+    astFrameworkPatterns: [
+        {
+            framework: 'uikit',
+            entryPointMultiplier: 2.5,
+            reason: 'uikit-lifecycle',
+            patterns: [
+                'viewDidLoad',
+                'viewWillAppear',
+                'viewDidAppear',
+                'UIViewController',
+                '@IBOutlet',
+                '@IBAction',
+                '@objc',
+            ],
+        },
+        {
+            framework: 'swiftui',
+            entryPointMultiplier: 2.8,
+            reason: 'swiftui-pattern',
+            patterns: [
+                '@main',
+                'WindowGroup',
+                'ContentView',
+                '@StateObject',
+                '@ObservedObject',
+                '@EnvironmentObject',
+                '@Published',
+            ],
+        },
+        {
+            framework: 'vapor',
+            entryPointMultiplier: 3.0,
+            reason: 'vapor-routing',
+            patterns: ['app.get', 'app.post', 'req.content.decode', 'Vapor'],
+        },
+    ],
+    treeSitterQueries: tree_sitter_queries_js_1.SWIFT_QUERIES,
+    typeConfig: swift_js_2.typeConfig,
+    exportChecker: export_detection_js_1.swiftExportChecker,
+    importResolver: (0, resolver_factory_js_1.createImportResolver)(swift_js_3.swiftImportConfig),
+    callExtractor: (0, generic_js_5.createCallExtractor)(swift_js_7.swiftCallConfig),
+    fieldExtractor: (0, generic_js_2.createFieldExtractor)(swift_js_4.swiftConfig),
+    methodExtractor: (0, generic_js_3.createMethodExtractor)({
+        ...swift_js_5.swiftMethodConfig,
+        extractFunctionName: swiftExtractFunctionName,
+    }),
+    variableExtractor: (0, generic_js_4.createVariableExtractor)(swift_js_6.swiftVariableConfig),
+    classExtractor: (0, generic_js_1.createClassExtractor)(swift_js_1.swiftClassConfig),
+    // ── Swift doc comments (`///`, `/** */`) → description (issue #2270) ──
+    descriptionExtractor: (0, ast_helpers_js_1.createLeadingDocDescriptionExtractor)(),
+    orderSameNameTypeCandidates: orderSwiftSameNameTypeCandidates,
+    builtInNames: BUILT_INS,
+    // ── Scope-based resolution hooks (RFC #909 Ring 3, issue #937). See
+    //    languages/swift/ for the implementations. ──────────────────────
+    emitScopeCaptures: index_js_2.emitSwiftScopeCaptures,
+    cfgVisitor: (0, swift_js_8.createSwiftCfgVisitor)(),
+    interpretImport: index_js_2.interpretSwiftImport,
+    interpretTypeBinding: index_js_2.interpretSwiftTypeBinding,
+    bindingScopeFor: index_js_2.swiftBindingScopeFor,
+    importOwningScope: index_js_2.swiftImportOwningScope,
+    receiverBinding: index_js_2.swiftReceiverBinding,
+    mergeBindings: (_scope, bindings) => (0, index_js_2.swiftMergeBindings)(bindings),
+    arityCompatibility: index_js_2.swiftArityCompatibility,
+});