From 09e301bbfae5728c3f4bee1cd6a992b81a52a33e Mon Sep 17 00:00:00 2001 From: Colby Mchenry Date: Mon, 20 Jul 2026 17:09:12 -0500 Subject: [PATCH] =?UTF-8?q?feat(kernel):=20R7b=20Swift=20walker=20?= =?UTF-8?q?=E2=80=94=20swift=20module,=20tree-sitter-swift=200.7.3=20bump,?= =?UTF-8?q?=20swift=20default-routed=20(#1381)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Fifth R7b batch-3 port, checklist-first recipe (docs/design/swift-kernel-port-checklist.md, 1,056 lines — the largest of the arc, with a built-extractor-validated emission pin and a childForFieldName truth table). Grammar bump first, validated standalone: tree-sitter-wasms ^0.4.0 (ABI 13) → crate 0.7.3 — with a provenance twist: the wasm is built from the CRATE TARBALL's src/ (alex-pinkus keeps generated files off main and the 0.7.3-with-generated-files tag ships an older ABI-14 generation that can never sha-match; grammar.json rules are JSON-equal; the tarball is byte-for-byte what the kernel's cargo build compiles — table identity by construction). Older crates evaluated and rejected: clean-parse shapes are byte-identical on 0.7.3 (53-line CST battery diff, all inert), so an older pin buys nothing and loses the macro-era wins. Delta = error-set membership (63 old-error files parse clean: swift-testing #expect, #Preview/#GET macros, package access, typed throws — vapor 23.1%→9.3%; 21 NEW-only regressions in 3 probed construct classes) + two gate-found categories: docstring boundaries near #if directives (7 clean files, docstring-field-only — verified mechanically) and array-literal-callee call refs (2 refs, 1 file). Every hunk classified via the error-union rule + parked-ref↔edge ripple pairing. Walker (the arc's biggest) centers on the #1020 DEDICATED property branch: computed properties → property nodes with the getter walked under the property (SwiftUI body), static let/var → constant/variable, stored → field, decorator/type-annotation/@Siblings-attr-arg refs all attached to the ENCLOSING TYPE, stored initializer calls attributed to the class. Preserved bug-for-bug: the never-resolving 'parameter' field (zero param type refs, zero signatures), present-false isAsync, open→internal visibility, everything-is-extends inheritance (first type_identifier per specifier), no instantiates refs ever, subscript reads as `calls arr`, `defer` as `calls defer`, multi-case enum entries minting only the first case, /** */ block docs ignored AND chain-breaking, init/deinit/subscript minting no nodes with visitNode-routed bodies (calls → class, static reads → nothing), multi- segment extension resolveName, sugar extension names, the #selector shapes, and the value_argument label-forward skip. ONE fix found by the sweep (then pinned in the fixture + checklist): the shared `assignment` shadow-prune case is swift-live — declared-then-assigned `let X: T` prunes X as a value-ref target. Gates: sweeps 0-diff Alamofire 89/98, vapor 224/247, swift-nio 407/554 (--max-deferral 0.3 — swift error incidence is 9–27% on BOTH arms, structural; every deferral count matches the survey's table exactly); full-init dumps byte-identical ×3 (31.9k/20.7k/126.3k lines); the Alamofire census reproduces property=348 (the #1020 number) on the kernel arm; kernel-swift-parity suite (206-line torture + CRLF + the #if-between-enum- cases defer fixture) + swift grammar-parity row; full suite 2,626 green ×2 under CODEGRAPH_KERNEL_EXPECT=1. DEFAULT_ROUTED += swift (14 langs). Co-authored-by: Claude Fable 5 --- CHANGELOG.md | 3 +- .../fixtures/kernel-parity/torture.swift | 206 +++ __tests__/kernel-grammar-parity.test.ts | 2 +- __tests__/kernel-swift-parity.test.ts | 127 ++ codegraph-kernel/Cargo.lock | 11 + codegraph-kernel/Cargo.toml | 5 + codegraph-kernel/src/langs.rs | 7 +- codegraph-kernel/src/lib.rs | 2 + codegraph-kernel/src/swift.rs | 1603 +++++++++++++++++ docs/design/kotlin-kernel-port-checklist.md | 1121 ++++++++++++ docs/design/rust-kernel-migration-plan.md | 2 +- docs/design/swift-kernel-port-checklist.md | 1084 +++++++++++ scripts/kernel-parity.mjs | 3 +- src/extraction/grammars.ts | 9 + src/extraction/kernel/index.ts | 6 + src/extraction/wasm/tree-sitter-swift.wasm | Bin 0 -> 3726622 bytes 16 files changed, 4185 insertions(+), 6 deletions(-) create mode 100644 __tests__/fixtures/kernel-parity/torture.swift create mode 100644 __tests__/kernel-swift-parity.test.ts create mode 100644 codegraph-kernel/src/swift.rs create mode 100644 docs/design/kotlin-kernel-port-checklist.md create mode 100644 docs/design/swift-kernel-port-checklist.md create mode 100755 src/extraction/wasm/tree-sitter-swift.wasm diff --git a/CHANGELOG.md b/CHANGELOG.md index 597be98..4d2d26b 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,7 +11,7 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). ### New Features -- Indexing TypeScript, TSX, JavaScript, JSX, Java, Python, Go, C, C++, Rust, C#, Ruby, and PHP projects is faster: parsing and symbol extraction now run in a native engine when a prebuilt binary is available for your platform (release bundles include one), producing exactly the same graph — verified byte-for-byte against the previous engine on real repositories, from small libraries up to vscode-, dubbo-, django-, git-, protobuf-, tokio-, rust-analyzer-, jellyfin-, rails-, and symfony-scale codebases (Lombok-generated members, C function-pointer tables, and Unreal-Engine-style macro-heavy headers included; CUDA and Metal sources ride the C++ path). The speedup is largest on resource-constrained machines like CI runners. No setup needed: platforms without the native binary, and individual files with syntax errors, automatically use the previous engine, and `CODEGRAPH_KERNEL=0` turns the native path off entirely. +- Indexing TypeScript, TSX, JavaScript, JSX, Java, Python, Go, C, C++, Rust, C#, Ruby, PHP, and Swift projects is faster: parsing and symbol extraction now run in a native engine when a prebuilt binary is available for your platform (release bundles include one), producing exactly the same graph — verified byte-for-byte against the previous engine on real repositories, from small libraries up to vscode-, dubbo-, django-, git-, protobuf-, tokio-, rust-analyzer-, jellyfin-, rails-, symfony-, and swift-nio-scale codebases (Lombok-generated members, C function-pointer tables, and Unreal-Engine-style macro-heavy headers included; CUDA and Metal sources ride the C++ path). The speedup is largest on resource-constrained machines like CI runners. No setup needed: platforms without the native binary, and individual files with syntax errors, automatically use the previous engine, and `CODEGRAPH_KERNEL=0` turns the native path off entirely. - Reference resolution now runs in parallel on large projects. When a project has enough pending references to make it worthwhile (roughly 150k+, typical for big Java/Kotlin/Spring codebases), resolution fans out across worker threads while results are applied in the exact order the single-threaded path would have used — the graph comes out byte-for-byte identical, about twice as fast end-to-end on a 4,000-file Java project in our testing. Small projects keep the single-threaded path automatically (the fan-out costs more than it saves there). Set `CODEGRAPH_NO_PARALLEL_RESOLVE=1` to disable, or `CODEGRAPH_PARALLEL_RESOLVE_MIN=` to tune when it engages. - Indexing large projects got another sizeable speedup — about a quarter less wall-clock on the same 4,000-file Java project, with the graph still byte-for-byte identical. Two changes: the database no longer interleaves expensive checkpoint housekeeping into the middle of resolution on a fresh index (it's folded once at the end instead), and while one batch's results are being written out, the worker threads are already resolving the next batch instead of sitting idle. - The dynamic-dispatch analysis that runs at the end of indexing (callback, event, and framework wiring) now runs its passes in parallel on large projects, cutting that stage roughly in half there — and a pass that crashes now retries safely instead of failing the whole index, which also makes very large codebases that previously died in this stage more likely to index to completion. Graphs remain byte-for-byte identical. @@ -31,6 +31,7 @@ and adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). - Rust files also parse with an up-to-date grammar now (the previously bundled build dated from 2023), which additionally sharpens method-call attribution: calls through struct fields resolve with receiver context instead of falling back to ambiguous bare-name matching, removing a class of wrong call edges on common names like `len` and `start`. - Ruby files also parse with an up-to-date grammar now (the previously bundled build dated from early 2024), which fixes a misparse of safe-navigation operator-method calls (`recv&.!= x`) that had recorded the wrong callee name. - PHP files also parse with an up-to-date grammar now (the previously bundled build dated from 2023): files using modern PHP features — enum constants, PHP 8.4 property hooks, parenthesis-free `new X()->method()` chaining — no longer hit parse errors or misparses that dropped or garbled their symbols, so codebases like Symfony and Laravel index substantially more accurately. +- Swift files also parse with an up-to-date grammar now (the previously bundled build dated from 2023): swift-testing `#expect`, `#Preview`-style macros, the `package` access modifier, and typed `throws` no longer produce parse errors that dropped surrounding symbols — server-side Swift projects like Vapor see the biggest recovery. - Searching or exploring by field names now finds the code that defines them. A query made of object keys or API field names (`profileInfo isTrialEligible quotaInfo billingMethod`) used to return unrelated results while the defining files never appeared, because three retrieval steps each dropped multi-word camelCase terms: an internal case-comparison bug, a match step that only considered classes (never functions or methods), and exploration seeding that required exact symbol-name matches. All three are fixed — `codegraph_explore` with a bag of field names now surfaces the controllers and services that assemble those fields. (#1196) - `codegraph.json`'s `includeIgnored` works again for the "folder of repos" layout: when one `.gitignore` rule covers a parent directory (`/repos/`) holding several embedded git repositories, opting in the individual repos (`"includeIgnored": ["repos/a/"]` — the exact spelling `codegraph init`'s own hint suggests) previously matched nothing and indexed zero files, looping the same suggestion back at you. Both spellings now work — name the parent directory to opt in everything under it, or name individual repos to opt in just those — and the hint no longer re-suggests repos that are already configured. (#1295) - Method calls on literals (`", ".join(...)` in Python, `"x".split(...)` in JavaScript, and the like) no longer produce call edges to unrelated project functions that happen to share the builtin's name — a codebase with a function called `join`, `get`, or `update` could show phantom callers from every string-builtin use. Additionally, a function nested inside another function is now only matched as a call target from inside its container, since it isn't reachable from anywhere else. Blast-radius and affected-test results get cleaner on Python and JavaScript codebases especially. (#1230) diff --git a/__tests__/fixtures/kernel-parity/torture.swift b/__tests__/fixtures/kernel-parity/torture.swift new file mode 100644 index 0000000..d0c4a3e --- /dev/null +++ b/__tests__/fixtures/kernel-parity/torture.swift @@ -0,0 +1,206 @@ +import Foundation +import UIKit.UIView + +/// Class doc line one +/// Class doc line two +public final class Session: NSObject, RequestDelegate { + let rootQueue: DispatchQueue = DispatchQueue(label: "root") + var mutable = 0 + static let SHARED_MAX: Int = 5 + static var counter = 0 + lazy var expensive: Cache = Cache.build() + @Published private var wrapped: Bool = false + weak var delegate: SessionDelegate? + var observed: Int = 0 { + willSet { prepare(newValue) } + didSet { react(oldValue) } + } + var isCloudProxy: Bool { return check(SHARED_MAX) } + open class func classFunc() {} + + /// method doc + public func request(_ convertible: URLConvertible, method: HTTPMethod) -> DataRequest { + let req = DataRequest.make().validate() + let m = HTTPMethod.get + let g = Session.SHARED_MAX + self.own() + super.retain() + rootQueue.async { self.perform(req) } + return req + } + init(raw: String) { + self.raw = raw + setupMonitor() + } + deinit { cleanup() } + subscript(index: Int) -> Foo { get { store[index] } set { store[index] = newValue } } +} + +struct HTTPMethod: RawRepresentable, Equatable { + let rawValue: String + static let get = HTTPMethod(rawValue: "GET") +} + +enum AFError: Error, CustomStringConvertible { + case invalidURL(url: URLConvertible) + case explicitlyCancelled, sessionDeinitialized + indirect case wrapped(AFError) + var description: String { renderDescription() } + static func make() -> AFError { .explicitlyCancelled } +} + +protocol RequestDelegate: AnyObject { + var sessionState: Int { get } + func didFinish(_ request: Request) + static func build() -> Self +} + +extension Session: EventMonitor { + func heard(event: Event) { record(event) } +} + +extension KF.Builder { + func done() -> KF.Builder { self } +} + +extension Array where Element: Equatable { + func dedup() -> [Element] { self } +} + +actor Counter { + var n = 0 + func bump() { n += 1 } +} + +typealias Handler = (Data) -> Void +typealias BuilderAlias = KF.Builder + +let TOP_LEVEL_MAX = 3 +var topVar: Int = compute() + +func freeFn(a: Int, cb: @escaping (Int) -> Void) -> Session? { + helper() + Foo() + obj.method(1) + a.b.deep() + x?.optCall() + y!.forced() + Foo.make().draw() + foo.bar().baz() + "lit".upper() + arr.map { $0.name } + let tbl = [cbA, cbB] + o.cb = handler + reg2(onFire) + forward(value: value) + let sel = #selector(Holder.fire) + defer { cleanup() } + let d = dict["k"] + return nil +} + +func onFire() {} +func handler() {} +func cbA() {} +func cbB() {} + +// ---- extension rows (checklist inventory) ---- +// non-ASCII line before a symbol: café ünïcode 😀 +@objc enum Suit: Int { + case hearts = 1 + case spades +} + +@main struct MainApp { + var body: some View { VStack { Text(label) } } +} + +/** block doc is IGNORED and breaks the chain */ +func blockDoc() {} + +/// kept over attribute +@objc func attributed() {} + +func <+> (lhs: Session, rhs: Session) -> Session { lhs } + +public class Visi { + public private(set) var setterGated = 1 + static let A_B: Int = 2 + let (tup, tup2) = makePair() + @Siblings(through: Pivot.self, from: \.$left) var siblings: [Tag] +} + +protocol Inherited: AnyObject, Identifiable { + var reqComputed: String { get set } + static var reqStatic: Int { get } +} + +extension [ServerTrustEvaluating] { + func sugarExt() {} +} + +func voidParamProof(cb: (Void) -> Void) -> Result { + callMe() + return .success(Foo()) +} + +func nestedGenericRet() -> Result, Err> { fail() } +func voidRet() -> Void { noop() } +func tupleRet() -> (Int, Foo) { (1, Foo()) } +func fnRet() -> (Int) -> Foo { { _ in Foo() } } +func optRet() -> Session? { nil } +func builderRet() -> KF.Builder { KF.Builder() } + +func callZooExtra(m: [[Int]], arr: [Int], f: () -> Void) { + Foo.init(raw: "x") + """ + multi + """.trimmed() + ["k": 1].lookup() + (f)() + arr[0] + m[1][2] + .make() + try? thrower() + Task { await asyncFn() } + let msg = "count \(counter.next())" + #warning("torture warning") +} + +func staticReads(u: User) { + let c = Color.red + let r = Suit.hearts.rawValue + let s = UserModel.self + let d = Deep.Nested.leaf + let i = lowercase.field + let k = \Foo.bar +} + +#if os(iOS) +func insideDirective() { directiveCall() } +#endif + +// declared-then-assigned: the assignment-prune case (kernel-sweep-caught) — +// laterAssigned MUST be pruned as a value-ref target. +let laterAssigned: Int +if TOP_LEVEL_MAX > 2 { + laterAssigned = 1 +} else { + laterAssigned = 2 +} +let readsLater = laterAssigned + TOP_LEVEL_MAX + +func guardNoPrune() { + guard let TOP_LEVEL_MAX = optSource() else { return } + use(TOP_LEVEL_MAX) +} + +func fnRefExtras() { + reg(cb: onFire) + let sel1 = #selector(fire) + let sel2 = #selector(onNote(_:)) + self.x = x +} + +import class Darwin.FILE +@testable import TortureKit diff --git a/__tests__/kernel-grammar-parity.test.ts b/__tests__/kernel-grammar-parity.test.ts index e9e241f..4747348 100644 --- a/__tests__/kernel-grammar-parity.test.ts +++ b/__tests__/kernel-grammar-parity.test.ts @@ -36,7 +36,7 @@ const kernelBuilt = fs.existsSync(KERNEL_PATH); // Every kernel-capable language. `jsx` shares the javascript grammar on BOTH // paths (langs.rs mirrors WASM_GRAMMAR_FILES), so the distinct grammars are: -const GRAMMAR_LANGUAGES: Language[] = ['typescript', 'tsx', 'javascript', 'java', 'python', 'go', 'c', 'cpp', 'rust', 'csharp', 'ruby', 'php']; +const GRAMMAR_LANGUAGES: Language[] = ['typescript', 'tsx', 'javascript', 'java', 'python', 'go', 'c', 'cpp', 'rust', 'csharp', 'ruby', 'php', 'swift']; describe.skipIf(!kernelBuilt)('kernel↔wasm grammar parity', () => { beforeAll(async () => { diff --git a/__tests__/kernel-swift-parity.test.ts b/__tests__/kernel-swift-parity.test.ts new file mode 100644 index 0000000..ae0f182 --- /dev/null +++ b/__tests__/kernel-swift-parity.test.ts @@ -0,0 +1,127 @@ +/** + * Kernel↔wasm Swift extraction parity (R7b of the kernel migration). + * + * Asserts the native walker (codegraph-kernel/src/swift.rs) produces the SAME + * ExtractionResult as the wasm TreeSitterExtractor — nodes, edges, and + * unresolved refs compared as canonicalized multisets — over the checked-in + * torture fixture (torture.swift: the DEDICATED in-class property branch + * (#1020 — computed→property with getter walk, static let/var→constant/ + * variable, stored→field, owner-attributed decorator/type/attr-arg refs, + * observed-property field + class-attributed observer calls), extensions + * (multi-segment resolveName, sugar `[Proto]` names, where-clauses), + * everything-is-extends inheritance, the full call matrix (subscript reads, + * `defer`, optional-chaining receivers, #750 re-encode, literal-set + * membership quirks, implicit members), positional return types with the + * nested-generic failure, present-false isAsync, `open`→internal visibility, + * multi-case enum first-only minting, `/** *​/` docs ignored-and-chain- + * breaking, value-ref targets incl. the declared-then-assigned + * assignment-prune case the swift-nio sweep caught, SWIFT_SPEC fn-refs with + * the label-forward skip and #selector shapes) and its CRLF variant (derived + * in-memory — #1329). + * + * The full-repo sweep lives in scripts/kernel-parity.mjs (Alamofire/vapor/ + * swift-nio, --max-deferral 0.3 — swift error incidence is structurally + * 9–27% on BOTH arms); this suite keeps the invariant alive in `npm test`. + * Skips when no kernel binary is staged; CODEGRAPH_KERNEL_EXPECT=1 turns + * that into a failure (kernel-scaffold.test.ts). + */ + +import { describe, it, expect, beforeAll, beforeEach, afterEach } from 'vitest'; +import * as fs from 'fs'; +import * as path from 'path'; +import { extractFromSource } from '../src/extraction'; +import { initGrammars, loadGrammarsForLanguages } from '../src/extraction/grammars'; +import { tryKernelExtract, resetKernelForTests } from '../src/extraction/kernel'; +import type { ExtractionResult } from '../src/types'; + +const KERNEL_PATH = path.join( + __dirname, + '..', + 'codegraph-kernel', + 'prebuilds', + `${process.platform}-${process.arch}`, + 'codegraph-kernel.node' +); +const kernelBuilt = fs.existsSync(KERNEL_PATH); + +const FIXTURE_DIR = path.join(__dirname, 'fixtures', 'kernel-parity'); + +function canon(result: ExtractionResult): { nodes: string[]; edges: string[]; refs: string[] } { + return { + nodes: result.nodes + .map(({ updatedAt: _u, ...n }) => JSON.stringify(n, Object.keys(n).sort())) + .sort(), + edges: result.edges.map((e) => JSON.stringify(e, Object.keys(e).sort())).sort(), + refs: result.unresolvedReferences + .map((r) => JSON.stringify(r, Object.keys(r).sort())) + .sort(), + }; +} + +const ENV_KEYS = ['CODEGRAPH_KERNEL', 'CODEGRAPH_KERNEL_LANGS'] as const; +let savedEnv: Record; + +describe.skipIf(!kernelBuilt)('kernel Swift extraction parity', () => { + beforeAll(async () => { + await initGrammars(); + await loadGrammarsForLanguages(['swift']); + }); + + beforeEach(() => { + savedEnv = Object.fromEntries(ENV_KEYS.map((k) => [k, process.env[k]])); + resetKernelForTests(); + }); + + afterEach(() => { + for (const k of ENV_KEYS) { + if (savedEnv[k] === undefined) delete process.env[k]; + else process.env[k] = savedEnv[k]; + } + resetKernelForTests(); + }); + + function assertParity(filePath: string, source: string, minNodes = 3): void { + process.env.CODEGRAPH_KERNEL_LANGS = 'all'; + delete process.env.CODEGRAPH_KERNEL; + const viaKernel = tryKernelExtract(filePath, source, 'swift'); + expect(viaKernel, `kernel extraction failed for ${filePath}`).not.toBeNull(); + + process.env.CODEGRAPH_KERNEL = '0'; + const viaWasm = extractFromSource(filePath, source, 'swift'); + delete process.env.CODEGRAPH_KERNEL; + + const k = canon(viaKernel!); + const w = canon(viaWasm); + expect(k.nodes, `${filePath}: nodes`).toEqual(w.nodes); + expect(k.edges, `${filePath}: edges`).toEqual(w.edges); + expect(k.refs, `${filePath}: refs`).toEqual(w.refs); + expect(viaWasm.nodes.length).toBeGreaterThanOrEqual(minNodes); + } + + it('torture fixture: property branch, extensions, call matrix, value refs, fn-refs', () => { + const file = path.join(FIXTURE_DIR, 'torture.swift'); + assertParity('fixtures/torture.swift', fs.readFileSync(file, 'utf8'), 40); + }); + + // CRLF variant — the shape every Windows autocrlf checkout has. Derived in + // memory so no platform or editor can silently normalize it away; pins the + // JS-multiline-^ docstring semantics for `///` runs (#1329). + it('torture fixture CRLF parity', () => { + const file = path.join(FIXTURE_DIR, 'torture.swift'); + const crlf = fs.readFileSync(file, 'utf8').replace(/(? { + // A NEW-only regression construct (`#if` between enum cases — the swift + // checklist's grammar-bump delta 5) — errors on the 0.7.3 grammar. + const broken = 'enum E {\n case a\n#if DEBUG\n case b\n#endif\n}\n'; + process.env.CODEGRAPH_KERNEL_LANGS = 'all'; + delete process.env.CODEGRAPH_KERNEL; + expect(tryKernelExtract('src/Broken.swift', broken, 'swift')).toBeNull(); + process.env.CODEGRAPH_KERNEL = '0'; + const viaWasm = extractFromSource('src/Broken.swift', broken, 'swift'); + delete process.env.CODEGRAPH_KERNEL; + expect(viaWasm.nodes.some((n) => n.kind === 'file')).toBe(true); + }); +}); diff --git a/codegraph-kernel/Cargo.lock b/codegraph-kernel/Cargo.lock index 3011e05..b8ebb90 100644 --- a/codegraph-kernel/Cargo.lock +++ b/codegraph-kernel/Cargo.lock @@ -62,6 +62,7 @@ dependencies = [ "tree-sitter-python", "tree-sitter-ruby", "tree-sitter-rust", + "tree-sitter-swift", "tree-sitter-typescript", ] @@ -594,6 +595,16 @@ dependencies = [ "tree-sitter-language", ] +[[package]] +name = "tree-sitter-swift" +version = "0.7.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "fe36052155b9dd69ca82b3b8f1b4ccfb2d867125ac1a4db1dd7331829242668c" +dependencies = [ + "cc", + "tree-sitter-language", +] + [[package]] name = "tree-sitter-typescript" version = "0.23.2" diff --git a/codegraph-kernel/Cargo.toml b/codegraph-kernel/Cargo.toml index 71f11de..e5e149c 100644 --- a/codegraph-kernel/Cargo.toml +++ b/codegraph-kernel/Cargo.toml @@ -41,6 +41,11 @@ tree-sitter-ruby = "=0.23.1" # php: the walker calls LANGUAGE_PHP (the full HTML-interleaving variant the # wasm ships) — NEVER LANGUAGE_PHP_ONLY, which errors on leading HTML. tree-sitter-php = "=0.24.2" +# swift: the vendored wasm is built from THIS crate's tarball src/ (the tag's +# checked-in parser.c is an older ABI-14 generation that can never sha-match; +# grammar.json rules are JSON-equal — swift checklist header). parser.c is +# ~20MB generated — expect slow compiles. +tree-sitter-swift = "=0.7.3" [build-dependencies] napi-build = "2" diff --git a/codegraph-kernel/src/langs.rs b/codegraph-kernel/src/langs.rs index 0f93532..455ffc0 100644 --- a/codegraph-kernel/src/langs.rs +++ b/codegraph-kernel/src/langs.rs @@ -15,9 +15,9 @@ use tree_sitter::Language; /// Languages this kernel binary can extract (reported by contractInfo; /// TS-side routing policy decides what actually routes). -pub const LANGUAGES: [&str; 13] = [ +pub const LANGUAGES: [&str; 14] = [ "typescript", "tsx", "javascript", "jsx", "java", "python", "go", "c", "cpp", "rust", - "csharp", "ruby", "php", + "csharp", "ruby", "php", "swift", ]; pub fn grammar_for(language: &str) -> Option { @@ -44,6 +44,9 @@ pub fn grammar_for(language: &str) -> Option { // R7b: v0.24.2, the full HTML-interleaving variant — LANGUAGE_PHP, // NEVER LANGUAGE_PHP_ONLY (which errors on leading HTML). "php" => Some(tree_sitter_php::LANGUAGE_PHP.into()), + // R7b: crate 0.7.3 — the vendored wasm is built from this crate's own + // tarball src/ (table identity by construction; see grammars.ts). + "swift" => Some(tree_sitter_swift::LANGUAGE.into()), _ => None, } } diff --git a/codegraph-kernel/src/lib.rs b/codegraph-kernel/src/lib.rs index 555a9a0..c3f946e 100644 --- a/codegraph-kernel/src/lib.rs +++ b/codegraph-kernel/src/lib.rs @@ -28,6 +28,7 @@ mod langs; mod php; mod ruby; mod rustlang; +mod swift; mod textutil; mod python; mod tsjs; @@ -219,6 +220,7 @@ pub fn extract_file(file_path: String, content: String, language: String) -> Res "csharp" => csharp::extract(&file_path, &content).map_err(Error::from_reason)?, "ruby" => ruby::extract(&file_path, &content).map_err(Error::from_reason)?, "php" => php::extract(&file_path, &content).map_err(Error::from_reason)?, + "swift" => swift::extract(&file_path, &content).map_err(Error::from_reason)?, _ => tsjs::extract(&file_path, &content, &language).map_err(Error::from_reason)?, }; Ok(ExtractBuffers { diff --git a/codegraph-kernel/src/swift.rs b/codegraph-kernel/src/swift.rs new file mode 100644 index 0000000..e365b71 --- /dev/null +++ b/codegraph-kernel/src/swift.rs @@ -0,0 +1,1603 @@ +//! Swift extraction — a faithful Rust port of `TreeSitterExtractor`'s Swift +//! paths (src/extraction/tree-sitter.ts) plus languages/swift.ts. +//! +//! Same porting contract as the other walkers: behavior parity, bug-for-bug. +//! The authoritative quirk list is docs/design/swift-kernel-port-checklist.md. +//! The port's center of gravity is the DEDICATED in-class property branch +//! (#1020 — Alamofire's 348 `property` nodes): computed properties become +//! `property` nodes whose getter walks with the property pushed; stored +//! `static let/var` → constant/variable, instance stored → field; decorator/ +//! type-annotation/attr-arg refs all attach to the ENCLOSING TYPE; stored +//! declarations descend so initializer calls attribute to the class. Also +//! preserved on purpose: `parameter` field never resolves (zero param type +//! refs, zero signatures), isAsync is present-false (dead hook), `open` → +//! internal visibility, everything-is-`extends` inheritance (first +//! type_identifier of each specifier), no instantiates refs ever (`Foo()` is +//! a plain call), subscript reads as `calls arr`, `defer` as `calls defer`, +//! multi-case enum entries minting only the first case, `/** */` block docs +//! ignored AND chain-breaking, init/deinit/subscript minting no nodes with +//! their bodies routed through visitNode (calls → class, static reads → +//! nothing). Positions in UTF-16 code units. Files with parse errors defer +//! to wasm (structurally high incidence, 9–27% — the sweep runs +//! --max-deferral 0.3 by measured both-arm reality). + +use crate::buffers::{ + build_meta, edge_kind_index, node_kind_index, Arena, BoolFlags, EdgeRow, EmitOut, NodeRow, + RefRow, StrRef, Tables, FLAG_IS_ASYNC, FLAG_IS_EXPORTED, FLAG_IS_STATIC, FUNCTION_REF_CODE, + NONE, NONE_STR, +}; +use crate::docstring::preceding_docstring; +use crate::ids; +use crate::textutil as util; +use regex::Regex; +use std::collections::{HashMap, HashSet, VecDeque}; +use std::sync::OnceLock; +use tree_sitter::{Node, Parser}; + +const MAX_VALUE_REF_NODES: usize = 20_000; + +/// BUILTIN_TYPES (tree-sitter.ts) — full shared table (`Bool` is NOT in it; +/// `Int`/`String`/`Double` are, via the Scala rows — checklist nuances). +fn is_builtin_type(name: &str) -> bool { + matches!( + name, + "string" | "number" | "boolean" | "void" | "null" | "undefined" | "never" | "any" + | "unknown" | "object" | "symbol" | "bigint" | "true" | "false" + | "str" | "bool" | "i8" | "i16" | "i32" | "i64" | "i128" | "isize" + | "u8" | "u16" | "u32" | "u64" | "u128" | "usize" | "f32" | "f64" | "char" + | "int" | "long" | "short" | "byte" | "float" | "double" + | "int8" | "int16" | "int32" | "int64" | "uint8" | "uint16" | "uint32" | "uint64" + | "float32" | "float64" | "complex64" | "complex128" | "rune" | "error" + | "Int" | "Long" | "Short" | "Byte" | "Float" | "Double" | "Boolean" | "Char" + | "Unit" | "String" | "Any" | "AnyRef" | "AnyVal" | "Nothing" | "Null" + ) +} + +/// NAME_STOPLIST (function-ref.ts). +fn is_stoplisted(name: &str) -> bool { + matches!( + name, + "this" | "self" | "super" | "null" | "nil" | "true" | "false" | "undefined" | "new" + | "NULL" | "nullptr" | "None" + ) +} + +/// LITERAL_RECEIVER_TYPES (tree-sitter.ts:373) — full shared set. Note the +/// swift-relevant membership quirks: `line_string_literal` IS in it, +/// `multi_line_string_literal` and `dictionary_literal` are NOT. +fn is_literal_receiver(kind: &str) -> bool { + matches!( + kind, + "string" | "string_literal" | "interpreted_string_literal" | "raw_string_literal" + | "template_string" | "concatenated_string" | "formatted_string" | "f_string" + | "line_string_literal" | "string_content" | "heredoc_body" + | "number" | "number_literal" | "integer" | "integer_literal" | "float" + | "float_literal" | "int_literal" | "decimal_integer_literal" | "real_literal" + | "char_literal" | "character_literal" | "rune_literal" | "regex" | "regex_literal" + | "true" | "false" | "boolean_literal" | "bool_literal" | "none" | "null" | "nil" + | "null_literal" | "undefined" + | "list" | "list_literal" | "array" | "array_literal" | "array_creation_expression" + | "dictionary" | "dict_literal" | "object" | "tuple" | "set" + ) +} + +/// `/^[A-Za-z_]\w*$/` with JS's ASCII `\w`. +fn ascii_ident_re() -> &'static Regex { + static RE: OnceLock = OnceLock::new(); + RE.get_or_init(|| Regex::new(r"^[A-Za-z_][0-9A-Za-z_]*$").unwrap()) +} +/// getReturnType's generics strip (`/<[^>]*>/g`) — non-nesting (rust-class quirk). +fn generic_args_re() -> &'static Regex { + static RE: OnceLock = OnceLock::new(); + RE.get_or_init(|| Regex::new(r"<[^>]*>").unwrap()) +} +/// extractStaticMemberRef's capitalized-receiver test. +fn capitalized_re() -> &'static Regex { + static RE: OnceLock = OnceLock::new(); + RE.get_or_init(|| Regex::new(r"^[A-Z][A-Za-z0-9_]*$").unwrap()) +} + +/// JS `\s` for the chained-call inner-callee strip (`.replace(/\s+/g, '')`). +fn is_js_space(c: char) -> bool { + matches!( + c, + '\t' | '\n' | '\x0B' | '\x0C' | '\r' | ' ' | '\u{00A0}' | '\u{1680}' + | '\u{2000}'..='\u{200A}' | '\u{2028}' | '\u{2029}' | '\u{202F}' | '\u{205F}' + | '\u{3000}' | '\u{FEFF}' + ) +} +fn strip_js_ws(s: &str) -> String { + s.chars().filter(|c| !is_js_space(*c)).collect() +} + +struct Scope { + row: u32, + kind: &'static str, + name: String, +} + +#[derive(Default)] +struct Extra { + docstring: Option, + signature: Option, + visibility: Option, + is_static: Option, + is_async: Option, + is_exported: Option, + return_type: Option, +} + +struct ValueScope<'t> { + row: u32, + node: Node<'t>, + name: String, +} + +struct Cand { + from: u32, + name: String, + line: u32, + column_byte: usize, + row: usize, +} + +struct SwiftPropInfo<'t> { + name_node: Option>, + is_let: bool, + is_computed: bool, +} + +pub struct Walker<'t> { + src: &'t str, + file_path: &'t str, + line_starts: Vec, + arena: Arena, + tables: Tables, + stack: Vec, + node_ids: Vec, + defined_fn_names: HashSet, + imported_names: HashSet, + fn_ref_cands: Vec, + fs_values: HashMap, + fs_value_counts: HashMap, + value_scopes: Vec>, +} + +pub fn extract(file_path: &str, source: &str) -> Result { + let grammar = crate::langs::grammar_for("swift").ok_or("no swift grammar")?; + let t0 = std::time::Instant::now(); + let mut parser = Parser::new(); + parser + .set_language(&grammar) + .map_err(|e| format!("set_language(swift) failed: {e}"))?; + let tree = parser + .parse(source, None) + .ok_or_else(|| "parser returned null tree".to_string())?; + if tree.root_node().has_error() { + return Err("defer: parse tree contains errors — wasm recovery is canonical".to_string()); + } + + let mut w = Walker { + src: source, + file_path, + line_starts: util::line_starts(source), + arena: Arena::default(), + tables: Tables::default(), + stack: Vec::new(), + node_ids: Vec::new(), + defined_fn_names: HashSet::new(), + imported_names: HashSet::new(), + fn_ref_cands: Vec::new(), + fs_values: HashMap::new(), + fs_value_counts: HashMap::new(), + value_scopes: Vec::new(), + }; + + let line_count = source.bytes().filter(|b| *b == b'\n').count() as u32 + 1; + let base_name = file_path.rsplit(['/', '\\']).next().unwrap_or(file_path); + let mut flags = BoolFlags::default(); + flags.set(FLAG_IS_EXPORTED, false); + let file_id = w.arena.put(&ids::file_node_id(file_path)); + let name_ref = w.arena.put(base_name); + let qn_ref = w.arena.put(file_path); + w.tables.push_node(&NodeRow { + kind: node_kind_index("file").unwrap(), + visibility: 0, + flags, + start_line: 1, + end_line: line_count, + start_column: 0, + end_column: 0, + name: name_ref, + qualified_name: qn_ref, + id: file_id, + docstring: NONE_STR, + signature: NONE_STR, + decorators: NONE_STR, + type_parameters: NONE_STR, + return_type: NONE_STR, + extra_json: NONE_STR, + }); + w.node_ids.push(ids::file_node_id(file_path)); + w.stack.push(Scope { row: 0, kind: "file", name: base_name.to_string() }); + + // No packageTypes — swift has no namespace node; top-level QNs are bare. + w.visit_node(tree.root_node()); + w.flush_fn_ref_candidates(); + w.flush_value_refs(tree.root_node()); + w.stack.pop(); + + let duration_ms = t0.elapsed().as_secs_f64() * 1000.0; + let meta = build_meta(&w.tables, w.arena.len(), NONE_STR, duration_ms); + Ok(EmitOut { + meta, + nodes: w.tables.nodes, + edges: w.tables.edges, + refs: w.tables.refs, + arena: w.arena.into_vec(), + }) +} + +/// firstSimpleIdentifier (tree-sitter.ts:261): BFS (FIFO), at most 40 nodes +/// popped, first `simple_identifier` wins. +fn first_simple_identifier<'t>(node: Option>) -> Option> { + let mut q: VecDeque> = VecDeque::new(); + if let Some(n) = node { + q.push_back(n); + } + let mut guard = 0; + while guard < 40 { + let Some(n) = q.pop_front() else { break }; + guard += 1; + if n.kind() == "simple_identifier" { + return Some(n); + } + for i in 0..n.named_child_count() { + if let Some(c) = n.named_child(i) { + q.push_back(c); + } + } + } + None +} + +/// lastNamedOfType (function-ref.ts:600): rightmost matching DESCENDANT in +/// document order (deeper matches override). +fn last_simple_identifier<'t>(node: Node<'t>) -> Option> { + let mut found: Option> = None; + for i in 0..node.named_child_count() { + let Some(child) = node.named_child(i) else { continue }; + if child.kind() == "simple_identifier" { + found = Some(child); + } + if let Some(deeper) = last_simple_identifier(child) { + found = Some(deeper); + } + } + found +} + +impl<'t> Walker<'t> { + fn text(&self, node: Node) -> &'t str { + &self.src[node.byte_range()] + } + fn line_of(&self, node: Node) -> u32 { + node.start_position().row as u32 + 1 + } + fn col_of(&self, node: Node) -> u32 { + util::col16(self.src, &self.line_starts, node.start_position().row, node.start_byte()) + } + fn end_col_of(&self, node: Node) -> u32 { + util::col16(self.src, &self.line_starts, node.end_position().row, node.end_byte()) + } + fn top_row(&self) -> u32 { + self.stack.last().map(|s| s.row).unwrap_or(0) + } + fn inside_class_like(&self) -> bool { + self.stack + .last() + .map(|s| matches!(s.kind, "class" | "struct" | "interface" | "trait" | "enum" | "module")) + .unwrap_or(false) + } + + fn push_ref(&mut self, from_row: u32, name: &str, kind_code: u8, line: u32, column: u32) { + let name_ref = self.arena.put(name); + self.tables.push_ref(&RefRow { + from_idx: from_row, + kind: kind_code, + line, + column, + reference_name: name_ref, + candidates: NONE_STR, + from_id_str: NONE_STR, + }); + if kind_code == edge_kind_index("imports").unwrap() { + if util::simple_name().is_match(name) { + self.imported_names.insert(name.to_string()); + } else if let Some(c) = util::qualified_import().captures(name) { + self.imported_names.insert(c[1].to_string()); + } + } + } + + fn push_ref_at(&mut self, from_row: u32, name: &str, kind_code: u8, node: Node) { + self.push_ref(from_row, name, kind_code, self.line_of(node), self.col_of(node)); + } + + // --- createNode ------------------------------------------------------------ + + fn create_node(&mut self, kind: &'static str, name: &str, node: Node<'t>, extra: Extra) -> Option { + if name.is_empty() { + return None; + } + let start_line = self.line_of(node); + let id = ids::node_id(self.file_path, kind, name, start_line); + let end_line = node.end_position().row as u32 + 1; // no resolveBody for swift + + let qualified = { + let mut parts: Vec<&str> = Vec::new(); + for s in &self.stack { + if s.kind != "file" { + parts.push(&s.name); + } + } + let mut qn = parts.join("::"); + if !qn.is_empty() { + qn.push_str("::"); + } + qn.push_str(name); + qn + }; + + let mut flags = BoolFlags::default(); + if let Some(v) = extra.is_exported { + flags.set(FLAG_IS_EXPORTED, v); + } + if let Some(v) = extra.is_async { + flags.set(FLAG_IS_ASYNC, v); + } + if let Some(v) = extra.is_static { + flags.set(FLAG_IS_STATIC, v); + } + let name_ref = self.arena.put(name); + let qn_ref = self.arena.put(&qualified); + let id_ref = self.arena.put(&id); + let doc_ref = opt_str(&mut self.arena, extra.docstring.as_deref()); + let sig_ref = opt_str(&mut self.arena, extra.signature.as_deref()); + let ret_ref = opt_str(&mut self.arena, extra.return_type.as_deref()); + let row = self.tables.push_node(&NodeRow { + kind: node_kind_index(kind).unwrap(), + visibility: extra.visibility.unwrap_or(0), + flags, + start_line, + end_line, + start_column: self.col_of(node), + end_column: self.end_col_of(node), + name: name_ref, + qualified_name: qn_ref, + id: id_ref, + docstring: doc_ref, + signature: sig_ref, + decorators: NONE_STR, // extractModifiers absent — never set from modifiers + type_parameters: NONE_STR, + return_type: ret_ref, + extra_json: NONE_STR, + }); + self.node_ids.push(id); + + let parent_row = self.top_row(); + self.tables.push_edge(&EdgeRow { + source_idx: parent_row, + target_idx: row, + kind: edge_kind_index("contains").unwrap(), + provenance: 0, + line: NONE, + column: NONE, + metadata_json: NONE_STR, + source_id_str: NONE_STR, + target_id_str: NONE_STR, + }); + + if kind == "function" || kind == "method" { + self.defined_fn_names.insert(name.to_string()); + } + // captureValueRefScope — struct:/enum: parents accepted (the swift + // static-let-namespacing idiom). + let target_kind_ok = kind == "constant" || kind == "variable"; + if target_kind_ok + && util::utf16_len(name) >= 3 + && util::has_upper_or_underscore().is_match(name) + { + let parent_ok = self + .stack + .last() + .map(|s| matches!(s.kind, "file" | "class" | "module" | "struct" | "enum")) + .unwrap_or(false); + if parent_ok { + self.fs_values.insert(name.to_string(), row); + *self.fs_value_counts.entry(name.to_string()).or_insert(0) += 1; + } + } + if matches!(kind, "function" | "method" | "constant" | "variable") { + self.value_scopes.push(ValueScope { row, node, name: name.to_string() }); + } + Some(row) + } + + // --- hooks (languages/swift.ts) ---------------------------------------------- + + /// extractName incl. the resolveName hook: a multi-segment extension name + /// (`extension KF.Builder`) takes the LAST type_identifier's text. + fn extract_name(&self, node: Node) -> String { + if node.kind() == "class_declaration" { + if let Some(name_node) = node.child_by_field_name("name") { + if name_node.kind() == "user_type" { + let ids: Vec = (0..name_node.named_child_count()) + .filter_map(|i| name_node.named_child(i)) + .filter(|c| c.kind() == "type_identifier") + .collect(); + if ids.len() > 1 { + return self.text(ids[ids.len() - 1]).to_string(); + } + } + } + } + if let Some(name_node) = node.child_by_field_name("name") { + return self.text(name_node).to_string(); + } + for i in 0..node.named_child_count() { + if let Some(c) = node.named_child(i) { + if matches!(c.kind(), "identifier" | "type_identifier" | "simple_identifier" | "constant") { + return self.text(c).to_string(); + } + } + } + "".to_string() + } + + /// getVisibility: whole-text substring matching over `modifiers` children; + /// default INTERNAL. `open` → internal, `fileprivate` → private (via the + /// 'private' substring), `public private(set)` → public (first match). + fn visibility_of(&self, node: Node) -> u8 { + for i in 0..node.child_count() { + let Some(child) = node.child(i) else { continue }; + if child.kind() == "modifiers" { + let text = self.text(child); + if text.contains("public") { + return 1; + } + if text.contains("private") { + return 2; + } + if text.contains("internal") { + return 4; + } + // 'fileprivate' arm is dead — 'private' already matched. + } + } + 4 // Swift defaults to internal + } + + /// isStatic: modifiers text contains 'static' OR 'class' (class members + /// count — deliberate; substring semantics preserved). + fn is_static(&self, node: Node) -> bool { + (0..node.child_count()) + .filter_map(|i| node.child(i)) + .any(|c| { + c.kind() == "modifiers" && { + let t = self.text(c); + t.contains("static") || t.contains("class") + } + }) + } + + /// isAsync: dead hook — `async` never sits inside `modifiers` (it's an + /// anon child after the params) → effectively always false, but PRESENT. + fn is_async(&self, node: Node) -> bool { + (0..node.child_count()) + .filter_map(|i| node.child(i)) + .any(|c| c.kind() == "modifiers" && self.text(c).contains("async")) + } + + /// extractSwiftReturnType — POSITIONAL: first user_type/optional_type after + /// the name simple_identifier, before function_body; last dotted segment; + /// generics stripped non-nesting; Void → None. + fn return_type_of(&self, node: Node) -> Option { + let mut seen_name = false; + for i in 0..node.named_child_count() { + let Some(child) = node.named_child(i) else { continue }; + if child.kind() == "simple_identifier" && !seen_name { + seen_name = true; + continue; + } + if !seen_name { + continue; + } + if child.kind() == "function_body" { + return None; + } + let type_node = match child.kind() { + "user_type" => Some(child), + "optional_type" => (0..child.named_child_count()) + .filter_map(|j| child.named_child(j)) + .find(|c| c.kind() == "user_type"), + _ => None, + }; + if child.kind() == "user_type" || child.kind() == "optional_type" { + let Some(t) = type_node else { return None }; + let name = generic_args_re() + .replace_all(self.text(t).trim(), "") + .into_owned(); + let last = name.rsplit('.').next().unwrap_or("").trim(); + if last.is_empty() || !ascii_ident_re().is_match(last) || last == "Void" { + return None; + } + return Some(last.to_string()); + } + } + None + } + + /// swiftPropertyInfo (tree-sitter.ts:277). + fn swift_property_info(&self, node: Node<'t>) -> SwiftPropInfo<'t> { + let pattern = node.child_by_field_name("name").or_else(|| { + (0..node.named_child_count()) + .filter_map(|i| node.named_child(i)) + .find(|c| matches!(c.kind(), "value_binding_pattern" | "pattern")) + }); + let binding = (0..node.named_child_count()) + .filter_map(|i| node.named_child(i)) + .find(|c| c.kind() == "value_binding_pattern"); + let is_let = binding + .map(|b| self.text(b).trim_start().starts_with("let")) + .unwrap_or(false); + let is_computed = (0..node.named_child_count()) + .filter_map(|i| node.named_child(i)) + .any(|c| matches!(c.kind(), "computed_property" | "protocol_property_requirements")); + SwiftPropInfo { name_node: first_simple_identifier(pattern), is_let, is_computed } + } + + // --- the dispatcher (visitNode, Swift-relevant branches) ----------------------- + + fn visit_node(&mut self, node: Node<'t>) { + let kind = node.kind(); + let mut skip_children = false; + + self.maybe_capture_fn_refs(node); + + if kind == "function_declaration" { + if self.inside_class_like() { + self.extract_method(node); + } else { + self.extract_function(node); + } + skip_children = true; + } else if kind == "class_declaration" { + // classifyClassNode: `struct`/`enum` keyword children; actor and + // extension fall through to 'class'. + let mut classified = "class"; + for i in 0..node.child_count() { + if let Some(c) = node.child(i) { + if c.kind() == "struct" { + classified = "struct"; + break; + } + if c.kind() == "enum" { + classified = "enum"; + break; + } + } + } + match classified { + "struct" => self.extract_struct(node), + "enum" => self.extract_enum(node), + _ => self.extract_class(node), + } + skip_children = true; + } else if kind == "protocol_declaration" { + self.extract_interface(node); + skip_children = true; + } else if kind == "typealias_declaration" { + skip_children = self.extract_type_alias(node); + } else if kind == "property_declaration" && !self.inside_class_like() { + // Top-level let/var (extractVariable's swift branch). Initializers + // are NEVER walked — candidates-only scan. + self.extract_variable(node); + self.scan_fn_ref_subtree(node, 0); + skip_children = true; + } else if matches!(kind, "property_declaration" | "protocol_property_declaration") + && self.inside_class_like() + { + skip_children = self.dedicated_property_branch(node); + } else if kind == "import_declaration" { + self.extract_import(node); + } else if kind == "call_expression" { + self.extract_call(node); + } + // init/deinit/subscript declarations, macro_invocation, directive, + // diagnostic, operator/precedence declarations, protocol function + // requirements, associatedtype: no branch — recursed. Their calls + // attribute to the enclosing scope; static-member reads inside them + // emit NOTHING (the pass is body-walker-only). + + if !skip_children { + for i in 0..node.named_child_count() { + if let Some(c) = node.named_child(i) { + self.visit_node(c); + } + } + } + } + + /// THE DEDICATED PROPERTY BRANCH (tree-sitter.ts:1113-1193, #1020). + /// Returns skipChildren. + fn dedicated_property_branch(&mut self, node: Node<'t>) -> bool { + let owner_row = self.top_row(); + let info = self.swift_property_info(node); + let mut computed_prop: Option<(u32, String)> = None; + + if let Some(name_node) = info.name_node { + let name = self.text(name_node).to_string(); + if info.is_computed { + let row = self.create_node( + "property", + &name, + node, + Extra { + visibility: Some(self.visibility_of(node)), + is_static: Some(self.is_static(node)), + ..Extra::default() + }, + ); + if let Some(row) = row { + computed_prop = Some((row, name)); + } + } else { + let is_static = self.is_static(node); + let kind: &'static str = if is_static { + if info.is_let { "constant" } else { "variable" } + } else { + "field" + }; + self.create_node( + kind, + &name, + node, + Extra { + visibility: Some(self.visibility_of(node)), + is_static: Some(is_static), + ..Extra::default() + }, + ); + } + } + + // All three ref passes attach to the ENCLOSING TYPE (ownerId). + self.extract_decorators_for(node, owner_row); + // extractVariableTypeAnnotation: the direct type_annotation child. + let ta = (0..node.named_child_count()) + .filter_map(|i| node.named_child(i)) + .find(|c| c.kind() == "type_annotation"); + if let Some(ta) = ta { + self.extract_type_refs_from_subtree(ta, owner_row); + } + // walkAttrArgs: extractStaticMemberRef over the whole modifiers subtree + // (`@Siblings(through: Pivot.self)` metatype args). + let mods = (0..node.named_child_count()) + .filter_map(|i| node.named_child(i)) + .find(|c| c.kind() == "modifiers"); + if let Some(mods) = mods { + self.walk_attr_args(mods); + } + + if let Some((row, name)) = computed_prop { + let getter = (0..node.named_child_count()) + .filter_map(|i| node.named_child(i)) + .find(|c| matches!(c.kind(), "computed_property" | "protocol_property_requirements")); + if let Some(getter) = getter { + self.stack.push(Scope { row, kind: "property", name }); + self.visit_function_body(getter); + self.stack.pop(); + } + return true; // skipChildren — computed only + } + // Stored: descend generically — initializer calls attribute to the + // CLASS; observers' bodies likewise; modifiers re-walk is harmless. + false + } + + fn walk_attr_args(&mut self, n: Node<'t>) { + self.extract_static_member_ref(n); + for i in 0..n.named_child_count() { + if let Some(c) = n.named_child(i) { + self.walk_attr_args(c); + } + } + } + + // --- visitFunctionBody --------------------------------------------------------- + + fn visit_function_body(&mut self, body: Node<'t>) { + self.visit_for_calls_and_structure(body); + } + + fn visit_for_calls_and_structure(&mut self, node: Node<'t>) { + let kind = node.kind(); + self.maybe_capture_fn_refs(node); + + if kind == "call_expression" { + self.extract_call(node); + } + // (INSTANTIATION_KINDS has no swift types; extractBareCall absent.) + + self.extract_static_member_ref(node); + + if kind == "function_declaration" { + let name = self.extract_name(node); + if name != "" { + self.extract_function(node); + return; + } + } + if kind == "class_declaration" { + let mut classified = "class"; + for i in 0..node.child_count() { + if let Some(c) = node.child(i) { + if c.kind() == "struct" { + classified = "struct"; + break; + } + if c.kind() == "enum" { + classified = "enum"; + break; + } + } + } + match classified { + "struct" => self.extract_struct(node), + "enum" => self.extract_enum(node), + _ => self.extract_class(node), + } + return; + } + if kind == "protocol_declaration" { + self.extract_interface(node); + return; + } + + for i in 0..node.named_child_count() { + if let Some(c) = node.named_child(i) { + self.visit_for_calls_and_structure(c); + } + } + } + + // --- extractors ----------------------------------------------------------------- + + fn extract_function(&mut self, node: Node<'t>) { + let name = self.extract_name(node); + if name == "" { + if let Some(body) = node.child_by_field_name("body") { + self.visit_function_body(body); + } + return; + } + let extra = Extra { + docstring: preceding_docstring(node, self.src), + signature: None, // getSignature reads the never-resolving 'parameter' field + visibility: Some(self.visibility_of(node)), + is_async: Some(self.is_async(node)), // present-false (dead hook) + is_static: Some(self.is_static(node)), + return_type: self.return_type_of(node), + ..Extra::default() + }; + let Some(row) = self.create_node("function", &name, node, extra) else { return }; + self.extract_type_annotations(node, row); + self.extract_decorators_for(node, row); + self.stack.push(Scope { row, kind: "function", name }); + if let Some(body) = node.child_by_field_name("body") { + self.visit_function_body(body); + } + self.stack.pop(); + } + + fn extract_method(&mut self, node: Node<'t>) { + let name = self.extract_name(node); + let extra = Extra { + docstring: preceding_docstring(node, self.src), + signature: None, + visibility: Some(self.visibility_of(node)), + is_async: Some(self.is_async(node)), + is_static: Some(self.is_static(node)), + return_type: self.return_type_of(node), + ..Extra::default() + }; + let Some(row) = self.create_node("method", &name, node, extra) else { return }; + self.extract_type_annotations(node, row); + self.extract_decorators_for(node, row); + self.stack.push(Scope { row, kind: "method", name }); + if let Some(body) = node.child_by_field_name("body") { + self.visit_function_body(body); + } + self.stack.pop(); + } + + fn extract_class(&mut self, node: Node<'t>) { + let name = self.extract_name(node); + let extra = Extra { + docstring: preceding_docstring(node, self.src), + visibility: Some(self.visibility_of(node)), + ..Extra::default() + }; + let Some(row) = self.create_node("class", &name, node, extra) else { return }; + self.extract_inheritance(node, row); + // primaryCtor refs: csharp-only (no parameter_list child type). + // Classes DO get decorates (`@Observable class`), unlike struct/enum. + self.extract_decorators_for(node, row); + self.stack.push(Scope { row, kind: "class", name }); + let body = node.child_by_field_name("body").unwrap_or(node); + for i in 0..body.named_child_count() { + if let Some(c) = body.named_child(i) { + self.visit_node(c); + } + } + self.stack.pop(); + } + + fn extract_struct(&mut self, node: Node<'t>) { + // Body gate (:1876) — bodiless mints nothing (record exemption is C#). + let Some(body) = node.child_by_field_name("body") else { return }; + let name = self.extract_name(node); + let extra = Extra { + docstring: preceding_docstring(node, self.src), + visibility: Some(self.visibility_of(node)), + ..Extra::default() + }; + let Some(row) = self.create_node("struct", &name, node, extra) else { return }; + self.extract_inheritance(node, row); + // NO extractDecoratorsFor for structs (`@main struct` emits nothing). + self.stack.push(Scope { row, kind: "struct", name }); + for i in 0..body.named_child_count() { + if let Some(c) = body.named_child(i) { + self.visit_node(c); + } + } + self.stack.pop(); + } + + fn extract_enum(&mut self, node: Node<'t>) { + let Some(body) = node.child_by_field_name("body") else { return }; + let name = self.extract_name(node); + let extra = Extra { + docstring: preceding_docstring(node, self.src), + visibility: Some(self.visibility_of(node)), + ..Extra::default() + }; + let Some(row) = self.create_node("enum", &name, node, extra) else { return }; + // Raw-value types ride inheritance (`enum Suit: String` → extends + // String — extends refs have NO builtin filter). NO decorates. + self.extract_inheritance(node, row); + self.stack.push(Scope { row, kind: "enum", name }); + for i in 0..body.named_child_count() { + let Some(child) = body.named_child(i) else { continue }; + if child.kind() == "enum_entry" { + self.extract_enum_members(child); + } else { + self.visit_node(child); + } + } + self.stack.pop(); + } + + fn extract_enum_members(&mut self, node: Node<'t>) { + // `name` field = the FIRST case name only — `case put, delete` mints + // ONLY `put` (the identifier-scan fallback is dead, the field always + // resolves). Associated/raw values never walked. + if let Some(name_node) = node.child_by_field_name("name") { + let name = self.text(name_node).to_string(); + self.create_node("enum_member", &name, node, Extra::default()); + } + } + + fn extract_interface(&mut self, node: Node<'t>) { + let name = self.extract_name(node); + let extra = Extra { + docstring: preceding_docstring(node, self.src), + ..Extra::default() // NO visibility, NO decorates + }; + let Some(row) = self.create_node("interface", &name, node, extra) else { return }; + self.extract_inheritance(node, row); + self.stack.push(Scope { row, kind: "interface", name }); + let body = node.child_by_field_name("body").unwrap_or(node); + for i in 0..body.named_child_count() { + if let Some(c) = body.named_child(i) { + self.visit_node(c); + } + } + self.stack.pop(); + } + + /// extractTypeAlias (:2890) — plain type_alias node + value-subtree type + /// refs (`typealias Handler = (Data) -> Void` → refs Data + Void…Void is + /// builtin-suppressed; `= KF.Builder` → refs KF AND Builder). Returns + /// skipChildren=false (children also recursed, harmlessly). + fn extract_type_alias(&mut self, node: Node<'t>) -> bool { + let name = self.extract_name(node); + if name == "" { + return false; + } + let extra = Extra { + docstring: preceding_docstring(node, self.src), + ..Extra::default() + }; + let row = self.create_node("type_alias", &name, node, extra); + if let Some(row) = row { + if let Some(value) = node.child_by_field_name("value") { + self.extract_type_refs_from_subtree(value, row); + } + } + false + } + + /// extractVariable — the swift top-level branch (:2851): let → constant / + /// var → variable via swiftPropertyInfo; computed skipped; position = the + /// whole declaration; extras = docstring + isExported literal FALSE. + fn extract_variable(&mut self, node: Node<'t>) { + let docstring = preceding_docstring(node, self.src); + let info = self.swift_property_info(node); + let Some(name_node) = info.name_node else { return }; + if info.is_computed { + return; + } + let kind: &'static str = if info.is_let { "constant" } else { "variable" }; + let name = self.text(name_node).to_string(); + self.create_node( + kind, + &name, + node, + Extra { docstring, is_exported: Some(false), ..Extra::default() }, + ); + } + + fn extract_import(&mut self, node: Node<'t>) { + let import_text = self.text(node).trim().to_string(); + let identifier = (0..node.named_child_count()) + .filter_map(|i| node.named_child(i)) + .find(|c| c.kind() == "identifier"); + let Some(identifier) = identifier else { return }; // hook null → nothing + let module_name = self.text(identifier).to_string(); + if module_name.is_empty() { + return; + } + self.create_node( + "import", + &module_name, + node, + Extra { signature: Some(import_text), ..Extra::default() }, + ); + let parent = self.top_row(); + self.push_ref_at(parent, &module_name.clone(), edge_kind_index("imports").unwrap(), node); + } + + /// extractCall — swift rides the generic member branch (navigation) and + /// the raw-text else; the full matrix is in the checklist. + fn extract_call(&mut self, node: Node<'t>) { + if self.stack.is_empty() { + return; + } + let caller = self.top_row(); + let func = node + .child_by_field_name("function") + .or_else(|| node.named_child(0)); + let Some(func) = func else { return }; + let mut callee_name = String::new(); + + if func.kind() == "navigation_expression" { + // property = property/field fields (null) → namedChild(1), with + // the navigation_suffix simple_identifier unwrap. + let property = func + .child_by_field_name("property") + .or_else(|| func.child_by_field_name("field")) + .or_else(|| { + let c1 = func.named_child(1); + match c1 { + Some(c) if c.kind() == "navigation_suffix" => (0..c.named_child_count()) + .filter_map(|i| c.named_child(i)) + .find(|g| g.kind() == "simple_identifier") + .or(Some(c)), + other => other, + } + }); + if let Some(property) = property { + let method_name = self.text(property); + let receiver = func + .child_by_field_name("object") + .or_else(|| func.child_by_field_name("operand")) + .or_else(|| func.child_by_field_name("argument")) + .or_else(|| func.named_child(0)); + if let Some(r) = receiver { + if is_literal_receiver(r.kind()) { + return; // `"lit".upper()` / `5.times()` — nothing + } + } + let recv_ident = receiver.filter(|r| { + matches!(r.kind(), "identifier" | "simple_identifier" | "field_identifier") + }); + if let Some(r) = recv_ident { + let receiver_name = self.text(r); + if matches!(receiver_name, "self" | "this" | "cls" | "super") { + callee_name = method_name.to_string(); + } else { + callee_name = format!("{receiver_name}.{method_name}"); + } + } else if receiver.map(|r| r.kind() == "call_expression").unwrap_or(false) { + // #750 swift re-encode: innerNav = receiver.namedChild(0), + // ws-stripped; capitalized chains only. + let inner = receiver.unwrap().named_child(0); + let inner_callee = + inner.map(|n| strip_js_ws(self.text(n))).unwrap_or_default(); + let reencode = inner_callee + .as_bytes() + .first() + .map(|b| b.is_ascii_uppercase()) + .unwrap_or(false); + callee_name = if reencode { + format!("{inner_callee}().{method_name}") + } else { + method_name.to_string() + }; + } else { + // self_expression / super_expression / inner nav / + // postfix / multi_line_string_literal → bare method name. + callee_name = method_name.to_string(); + } + } + } else { + // Raw func text: bare `helper`, `Foo` (constructor = plain call), + // `arr` (subscript reads!), `m[i]`, `defer`, `.make`, tuple + // callees (conv-regex below), array-literal callees (bump delta 8). + callee_name = self.text(func).to_string(); + } + + if !callee_name.is_empty() { + if let Some(c) = util::paren_conversion().captures(&callee_name) { + callee_name = c[1].to_string(); + } + self.push_ref_at(caller, &callee_name.clone(), edge_kind_index("calls").unwrap(), node); + } + } + + /// extractStaticMemberRef — swift's navigation_expression value reads, + /// body walker + walkAttrArgs only. + fn extract_static_member_ref(&mut self, node: Node<'t>) { + if node.kind() != "navigation_expression" { + return; + } + if self.stack.is_empty() { + return; + } + let owner = self.top_row(); + // Skip the callee nav of a call. + if let Some(parent) = node.parent() { + if parent.kind() == "call_expression" { + let callee = parent + .child_by_field_name("function") + .or_else(|| parent.child_by_field_name("method")) + .or_else(|| parent.named_child(0)); + if let Some(callee) = callee { + if callee.start_byte() == node.start_byte() { + return; + } + } + } + } + let recv = node + .child_by_field_name("object") + .or_else(|| node.child_by_field_name("expression")) + .or_else(|| node.child_by_field_name("scope")) + .or_else(|| node.named_child(0)); + let Some(recv) = recv else { return }; + if matches!( + recv.kind(), + "identifier" | "type_identifier" | "simple_identifier" | "name" | "scoped_type_identifier" + ) { + let text = self.text(recv); + if capitalized_re().is_match(text) { + self.push_ref_at(owner, &text.to_string(), edge_kind_index("references").unwrap(), recv); + } + } + } + + /// extractInheritance — the swift inheritance_specifier case: FIRST + /// type_identifier of each specifier's user_type, everything as `extends` + /// (conformances included; `: Module.Base` takes `Module`). + fn extract_inheritance(&mut self, node: Node<'t>, class_row: u32) { + let extends_kind = edge_kind_index("extends").unwrap(); + for i in 0..node.named_child_count() { + let Some(child) = node.named_child(i) else { continue }; + if child.kind() != "inheritance_specifier" { + continue; + } + let user_type = (0..child.named_child_count()) + .filter_map(|j| child.named_child(j)) + .find(|c| c.kind() == "user_type"); + let Some(user_type) = user_type else { continue }; + let type_id = (0..user_type.named_child_count()) + .filter_map(|j| user_type.named_child(j)) + .find(|c| c.kind() == "type_identifier"); + let Some(type_id) = type_id else { continue }; + let name = self.text(type_id).to_string(); + self.push_ref_at(class_row, &name, extends_kind, type_id); + } + } + + /// extractTypeAnnotations — generic path: the 'parameter' field NEVER + /// resolves (zero param refs), 'return_type' DOES; the direct + /// type_annotation find is null for functions. + fn extract_type_annotations(&mut self, node: Node<'t>, from_row: u32) { + if let Some(params) = node.child_by_field_name("parameter") { + // Unreachable (field never resolves) — mirrored for shape. + self.extract_type_refs_from_subtree(params, from_row); + } + if let Some(ret) = node.child_by_field_name("return_type") { + self.extract_type_refs_from_subtree(ret, from_row); + } + let ta = (0..node.named_child_count()) + .filter_map(|i| node.named_child(i)) + .find(|c| c.kind() == "type_annotation"); + if let Some(ta) = ta { + self.extract_type_refs_from_subtree(ta, from_row); + } + } + + fn extract_type_refs_from_subtree(&mut self, node: Node<'t>, from_row: u32) { + if node.kind() == "type_identifier" { + let type_name = self.text(node).to_string(); + if !type_name.is_empty() && !is_builtin_type(&type_name) { + self.push_ref_at(from_row, &type_name, edge_kind_index("references").unwrap(), node); + } + return; + } + for i in 0..node.named_child_count() { + if let Some(c) = node.named_child(i) { + self.extract_type_refs_from_subtree(c, from_row); + } + } + } + + /// extractDecoratorsFor — swift `attribute` nodes inside `modifiers`. + /// Coverage: functions/methods/classes/dedicated-branch properties only. + fn extract_decorators_for(&mut self, decl: Node<'t>, decorated_row: u32) { + for i in 0..decl.named_child_count() { + let Some(child) = decl.named_child(i) else { continue }; + self.consider_decorator(child, decorated_row); + if child.kind() == "modifiers" { + for j in 0..child.named_child_count() { + if let Some(m) = child.named_child(j) { + self.consider_decorator(m, decorated_row); + } + } + } + } + // Preceding-sibling scan — swift attributes are never siblings; the + // scan stops at the first non-decorator sibling immediately. + let Some(parent) = decl.parent() else { return }; + let decl_start = decl.start_byte(); + let mut decl_idx: isize = -1; + for i in 0..parent.named_child_count() { + if let Some(sib) = parent.named_child(i) { + if sib.start_byte() == decl_start { + decl_idx = i as isize; + break; + } + } + } + if decl_idx > 0 { + let mut j = decl_idx - 1; + while j >= 0 { + let Some(sib) = parent.named_child(j as usize) else { + j -= 1; + continue; + }; + if !matches!(sib.kind(), "decorator" | "annotation" | "marker_annotation") { + break; + } + self.consider_decorator(sib, decorated_row); + j -= 1; + } + } + } + + fn consider_decorator(&mut self, n: Node<'t>, decorated_row: u32) { + if !matches!(n.kind(), "decorator" | "annotation" | "marker_annotation" | "attribute") { + return; + } + let mut target: Option = None; + for i in 0..n.named_child_count() { + let Some(child) = n.named_child(i) else { continue }; + if child.kind() == "call_expression" { + target = child.child_by_field_name("function").or_else(|| child.named_child(0)); + if target.is_some() { + break; + } + } + if matches!( + child.kind(), + "identifier" | "member_expression" | "scoped_identifier" | "navigation_expression" + | "user_type" | "type_identifier" + ) { + target = Some(child); + break; + } + } + let Some(target) = target else { return }; + let name = strip_generic_and_qualifier(self.text(target)); + if name.is_empty() { + return; + } + self.push_ref_at(decorated_row, &name, edge_kind_index("decorates").unwrap(), n); + } + + // --- function-as-value refs (SWIFT_SPEC, function-ref.ts:288) ------------------- + + fn maybe_capture_fn_refs(&mut self, node: Node<'t>) { + enum Mode { + Args, + Rhs, + List, + Varinit, + } + let mode = match node.kind() { + "value_arguments" => Mode::Args, + "assignment" => Mode::Rhs, // field 'result' + "array_literal" => Mode::List, + "property_declaration" => Mode::Varinit, // field 'value' + _ => return, + }; + if self.stack.is_empty() { + return; + } + let from = self.top_row(); + + let mut values: Vec = Vec::new(); + match mode { + Mode::Args | Mode::List => { + for i in 0..node.named_child_count() { + if let Some(c) = node.named_child(i) { + values.push(c); + } + } + } + Mode::Rhs => { + if let Some(rhs) = node.child_by_field_name("result") { + // Param-storage skip — swift's LHS field is `target`. + let lhs = node + .child_by_field_name("left") + .or_else(|| node.child_by_field_name("lhs")) + .or_else(|| node.child_by_field_name("target")) + .or_else(|| { + if node.named_child_count() >= 2 { node.named_child(0) } else { None } + }); + let lhs_text = lhs.map(|l| self.text(l)).unwrap_or(""); + let lhs_last = util::lhs_last_name() + .captures(lhs_text) + .and_then(|c| c.get(1)) + .map(|m| m.as_str()); + let rhs_text = self.text(rhs).trim(); + if !(lhs_last.is_some() && lhs_last == Some(rhs_text)) { + values.push(rhs); + } + } + } + Mode::Varinit => { + // Destructuring gate: swift's name field is a `pattern` node — + // never in the pattern-kind set → never skipped. + let name_child = node + .child_by_field_name("name") + .or_else(|| node.child_by_field_name("pattern")); + let is_destructuring = name_child + .map(|nc| { + matches!( + nc.kind(), + "object_pattern" | "array_pattern" | "tuple_pattern" | "struct_pattern" + ) + }) + .unwrap_or(false); + if !is_destructuring { + if let Some(v) = node.child_by_field_name("value") { + values.push(v); + } + } + } + } + + for v in values { + self.normalize_fn_ref_value(v, from, 0); + } + } + + fn normalize_fn_ref_value(&mut self, v: Node<'t>, from: u32, depth: u32) { + if depth > 4 { + return; + } + match v.kind() { + "simple_identifier" => { + let name = self.text(v); + self.push_fn_ref_cand(from, name, v); + } + "value_argument" => { + // Layer with field 'value' + the label-forward skip (the + // Alamofire A/B finding): label text == value text → dropped. + let label = v.child_by_field_name("name"); + let value = v.child_by_field_name("value").or_else(|| { + if v.named_child_count() > 0 { + v.named_child(v.named_child_count() - 1) + } else { + None + } + }); + if let (Some(l), Some(val)) = (label, value) { + if self.text(l).trim() == self.text(val).trim() { + return; + } + } + if let Some(inner) = v.child_by_field_name("value") { + self.normalize_fn_ref_value(inner, from, depth + 1); + } + } + "selector_expression" => { + // `#selector(fire)` → fire; dotted → rightmost + // simple_identifier (incl. the `_` quirk); else trimmed text. + let Some(inner) = v.named_child(0) else { return }; + if matches!(inner.kind(), "identifier" | "simple_identifier") { + let name = self.text(inner); + self.push_fn_ref_cand(from, name, inner); + return; + } + if let Some(last) = last_simple_identifier(v) { + let name = self.text(last); + self.push_fn_ref_cand(from, name, last); + return; + } + let name = self.text(inner).trim().to_string(); + self.push_fn_ref_cand(from, &name, inner); + } + _ => {} + } + } + + fn push_fn_ref_cand(&mut self, from: u32, name: &str, node: Node) { + if name.is_empty() || is_stoplisted(name) { + return; + } + let p = node.start_position(); + self.fn_ref_cands.push(Cand { + from, + name: name.to_string(), + line: p.row as u32 + 1, + column_byte: node.start_byte(), + row: p.row, + }); + } + + fn scan_fn_ref_subtree(&mut self, node: Node<'t>, depth: u32) { + if depth > 12 { + return; + } + // Halts at functionTypes (function_declaration) + the fixed list — + // lambda_literal IS in it (closures halt the scan). + if depth > 0 + && matches!( + node.kind(), + "function_declaration" | "arrow_function" | "function_expression" | "lambda_literal" + | "lambda_expression" + ) + { + return; + } + self.maybe_capture_fn_refs(node); + for i in 0..node.named_child_count() { + if let Some(c) = node.named_child(i) { + self.scan_fn_ref_subtree(c, depth + 1); + } + } + } + + fn flush_fn_ref_candidates(&mut self) { + let cands = std::mem::take(&mut self.fn_ref_cands); + if cands.is_empty() || util::is_generated_file(self.file_path) { + return; + } + let mut seen: HashSet<(String, String)> = HashSet::new(); + for c in cands { + if !c.name.starts_with("this.") + && !c.name.contains("::") + && !self.defined_fn_names.contains(&c.name) + && !self.imported_names.contains(&c.name) + { + continue; + } + if !seen.insert((self.node_ids[c.from as usize].clone(), c.name.clone())) { + continue; + } + let column = util::col16(self.src, &self.line_starts, c.row, c.column_byte); + let name_ref = self.arena.put(&c.name); + self.tables.push_ref(&RefRow { + from_idx: c.from, + kind: FUNCTION_REF_CODE, + line: c.line, + column, + reference_name: name_ref, + candidates: NONE_STR, + from_id_str: NONE_STR, + }); + } + } + + // --- value references ------------------------------------------------------------- + + fn flush_value_refs(&mut self, root: Node<'t>) { + let scopes = std::mem::take(&mut self.value_scopes); + let mut targets = std::mem::take(&mut self.fs_values); + let counts = std::mem::take(&mut self.fs_value_counts); + if std::env::var("CODEGRAPH_VALUE_REFS").as_deref() == Ok("0") { + return; + } + if targets.is_empty() || scopes.is_empty() || util::is_generated_file(self.file_path) { + return; + } + + // Shadow prune — TWO cases resolve for swift: property_declaration + // (firstSimpleIdentifier over the name/binding pattern; guard-let/ + // if-let bindings have no property_declaration → never prune) AND the + // shared `assignment` case — a declared-then-assigned `let X: T` + // followed by `X = …` branches counts one bump per assignment (the + // directly_assignable_expression's simple_identifier child), pruning + // X exactly as the wasm arm does (caught by the swift-nio sweep). + let mut decl_counts: HashMap<&str, u32> = HashMap::new(); + let mut dstack: Vec = vec![root]; + let mut dvisited = 0usize; + while let Some(n) = dstack.pop() { + if dvisited >= MAX_VALUE_REF_NODES { + break; + } + dvisited += 1; + if n.kind() == "assignment" { + let left = n + .child_by_field_name("left") + .or_else(|| n.child_by_field_name("pattern")) + .or_else(|| n.named_child(0)); + if let Some(left) = left { + if left.kind() == "identifier" { + let nm = self.text(left); + if targets.contains_key(nm) { + *decl_counts.entry(nm).or_insert(0) += 1; + } + } else { + for i in 0..left.named_child_count() { + let Some(c) = left.named_child(i) else { continue }; + if matches!(c.kind(), "identifier" | "simple_identifier") { + let nm = self.text(c); + if targets.contains_key(nm) { + *decl_counts.entry(nm).or_insert(0) += 1; + } + } + } + } + } + } + if n.kind() == "property_declaration" { + let vd = (0..n.named_child_count()) + .filter_map(|i| n.named_child(i)) + .find(|c| c.kind() == "variable_declaration"); // kotlin shape — None for swift + let id = match vd { + Some(vd) => (0..vd.named_child_count()) + .filter_map(|i| vd.named_child(i)) + .find(|c| c.kind() == "simple_identifier"), + None => first_simple_identifier(n.child_by_field_name("name").or_else(|| { + (0..n.named_child_count()) + .filter_map(|i| n.named_child(i)) + .find(|c| matches!(c.kind(), "value_binding_pattern" | "pattern")) + })), + }; + if let Some(id) = id { + if matches!(id.kind(), "identifier" | "simple_identifier") { + let nm = self.text(id); + if targets.contains_key(nm) { + *decl_counts.entry(nm).or_insert(0) += 1; + } + } + } + } + for i in 0..n.named_child_count() { + if let Some(c) = n.named_child(i) { + dstack.push(c); + } + } + } + let shadowed: Vec = decl_counts + .iter() + .filter(|(nm, c)| **c > counts.get(**nm).copied().unwrap_or(1)) + .map(|(nm, _)| nm.to_string()) + .collect(); + for nm in shadowed { + targets.remove(&nm); + } + if targets.is_empty() { + return; + } + + let refs_kind = edge_kind_index("references").unwrap(); + for scope in &scopes { + let mut seen: HashSet<&str> = HashSet::new(); + let mut stack: Vec = vec![scope.node]; + let mut visited = 0usize; + while let Some(n) = stack.pop() { + if visited >= MAX_VALUE_REF_NODES { + break; + } + visited += 1; + if matches!(n.kind(), "identifier" | "constant" | "name" | "simple_identifier") { + let ref_name = self.text(n); + if let Some(&target_row) = targets.get(ref_name) { + let target_id = self.node_ids[target_row as usize].as_str(); + if target_id != self.node_ids[scope.row as usize] + && ref_name != scope.name + && !seen.contains(&target_id) + { + seen.insert(target_id); + let meta = self.arena.put(r#"{"valueRef":true}"#); + self.tables.push_edge(&EdgeRow { + source_idx: scope.row, + target_idx: target_row, + kind: refs_kind, + provenance: 0, + line: NONE, + column: NONE, + metadata_json: meta, + source_id_str: NONE_STR, + target_id_str: NONE_STR, + }); + } + } + } + for i in 0..n.named_child_count() { + if let Some(c) = n.named_child(i) { + stack.push(c); + } + } + } + } + } +} + +/// The shared decorator-name normalization: strip `<...` from the first `<` +/// (index > 0), keep the segment after the last `.`/`::`, strip ONE leading +/// `:` or `.`, trim. +fn strip_generic_and_qualifier(raw: &str) -> String { + let mut name = raw.to_string(); + if let Some(lt) = name.find('<') { + if lt > 0 { + name.truncate(lt); + } + } + let last_dot = name + .rfind('.') + .map(|i| i as isize) + .unwrap_or(-1) + .max(name.rfind("::").map(|i| i as isize).unwrap_or(-1)); + if last_dot >= 0 { + name = name[(last_dot as usize + 1)..].to_string(); + if name.starts_with(':') || name.starts_with('.') { + name.remove(0); + } + } + name.trim().to_string() +} + +fn opt_str(arena: &mut Arena, s: Option<&str>) -> StrRef { + match s { + Some(s) => arena.put(s), + None => NONE_STR, + } +} diff --git a/docs/design/kotlin-kernel-port-checklist.md b/docs/design/kotlin-kernel-port-checklist.md new file mode 100644 index 0000000..6820a37 --- /dev/null +++ b/docs/design/kotlin-kernel-port-checklist.md @@ -0,0 +1,1121 @@ +# Kotlin kernel port (R7b) — the bug-for-bug checklist + +**Status: SURVEY COMPLETE (2026-07-20) — PORT NOT STARTED.** Survey basis: every +TS-side branch a `.kt`/`.kts` file exercises, with file:line anchors as of +**`a6c62d7`** (HEAD at survey time, clean main). Every grammar-shape claim below +was **probed against both the production tree-sitter-wasms build and a fresh +fwcd 0.3.8 tag build** (probe scripts + dumps in the session scratchpad +`svy-kotlin/` — see §Probe artifacts), and every extraction-behavior claim was +**pinned against the real `dist/` extractor** (`extract-*.txt` ground-truth +dumps), not derived from code reading alone. Read WITH +`docs/design/rust-kernel-migration-plan.md` (§0a recipe, §2 boundary, §4 +tracker row "kotlin", §5 gates) and the format precedents +(`rust-lang-kernel-port-checklist.md`, `ruby-kernel-port-checklist.md`, +`php-kernel-port-checklist.md`, `csharp-kernel-port-checklist.md`). + +**Blocking findings: none — but two eyes-open items, one of them a NOVEL +mechanism.** (1) The grammar bump is **behavior-neutral** (rust-style gate: +byte-identical CSTs on all 1,984 gate-repo files, 0 error disagreements) — +**but the crates.io crate `tree-sitter-kotlin = 0.3.8` is UNUSABLE by the +kernel** (it pins `tree-sitter >= 0.21, < 0.23`; the kernel links 0.25), and +the successor crate `tree-sitter-kotlin-ng` is a **different grammar** (8 +fields vs 0, 289 vs 357 symbols, renamed kinds — would break every kotlin.ts +branch). The port must take the **vendored-grammar-C route**: compile the +sha-matched 0.3.8 `parser.c`+`scanner.c` inside `codegraph-kernel` via +build.rs — the FIRST language to exercise the mechanism the §4 tracker +prescribes for vendored grammars (§Grammar prep). (2) **Both-arm parse-error +incidence is 4.7–8.5%** on the gate repos (fun-interface misparses, phantom +single-line-class-body errors, soft-keyword identifiers, `call().prop = x` +LHS shapes — all grammar-inherent, all identical across arms). The default +`--max-deferral 0.1` HOLDS but with only ~1.2–2× headroom (okhttp 8.45%) — +expect double-digit deferral COUNTS on kotlin sweeps and don't misread them +as walker bugs (§Architecture decisions #6). + +## Grammar prep (behavior-neutral re-vendor + the vendored-C kernel build) + +kotlin is NOT in `VENDORED_WASM_LANGS` (grammars.ts:291-317) — production +loads `node_modules/tree-sitter-wasms/out/tree-sitter-kotlin.wasm` +(mapping `kotlin: 'tree-sitter-kotlin.wasm'` at grammars.ts:35; +tree-sitter-wasms 0.1.13 builds it from npm `tree-sitter-kotlin` **^0.3.1**, +the fwcd lineage; production wasm sha256 `b5cb00c8…`, 4,052,705 bytes, ABI 14). + +- **Lineage decision (investigated, not assumed):** two crates exist. + - `tree-sitter-kotlin` **0.3.8** (crates.io max_stable, published + 2024-08-03; repo fwcd/tree-sitter-kotlin — OUR wasm's lineage; repo still + active but no crate release since). Tag `0.3.8` (annotated tag `9e7e624` → + commit `e1a2d5ad1f61f5740677183cd4125bb071cd2f30`); sha256-verified + crate-tarball ↔ tag, BOTH generated artifacts (kotlin HAS an external + scanner): + - `src/parser.c` `54104a7ef1555c265b746c790e0f8bb953cc17806e9df0c3af82f7f62c06a70a` + - `src/scanner.c` `27f73337ec357fc341fa57538f34c14277b0346980c3405dc30beab6202ec6d0` + - `tree-sitter-kotlin-ng` 1.1.0 (tree-sitter-grammars org, 2025-01) — + **REJECTED**: a different grammar, not a re-publish (STATE_COUNT 11432 vs + 10155, SYMBOL_COUNT 289 vs 357, **FIELD_COUNT 8 vs 0**, kinds renamed — + `additive_expression`→`binary_expression`, `call_suffix` gone, + `binding_pattern_kind` gone…). Adopting it is an extractor REWRITE, not a + port. Do not revisit until/unless the TS side migrates grammars. +- **The 0.3.8 build is behavior-IDENTICAL to the production wasm** (this bump + is a reproducibility re-vendor, csharp-flavored, not a version change): + kind/field tables identical (360 node types, 134 named kinds, 0 fields, + ABI 14 both — `table-compare.cjs`); the 258-line torture file's full CST dump + is byte-identical OLD↔NEW; and the gate-repo sweep (`error-sweep.cjs + --sexp`) found **0 error disagreements and 0 s-expression mismatches + on every clean file across all three repos**. Expect the standalone bump + gate's old-vs-new full-init dump diff to be **byte-identical on all three** + (rust-style "expect zero", NOT php's enumerate+classify). +- **ABI note:** the 0.3.8 tag's checked-in parser.c declares + `LANGUAGE_VERSION 14` — content parity, ABI stays 14 (ruby precedent). + kernel-grammar-parity must assert same-revision, not an ABI change. +- **FIELD_COUNT 0 is load-bearing for the whole port**: every + `childForFieldName`/`getChildByField` lookup in the kotlin path returns + null, which is what makes several TS hooks dead code (§Extractor config). + The walker must reproduce the null-field world exactly — do NOT "helpfully" + use -ng-style fields that don't exist here. +- **Wasm build (from the tag's CHECKED-IN parser.c — never `tree-sitter + generate`):** + ``` + git clone --depth 1 --branch 0.3.8 https://github.com/fwcd/tree-sitter-kotlin + cd tree-sitter-kotlin + # the 0.3.8 tag predates tree-sitter.json, which cli 0.25.10 requires — + # add the METADATA-ONLY shim (grammar name/scope; nothing regenerated): + # {"grammars":[{"name":"kotlin","scope":"source.kotlin","path":".", + # "file-types":["kt","kts"]}],"metadata":{"version":"0.3.8","license":"MIT"}} + npx -y tree-sitter-cli@0.25.10 build --wasm -o tree-sitter-kotlin.wasm . + ``` + (brew emcc present; survey artifact sha256 + `c80c88867a589a1a0959bcea89de84b7e9684b3693b2cdb2944812458e62ff48`, + 4,052,313 bytes, at scratchpad `svy-kotlin/tree-sitter-kotlin-NEW.wasm`. + Do NOT use tree-sitter-cli 0.24 — it drops `\p{...}` classes, the #1164 + vbnet lesson, and this grammar's identifiers use them.) +- **Kernel side — the NOVEL part (crate pin impossible):** the 0.3.8 crate's + `[dependencies.tree-sitter] version = ">= 0.21, < 0.23"` + old-style + `pub fn language() -> tree_sitter::Language` bindings cannot link against + the kernel's `tree-sitter = "0.25"`. Instead of a crate dep, **vendor the + grammar C into the kernel** (the §4 tracker's prescription for + vendored-grammar languages — kotlin is the first to need it): + - copy the tag's `src/parser.c`, `src/scanner.c`, and `src/tree_sitter/*.h` + to `codegraph-kernel/grammars/kotlin/` (shas above, recorded in a comment); + - `codegraph-kernel/build.rs`: `cc::Build` compiling both C files with the + crate's own flag set (`-Wno-unused-parameter`, + `-Wno-unused-but-set-variable`, `-Wno-trigraphs`; msvc `-utf-8` — crib + the tarball's `bindings/rust/build.rs`); + - Cargo: add `tree-sitter-language = "0.1"` (the version-agnostic + `LanguageFn` shim every modern grammar crate uses) + `cc` as a + build-dependency (if not already present); + - `langs.rs`: + ```rust + extern "C" { fn tree_sitter_kotlin() -> *const (); } + // … + "kotlin" => Some(unsafe { tree_sitter_language::LanguageFn::from_raw(tree_sitter_kotlin) }.into()), + ``` + plus `LANGUAGES` += `"kotlin"` (14 entries). + - `__tests__/kernel-grammar-parity.test.ts:39` `GRAMMAR_LANGUAGES += 'kotlin'` + — the id-by-id ABI/kind/field-table compare against the vendored wasm is + the proof the C build and the wasm build are the same revision. +- **Staging plan (bump PR, before any walker exists):** vendor the wasm to + `src/extraction/wasm/tree-sitter-kotlin.wasm`; `VENDORED_WASM_LANGS += + 'kotlin'` (grammars.ts:291) with an R7b comment (tag + sha-matched note + + "crate unusable — kernel compiles vendored C, see codegraph-kernel/grammars/ + kotlin"); the kernel C vendor + build.rs + langs.rs + grammar-parity row can + land WITH the bump (they're inert until a walker exists) or with the walker — + but wasm + C must be same-tag from day one. `copy-assets` already globs + `src/extraction/wasm/*.wasm`. MIT license (fwcd), same family as the rest. +- **Error incidence (both arms, all `.kt`/`.kts` ≤1MiB, `error-sweep.cjs`):** + + | Repo | files | OLD hasError | NEW hasError | disagreements | sexp mismatches (clean files) | + |---|---|---|---|---|---| + | okio | 322 | 23 (7.14%) | 23 (7.14%) | 0 | 0 | + | okhttp | 580 | 49 (8.45%) | 49 (8.45%) | 0 | 0 | + | kotlinx.coroutines | 1,082 | 51 (4.71%) | 51 (4.71%) | 0 | 0 | + + Error classes (sampled + probed): **(a) `fun interface`** — unsupported by + the grammar, ALWAYS errors (okhttp 10/49, kotlinx 6/51; okhttp3's core + `Call.kt`/`Authenticator.kt`/`Dns.kt` are in this class); **(b) phantom + single-line class bodies** — `class X { fun f() {} }` sets `hasError=true` + with ZERO ERROR/missing nodes and a COMPLETE, correct CST (probed both + arms; okio 1, okhttp 7, kotlinx 6); **(c) soft-keyword identifiers** + (`var final = false; final = true` errors — `final` is reserved by the + grammar); **(d) `call("x").prop = value`** navigation-off-call assignment + LHS (errors; plain `obj.prop = x` is fine); **(e)** assorted expect-header + and gradle-kts DSL shapes. `class Foo private constructor(x)` and + `@Inject constructor` parse CLEAN (probed — don't blame ctor visibility). + All classes error on BOTH arms → defer-to-wasm keeps parity; only the + speedup is lost on those files. +- Probe scripts + outputs live in the survey scratchpad (`…/scratchpad/ + svy-kotlin/`): `table-compare.cjs`, `shape-probe-kotlin.cjs` + + `torture-{OLD,NEW}.txt` (byte-identical), `mini-probes.cjs` + + `mini-probes.out` (17 targeted shapes, all OLD==NEW), `error-sweep.cjs` + + `errors-.txt`, `extract-probe.cjs` (runs the REAL dist extractor — + its `extract-{torture,vref,vref-nopkg,docs,bodiless,crlf,funiface,lfpkg,kts}.txt` + dumps are the pinned ground truth cited throughout and double as walker + test expectations), `torture.kt` + the small fixtures, the 0.3.8 tag clone + + crate tarball + ng tarball with matching shas. Scratch is throwaway — + re-derive from this doc if gone. + +## Architecture decisions + +1. **No preParse.** `kotlinExtractor` has no `preParse` hook (languages/ + kotlin.ts — whole file, no such key), so `preParsedSource` + (kernel/index.ts:96) is a no-op — both arms parse raw bytes. Nothing to + hoist. No `POST_PASSES` entry either (kernel/index.ts:81) → + `tryKernelExtractRaw` stays eligible. +2. **Three framework resolvers can force the DECODED path for kotlin; none of + the gate repos trips any of them (verified).** parse-worker.ts:93-100 + forces any language with an applicable framework `extract()` onto the + decoded `extractFromSource` path. Kotlin appears in: + - `springResolver` (frameworks/java.ts:13, `languages: ['java','kotlin', + 'yaml','properties']`; extract() at :197 regexes `@GetMapping` etc. over + raw `.kt` source) — detect (:23) = pom.xml/build.gradle/build.gradle.kts + containing `spring-boot`/`springframework`, or Spring annotations in any + `.java` file. okio/okhttp/kotlinx.coroutines: none match (grepped). + - `expoModulesResolver` (frameworks/expo-modules.ts:154, `languages: + ['swift','kotlin']`) — detect = package.json `expo-modules-core` or an + Expo `Module` DSL source scan. Not present. + - `fabricViewResolver` (frameworks/fabric.ts:366, kotlin in languages) — + detect needs `codegenNativeComponent`. Not present. + So all three parity repos exercise the raw buffers-to-store transport; + a Spring-Boot Kotlin app or an Expo/RN app is the decoded-path smoke check. +3. **The framework extractors themselves need NO port** — regex over raw + source, run in extractFromSource:6736-6758 after either arm. §Frameworks + pins their input contracts. +4. **One walker module** (suggest `codegraph-kernel/src/kotlin.rs`; no crate + collision since there is no kotlin crate dep), registered in langs.rs; + per-file `has_error()` → `defer:` like every walker. **java.rs is the + closest crib** (JVM package→namespace node via `extractFilePackage`, + class-like scope stack, methods-in-class-like, dotted imports, + STATIC_MEMBER + TYPE_ANNOTATION + VALUE_REF membership, annotation + decorators, `node_ids` vec). Kotlin diverges from it in nine places, each + detailed below: (a) a `visitNode` hook whose PROPERTY branch is the only + live-in-kernel part (fun-interface recovery is defer-shielded); (b) + `getReceiverType` — extension functions → receiver-qualified method QNs + + the owner-contains fallback (NO ported walker has this surface yet); (c) + `extractModifiers` — expect/actual → node DECORATORS (also a first); (d) + `resolveBody` by TYPE (zero-field grammar); (e) `extraClassNodeTypes` + (`object_declaration`); (f) classifyClassNode keyword sniffing + (interface/enum reuse `class_declaration`); (g) the #750 kotlin re-encode + in extractCall (namedChild(0), NOT a function field); (h) a fn-ref spec + with EMPTY idTypes + `callable_reference`/`navigation_expression` + specials; (i) dead-field lookups everywhere (signatures, type + annotations) that must stay dead. +5. **`.kt`/`.kts` → `kotlin`** at detectLanguage (grammars.ts:106-107), no + content sniffing, no dialect. `.kts` scripts are ordinary kotlin files + whose top-level statements attribute calls to the FILE node (pinned: + `extract-kts.txt` — `calls println from=file`, top-level `val` → + `constant`). MAX_FILE_SIZE (1 MiB, extraction/index.ts:132) and + generated-file skips are orchestrator/TS-side and shared. +6. **Deferral expectations:** okio 23/322 = 7.14%, okhttp 49/580 = 8.45%, + kotlinx.coroutines 51/1,082 = 4.71% — grammar-inherent, both-arm (§Grammar + prep table). Keep the sweep default `--max-deferral 0.1` (it holds on all + three) but EXPECT these counts; a kotlin sweep at ~8% deferral is normal, + one at >10% means a walker bug. No c/cpp 0.5 exemption. +7. **REF_FLAG_FILE_PATH (wire v2 slot) is NOT needed for kotlin.** No kotlin + extraction path emits refs carrying `filePath` (the visitNode hook only + creates nodes; verified across every ground-truth dump — zero refs printed + a filePath). The ruby/php trait-mixin bit stays unused here. + +## Extractor config (languages/kotlin.ts — 353 lines, read it whole) + +Types: functionTypes=[`function_declaration`]; classTypes=[`class_declaration`] +(covers class/interface/enum via classifyClassNode); methodTypes= +[`function_declaration`] (same list — the 994/995 gate routes in-class-like +functions to extractMethod); interfaceTypes=[] ; structTypes=[]; enumTypes=[]; +enumMemberTypes=[`enum_entry`]; typeAliasTypes=[`type_alias`]; +importTypes=[`import_header`]; callTypes=[`call_expression`]; +variableTypes=[`property_declaration`]; fieldTypes=[`property_declaration`] +(both lists — the hook consumes nearly all of them first); +extraClassNodeTypes=[`object_declaration`]. nameField=`simple_identifier`, +bodyField=`function_body`, paramsField=`function_value_parameters`, +returnField=`type`. + +**FIELD_COUNT 0 consequences (the dead-field cluster — reproduce the deadness):** + +- `nameField`/`bodyField`/`paramsField`/`returnField` are node-TYPE names used + as FIELD names — every `getChildByField` on them returns null. Names resolve + via extractName's FALLBACK (first direct namedChild of type + `identifier`|`type_identifier`|`simple_identifier`|`constant`, + tree-sitter.ts:178-189); bodies resolve via the `resolveBody` hook (by + type); params/return field walks are DEAD (§Type-annotation refs). +- **getSignature (kotlin.ts:277) is DEAD CODE — always undefined.** It reads + `getChildByField(node, 'function_value_parameters')` → null → early return. + Ground truth: every function/method in `extract-torture.txt` has + `sig=undefined`. The walker must emit NO signature for functions/methods. +- **The property hook's `typeNode = node.childForFieldName('type')` + (kotlin.ts:125) is DEAD** → property `signature` is always undefined too + (`val topVal: Int = 3` → sig undefined — pinned). + +Hooks PRESENT (port each exactly): + +- **visitNode (kotlin.ts:87-215)** — runs for EVERY node the main walker + visits (tree-sitter.ts:943-953; NOT in visitFunctionBody). Three branches: + 1. **`property_declaration` (:98-131) — the LIVE branch.** varDecl = first + namedChild of type `variable_declaration`; nameNode = ITS first + `simple_identifier`; either missing (destructuring's + `multi_variable_declaration`) → return false (fall to the ladder). Then + the SCOPE WALK up the parent chain, first match wins: + `function_body|function_declaration|lambda_literal| + anonymous_initializer|control_structure_body|getter|setter` → 'local' → + **return true, extract nothing** (this is how init-block/getter-body/ + top-level-control-flow locals reached via visitNode recursion are + skipped); `companion_object|object_declaration` → 'const'; + `class_declaration` → 'instance'; nothing matches (top level) → 'const' + (the initial value). Kind: instance → **`field`**; else `val` (a + `binding_pattern_kind` child with text exactly `val`) → **`constant`**, + `var` → **`variable`** (`const val` is just a val; a delegated + `by lazy {}` property has no `=` but still a binding → same rule). + `ctx.createNode(kind, name, node, { signature: undefined })` — extra + carries ONLY the (always-undefined) signature: **no docstring, no + visibility, no isStatic, no returnType on kotlin property nodes** — + but createNode's extractModifiers merge still runs, so `expect val` / + `actual val` DO get decorators. Return true → the dispatcher runs + `scanFnRefSubtree(node, 0)` (capture-only, halts at nested + function/lambda types) and NEVER descends → **property initializers + emit NO calls/instantiates refs anywhere** (`val SHARED = WidgetK(0)` + → nothing; `by lazy { compute() }` → nothing, the scan halts at the + lambda_literal). Consequences pinned in `extract-torture.txt`. + 2. **`lambda_literal` after a fun-interface ERROR (:139-143)** and + 3. **fun-interface misparse recovery (:145-214)** (ERROR/ + function_declaration shapes; `isFunInterfaceNode` :46; Pattern 1 walks + the sibling lambda's `statements` with a synthesized `interface` node + pushed — ground truth `extract-funiface.txt`: interface node at the + ERROR's extent + `transform` as its method) — **both branches are + DEFER-SHIELDED in the kernel**: every `fun interface` (either pattern, + probed) makes the tree `hasError=true`, so the kernel defers the whole + FILE to wasm before the walker would run. **Do NOT port branches 2-3.** + Walker rule: port branch 1 only; a `defer:` on has_error covers the + rest. (The parity suite still needs a fun-interface fixture asserting + the kernel defers and the wasm arm serves the pinned output.) +- **resolveBody (kotlin.ts:219-241)** — find by TYPE among namedChildren: + first `ERROR` child whose child(0) is `{` (the fun-interface parent-body + case — unreachable on non-erroring files, keep for wasm-parity of the TS + side only), else first `function_body` | `class_body` | `enum_class_body`. + Used by extractFunction/Method/Class/Enum body resolution AND by + createNode's endLine extension (tree-sitter.ts:1329-1333, function/method + kinds only). Single-expression bodies (`fun f() = expr`) are a + `function_body` starting with `=` — resolved and walked like any body. +- **classifyClassNode (kotlin.ts:242-255)** — scan ALL children (anon + included): child.type `interface` → 'interface'; `enum` → 'enum'; else + 'class'. `annotation class` / `data class` / `sealed class` → 'class' + (their `class_modifier` children don't match); `sealed interface` → + 'interface'. +- **getReceiverType (kotlin.ts:256-276) — LIVE, the extension-function + surface.** Walk ALL children in order: remember the last `user_type`; on a + `.` (anon) child WITH a remembered user_type → return that user_type's + FIRST `type_identifier` child's text (else the whole user_type text); on + `simple_identifier` or `function_value_parameters` → break (past the name; + no receiver). Probed shapes: + - `fun WidgetK.extend()` → `WidgetK`. + - `fun List.genericExt()` → `List` (type_parameters is skipped; + generic args live in a `type_arguments` child of the user_type, and the + FIRST type_identifier is the base). + - **`fun com.example.Qualified.qext()` → `com`** — a qualified receiver's + user_type holds MULTIPLE type_identifiers (`com`,`example`,`Qualified`) + and the find takes the FIRST segment. QN becomes `com::qext`. BUG, + PRESERVE. + - `infix fun Int.pow()` → `Int`; `operator fun WidgetK.plus()` → `WidgetK` + (modifiers don't disturb the walk). +- **getVisibility (kotlin.ts:288-301)** — for each child of type `modifiers`: + TEXT `.includes('public'|'private'|'protected'|'internal')` in that order; + no modifiers/no match → **'public'**. QUIRKS, PRESERVE: (a) kotlin emits a + visibility value no other language does — **'internal'**; (b) the probe + file's `private internal fun` (invalid kotlin, parses fine) → 'private' + (order); (c) TEXT-includes false positives — annotations live inside + `modifiers`, so `@publicize`-style lowercase annotation text containing a + keyword flips visibility (e.g. a lone `@internalApi` annotation → 'internal' + instead of 'public'). Match the includes-on-raw-text semantics exactly. +- **isStatic (kotlin.ts:302-305)** — always **false** (not undefined): every + function/method node carries `isStatic: false`. +- **isAsync (kotlin.ts:306-315)** — any `modifiers` child whose TEXT + `.includes('suspend')` → true, else false. The real shape is + `modifiers > function_modifier > suspend`. TEXT-includes false positive, + PRESERVE (probed, `mini-probes.out` suspendFalsePos): `@suspendMarker fun + g()` → **isAsync true** (the annotation text contains lowercase 'suspend'). +- **extractModifiers (kotlin.ts:316-338) — expect/actual, the KMP surface.** + Scan children for `modifiers` → their `platform_modifier` children → their + children of NODE TYPE `expect`/`actual` (anon keyword nodes; matched by + type, not text) → collect in order; empty → undefined. Runs inside + createNode (tree-sitter.ts:1355-1358) for **EVERY node kind** — merged + `newNode.decorators = [...(existing ?? []), ...mods]`. Ground truth: + `expect fun`/`expect class` → dec=["expect"]; `actual fun/class/val` → + ["actual"]; **`actual typealias PlatformClock` → type_alias node with + dec=["actual"]** (the synthesizer's KMP_TYPE_KINDS depends on this); + members of an `expect class` are NOT marked (no platform_modifier of their + own) but an `actual fun` inside an `actual class` IS. `decorators` on + kotlin nodes come ONLY from this hook — the annotation channel is + `decorates` REFS, never the node list (§Decorators). +- **extractImport (kotlin.ts:339-346)** — signature = trimmed + `source.substring(node.startIndex, node.endIndex)` (UTF-16); moduleName = + the first namedChild of type `identifier`'s substring (the dotted path). + No identifier → null (doesn't occur; even `import a.b.*` has the + identifier). No handledRefs → the generic imports ref also fires + (§Imports). +- **packageTypes=[`package_header`] + extractPackage (kotlin.ts:347-352)** — + first namedChild of type `identifier` → trimmed substring + (`com.example.torture`); none → null. §Namespace capture. + +Hooks ABSENT (the walker must NOT do these): `preParse`, `resolveName`, +`recoverMangledName`, `isMisparsedFunction`, `isConst`, `isExported` +(**undefined on every node except the file node's literal `false`**), +`classifyMethodNode`, `extractPropertyName`, `propertyTypes`, +`interfaceKind` (→ kind `interface`), `extractBareCall`, `synthesizeMembers`, +`skipBodilessClass` (**a bodiless `class Foo` still mints a node** — the +1685 comment names Kotlin as the deliberate case), `methodsAreTopLevel`, +`resolveTypeAliasKind`. + +## tree-sitter.ts branches (anchors as of `a6c62d7`) + +### visitNode dispatch — what each kotlin node hits (ladder at 936-1303) + +| Node | Branch | Behavior | +|---|---|---| +| every node | visitNode hook first (943) | property_declarations (non-destructuring) consumed there; handled → `scanFnRefSubtree` + STOP | +| every node | maybeCaptureFnRefs (990) | fires for `value_arguments`/`assignment` (the KOTLIN_SPEC keys) in visitNode context too — how top-level/class-scope callable refs in call args are captured | +| `function_declaration` | functionTypes:994 | inside class-like AND ∈ methodTypes → extractMethod:1737; else extractFunction:1517 (which itself diverts to extractMethod when getReceiverType fires — extension fns at any scope). skipChildren | +| `class_declaration` | classTypes:1005 → classify | 'interface' → extractInterface:1834; 'enum' → extractEnum:1914; else extractClass:1679 | +| `object_declaration` | extraClassNodeTypes:1022 | extractClass(node) → kind **`class`** (objects and sealed-class `object` members are class nodes; extractInheritance runs → their delegation_specifiers emit extends) | +| `companion_object` | **no branch** | recursed → its class_body children visited with the OUTER CLASS still on top: properties → hook ('const' scope → constant/variable under the class, class: parent ⇒ value-ref targets), functions → extractMethod of the outer class. A NAMED companion (`companion object Named`) is identical — the name mints nothing | +| `property_declaration` (hook-declined = destructuring) | fieldTypes:1084 (in class-like) else variableTypes:1098 | extractField / extractVariable — both emit **NOTHING** for kotlin destructuring (no `variable_declarator`/`variable_declaration`/`identifier` direct children; extractVariable's generic fallback :2863-2881 finds no `identifier`-typed child — kotlin names are `simple_identifier`). skipChildren + scanFnRefSubtree → the RHS call is invisible too. `isClassScopeConstantAssignment` (1508) needs node.type `assignment` → always false for kotlin | +| `type_alias` | typeAliasTypes:1071 → extractTypeAlias:2890 | plain `type_alias` node (no resolveTypeAliasKind). QUIRK: the alias-value ref walk reads `getChildByField(node,'value')` → null (no fields) → **NO reference to the aliased type**; returns false → the alias's children ARE re-visited (harmless — user_type/modifiers match nothing) | +| `import_header` | importTypes:1209 → extractImport:3170 | §Imports (the `import_list` wrapper has no branch and recurses into each header) | +| `package_header` | consumed by extractFilePackage BEFORE the walk (1397) | during the walk it's recursed, nothing matches | +| `call_expression` (top level / class body / object body / .kts statements) | callTypes:1248 → extractCall:3684 | attributes to the nodeStack top (file/namespace/class). Note class-BODY calls only occur via init blocks etc. (below) | +| `anonymous_initializer` (`init { }`) | no branch | recursed → its statements' calls → **`calls` refs FROM THE CLASS node**; its `val` locals → hook 'local' → nothing (pinned: `calls "register" from=class:WidgetK`) | +| `secondary_constructor` | no branch | **NO constructor node**; recursed → body calls attribute to the CLASS (`calls "log" from=class:WidgetK`); the `constructor_delegation_call`'s value_arguments still feed fn-ref capture | +| `getter`/`setter` as SIBLINGS (accessor on its own line) | no branch | recursed → accessor-body calls attribute to the CLASS (or file). See §Properties for the sibling/child split | +| `object_literal` (`object : T { … }` initializer) | no branch anywhere | never a node; see §Body walker for the method-leak quirk | +| `file_annotation` (`@file:JvmName("x")`) | no branch | recursed; its value_arguments feed fn-ref capture (string args → nothing). No decorates ref | +| INSTANTIATION_KINDS (354-361) | **no kotlin member** | extractInstantiation:4610 is **UNREACHABLE** for kotlin — constructor calls `Foo()` are call_expressions → plain `calls` refs named `Foo` (capitalized). Kotlin emits **zero `instantiates` refs**, ever | +| `impl_item`:1274 / property_signature:1282 / export_statement / swift property:1121 | never | not kotlin node kinds (the swift `property_declaration` branch at 1121-1193 is gated `language === 'swift'` — kotlin property_declarations never enter it) | + +### Node creation, IDs, qualified names + +- createNode (1308): id = `generateNodeId(filePath, kind, name, startRow+1)` + = `` `${kind}:${sha256(`${filePath}:${kind}:${name}:${line}`).hex.slice(0,32)}` `` + (tree-sitter-helpers.ts:18-30). FILE node id = literal `file:${filePath}` + (509), name = basename, qualifiedName = filePath, endLine = + `source.split('\n').length`, isExported false. Dedupe/self-checks compare + ID STRINGS (`node_ids` vec pattern). +- endLine extension via resolveBody (1329) is LIVE for kotlin + function/method nodes (body found by type; in-range for this grammar, so + in practice a no-op extension — but CALL the hook, the ERROR-body branch + is part of the contract). +- contains edge from nodeStack top for every created node (1363); + extractModifiers merge (1355-1358); captureValueRefScope (1374). +- **Namespace capture** — extractFilePackage (1397): scan the ROOT's direct + namedChildren for the first `package_header` (a leading `file_annotation` + or KDoc is skipped by the type filter); extractPackage → dotted text → + `createNode('namespace', 'com.example.torture', pkgNode)` = **node #2 + after the file node**, pushed for the WHOLE walk. Every top-level symbol's + qualifiedName = `com.example.torture::Name` (buildQualifiedName:1447 joins + stack names with `::`; namespacePrefix always empty outside C/C++). No + package header (scripts) → no namespace node, bare QNs, file: parents. +- **Receiver-QN override**: extension methods get `extraProps.qualifiedName = + composeReceiverQualifiedName(receiverType, name)` (1790-1792) = + `` `${receiverType}::${name}` `` verbatim (1435-1436; prefix empty → pass + through) — **NO package prefix**: `fun WidgetK.extend` in package + com.example.torture has QN `WidgetK::extend` (pinned). This is the first + ported walker with the receiver-QN surface — get the two QN builders' + divergence exactly right. +- isInsideClassLikeNode (1486): stack-top node kind ∈ {class, struct, + interface, trait, enum, module} — **`namespace` does NOT count** (top-level + fns under the package namespace stay functions). + +### extractFunction / extractMethod (1517 / 1737) + +- extractFunction: **line 1522 — getReceiverType short-circuit is LIVE**: any + function_declaration with a receiver (top-level extension fns, and nested + ones inside bodies) diverts to extractMethod. Name via extractName fallback + (first simple_identifier — backtick names keep their backticks: + `` function "`weird name`" ``). `` unreachable (grammar requires + the name). Extras: docstring (§Docstrings), signature undefined (dead + hook), visibility (hook), isExported undefined, isAsync (hook), isStatic + false, returnType (hook — §below). extractTypeAnnotations → **emits + NOTHING** (§Type-annotation refs); extractDecoratorsFor → §Decorators. + Push, body via resolveBody, visitFunctionBody, pop. +- extractMethod (in-class-like functions + receiver-diverted extension fns): + receiverType recomputed (1742); gate 1747 passes via class-like OR + receiver. Same extras. **Receiver path (extension fns): QN override + (1790) + the owner-contains fallback (1799-1813)** — receiver present AND + not class-like → find the FIRST node in `this.nodes` with `name === + receiverType && filePath === this.filePath && kind ∈ {struct, class, enum, + trait}` → contains edge owner→method. QUIRKS, PRESERVE: **`interface` is + NOT in the kind set** — `fun Drawable.ext()` never gets an owner edge even + with Drawable in-file; source-order dependent (extension above its class → + no edge); the qualified-receiver bug (`com::qext`) looks up a node named + `com` (never found). Extension fns keep their normal contains edge from + the nodeStack top (namespace/file) REGARDLESS — the owner edge is + additive. +- **`expect fun` has no body** → resolveBody null → no body walk; node still + minted with dec=["expect"]. Interface bodiless methods likewise. +- Nested named `fun` inside a body → visitFunctionBody:5245 → + extractFunction → a `function` node contained by the enclosing + function/method (QN `…::caller::localFn`), receiver check applies (a + nested extension fn becomes a method with owner-contains). + +### getReturnType = extractKotlinReturnType (kotlin.ts:17-43) + +Positional (no fields): iterate namedChildren; before +`function_value_parameters` → skip; after it, the FIRST `user_type` | +`nullable_type` wins; hitting `function_body` or `type_constraints` first → +undefined. nullable_type unwraps to its inner user_type (`?? child`). Name = +the user_type's first `type_identifier`'s text (`?? the whole user_type`), +trimmed; must match `/^[A-Za-z_]\w*$/`; `Unit`/`Nothing` +(KOTLIN_NON_CLASS_RETURN kotlin.ts:6) → undefined. Pinned: `: WidgetK` → +WidgetK; `: WidgetK?` → WidgetK; `: Unit` → undefined; inferred `= expr` → +undefined; `: (Int) -> Unit` (function_type) → undefined; **`: T` (generic +param) → `T`** (leaks as a returnType — preserve); extension receiver types +never mistaken (they sit BEFORE the params). Methods and functions both. + +### extractClass (1679) — and the bodiless-header asymmetry + +resolvedBody = resolveBody (class_body by type; null for bodiless). NO +skipBodilessClass → bodiless classes mint nodes. Extras: docstring, +visibility (hook), isExported undefined; decorators via createNode's +extractModifiers (expect/actual classes). Then extractInheritance (§below) — +**BEFORE the body walk**, so extends refs precede member emissions. Then +extractCsharpPrimaryCtorParamRefs (no-op — needs language csharp… actually +gated at :5939 by language, cheap early-out) and extractDecoratorsFor +(§Decorators — the `@MyMarker class` ref). Push, walk, pop. + +- **Bodied class: body = class_body → ONLY class_body children are visited.** + The `primary_constructor` is a DIRECT child of class_declaration, NOT of + class_body → **constructor properties (`class Foo(val a: Int)`) mint NO + field nodes, ctor default-value calls emit NOTHING, and `data class` + components are invisible** (pinned: DataK has zero members). +- **Bodiless class: body = the class node itself (1714) → the HEADER children + are visited**: the primary_constructor recursion reaches default-value + `call_expression`s → **`calls` refs from the CLASS node**, and + delegation_specifier recursion reaches super-ctor argument calls too. + Ground truth (`extract-bodiless.txt`): `class Bodiless(val b: Int = + initB()) : Base(readCfg2())` → extends `Base` + calls `initB` + calls + `readCfg2`, all from class:Bodiless; the IDENTICAL bodied class emits + ONLY extends `Base`. Reproduce the asymmetry exactly; also note the + header's value_arguments feed fn-ref capture in the bodiless case only. +- Class-body members: hook properties (fields/constants), function_ + declarations → extractMethod, nested class/object/enum → their branches, + `getter`/`setter` siblings + `anonymous_initializer` + `secondary_ + constructor` → plain recursion (calls attribute to the class). +- extractInterface (1834): kind `interface`; docstring, isExported undefined — + **NO visibility** (extractInterface never calls getVisibility; pinned + vis=undefined). extractInheritance runs; body walk with the interface + pushed (bodiless member funs still mint method nodes; a `val prop` with + same-line getter → hook → `field`). Bodiless interface (`sealed interface + SealedIface`) → body ?? node fallback (1856) → header children re-visited + (nothing emits — but keep the traversal). +- extractEnum (1914): body REQUIRED (resolveBody finds `enum_class_body`) — + a bodiless enum would mint nothing (doesn't occur). docstring, visibility, + isExported undefined. extractInheritance (enum delegation_specifiers). + Body loop (1941-1950): `enum_entry` ∈ enumMemberTypes → + extractEnumMembers(entry); everything else (function_declaration after the + `;`, companion_object, secondary constructors) → visitNode with the enum + pushed → methods of the enum, companion constants under it. +- **extractEnumMembers (1958)**: `getChildByField(node,'name')` → null (no + fields) → the identifier-children scan (1967-1974): one `enum_member` node + per direct `simple_identifier` child, **positioned at the IDENTIFIER node** + (`createNode('enum_member', text, child)`) — one per entry in practice. + QUIRKS, PRESERVE: an entry's `value_arguments` (`OK(200)`) and **an entry's + `class_body` (`OK(200) { override fun label() … }`) are NEVER visited — the + override methods and any calls inside them are COMPLETELY INVISIBLE** + (pinned: Http has enum_members OK/ERR + methods label/common/of only). + +### Properties — the hook rules + the getter-position split (probed) + +- Same-line accessor (`val a: Int get() = compute()`) → the `getter` is a + CHILD of property_declaration → the hook consumes everything → **the + getter body is never walked** (no calls refs). +- Next-line accessor (`val b: Int\n get() = compute()`) → the `getter` is + a **SIBLING** (child of class_body / source_file) → after the hook handles + the property, the walker visits the getter separately → its body's calls + attribute to the CLASS (or file/namespace at top level). Pin BOTH variants. +- Top-level properties: scope 'const' → `val`→constant / `var`→variable, + contained by the namespace (or file). Class body → `field`. companion/ + object body → constant/variable under the CLASS node (stack top). Interface + body → `field` (class_declaration parent matches 'instance'). +- Body-context locals NEVER reach the hook (visitFunctionBody doesn't run + it) — instead they're plain-recursed: **a local `val fn = { … }` lambda + initializer IS walked, so its inner calls attribute to the enclosing + function** (pinned: `println` from caller), unlike hook-consumed + properties. Local `val x: T = …` type annotations emit nothing + (§Type-annotation refs). +- `lateinit var svc: Service` in a class → field `svc` (modifiers don't + matter to the hook). + +### Imports (3170-3236) — and the comment-gluing trap + +Hook returns {moduleName: dotted path, signature: trimmed full text}: import +node (name = `com.example.other.OtherClass`; QN = namespace-prefixed) + the +generic `imports` ref (3183-3194): {fromNodeId: nodeStack top — **the +namespace node when a package exists, else the file node**, referenceName: +the dotted path, line: import_header startRow+1, column: startColumn}. NO +kotlin-specific emit pass (the 3197-3234 rust/php/ruby/python emitters are +all gated off). Shapes (probed): + +- `import a.b.C` → identifier text `a.b.C`. +- **wildcard `import com.example.wild.*`** → the `identifier` covers only + `com.example.wild` (the `.*` is a sibling `wildcard_import`) → a normal + import node/ref named `com.example.wild` (NOT null, unlike rust's + wildcard). +- **alias `import a.b.LongName as Short`** → identifier = `a.b.LongName` + (the `import_alias` child is ignored) — the SOURCE path, the alias binds + nothing. +- **Comment-gluing (grammar quirk, LF and CRLF alike): comments FOLLOWING an + import (or the package header) attach INSIDE the import_header / + package_header node** → the node's extent extends over them and the + hook's `signature` (trimmed full text) INCLUDES the comment lines + verbatim (pinned: sig `"import com.example.alias.LongName as Short\n\n// + line comment run 1\n// line comment run 2"`, node L7-10); the namespace + node similarly spans to the last glued comment (`extract-lfpkg.txt`: + namespace L1-4). Ref line/column stay at the header START. Downstream: + those comments are NOT siblings of the next declaration → its docstring is + LOST (§Docstrings). +- flushFnRefCandidates' QUALIFIED_IMPORT (665) matches dotted paths → kotlin + imports contribute their LAST segment to importedNames (`OtherClass`, + `helper`, `wild`, `LongName`) — the fn-ref gate is "defined in this file ∪ + imported simple names" (unlike rust/ruby). + +### extractCall (3684) — the kotlin paths + +Entry: not vbnet/erlang/ruby/arkts. `func = getChildByField(node,'function') +?? node.namedChild(0)` (4313) → always namedChild(0) for kotlin (no fields). +The cpp operator recovery (4324) is language-gated off. + +**Member branch (4364)** — func.type === `navigation_expression`: + +1. property (4369-4378): field lookups null → `child1 = func.namedChild(1)`; + `navigation_suffix` → its first `simple_identifier` (?? the suffix itself + — unreachable in valid code: suffixes carry the identifier; `::class` + suffixes never appear under a call's function position). methodName = + its text. Safe-call suffixes (`?.`) carry the same simple_identifier — + **`x?.render()` emits exactly like `x.render()`**. +2. receiver = object/operand/argument fields (null) ?? `func.namedChild(0)` + (4385-4389). +3. **LITERAL_RECEIVER_TYPES (4397, set at 373-388)**: kotlin members that + occur: `string_literal` (`"literal".uppercase()`), `integer_literal` + (`5.toString()`) → **emit NOTHING** (pinned). Kotlin's other literal kinds + (`boolean_literal`, `character_literal`, `null`) also appear in the set — + port the WHOLE set verbatim. +4. receiver `simple_identifier` (4401; kotlin's name kind IS in the check + list) not in SKIP_RECEIVERS {self,this,cls,super} (by TEXT — kotlin + receivers are never those texts as simple_identifiers) → + `` `${recv}.${method}` `` (`w.render`, `Registry.register`, + `Short.static`, `instances.add`, `it.render`, `anon.draw`). +5. receiver `this_expression`/`super_expression` → none of the branches → + fall to the ELSE → **bare methodName** (`this.toString()` → `toString`; + `super.hashCode()` → `hashCode`). Same net effect as SKIP, different + path. +6. **receiver `call_expression` + kotlin in the gate list (4408-4418) — the + #750 re-encode (4429-4442):** `innerNav = receiver.namedChild(0)` (NOT a + function field!) → its text with `/\s+/g` stripped; **re-encode ONLY when + `/^[A-Z]/`** → `` `${innerCallee}().${methodName}` ``. Pinned: + `WidgetK.create().render()` → `WidgetK.create().render` (+ the inner + `WidgetK.create` from recursion); `Foo.getInstance().bar()` → + `Foo.getInstance().bar` + `Foo.getInstance`; `Foo().bar()` would → + `Foo().bar`; lowercase chains fall to bare: `lowerFactory().chain()` → + `chain` + `lowerFactory`; `w.chainInner().render()` → `render` + + `w.chainInner`; `listOf(1).forEach {…}` → `forEach` + `listOf`. +7. receiver `navigation_expression` (2-hop `a.b.method()`), `postfix_ + expression` (`x!!.draw()`), parenthesized, etc. → bare methodName. + +**Else branch (4518-4520)** — calleeName = RAW func text: bare +`helper`/`run`/`WidgetK` (constructor calls are plain capitalized `calls` +refs — kotlin emits NO instantiates, §dispatch table); backticked +`` `weird name` `` verbatim; generic calls `generic(1)` → `generic` +(type_arguments live in the call_suffix, not the callee). QUIRKS, PRESERVE +(all pinned in `extract-torture.txt`): + +- **Paren-then-lambda `trailing() { it * 3 }`** parses as + call(call(trailing,()), annotated_lambda) → TWO refs: the outer's callee is + the inner call's RAW TEXT **`trailing()`** (garbage, unresolvable) + the + inner `trailing`. A no-paren trailing call (`trailing { … }`, + `run { … }`) is ONE call → one clean ref. +- **Newline-glued invoke chains**: `fn(3)` followed by a line starting `(` + continues the expression (kotlin grammar) → `fn(3)\n(fn)(4)` is one + 3-deep call chain emitting callees `fn(3)\n (fn)` (raw text with + embedded newline), `fn(3)`, and `fn`. Deterministic garbage — reproduce + byte-for-byte. +- The parenthesized-conversion regex (4530, + `/^\(\s*\*?\s*([A-Za-z_][\w.]*)\s*\)$/`) applies to kotlin calleeNames — + a clean single-line `(handler)(4)` (as the FIRST statement of a body, + un-glued) has func text `(handler)` → rewritten to `handler`. Port the + regex. +- Template strip (4542) + cpp fn-ptr fan-out (4556) are c/cpp-gated — no. +- Final ref: {callerId = stack top, name, line = call startRow+1, column = + call startColumn (UTF-16)}. Inner calls of every chain are ALSO visited + (the body walker recurses after extractCall — no consumption). +- Calls inside string-template interpolations EMIT (in bodies): + `"… ${w.render()} …"` → calls `w.render` at the inner call's position + (interpolated_expression recursion). `$topVal` (interpolated_identifier) + emits nothing anywhere. + +### Static-member / value-read refs (4750-4808) — kotlin IS in STATIC_MEMBER_LANGS (345-347) + +Called ONLY from the body walker (5218) — top-level/class-scope reads emit +nothing (hook-consumed property initializers doubly so). +`navigation_expression` ∈ MEMBER_ACCESS_TYPES (326). Mechanics: + +- callee-of-call skip (4772-4778): parent ∈ callTypes AND parent.namedChild(0) + starts at this node → skip (`Registry.register(w)`'s nav emits no + references ref). +- recv = object/expression/scope fields (null) ?? namedChild(0); accepted + types include `simple_identifier` (4792); text must match + `/^[A-Z][A-Za-z0-9_]*$/` → `references` ref **at the RECEIVER's position** + (pushStaticMemberRef 4800). +- Pinned: `Registry.count` (statement) → references `Registry`; `Color.RED` + → references `Color`; **`com.example.Fq.CONST_READ` → NOTHING** (nested + navs — the outer recv is a navigation_expression, not accepted; the + innermost recv `com` is lowercase); `listOf(1).size` → nothing (recv is a + call). **Assignment WRITES emit nothing**: `Registry.count = 5` / + `+= 1` parse as `assignment > directly_assignable_expression` — that node + type is NOT in MEMBER_ACCESS_TYPES (pinned: assignRefs() emits zero refs). +- A `Foo.Bar` nav nested inside a bigger expression is visited on its own + as the walker recurses — each nav node is evaluated once. + +### Decorators — kotlin annotations DO emit `decorates` (unlike csharp/php), asymmetrically + +extractDecoratorsFor (4897) runs for functions/methods/classes (NOT +hook-created properties/fields/constants — the hook never calls it; pinned: +`@field:JvmField val fielded` → NO ref). Kotlin annotations live at +`modifiers > annotation > …` — scan #1 (4976-4987) descends into `modifiers` +children (the comment at 4979 names Kotlin) and consider() accepts node type +`annotation` (4928): + +- **`@JvmStatic` / `@MyMarker` (no args)** → annotation > `user_type` — + user_type IS in the target list (4950) → name = its text (`<`-strip + + last-`.`/`::`-segment normalization at 4959-4962 apply) → **`decorates` + ref** {from: the decorated node, name, line/col of the ANNOTATION node}. + Pinned: decorates `MyMarker` from class Annotated, `JvmStatic` from method + jvmStatic. +- **`@Deprecated("gone", ReplaceWith("new"))` (with args)** → annotation > + `constructor_invocation` — NOT `call_expression`, NOT in the identifier + list → **NO ref at all** (and the argument expressions are never visited + by anything — no calls refs either). Pinned: method `old` has zero + decorator refs. +- **Use-site targets `@field:JvmField`** on a FUNCTION/CLASS would emit (the + `use_site_target` child is skipped, the user_type matches) — but on + properties (their usual home) the hook path never runs the extractor, so + in practice they're silent. +- `platform_modifier` children of modifiers (expect/actual) → not accepted + types → no decorates refs (they ride node.decorators instead). +- The backward-sibling scan (5013-5022) is inert — kotlin annotations are + inside the declaration's `modifiers`, never preceding siblings + (file_annotation has no branch that reaches consider()). + +### Inheritance — delegation_specifier (5595-5615) + +extractInheritance's child loop runs over the CLASS NODE's direct +namedChildren — kotlin's `delegation_specifier`s are direct children +(probed; no wrapper node). Per specifier: + +- userType = find direct `user_type`; ctorInv = find direct + `constructor_invocation`; target = userType ?? ctorInv; none → skip. +- typeId: user_type → its FIRST `type_identifier` (?? itself); + constructor_invocation → its user_type's FIRST type_identifier (?? the + user_type ?? the invocation). +- ONE **`extends`** ref per specifier {name: typeId text, line/col: the + typeId node}. Kotlin NEVER emits `implements` — interfaces ride extends + too (pinned: SubK → extends OpenBase + Drawable + Comparable). +- QUIRKS, PRESERVE: **qualified supertype `: com.example.deep.RemoteBase()` + → ref named `com`** (first type_identifier of the multi-segment + user_type — pinned); generic supertype `Comparable` → `Comparable` + (type_arguments' identifiers aren't direct children); **`by`-delegation + (`: Drawable by d`) emits NOTHING** — the specifier's only child is + `explicit_delegation` and the direct-child finds miss (pinned: + DelegatedImpl has zero extends). +- Runs for classes, objects (extraClassNodeTypes → extractClass), interfaces, + enums. `object Add : SealedOp()` → extends SealedOp ✓. Anonymous + `object_literal`s never reach it (no class node). + +### Type-annotation references — kotlin ∈ TYPE_ANNOTATION_LANGUAGES (5753) but the machinery is DEAD + +extractTypeAnnotations (5788) for kotlin takes the GENERIC path: params = +`getChildByField(node, 'function_value_parameters')` (5844) → **null** (zero +fields); returnType = `getChildByField(node, 'type')` (5851) → **null**; the +`type_annotation` direct-child search (5873) → no such node kind in this +grammar. extractVariableTypeAnnotation (6074) needs a `type_annotation` +child → dead; the body-walker variable_declarator branch (5230) needs node +kind `variable_declarator` → kotlin has none. property_signature/ +method_signature (1282) are TS-only kinds. **Net: kotlin emits ZERO +type-annotation `references` refs — no param types, no return types, no +property types, no local types** (pinned: torture has no such refs). +BUILTIN_TYPES is never consulted for kotlin. The walker needs cheap +early-outs that preserve exactly this nothing. + +### Docstrings (tree-sitter-helpers.ts:95-127) — KDoc is DROPPED + +Kotlin comment node kinds: `line_comment` (`//`) and `multiline_comment` +(`/* */` AND KDoc `/** */`). getPrecedingDocstring accepts only +{comment, line_comment, block_comment, documentation_comment} — +**`multiline_comment` is NOT in the set → KDoc NEVER becomes a docstring, +and a KDoc sitting between a `//` run and the declaration BREAKS the chain** +(it's a non-comment named sibling to the scan). Pinned +(`extract-docs.txt`): `/** KDoc */` + `// line one` + `// line two` + fun → +doc = "line one\nline two"; KDoc-only → doc undefined; `/** kdoc */` then +`// trailing line` then fun → "trailing line" only. DOCSTRING_WRAPPER_TYPES +(55-62) contains no kotlin kinds → no anchor climbing. cleanCommentMarkers +(77-90): only the `^\/\/[/!]?\s?` per-line strip fires for kotlin line +comments — all `gm` strips ride `js_multiline_strip` in docstring.rs (#1329 +CRLF semantics) — **call the shared docstring.rs, port nothing**. Properties +(hook-created) never get docstrings at all. The import/package +comment-gluing (§Imports) eats the docstring of the first declaration after +the import block — pinned: `topLevel` has doc=undefined despite two `//` +lines directly above it. + +### Value-reference edges (398-931) — kotlin IS in VALUE_REF_LANGS (401) + +Port the full machinery (crib java.rs/go.rs): `CODEGRAPH_VALUE_REFS=0` kill; +MAX_VALUE_REF_NODES = 20,000 caps the prune DFS and each reader scan; +isGeneratedFile skip. + +- **Targets** (captureValueRefScope:735): kind constant|variable, name + length ≥3 AND `/[A-Z_]/` (`file_table` qualifies via `_`; `count` does + not), parent id prefix ∈ {file:, class:, module:, struct:, enum:}. + **QUIRK (the php-namespace analogue, pinned): in ANY file with a `package` + header, top-level properties' parent is the `namespace:` node → NOT + accepted → top-level kotlin constants are NEVER value-ref targets.** Only + un-packaged files (scripts, `.kts`) keep file-level targets + (`extract-vref-nopkg.txt`), and class/object/companion-scope constants + (class: parent) are the working population (`extract-vref.txt`: + readTop → TOP_LIMIT, readBoth → SHARED_TABLE). +- **Reader scopes**: every function/method/constant/variable node (764) — + fields are NOT readers (a class `val`'s initializer reads nothing; + a hook-'const' object property IS a reader — its whole + property_declaration subtree incl. `by lazy { }` lambda contents is + DFS'd; the reader DFS has NO lambda halt, unlike the fn-ref scan). +- **Shadow prune** (803-878): the kotlin declarator case is + **`property_declaration` (856-869)** — vd = find direct + `variable_declaration` → its first `simple_identifier` → bump (the + Swift half of that case — name field / value_binding_pattern — is null + path for kotlin); destructuring (multi_variable_declaration) bumps + NOTHING (a destructured local shadow never prunes — quirk, preserve). + bump() counts `identifier`/`simple_identifier` nodes (807 — the comment + names Kotlin). Every `val`/`var` ANYWHERE in the tree bumps its name: + the target's own declarator + any body-local re-declaration → declCount + > fileScopeCount → target deleted. Pinned: companion `RETRY_MAX` + + a method-local `val RETRY_MAX = 9` → RETRY_MAX pruned (readBoth emits + only SHARED_TABLE). +- **Emission** (880-930): per reader scope DFS (stack-based, namedChildren + pushed in order and POPPED — reverse-source-order visitation, ruby + precedent; edge ORDER follows); reader node type `simple_identifier` + (906-909 — the comment names Kotlin; `identifier`/`constant`/`name` never + occur in kotlin trees). Any textual occurrence whose text maps to a + target: nav members (`X.SHARED_TABLE`'s member half), `${TARGET}` + interpolations (interpolated_expression > simple_identifier) — but NOT + `$TARGET` (node kind `interpolated_identifier`, not accepted — pinned). + Skip self-id, same-name, dedupe per (scope,target) → EDGE + {kind:'references', metadata:{valueRef:true}}, appended AFTER the walk + (flush order below). The Dart/Pascal sibling pull (891) is inert — a + kotlin property's next sibling can be a `getter`, which is neither + `function_body` nor `block`. + +### Function-as-value capture (#756) — KOTLIN_SPEC (function-ref.ts:240-248) + +idTypes = **EMPTY** (bare simple_identifiers are NEVER candidates; +explicitRef always true — irrelevant, no addressOfOnly). dispatch: +`value_arguments` → args; `assignment` → rhs with **NO field** (RHS = LAST +named child; the lhs for the param-storage skip comes from +namedChild(0) — the `directly_assignable_expression`; the skip +(408:430-443) compares the LHS's trailing identifier to the FULL rhs text — +callable refs start `::`, so it effectively never fires for kotlin, but port +the comparison). layers: `value_argument` → null (fan out namedChildren). +special: {`callable_reference`, `navigation_expression`}. No +unwrap/ungatedModes/addressOfOnly. + +- The `value_argument` **label-forward skip (547-557) is DEAD for kotlin** — + it reads `getChildByField(node,'name')` → null (zero fields), so a named + argument `f(cb = cb)` is NOT skipped; the fan-out visits both the label + and value identifiers (bare ids → nothing anyway, idTypes empty). Only + Swift exercises the skip. Reproduce the fan-out. +- **`callable_reference` special (649-665):** scan namedChildren — receiver = + last `type_identifier` child, member = last `simple_identifier` child. No + member → [] (**`String::class` — the `class` is an anon keyword → member + null → nothing**). No receiver → bare member (`::topLevel` → `topLevel`, + gated). Receiver present → `/^[A-Z]/` on its text: `OtherClass::handle` → + candidate **`OtherClass::handle`** (the `::` rule at flush:709 — + ALWAYS-flush); **`w::render` → [] — the grammar parses even a lowercase + variable receiver as `type_identifier`, and the CASE regex (not the node + type) is what drops it** (pinned: no ref). +- **`navigation_expression` special (671-681):** only when the WHOLE node's + text starts `this::` → the navigation_suffix starting `::` → its LAST + named child → candidate **`this.`** (ALWAYS-flush). `this::caller` + pinned. Ordinary `a.b` navs in args → []. +- Capture points: visitNode:990 (top-level/class-scope call args), + visitFunctionBody:5137, scanFnRefSubtree (hook-consumed property + subtrees — `val x = register(::f)` captures via the inner + value_arguments; **the scan halts at `lambda_literal` (610), so refs + inside `by lazy { }`/trailing lambdas under a hook-consumed property are + NOT captured**). **NOT captured anywhere: property/local initializer + callable refs (`val m = ::caller`, `val bound = w::render`) — kotlin's + dispatch has NO property_declaration/varinit key** (unlike SWIFT_SPEC — + do not borrow it). Pinned: torture emits exactly three function_refs — + `topLevel` (definedHere), `OtherClass::handle`, `this.caller`. +- Flush gate (639-728): generated-file skip; `this.`-prefixed + + `::`-containing candidates always flush; bare names need definedHere + (same-file function/method names) ∪ importedNames (dotted-import last + segments — §Imports). Dedupe `${fromNodeId}|${name}` → + {referenceKind:'function_ref'} (FUNCTION_REF_CODE 200 on the wire). + +### visitFunctionBody (5129-5286) — kotlin rows + +- maybeCaptureFnRefs (5137) per node; `macro_invocation` branch rust-gated. +- `call_expression` → extractCall (5143), NO return → children recursed + (chains/args re-visited). +- INSTANTIATION_KINDS (5145) — never for kotlin. extractBareCall — absent. +- extractStaticMemberRef (5218) — every body node (§Static-member). +- variable_declarator type-annotation branch (5230) — dead (no such kind). +- **Nested `function_declaration` (5245)** → named → extractFunction (→ + receiver check → possibly extractMethod). Local funs become `function` + nodes (QN `…::caller::localFn`). +- classTypes (5255): a body-local `class LocalClass { … }` → full + extractClass (kind via classify), contained by the enclosing function — + its methods extract normally (pinned: `caller::LocalClass::lm`). +- **`object_declaration` in a body is NOT dispatched** (extraClassNodeTypes + is not checked in visitForCallsAndStructure) → recursed → its class_body's + `fun`s hit 5245 → **extractFunction: a local object's methods become + FUNCTIONS contained by the enclosing function** (pinned: `caller::om`), + its properties mint nothing (no hook here). Same for **`object_literal` + (anonymous objects)**: `val anon = object : Drawable { override fun + draw() … }` in a body → NO class node, NO extends ref, `draw` leaks out as + a function under the enclosing fn with its body calls attributed to it + (pinned: `caller::draw`, `calls helper from=function:draw`). At + TOP-LEVEL/class scope the same object_literal sits inside a hook-consumed + property → **completely invisible** (methods and all — scan halts at + nothing relevant but extraction never runs). Pin the asymmetry. +- Bodies recursed transparently through when/if/for/try + (control_structure_body), elvis, postfix `!!`, labels (`label@`), lambdas + (annotated_lambda/lambda_literal — enclosing-fn attribution), string + templates (interpolated_expression emits calls; interpolated_identifier + is inert). + +### Misc shared paths + +- Positions: `line = startPosition.row + 1`, `column = startPosition.column` + — **UTF-16 code units** (textutil::col16), as are startIndex/endIndex + substrings (getNodeText everywhere) and the import-signature `.trim()`. +- Refs carry NO filePath/language (store denormalizes; §arch-7 — no + REF_FLAG_FILE_PATH use). `function_ref` = wire code 200. +- `extract()` wrap: file node → namespace node (if package) → walk order → + `flushFnRefCandidates` then `flushValueRefs` (538-539, both while the + namespace is still pushed) → pops. Table order: nodes in creation order; + contains edges interleaved with creation, value-ref EDGES appended LAST; + walk-order refs, then function_ref refs at flush. Store/harness are + rowid-order-sensitive — reproduce exactly. +- **CRLF hazards inventory for the kotlin path**: kotlin.ts has NO regexes + over multi-line source (getReturnType's `/^[A-Za-z_]\w*$/` and the + visibility `.includes` are single-token); the shared paths' regexes that + fire for kotlin are extractCall's parenthesized-conversion (4530, + single-name, `\s*` can eat `\r` — port as-is with `\s` semantics), + the #750 `\s+` strip (JS `\s` ⊇ `\r` — Rust regex `\s` matches `\r` too, + parity holds), decorator name normalization (4959-4962), and + cleanCommentMarkers' `gm` strips → **`js_multiline_strip` in docstring.rs + (#1329), call it**. Grammar-level CRLF probed clean (identical shapes, + no errors, `extract-crlf.txt` byte-sane; the comment-gluing reproduces on + CRLF identically). +- Defer policy: per-file `has_error()` → `defer:`; expected incidence + 4.7–8.5% (§arch-6) including the PHANTOM class (hasError with no + ERROR/missing node — trust the flag, not node presence). wasm recovery is + canonical; fun-interface files always land here. +- MAX_FILE_SIZE / generated-file skips: shared, nothing kotlin-specific. + +## Frameworks & synthesis consumers (stay TS-side — pin the walker's output contract) + +- **kotlinExpectActualEdges (resolution/callback-synthesizer.ts:987-1026; + doc block :955-985)** — the tracker's "expect/actual pairing is + synthesis-side". Reads `queries.iterateNodesByLanguageWithDecorator( + 'kotlin','actual')` (db/queries.ts:1082 — a LIKE pre-filter over the + node DECORATORS column) then exact `decorators.includes('actual')`, + `getNodesByQualifiedNameExact(act.qualifiedName)`, kind compatibility via + KMP_TYPE_KINDS {class, interface, struct, enum, **type_alias**} (:982 — + `actual typealias` fulfillment), different file, counterpart NOT marked + actual → synthesized `calls` edge decl→actual. **Walker obligations: + decorators content+order from extractModifiers; EXACT qualifiedNames + (package-prefixed — `com.example::PlatformFile`); kinds; filePath; + startLine.** Validate on kotlinx.coroutines (the KMP gate repo: 30 + expect-files / 95 actual-files at survey time) — spot-check + `synthesizedBy: 'kotlin-expect-actual'` edge counts are IDENTICAL under + kernel and wasm arms after a full init of each. +- **Closure-collection pass (callback-synthesizer.ts:252-326, CC_LANGUAGES + :77 = {swift, kotlin} — the #1235 gate)** — synthesis-side, no port, but + it consumes extraction artifacts: for every method/function node with + `language === 'kotlin'` it re-reads source and slices + `sliceLines(content, m.startLine, m.endLine)`, regexing + `.forEach { it( ` dispatchers and `.append/.add/.push/.insert(` + registrars. **Walker obligations: method/function node startLine/endLine + spans (incl. the resolveBody endLine extension) and the language tag** — + a truncated endLine silently drops dispatch edges. +- **rnCrossPlatformEdges (callback-synthesizer.ts:1645+)** — kotlin ∈ NATIVE + set (:1649); pairs native method/function node NAMES across + java/kotlin/objc/cpp with JS callers. Standard node-table obligation only. +- **springResolver / expoModulesResolver / fabricViewResolver** (§arch-2) — + regex over raw `.kt` source in extractFromSource:6736-6758; their route + nodes carry literal ids (`route:${filePath}:${line}:…`) and their refs + carry filePath+language (framework refs, unlike extraction refs). No + walker dependency beyond method/class node names for their handler-ref + resolution. + +## Parity mechanics (all have bitten before) + +- **Emission order** per §Misc: file → namespace → source-order walk (per + construct: node + contains edge → extends refs BEFORE body members → + extractor-order refs) → function_ref refs → value-ref EDGES last. +- **generateNodeId inputs**: (filePath, kind, name, startRow+1) — name keeps + backticks; import nodes are named the dotted path; enum_member line = the + IDENTIFIER's line (not the enum_entry's — same line in practice, but the + COLUMN and the node's position row both come from the identifier child); + namespace line = the package_header start; the glued-comment extents + affect endLine/endColumn (and import signatures), never the id line. +- **Receiver-QN methods**: id hashes the NAME only — the qualifiedName + override (`WidgetK::extend`) does not enter generateNodeId. +- **UTF-16 columns/slices** (textutil::col16/slice_utf16): every ref/node + column, getNodeText substrings, import-signature trim. Kotlin sources are + multibyte-heavy (string templates, KDoc) — the torture fixture needs a + non-ASCII line before a symbol. +- **CRLF**: §Misc inventory; CRLF variants of every fixture derived + in-memory (kernel-tsjs-parity pattern). +- **Defer policy**: `has_error()` → `defer:` — INCLUDING phantom errors + (complete CSTs; do not "optimize" by checking for ERROR nodes) and every + fun-interface file. Sweep with the default `--max-deferral 0.1`; expected + deferral counts okio 23 / okhttp 49 / kotlinx.coroutines 51. +- **node-ID-string dedupe**: `node_ids` vec pattern (same-(kind,name,line) + collisions are routine — e.g. one-line `class X { fun x() … }` shapes). + +## Gates (per plan §5, no exceptions) + +- **Standalone GRAMMAR-BUMP gate first (rust pattern), before any walker:** + vendor the wasm + `VENDORED_WASM_LANGS += 'kotlin'` (+ the kernel C + vendor/build.rs/langs.rs/grammar-parity row staged with it), then + old-vs-new **full-init dump-diffs** (`scripts/dump-graph.mjs`, cmp) on the + three gate repos with the kernel OFF both arms. Expected: + **byte-identical on all three** (behavior-neutral bump — any hunk at all + blocks). Full suite green ×2. +- **Torture fixtures** per `## Fixtures to build` below, exercised by a new + `__tests__/kernel-kotlin-parity.test.ts`. +- **Parity sweeps** (`scripts/kernel-parity.mjs `, order-sensitive + full-object, default `--max-deferral 0.1`): + - `/private/tmp/claude-501/-Users-colby-Development-CodeGraph-codegraph/0c11bda1-0b19-4fec-bcd9-d0cb4b2d6e8a/scratchpad/gate-repos/okio` (small, 322 kt/kts files) + - `…/gate-repos/okhttp` (medium, 580) + - `…/gate-repos/kotlinx.coroutines` (large, 1,082 — **the KMP/expect-actual gate**) + (cloned fresh at survey; re-clone public OSS if gone — agent-eval policy). + Expect 0-diff on every NON-deferred file and exactly the §arch-6 deferral + counts. Then **full-init dump-diffs byte-identical** (kernel arm vs + `CODEGRAPH_KERNEL=0`, `dump-graph.mjs`, cmp) on the same three. +- **KMP synthesis spot-check** (tracker row requirement): after the + kotlinx.coroutines dumps, `select count(*) from edges where + json_extract(metadata,'$.synthesizedBy')='kotlin-expect-actual'` equal + across arms (the dump gate already implies it; assert it explicitly once). +- **Suite**: kernel-kotlin-parity torture + CRLF variants + the defer + fixture (a `fun interface` file — asserts kernel `defer:` + wasm-served + output matches `extract-funiface.txt` shape) + a phantom-error fixture + (single-line class body — kernel defers despite the complete CST); full + suite ×2 green with `CODEGRAPH_KERNEL_EXPECT=1`. +- **`DEFAULT_ROUTED += 'kotlin'`** (kernel/index.ts:37) only after ALL of + the above; changelog rides the existing kernel entry. +- Post-route perf sanity: gate repos ride the raw path (§arch-2); a + Spring-Boot-Kotlin or Expo repo is the decoded-path smoke check. Deferral + costs mean the kotlin speedup lands on ~92-95% of files — measure + accordingly. + +## Fixtures to build + +1. `__tests__/fixtures/kernel-parity/torture.kt` — the survey's + `svy-kotlin/torture.kt` is the seed (its `extract-torture.txt` is the + expected-output pin). Inventory, by branch: package header + file KDoc + + `@file:` annotation; imports: plain, dotted, wildcard (`.*` → package + path), alias (`as` — source path), **comment-glued signature** (comments + after the last import); top-level fn with params/return (ret from + user_type; sig undefined); extension fns: plain (`WidgetK::extend`), + generic receiver (`List`), **qualified receiver (`com::qext` bug)**, + infix (`Int::pow`), operator; suspend fn (isAsync true) + the + **`@suspendMarker` text-includes false positive**; `private internal` + (visibility order) + an `internal fun` ('internal'); inferred return / + `Unit` / nullable / lambda return / `: T` generic leak; `expect fun` + (bodiless + dec) / `actual fun`; tailrec self-call in expression body; + top-level `val`/`var`/`const val`/`by lazy {}` (constant/variable kinds, + NO initializer refs, NO capture inside the delegate lambda) + + **destructuring (`val (a,b)` → nothing, both scopes)** + next-line-getter + top-level `val` (getter calls → file/namespace); class with primary ctor + (props invisible, defaults not walked), class-body val/var/computed + (fields; same-line getter consumed vs **next-line getter → class-attributed + calls**), init block + secondary ctor (class-attributed calls), methods, + companion (constants under the class + method + **named companion + `Named`** minting nothing); bodiless-vs-bodied header asymmetry (`class + Bodiless(val b = initB()) : Base(readCfg2())` → extends + 2 class-level + calls; the bodied twin → extends only); data class (no members); + abstract/open one-liners (phantom-error shapes — but keep the PARITY + fixture erroring-free: single-line bodies go in the DEFER fixture + instead, since the kernel defers them!); interface (no visibility; + bodiless method nodes; default impl; `val prop` w/ same-line getter → + field); sealed class + nested `object`/`data class` members (extends + SealedOp); sealed interface (bodiless); enum: simple entries (positions = + identifier), ctor'd entries, **entry-with-body (overrides invisible)**, + post-`;` methods + companion-in-enum; `object` declaration (class kind; + members; value-ref targets); `annotation class`; annotated class/method + (`@MyMarker`/`@JvmStatic` → decorates; **`@Deprecated("x", …)` → NOTHING**; + `@field:`/`@get:` on properties → nothing); typealias ×2 (no value refs) + + **`actual typealias` (dec on type_alias)**; `expect class` + + `actual class` (+ marked member); call shapes: bare, constructor + (`WidgetK` calls ref, NO instantiates), `this.`/`super.` (bare), member, + aliased-import receiver, literal receivers (nothing), capitalized-chain + re-encode (`WidgetK.create().render` + inner) + lowercase chains (bare + + inner), 2-hop nav call, safe-call `x?.render()` (plain encoding), `!!` + receiver (bare), elvis-arm ctor call, trailing lambda (`run {}` / + `w.let {}` / `listOf(1).forEach {}`), **paren-then-lambda + (`trailing() {}` → `trailing()` + `trailing`)**, generic call + (`generic(1)` → `generic`), backtick call, glued newline-invoke + chain (raw-text callee — or a note excluding it if the fixture keeps + statements separated; pin ONE of the two deliberately), `(handler)(4)` + first-in-body (conv-regex rewrite), interpolation call + (`"${w.render()}"`) + `$id` (nothing); static-member reads: + `Registry.count` / `Color.RED` (references at receiver pos), + `com.example.Fq.X` (nothing), `Cls.member` as callee (skip), + **assignment LHS writes (nothing)**; delegation specifiers: plain + + ctor'd + generic + **qualified (`com` bug)** + **`by` delegation + (nothing)**; local declarations in bodies: named local fn, local class + (full), **local `object` (methods leak as functions)**, **`object : + Iface {}` literal (function leak; and the top-level-property twin — + invisible)**; callable refs: `::topLevel` (defined-here gate), + `OtherClass::handle` (import gate irrelevant — always-flush), + `w::render` (dropped), `this::caller` (`this.` flush), + `String::class` (nothing), `val m = ::caller` (NOT captured), + assignment `obj.cb = ::handler` (captured), named-arg + `f(cb = ::handler)` (fan-out capture); value refs: companion/object + constants + readers (incl. a `${CONST}` interpolation read and a + `$CONST` non-read), the local-shadow prune, `count`-style + non-target names, and the namespace-drop (packaged file: top-level + consts are NOT targets — plus the un-packaged `.kts`/no-package twin + where they ARE); docstrings: `//` runs (kept), KDoc (dropped), KDoc + above a `//` run (run kept), KDoc between run and decl (chain broken), + comment-after-imports (lost to gluing); a non-ASCII (UTF-16) line + before a symbol; a `when`/`for`/labeled-loop body. +2. **CRLF variants** of the fixtures derived in-memory (kernel-tsjs-parity + pattern) — docstring cleaning + comment-gluing + import signatures under + CRLF bytes. +3. **`.kts` fixture** — top-level statements (calls from the FILE node), + top-level val (file-parent value-ref target), no package header. +4. **Defer fixture #1: `fun interface`** (Pattern 1 shape) — kernel defers + (`defer:`), wasm output serves the pinned interface+method recovery + (`extract-funiface.txt`). +5. **Defer fixture #2: phantom error** — `abstract class A { abstract fun + i(): Int }` one-liner — kernel defers on has_error() despite a complete, + ERROR-node-free CST; wasm output is byte-normal. +6. **KMP fixture pair** — `expect class` + `fun` in one file, `actual class` + + `actual typealias` in another (same QNs, different files) — feeds the + expect/actual synthesizer identically under both arms (can fold into the + frameworks-integration or synthesizer suites if simpler). + +## Probe artifacts (session scratchpad `svy-kotlin/`) + +`table-compare.cjs` (kind/field/ABI tables), `shape-probe-kotlin.cjs` + +`torture-{OLD,NEW}.txt` (full CST dumps, byte-identical) + `torture.diff` +(empty), `mini-probes.cjs` + `mini-probes.out` (fun-interface ×2, +destructuring ×2, safe-call/elvis, assignment shapes, file annotation, +delegates, named-arg refs, getter nesting, KDoc runs, CRLF, suspend +false-positive, lateinit, top-level object literal — all OLD==NEW), +`error-sweep.cjs` + `errors-{okio,okhttp,kotlinx.coroutines}.txt`, +`extract-probe.cjs` + `extract-{torture,vref,vref-nopkg,docs,bodiless,crlf, +funiface,lfpkg,kts}.txt` (dist-extractor ground truth), fixtures +(`torture.kt`, `vref.kt`, `vref-nopkg.kt`, `docs.kt`, `bodiless.kt`, +`crlf.kt`, `funiface.kt`, `lfpkg.kt`, `script.kts`), grammar material +(`tree-sitter-kotlin/` 0.3.8 tag clone + the tree-sitter.json shim, +`crate-extract/` = crates.io 0.3.8 tarball, `ng-extract/` = kotlin-ng 1.1.0 +tarball, `tree-sitter-kotlin-NEW.wasm` = the staged-candidate build, +sha256s in §Grammar prep). Scratch dirs are throwaway — re-derive from this +doc if gone. diff --git a/docs/design/rust-kernel-migration-plan.md b/docs/design/rust-kernel-migration-plan.md index bd2c19c..b24e21a 100644 --- a/docs/design/rust-kernel-migration-plan.md +++ b/docs/design/rust-kernel-migration-plan.md @@ -610,7 +610,7 @@ parity before porting the language. | rust | `languages/rust.ts` | T1 | crates.io | **DONE (R7b #1, 2026-07-20)** — `rustlang.rs` walker; grammar bumped to v0.24.2 (crate + vendored wasm together). Parity 0-diff on ripgrep/tokio/rust-analyzer + dump byte-identical ×3; rust-analyzer's parser crates defer 18% (token-macro tables, both-arm parse errors — grammar-inherent). Quirk list: docs/design/rust-lang-kernel-port-checklist.md. | ☑ | | dart, scala, lua, luau, r | dedicated files | T1 | crates.io (luau/r/scala: verify crate freshness vs our wasm) | Long-tail T1; port opportunistically after the big five. | ☐ | | kotlin | `languages/kotlin.ts` | T1½ | crates.io | Expect/actual pairing is synthesis-side (fine); extraction is clean but validate against a KMP repo. | ☐ | -| swift | shared + dedicated branch | T1½ | crates.io | **Trap:** in-class property extraction lives in `tree-sitter.ts`'s DEDICATED branch, not `swift.ts` (#1020 — Alamofire went 0→348 props). Gate on Alamofire. | ☐ | +| swift | shared + dedicated branch | T1½ | crates.io | **DONE (R7b #5, 2026-07-20)** — `swift.rs` walker incl. the #1020 dedicated property branch (Alamofire's 348 property nodes reproduced exactly on the kernel arm); grammar bumped to crate 0.7.3 (wasm built from the CRATE TARBALL's src — the tag ships an older ABI-14 generation; delta = error-set membership + 2 gate-found categories, all classified). Parity 0-diff Alamofire/vapor/swift-nio (720 clean files; deferral 9–27% both-arm structural — sweeps use --max-deferral 0.3). One walker fix found by the sweep: the shared `assignment` shadow-prune case is swift-live (declared-then-assigned `let X: T`). Quirk list: docs/design/swift-kernel-port-checklist.md. | ☑ | | c, cpp | `languages/c-cpp.ts` | **T2** | crates.io | **DONE (R7a, 2026-07-17)** — `ccpp/` walker; ALL pre-passes stayed TS-side via the route-point preParse hoist (+6 new blanks added during gating — see the checklist doc); content-based `.h` C-vs-C++ detection stays upstream at detectLanguage. Parity 0-diff + dump byte-identical on redis/git/fmt/protobuf/ALS. | ☑ | | metal, cuda | dialects over the cpp grammar | **T2** (rides c/cpp) | crates.io (cpp) | **DONE (rides R7a)** — `.metal`/`.cu`/`.cuh` map to 'cpp' and their blanks run in the hoisted preParse (filePath rides along for the extension gates); hoist-parity pinned in kernel-ccpp-parity.test.ts + the metal/cuda suites. | ☑ | | objc | `languages/objc.ts` | T2 | crates.io | Rides the c-cpp trap family; RN bridge extraction feeds `rnCrossPlatformEdges` (synthesis-side, fine). | ☐ | diff --git a/docs/design/swift-kernel-port-checklist.md b/docs/design/swift-kernel-port-checklist.md new file mode 100644 index 0000000..d897381 --- /dev/null +++ b/docs/design/swift-kernel-port-checklist.md @@ -0,0 +1,1084 @@ +# Swift kernel port (R7b) — the bug-for-bug checklist + +**Status: PORT COMPLETE (2026-07-20)** — walker `codegraph-kernel/src/swift.rs`, +all gates passed (bump validated standalone with the diff classified per the +error-union rule + ripple pairing + two gate-found categories 7/8 below; +parity sweeps 0-diff Alamofire 89/98 / vapor 224/247 / swift-nio 407/554 at +--max-deferral 0.3 with exactly the predicted deferral counts; dump gates +byte-identical ×3; the Alamofire census reproduced property=348 on the kernel +arm; kernel-swift-parity suite; DEFAULT_ROUTED += swift). **One survey +correction found by the swift-nio sweep: §Shadow prune understated the case +list — the shared `assignment` prune case (tree-sitter.ts:829) is ALSO +swift-live** (a declared-then-assigned `let X: T` + `X = …` branches bumps +per assignment via the directly_assignable_expression's simple_identifier, +pruning X — swift-nio's main.swift files pin it). Survey basis: every +TS-side branch a `.swift` file exercises, with file:line anchors as of +**`a6c62d7`** (HEAD at survey time, clean main). Every grammar-shape and +emission claim below was **probed against both the current production wasm +(tree-sitter-wasms 0.1.13 build of npm tree-sitter-swift ^0.4.0, ABI 13) and a +fresh crate-0.7.3 build (ABI 15)** — CST probes for shapes, **plus the built +`dist/` extractor run end-to-end on a 106-line torture file and on all 98 +Alamofire files** (emissions, order, counts pinned from real output, not +inference). Probe scripts + raw outputs: session scratchpad `svy-swift/` +(§Probe artifacts). Read WITH `docs/design/rust-kernel-migration-plan.md` +(§0a recipe, §2 boundary, §5 gates) and the format precedents +(`rust-lang-`, `csharp-`, `ruby-`, `php-kernel-port-checklist.md` — php's +non-neutral-bump "enumerate + classify" gate is the template here). + +**Blocking findings: none.** Three eyes-open findings that shape the port: +(1) the grammar bump is **NOT graph-neutral** — the old→new delta is confined +to *error-set membership* (65 files across the three gate repos parse +differently-erroneously per arm; three NEW-only regression construct classes +enumerated in §Grammar-bump deltas) while every clean-parse extractor-relevant +shape probed **byte-identical** (53-line CST diff across the whole battery, +all classified inert); the bump gate is php-style enumerate+classify, not +expect-zero. (2) **Swift error incidence is structurally high — 9.2–26.5% on +the NEW arm (both-arm reality, not a bump artifact)** — the parity-sweep +deferral guard MUST be raised for swift (§Deferral policy); a 0.1 guard fails +the sweep on all three gate repos. (3) The port's center of gravity is the +**dedicated in-class property branch in tree-sitter.ts (#1020)** — it is NOT +in languages/swift.ts, it attributes its refs to the *enclosing type* rather +than the property node, and Alamofire's 348 computed-property nodes (re-counted +at survey time: exactly 348) ride it (§Dedicated property branch). + +## Grammar prep (NOT staged — land FIRST, before any walker exists) + +swift is **not** in `VENDORED_WASM_LANGS` (grammars.ts:291) — production loads +`require.resolve('tree-sitter-wasms/out/tree-sitter-swift.wasm')` (mapping +`swift: 'tree-sitter-swift.wasm'` at grammars.ts:34; `.swift` → swift at +grammars.ts:105), a 2023/24-era **ABI-13** build of npm tree-sitter-swift +^0.4.0 (sha256 `41c4fdb2…`, 3,147,876 bytes; 540 node types / 45 fields). + +- **Version: crate `tree-sitter-swift = "=0.7.3"`** (crates.io max_stable, + published 2026-06-01; repo alex-pinkus/tree-sitter-swift). +- **PROVENANCE TWIST — the crate tarball is the canonical generated-file + source, NOT the git tag.** alex-pinkus keeps generated files off `main`; + tag `0.7.3-with-generated-files` (commit + `31d17fe7e818a2048c808b5c6fdc2dc792f4f5b5`) ships an **ABI-14** + parser.c (LANGUAGE_VERSION 14, SYMBOL_COUNT 565 — an *older-generator* run, + plus `parser_abi13.c`/`parser_abi14.c` variants), while the crates.io + tarball ships an **ABI-15** regeneration (LANGUAGE_VERSION 15, SYMBOL_COUNT + 558, STATE_COUNT 10321). The two are the SAME grammar — `grammar.json` + `rules` and `externals` are JSON-equal between tag and crate (probed) — but + the parser.c bytes differ, so a tag-side sha-match is impossible. + **Build the wasm from the CRATE TARBALL's `src/`** (that is literally what + the kernel's cargo build compiles → table-identity by construction, the + csharp-precedent verification posture). Never touch the tag's parser.c and + never run `tree-sitter generate`. + - crate `src/parser.c` sha256 + `d3edff6effe31b9a507f496577407987343b101b23eb7bee7a9b050e8ab5d27a` (20,642,243 bytes — expect slow builds) + - crate `src/scanner.c` sha256 + `f3d6271d64f58c39eed544104a70ca2cf9ecbf80c5d900620f1afd38836542cb` + (== the tag's scanner.c byte-for-byte). **External scanner: YES** — the + crate build compiles it automatically; the wasm build picks it up from `src/`. +- **Build (survey-verified commands):** + ``` + curl -sL https://crates.io/api/v1/crates/tree-sitter-swift/0.7.3/download -o ts-swift-0.7.3.crate + tar xzf ts-swift-0.7.3.crate && cd tree-sitter-swift-0.7.3 + # crate tarball lacks tree-sitter.json (metadata only — no effect on tables); + # copy it from the 0.7.3-with-generated-files tag clone: + cp ../tag-clone/tree-sitter.json . + npx -y tree-sitter-cli@0.25.10 build --wasm -o tree-sitter-swift.wasm . + ``` + (brew emcc present; one benign scanner warning. Survey artifact: ABI 15, + 3,726,622 bytes, sha256 + `cc77a63b8487956270e2f385e29a03ba0773ba532a3c8a8844a26b4c98793843`, 563 node + types / 46 fields, at scratchpad `svy-swift/tree-sitter-swift.wasm`.) +- **Version-choice rationale (evaluated, not defaulted):** the feared + alex-pinkus shape churn did NOT materialize for extraction — the full + OLD-vs-NEW CST battery (types/funcs/props/calls/imports/statics/docs) diffs + in only 53 lines, all inert (§deltas). An older crate (0.5.0/0.6.0) was + considered as a closer-match alternative and REJECTED: clean-parse shapes are + already identical on 0.7.3, so an older pin buys no shape proximity and + loses the error-set wins that dominate the delta — swift-testing `#expect` + (Alamofire's whole test suite), `#Preview`/`#GET`-style freestanding macros + (vapor 57→23 error files), `package` access, and typed `throws(E)` all parse + ONLY on 0.7.x. 0.7.3's three regression construct classes (§deltas) are + net-smaller (21 files) than its fixes (63 files) on the gate repos. +- **Staging plan:** vendor to `src/extraction/wasm/tree-sitter-swift.wasm`; + add `'swift'` to `VENDORED_WASM_LANGS` (grammars.ts:291) with an R7b + comment noting the crate-tarball provenance (NOT tag-sha-matched — state + why); pin `tree-sitter-swift = "=0.7.3"` in codegraph-kernel/Cargo.toml + (crate + wasm move TOGETHER); add `'swift'` to `GRAMMAR_LANGUAGES` in + `__tests__/kernel-grammar-parity.test.ts:39`; kernel symbol + `tree_sitter_swift::LANGUAGE` in langs.rs `grammar_for` + the `LANGUAGES` + const (langs.rs:18, `[&str; 13]` → 14). MIT license. `copy-assets` already + globs `src/extraction/wasm/*.wasm`. +- **Bump lands FIRST, standalone, full suite green + the enumerate+classify + dump gate (§Gates)** — the diff is expected NON-empty and must be confined + to the classified categories. + +## Grammar-bump deltas (old ^0.4.0 → 0.7.3), every one classified + +**Clean-parse shapes: byte-identical.** The whole probe battery (class-family, +functions, properties incl. wrappers/observers/tuple-lets, every call shape, +imports, static reads, docstrings) produced a 53-line CST diff, fully +decomposed into: + +**Inert (verified against every consuming branch):** + +1. `#selector` token split: OLD one anon `#selector` token; NEW anon `#` + + `selector`. `selector_expression`'s NAMED children are unchanged → + `normalizeSpecial` (function-ref.ts:685) and the body walker see identical + trees. Inert. +2. `#warning(…)` internals: OLD = one `diagnostic` leaf swallowing the full + text; NEW = `diagnostic` with an anon `#` child. `diagnostic` matches no + type list on either arm; no named children either way; no stray sibling + call on NEW (probed clean-file). Inert. +3. ABI/table renumber (540→563 node kinds, 45→46 fields) — kind-id churn + only; every consumer keys on type STRINGS. + +**Behavior-changing — ALL of it is error-set membership** (the wasm arm never +defers: production extracts from error-recovery trees, so files whose +error-status or recovery changes WILL diff in the bump gate's dump): + +4. **OLD-error → NEW-clean (the bump working as intended), 63 files across + the gate repos.** Construct classes, each probed to a minimal repro: + freestanding macros — `#Preview { }` (OLD: ERROR + orphan lambda; NEW: + `macro_invocation` — a NEW-only node type, in NO type list → recursed, its + lambda's calls attribute to the enclosing scope), swift-testing `#expect(…)` + (all 4 OLD-only Alamofire error files are Tests using it), vapor's `#GET` + route macros (drives vapor 57→23); `package` access modifier; typed throws + `throws(ErrorType)` (swift-nio ByteBuffer-views). Node/edge/ref diffs in + these files are expected and accepted. +5. **NEW-only error regressions, 21 files (3 Alamofire / 1 vapor / 17 + swift-nio), three construct classes probed to minimal repros:** + - `#if`/`#elseif` **between enum cases** (`enum E { case a\n#if DEBUG\n + case b\n#endif }`) → NEW ERROR, OLD clean. (`#if` at top level, between + CLASS members, around postfix `.modifier(x)` chains, and with `||` + conditions all stay clean on both.) + - **Parenthesized-compound directive conditions** + (`#if (compiler(<6.1) && !os(WASI)) || (compiler(>=6.1) && …)`) → NEW + ERROR (swift-nio's lock/NIOLock family). + - **Optional-subscript + cast + coalesce chain** + (`info?["k"] as? String ?? "d"`) → NEW ERROR (Alamofire HTTPHeaders). + - (vapor's one file combines a backtick-escaped `` `default` `` parameter + label with other syntax; the label alone parses clean on both.) + These files' dumps diff (different recovery trees). Accept as classified; + count them; they are the deferral set the kernel will hand to wasm anyway. +6. **BOTH-arm error files that diff anyway**: two grammars recover + differently from the SAME error (e.g. vapor Authenticator's + `if let c = try? await …` — errors on both, different trees). Any hunk in + a file that is in EITHER arm's error list falls under this category — the + gate's mechanical rule is per-file, not per-construct (below). +7. **(Found at bump-gate time, survey-missed.) Docstring boundaries near + `#if` directives on CLEAN files.** The NEW grammar's directive/comment + sibling structure changes what getPrecedingDocstring accumulates next to + `#if`/`#endif` lines: 7 clean-on-both files (5 Alamofire, 2 swift-nio + Mocking.swift) diff in the docstring field ONLY (verified mechanically: + every other node field byte-equal). Direction: NEW gains a docstring the + OLD chain dropped (`webSocketRequest` gains "Only Apple platforms…") or + extends it with directive-adjacent text (`_withWindowsPaths` gains a + leading "ENABLE_MOCKING" line). The walker reproduces this automatically + (same shared docstring code over the same NEW trees). +8. **(Found at bump-gate time, survey-missed.) Array-literal-callee call + refs.** One clean file (swift-nio IPv4Header.swift) emits 2 NEW-only + `calls` refs whose callee text is a whole multi-line array literal — + a call_expression whose namedChild(0) is the array literal on NEW where + OLD parsed the same bytes as separate expressions. Same garbage-but- + deterministic family as `m[i][j]`; the walker reproduces it via the raw + func-text rule. + +**Bump-gate rule (php precedent, adapted):** run the old-wasm vs new-wasm +full-init dump diff on all three gate repos; **every diffing file must be in +the union of the two arms' `hasError` file lists** (compute both lists first — +`svy-swift/error-incidence.cjs` does exactly this); a diff in a clean-on-both +file blocks the bump. Expect RESOLUTION ripple beyond the erroring files +(recovered symbols re-resolve refs in OTHER files — php's category-3 +mechanism); prove ripple hunks mechanically by ref↔edge pairing +(php checklist's ripple-proof.mjs pattern) instead of re-litigating per file. + +### Error incidence (probed, all `.swift` ≤1 MiB, both arms) + +| Repo | files | OLD (^0.4.0 ABI-13) | NEW (0.7.3) | OLD-only | NEW-only | both | +|---|---|---|---|---|---|---| +| Alamofire | 98 | 10 (10.20%) | 9 (9.18%) | 4 | 3 | 6 | +| vapor | 247 | 57 (23.08%) | **23 (9.31%)** | 35 | 1 | 22 | +| swift-nio | 554 | 154 (27.80%) | 147 (26.53%) | 24 | 17 | 130 | + +### Deferral policy — swift needs a c/cpp-style exemption + +Swift sits FAR outside the ts/java/py/go norm (0–0.42%): heavy `#if` +platform-conditionalization (swift-nio), `try? await` in conditions, and +`@storageRestrictions` init-accessors error on BOTH arms. Per-file +`has_error()` → `defer:` like every walker; **run parity sweeps with +`--max-deferral 0.3`** (covers swift-nio's 26.5% with headroom; Alamofire/vapor +sit under 10%). Double-digit deferral on swift is grammar reality, not a +walker bug — but a deferral-rate JUMP vs the table above is a walker bug. +Deferred files are served by wasm and byte-match by construction; the sweep's +compared set is the ~73–91% that parse clean. + +## Architecture decisions + +1. **No preParse.** `swiftExtractor` has no `preParse` hook (languages/swift.ts + — whole file, no such key) → `preParsedSource` (kernel/index.ts:96) is a + no-op; both arms parse raw bytes. Swift's `#if` is grammar-native + (`directive` nodes, both branches kept as siblings — probed) — nothing to + blank, unlike C/C#. +2. **Framework detection decides decoded vs raw path per repo.** THREE swift + resolvers carry `extract()` hooks (parse-worker.ts:93-99 forces any + language with an applicable framework `extract()` onto the decoded + `extractFromSource` path): `swiftUIResolver` (frameworks/swift.ts:11, + detect = any .swift containing `import SwiftUI`, else any file path ending + `.xcodeproj`/`.xcworkspace` — note `getAllFiles()` returns indexed files, + so the xcodeproj leg rarely fires; the pbxproj inside doesn't end with + `.xcodeproj`), `uikitResolver` (:136, detect = any .swift containing + `import UIKit`/`UIViewController`/`UIView`), `vaporResolver` (:269, detect + = `Package.swift` containing `vapor`, else `import Vapor`). Also + `expoModulesResolver` (expo-modules.ts:154, languages swift+kotlin, has + extract) and `swiftObjcBridgeResolver` (swift-objc.ts:251 — resolve-only, + NO extract, doesn't force decode). Gate-repo reality (verified): + **Alamofire → decoded** (Example/ imports UIKit; watchOS example imports + SwiftUI), **vapor → decoded** (Package.swift), **swift-nio → RAW buffers + path** (no detector fires) — one gate repo per transport, keep all three. +3. **Framework extractors themselves need NO port** (regex-over-raw-source TS, + run in extractFromSource after either arm). Their input contract on the + walker: node names/kinds (`struct`/`class`/`component` resolution by name, + frameworks/swift.ts:432) and — for the closure-collection pass — + function/method node **extents** (§CC pass). Vapor's route refs carry + filePath+language but those are FRAMEWORK refs (TS-side, post-walk). +4. **No extraction ref carries filePath** — swift has no visitNode hook and no + framework-independent denormalized refs (probed: every ref in the + torture/Alamofire runs has filePath undefined). **The v2 REF_FLAG_FILE_PATH + wire slot (buffers.rs:125 / layout.ts:98) stays UNUSED for swift** — flag + 0 on every ref, like rust/csharp. +5. **One walker module** (suggest `codegraph-kernel/src/swift.rs`), registered + in langs.rs (`grammar_for` → `tree_sitter_swift::LANGUAGE.into()`, + `LANGUAGES` += "swift"). Skeleton cribs: **java.rs** for the class-like + scope stack + static-member refs + decorators; **ruby.rs/php.rs** for + hook-heavy dispatch; **rustlang.rs** for the `node_ids` dedupe + import + hooks. The dedicated property branch has no precedent in any walker — it + is new logic, transcribe from §Dedicated property branch. +6. **`.swift` → swift only** (grammars.ts:105); no content sniffing, no + dialect. MAX_FILE_SIZE (1 MiB) and generated-file skips are + orchestrator/TS-side and shared. +7. **No POST_PASSES entry** (kernel/index.ts:81 — none for swift) → + `tryKernelExtractRaw` stays eligible. + +## Extractor config (languages/swift.ts — 138 lines, read it whole) + +Types: functionTypes=[`function_declaration`]; classTypes=[`class_declaration`]; +methodTypes=[`function_declaration`] (== functionTypes — the 994 branch handles +both; the 1027 methodTypes branch NEVER fires for swift); +interfaceTypes=[`protocol_declaration`]; structTypes=[`struct_declaration`] +(**DEAD — node type absent from BOTH grammars**, probed against the kind +tables); enumTypes=[`enum_declaration`] (**DEAD** likewise); +enumMemberTypes=[`enum_entry`]; typeAliasTypes=[`typealias_declaration`]; +importTypes=[`import_declaration`]; callTypes=[`call_expression`]; +variableTypes=[`property_declaration`, `constant_declaration`] +(**`constant_declaration` DEAD** — absent from both grammars; swift `let`/`var` +at every scope is `property_declaration`). nameField=`name`, bodyField=`body`, +paramsField=`parameter`, returnField=`return_type`. + +**THE FIELD-LOOKUP SUBTLETY (do not trust CST dumps here):** +`fieldNameForChild` labels a function's return type and a typealias's value +`name:` — but `childForFieldName` resolves MULTIPLE field names on those +children through hidden rules. Probed truth-table, IDENTICAL on both grammars +(`svy-swift/field-probe.cjs`): + +| lookup | result | +|---|---| +| function_declaration `name` | the simple_identifier (function name) | +| function_declaration `parameter` | **NULL** (parameter children are unfielded) | +| function_declaration `return_type` | **the return type node** (user_type/optional_type/…) | +| function_declaration `body` | function_body | +| typealias_declaration `name` | type_identifier (alias name) | +| typealias_declaration `value` | **the aliased type node** | +| property_declaration `name` | the `pattern` node | +| property_declaration `value` | the initializer expression | +| property_declaration `computed_value` | computed_property | +| enum_entry `name` | the FIRST case-name simple_identifier only | + +The Rust walker must reproduce these exact resolutions (tree-sitter's native +`child_by_field_name` has the same semantics — but pin them in the parity +fixture, this is the branch the whole type-ref story hangs on). + +Hooks PRESENT (port each exactly): + +- **getReturnType = extractSwiftReturnType (swift.ts:14)** — POSITIONAL scan of + namedChildren: skip everything until the first `simple_identifier` (the + name; modifiers/type_parameters before it are skipped via the `seenName` + latch); after it, `function_body` → undefined (body reached); `user_type` → + that node; `optional_type` → its first namedChild of type `user_type` + (`?? null`); first such hit wins: text = `getNodeText(typeNode).trim() + .replace(/<[^>]*>/g, '')`, last `.`-segment (`KF.Builder` → `Builder` — the + comment explains why NOT the first type_identifier), must match + `/^[A-Za-z_]\w*$/` and ≠ `'Void'` else undefined. Probed results: + `-> Widget` → `Widget`; `-> Foo?` → `Foo`; `-> KF.Builder` → `Builder`; + `-> Result` → `Result` (single-level generic strip); **nested + generics break like rust** — `Result, E>` → strip leaves + `Result, E>` → regex fails → undefined; `-> Void`/`-> [Foo]`(array_type)/ + `-> (Int, Foo)`(tuple_type)/`-> (Int) -> Foo`(function_type) → undefined. + Parameters never match (their node type is `parameter`, not user_type — the + scan does NOT descend). +- **resolveName (swift.ts:60)** — class_declaration ONLY, `name` field must be + a `user_type` with >1 `type_identifier` children → the LAST one's text + (`extension KF.Builder` → `Builder`, so extension members merge with the + extended type's simple name, #750). Single-segment (`extension Plain`) and + non-user_type names → undefined (default extraction). +- **getSignature (swift.ts:76)** — `getChildByField(node,'parameter')` is + **ALWAYS NULL** (table above) → `if (!params) return undefined` → + **signature is undefined on EVERY swift function/method** (probed: sig=null + across the torture file and Alamofire). The returnType concatenation is dead + code. The walker emits NO signature for swift, ever. +- **getVisibility (swift.ts:87)** — scan ALL children (anon included) for a + child of type `modifiers`; on its WHOLE text: `.includes('public')` → + 'public', `.includes('private')` → 'private', `.includes('internal')` → + 'internal', `.includes('fileprivate')` → 'private' (**dead arm** — + 'fileprivate' contains 'private', the second check already caught it); + no modifiers / no match → **'internal'**. QUIRKS, PRESERVE: **`open` → + 'internal'** (not checked — probed: `open class func classFunc` → + vis=internal); `public private(set)` → 'public' (first match); + substring-matching runs over ATTRIBUTE text inside modifiers too (an + attribute whose lowercase text contains 'private'/'public' would flip + visibility — not expressible with real-world wrappers, but the walker must + substring-match the same way). +- **isStatic (swift.ts:101)** — any `modifiers` child whose text includes + `'static'` OR `'class'` → true. `class func`/`class var` → static ✓ + deliberate. Same substring hazard (an `@objc(myclassthing)` attribute text + would set isStatic — match bug-for-bug). +- **classifyClassNode (swift.ts:112)** — scan ALL children for a child of + TYPE `struct` → 'struct', TYPE `enum` → 'enum', else 'class'. The grammar + puts the keyword in the `declaration_kind:` anon child (`class`/`struct`/ + `enum`/`actor`/`extension`) → **actor → 'class', extension → 'class'**. +- **isAsync (swift.ts:121)** — modifiers text includes 'async'. **Effectively + always FALSE** (rust-precedent dead code): the grammar puts `async` as an + anon child AFTER the parameter list, never inside `modifiers` (probed: + `func asyncy() async throws` → isAsync=false). The walker must reproduce + false — note extractFunction/extractMethod store `isAsync: false` (hook + present, returns false), NOT undefined. +- **extractImport (swift.ts:130)** — signature = trimmed full node text; + identifier = namedChildren `find(type === 'identifier')` → moduleName = its + FULL text (`Foundation`, `UIKit.UIView` — dotted kept). Kinded imports + (`import class Darwin.FILE` — anon `class` child) and `@testable import` + (modifiers first — find skips it) still find the identifier (probed). No + identifier → null → because the hook exists, tree-sitter.ts:3350 fires → + nothing emitted (no generic fallback; not constructible in valid swift). + `handledRefs` never set → generic `imports` ref {from file node, name = + moduleName, line/col of the import node} (tree-sitter.ts:3183-3194). None + of the language-gated binding emitters (TS/py/rust/php/ruby, :3197-3234) + match swift. + +Hooks ABSENT (the walker must NOT do these): `preParse`, `isConst` (**but +kinds still split let/const — via the swift-specific branches, not the +hook**), `isExported` (undefined on every node except the file node's literal +`false` and extractVariable's `?? false`), `isStatic` IS present (above), +`getReceiverType` (**never diverts extractFunction at :1522; methods happen +ONLY via isInsideClassLikeNode; no receiver QN override, no :1799 +owner-contains fallback**), `resolveBody`, `recoverMangledName`, +`isMisparsedFunction`, `classifyMethodNode`, `extractPropertyName`, +`propertyTypes`, `fieldTypes`, `extraClassNodeTypes`, `packageTypes`/ +`extractPackage` (no namespace node — top-level QNs are bare), +`extractModifiers`, `synthesizeMembers`, `extractBareCall`, `visitNode` hook, +`skipBodilessClass` (**but extractStruct/extractEnum have their own bodiless +skip** — §class-family), `methodsAreTopLevel`, `interfaceKind` (**protocols +are kind `interface`, NOT `protocol`**), `resolveTypeAliasKind`. + +Registration: `EXTRACTORS.swift` (languages/index.ts:54), `FN_REF_SPECS.swift` +(function-ref.ts:392). + +## tree-sitter.ts branches (anchors as of `a6c62d7`) + +### visitNode dispatch — what each swift node hits + +| Node | Branch | Behavior | +|---|---|---| +| `function_declaration` (top level) | functionTypes:994 → extractFunction:1517 | no receiver hook → always extractFunction at file scope | +| `function_declaration` (inside class-like) | :995 → extractMethod:1737 | methodTypes includes it + isInsideClassLikeNode (nodeStack top kind ∈ class/struct/interface/trait/enum/module, :1486) | +| `class_declaration` (class/struct/enum/actor/extension — ALL of them) | classTypes:1005 → classify → extractClass:1679 / extractStruct:1869 / extractEnum:1914 | §class-family | +| `protocol_declaration` | interfaceTypes:1054 → extractInterface:1834 | kind `interface`; §class-family | +| `typealias_declaration` | typeAliasTypes:1071 → extractTypeAlias:2890 | §Type aliases. Returns false → children ALSO recursed (nothing matches — user_type/function_type have no branches) | +| `property_declaration` (top level) | variableTypes:1098 (`!isInsideClassLikeNode()`) → extractVariable:2538 swift branch :2851 | §extractVariable. skipChildren=true + scanFnRefSubtree — **top-level initializers are NEVER walked: no calls/instantiates from them** (probed: `var topVar = compute()` emits nothing) | +| `property_declaration` (inside class-like) | **DEDICATED swift branch :1121-1193** | §Dedicated property branch. The :1098 gate fails first (isClassScopeConstantAssignment:1508 needs node.type `assignment` → false) | +| `protocol_property_declaration` | same dedicated branch (:1123) | protocol pushed = interface = class-like ✓ | +| `constant_declaration` | variableTypes | DEAD — node type doesn't exist | +| `import_declaration` | importTypes:1209 → extractImport:3170 | hook (§Extractor config) | +| `call_expression` (top-level statement / class-body initializer descent) | callTypes:1248 → extractCall:3684 | §extractCall. skipChildren stays false → nested calls recursed | +| `init_declaration` / `deinit_declaration` / `subscript_declaration` | **NO branch** | recursed by the generic loop :1295. **No node minted.** Their body statements are visited by visitNode (NOT visitFunctionBody) with the CLASS still on the stack → their calls attribute to the CLASS node (probed: `init { setupMonitor() }` → `calls setupMonitor from=class`; deinit's cleanup, subscript accessor bodies same). Consequences of the visitNode route: fn-ref capture fires (:990) but **extractStaticMemberRef does NOT** (body-walker-only, :5218) — a `Color.red` read inside `init` emits NOTHING | +| `enum_entry` | (via extractEnum's body loop only) | §class-family | +| `associatedtype_declaration`, `protocol_function_declaration`, `macro_invocation` (NEW), `directive`, `diagnostic`, `operator_declaration`-family, `precedence_group_declaration` | no branch | recursed, nothing extracted. **Protocol method requirements mint NO nodes** (probed — `func didFinish(_:)`/`static func build()` in a protocol produce nothing; only protocol_property_declarations become nodes via the dedicated branch) | +| `navigation_expression` (top level / class body) | no branch in visitNode | recursed. Static-member refs come ONLY from the body walker + walkAttrArgs — a top-level `Type.self` statement emits nothing | +| INSTANTIATION_KINDS (:354) | — | **contains NO swift node types** → `Foo()` is a plain `calls Foo` ref via extractCall; NO instantiates refs exist for swift, ever (probed) | + +### Node creation, IDs, order + +- createNode (:1308): id = `generateNodeId(filePath, kind, name, startRow+1)` + = `` `${kind}:${sha256(`${filePath}:${kind}:${name}:${line}`).hex.slice(0,32)}` `` + (tree-sitter-helpers.ts:18). File node id = literal `file:${filePath}` + (:509), name = basename, qualifiedName = filePath, endLine = + `source.split('\n').length`, isExported false. Dedupe/self-checks compare + ID STRINGS (`node_ids` vec pattern) — same-(kind,name,line) collisions are + legal. +- endLine extension via resolveBody (:1329) — no hook → no-op. +- contains edge from nodeStack top for every created node (:1363). +- qualifiedName = nodeStack names joined `::` (buildQualifiedName:1447; + namespacePrefix always empty outside C/C++). No package node → top-level + QN = bare name; members `Session::request`. Extension members ride the + extension's class node name (`Builder::done` for `extension KF.Builder`). +- extractModifiers hook absent → no decorators-from-modifiers merge (:1355 + no-op); the `decorators` node field stays unset (probed dec=null + everywhere) — decorator refs are separate unresolved refs. +- **Emission order** (pinned by the torture probe, `svy-swift/extract-probe.out`): + file node → source-order walk (per construct: node + contains edge → its + refs in extractor-internal order) → fn-ref refs (flushFnRefCandidates :538) + → value-ref EDGES (flushValueRefs :539, appended to edges LAST). Per + class: class node → extends refs (one per inheritance_specifier, source + order) → (extractCsharpPrimaryCtorParamRefs no-op — needs `parameter_list` + child type, absent) → decorates refs of the class → body members in source + order. Per dedicated-branch property: property/field/constant/variable + node → decorates (owner) → type-annotation refs (owner) → walkAttrArgs + static-member refs (owner) → then (stored only) initializer-descent refs. + Per method: node → type-annotation (return-type) refs → decorates → body + refs. + +### The class family — extractClass / extractStruct / extractEnum / extractInterface + +classify → 'struct': **extractStruct (:1869)** — body = `getChildByField(node, +'body')` (`class_body`); **bodiless → NO node** (:1876; record_declaration +exemption is C#-only; a bodiless struct isn't valid swift anyway). Node kind +`struct` {docstring, visibility, isExported:undefined}. extractInheritance → +§below. **NO extractDecoratorsFor** — `@main struct MyApp` emits NO decorates +ref (probed; the asymmetry: class YES, struct/enum/interface NO). Body +namedChildren visited with the struct pushed. + +classify → 'enum': **extractEnum (:1914)** — body field (`enum_class_body`); +bodiless → no node. Kind `enum` {docstring, visibility, isExported:undefined}. +extractInheritance (the raw-value type rides it — `enum Suit: String` → +`extends String`; extends refs have NO builtin filter, probed `extends Int`). +NO decorates. Body loop: `enum_entry` ∈ enumMemberTypes → extractEnumMembers +(:1958): **`name` field path — `getChildByField(node,'name')` returns the +FIRST case name → ONE `enum_member` node, positioned at the enum_entry, then +RETURN.** QUIRKS, PRESERVE (probed): multi-case `case put, delete` → ONLY +`put` (delete DROPPED — the identifier-scan fallback :1967 is dead for swift +since the field always exists); associated values (`case success(Data)` — +`data_contents: enum_type_parameters`) and raw values (`= "H"`) are never +walked → NO refs from them; `indirect case` same. Non-enum_entry children +(computed properties, methods, nested types) → visitNode with the enum pushed. + +classify → 'class' (incl. actor + extension): **extractClass (:1679)** — no +skipBodilessClass → a bodiless class_declaration would still mint (not valid +swift). Kind `class` {docstring, visibility, isExported:undefined}. +extractInheritance; extractCsharpPrimaryCtorParamRefs no-op; +**extractDecoratorsFor DOES run** (`@Observable class Model` → `decorates +Observable`). Push, visit body namedChildren via visitNode, no +synthesizeMembers, pop. **Extensions:** name via resolveName (multi-segment) +else raw `name`-field text — `extension Point` → class `Point` (a SECOND +class node named like the original — same name, different line → distinct +id); `extension [ServerTrustEvaluating]` → class named literally +**`[ServerTrustEvaluating]`** (raw sugar text, probed); `extension Array +where Element: Equatable` → class `Array`, and the `type_constraints` where +clause emits NOTHING (inheritance_constraint is not an inheritance_specifier). + +**extractInterface (:1834)** — protocol_declaration → kind `interface` (no +interfaceKind hook) {docstring, isExported:undefined — **NO visibility, NO +decorates**}. extractInheritance on the protocol node (protocol inheritance +`: AnyObject, Identifiable` → extends refs). Body (`protocol_body`) +namedChildren visited with the interface pushed: protocol_property_declaration +→ dedicated branch (§below); protocol_function_declaration / +init_declaration / associatedtype_declaration → recursed, nothing. + +### Inheritance — extractInheritance (:5291), the swift case (:5619-5632) + +Direct namedChildren scan of the declaration node; ONLY the +`inheritance_specifier` case matches swift (one specifier per conformance, +each `inherits_from: user_type`): userType = child.namedChildren +`find(type==='user_type')` → typeId = ITS namedChildren +`find(type==='type_identifier')` — the FIRST — → one **`extends`** ref +{from class/struct/enum/interface node, name = typeId text, line/col of the +TYPE IDENTIFIER}. QUIRKS, PRESERVE: **everything is `extends`** — protocol +conformance, protocol inheritance, raw-value types; swift emits NO +`implements` refs from extraction (resolution's supertype machinery handles +both kinds); a qualified base `: Module.Base` takes the FIRST segment +(`Module`) — the outer namespace, not the type. Where-clause constraints and +generic bounds (`type_parameter` `name:` bounds) emit nothing. None of the +other clause cases (extends_clause/base_class_clause/delegation_specifier/…) +match swift node types. + +## THE DEDICATED PROPERTY BRANCH (tree-sitter.ts:1113-1193) — #1020, the port's core + +Fires for `property_declaration` | `protocol_property_declaration` when +`language === 'swift'` AND isInsideClassLikeNode(). Position in the else-if +ladder: AFTER variableTypes (:1098 — which in-class properties fail, see +dispatch table), BEFORE importTypes. **Alamofire baseline (re-measured at +survey HEAD on the production path): 98 files → 3,988 nodes = method 1801 / +field 588 / class 379 / property 348 / enum_member 230 / import 183 / struct +111 / file 98 / constant 97 / enum 77 / type_alias 39 / interface 27 / +function 10; 16,426 refs.** The 348 `property` nodes are exactly this +branch's computed path — the #1020 number reproduced to the digit. + +### swiftPropertyInfo (tree-sitter.ts:277-291) — transcribe exactly + +``` +pattern = childForFieldName('name') + ?? namedChildren.find(t === 'value_binding_pattern' || t === 'pattern') + ?? null +binding = namedChildren.find(t === 'value_binding_pattern') // DIRECT children only +isLet = binding != null && text(binding).trimStart().startsWith('let') +isComputed = namedChildren.some(t === 'computed_property' || t === 'protocol_property_requirements') +nameNode = firstSimpleIdentifier(pattern) +``` + +`firstSimpleIdentifier` (:261-273): BFS (shift from a queue) over +namedChildren, **guard: at most 40 nodes popped**; first `simple_identifier` +wins. Tuple pattern `let (a, b)` → `a` only (one node for the whole +declaration, PRESERVE). + +Shape notes (probed, identical both grammars): +- class/struct/enum property_declaration: `value_binding_pattern` + (mutability let/var) and `name: pattern > bound_identifier: + simple_identifier` are SIBLING direct children → binding found → isLet real. +- **protocol_property_declaration NESTS the value_binding_pattern INSIDE the + `name: pattern`** → the direct-children `find` MISSES it → binding null → + **isLet always false for protocol requirements** (irrelevant today — they + are all computed — but transcribe the miss). +- `computed_value: computed_property` carries the getter; the code matches by + TYPE not field. +- **`willSet`/`didSet` observers are a `willset_didset_block`, NOT a + computed_property** → an observed stored property (`var observed: Int = 0 + { willSet {…} didSet {…} }`) is **isComputed=false → a `field` node**, and + (stored-path descent, below) the observer bodies' calls attribute to the + CLASS (probed: `calls prepare` / `calls react` from=class). + +### The branch body (:1126-1193), step by step + +1. `ownerId = nodeStack top` (the class/struct/enum/interface node). +2. If nameNode: + - **isComputed → `createNode('property', name, node, {visibility: hook, + isStatic: hook ?? false})`** — computed properties become `property` + nodes (the #1020 "var isCloudProxy: Bool" fix; SwiftUI `var body: some + View` is the canonical case). Note extras: NO docstring, NO signature, + NO returnType — visibility + isStatic ONLY (probed doc=null on all). + - else **stored: `isStatic = hook ?? false`; kind = isStatic ? (isLet ? + 'constant' : 'variable') : 'field'`** — `static let` → `constant`, + `static var` → `variable` (`class var` → isStatic via 'class' substring + → `variable`), instance stored (let OR var) → `field`. Same extras. + - Node position = the property_declaration (multi-line observed props span + the block). nameNode null (no simple_identifier in pattern) → NO node, + but steps 3-5 still run. +3. If ownerId: `extractDecoratorsFor(node, ownerId)` — **refs attach to the + ENCLOSING TYPE, not the property** (probed: `@Published private var wrapped` + → `decorates Published from=class:Session`). §Decorators for mechanics. +4. If ownerId: `extractVariableTypeAnnotation(node, ownerId)` (:6074) — finds + the direct `type_annotation` child → extractTypeRefsFromSubtree (:6090) → + one `references` ref per `type_identifier` leaf not in BUILTIN_TYPES, + **from the OWNER** (probed: `let rootQueue: DispatchQueue` → `references + DispatchQueue from=class` at the leaf's position). BUILTIN_TYPES nuances + (:5768): `Int`/`String`/`Double`/`Float`/`Boolean`/`Long`/`Char` are + suppressed (Scala rows), **`Bool` is NOT** (→ real `references Bool` + noise ref, probed), `Void`/`Character`/`Self` NOT. Wrappers recurse: + `[Tag]` → `Tag`; `Session?` → `Session`; `some View` (opaque_type) → + `View`. +5. If ownerId: **walkAttrArgs** (:1165-1175) — find the `modifiers` direct + child; if present, recursively run `extractStaticMemberRef(n)` over EVERY + node of the modifiers subtree. This is the Vapor `@Siblings(through: + PivotModel.self, from: \.$left, …)` mechanism: the attribute-argument + `navigation_expression` with target `simple_identifier PivotModel` + + suffix `.self` → `references PivotModel` from the OWNER at the RECEIVER's + position. Keypath args (`\.$left` — target is `key_path_expression`) and + the wrapper's own `user_type` are self-filtered (not MEMBER_ACCESS_TYPES / + not an accepted recv type). §Static-member refs for the shared mechanics. +6. Computed only: getter = namedChildren find(`computed_property` | + `protocol_property_requirements`); if found: push property id, + `visitFunctionBody(getter, '')`, pop; **skipChildren = true**. The + getter's calls/reads attribute to the PROPERTY node (probed: `calls check + from=property:isCloudProxy`; SwiftUI body's `VStack`/`Text` subtree + becomes the property's callees). protocol_property_requirements contains + only getter/setter specifiers → walks emit nothing. +7. **Stored: skipChildren stays FALSE** → the generic loop (:1295) descends + into the property_declaration's children via visitNode: the initializer's + call_expressions hit callTypes → **`calls` refs from the CLASS** (`let + stored = Session()` → `calls Session from=class`; `lazy var expensive = + Cache.build()` → `calls Cache.build from=class`); willset/didset bodies + likewise; the modifiers subtree is re-walked harmlessly (attributes have + no visitNode branches; walkAttrArgs already emitted the static refs — + different ref kinds, no dupes). Value-position navigation reads (`let m = + Suit.hearts` as an in-class initializer) emit NOTHING here (no + static-member call in visitNode) — contrast bodies. +8. fn-ref capture: maybeCaptureFnRefs ran at :990 BEFORE the branch — + property_declaration ∈ SWIFT_SPEC dispatch (varinit field `value`) → a + stored `let cb: Handler = onFire` captures `onFire`; computed properties + have no `value` field → nothing. + +## extractVariable — the swift top-level branch (tree-sitter.ts:2851-2862) + +Top-level property_declaration only (dispatch table). `swiftPropertyInfo` +again: nameNode && !isComputed → `createNode(isLet ? 'constant' : 'variable', +name, NODE, {docstring, isExported})` — **position = the whole declaration**, +extras: docstring (getPrecedingDocstring — top-level consts DO get +docstrings, unlike the in-class branch), isExported = `?? false` → literal +**false** (:2549; probed exp=false — the only swift nodes besides the file +node with a non-undefined isExported), **NO signature** (unlike the TS/Go +branches — no initializer capture), no visibility/isStatic. Computed +top-level (`var topComputed: Int { 9 }`) → **skipped entirely** (no node). +One node per declaration — tuple `let (a, b) = …` → `a` only. The :1098 +dispatch sets skipChildren=true + scanFnRefSubtree (capture-only, halts at +functionTypes + `lambda_literal` :610) → **top-level initializers emit NO +calls/instantiates refs** (probed: `var topVar: Int = compute()` → nothing +but the node; no type-annotation refs either — extractVariableTypeAnnotation +is NOT called on this path, PRESERVE the asymmetry with the in-class branch). + +## extractFunction / extractMethod for swift (:1517 / :1737) + +- extractFunction: no getReceiverType → never diverts. Name via extractName + (:90): resolveName (class_declaration-gated → undefined for functions) → + nameField `name` → the simple_identifier. **Operator functions:** `func <+> + (lhs:…)` has `name: custom_operator` → extractName returns the raw operator + text → a function node named `<+>` (probed clean-parse on both arms). + `` never occurs (grammar requires a name; the arrow/function_ + expression paths are TS-only). +- Node extras: docstring (§Docstrings), signature **undefined** (dead hook), + visibility (hook), isExported undefined, **isAsync false** (dead hook), + isStatic (hook — real for `static`/`class` modifiers), returnType (hook). +- Then extractTypeAnnotations (:1594) — §Type-annotation refs: **return-type + refs ONLY**. Then extractDecoratorsFor (:1599) — attributes inside + `modifiers` → real decorates refs (`@objc func attributed` → `decorates + objc`, position = the attribute node). Push, walk `body` field + (function_body) via visitFunctionBody, pop. +- extractMethod (function_declaration inside class-like): gate :1747 passes + via isInsideClassLikeNode. Same extras (visibility/isAsync-false/isStatic/ + returnType, signature undefined). receiverType undefined → no QN override + (:1790 skipped), no owner-contains fallback (:1799). Bodiless is + impossible for function_declaration in valid swift (protocol requirements + are a different node type, unhandled). +- **Nested named function in a body** → visitFunctionBody:5245 → + functionTypes + named → extractFunction → `function` node contained by the + enclosing method/function (its QN prefixes the enclosing chain via + nodeStack). Closures (`lambda_literal`) are NOT functionTypes → no nodes; + their calls attribute to the enclosing symbol (probed: `rootQueue.async { + self.perform(req) }` → `calls perform from=method:request`). +- Body-level class/struct/enum/protocol declarations → visitForCallsAndStructure + :5255-5275 dispatches classTypes (with classify)/interfaceTypes → full + extraction, contained by the enclosing function. + +## Type aliases — extractTypeAlias (:2890) + +typealias_declaration → name field (alias name). No resolveTypeAliasKind → +plain `type_alias` node {docstring, isExported:undefined}. swift ∈ +TYPE_ANNOTATION_LANGUAGES → value = `getChildByField(node,'value')` — **the +multi-field lookup WORKS** (table above) → extractTypeRefsFromSubtree over +the aliased type → refs per type_identifier leaf (probed: `typealias Handler += (Data) -> Void` → `references Data` + `references Void`; `typealias +BuilderAlias = KF.Builder` → refs `KF` AND `Builder` — one per segment). +The TS-only member extraction (:2983) is gated away. Returns false → +children recursed (nothing matches). + +## extractCall (:3684) — the swift paths + +Swift never hits the vbnet/erlang/objc/php/java branches (no name+object +fields on call_expression). Generic else :4312: `func = +childForFieldName('function') ?? namedChild(0)` — swift has NO function field +→ **namedChild(0) always**. cpp operator recovery (:4324) is cpp-gated. The +full observed matrix (every row probed via the built extractor): + +| Call shape | func node | Path | Emitted ref | +|---|---|---|---| +| `helper()` | simple_identifier | else :4518 raw text | `calls helper` | +| `Foo()` | simple_identifier | same | `calls Foo` (constructor = plain call; NO instantiates, ever) | +| `Foo.init(raw:)` | navigation_expression | :4364 member branch | `calls Foo.init` | +| `obj.method(1)` | navigation_expression | member | `calls obj.method` | +| `self.own()` | nav, target `self_expression` | receiver not identifier-typed → fallthrough | `calls own` (bare — swift `self` is its own node TYPE; SKIP_RECEIVERS:4400 {self,this,cls,super} is reached only for identifier-typed receivers, so the same net effect arrives via a different path than kotlin) | +| `super.parent()` | nav, target `super_expression` | same | `calls parent` | +| `a.b.deep()` | nav, target inner nav | fallthrough | `calls deep` (bare — 2-hop receivers drop) | +| `x?.optCall()` | nav, targets [simple_identifier x, anon `?`] | receiver = namedChild(0) = `x` | `calls x.optCall` (**optional chaining keeps the receiver** — the `?` is a second anon `target:` child, invisible to namedChild) | +| `y!.forced()` | nav, target postfix_expression | fallthrough | `calls forced` | +| `Foo.make().draw()` | nav, target call_expression | **#750 re-encode :4408-4442**: swift-gated; innerNav = receiver.namedChild(0) (`Foo.make` nav or bare identifier), text ws-stripped; `/^[A-Z]/` gate | `calls Foo.make().draw` + (recursion) `calls Foo.make` | +| `foo.bar().baz()` | same | innerCallee `foo.bar` lowercase → reencode false | `calls baz` + `calls foo.bar` | +| `"lit".upper()` | nav, target line_string_literal | LITERAL_RECEIVER_TYPES :4397 (`line_string_literal` ∈ set :377) | **NOTHING** | +| `"""…""".trimmed()` | nav, target multi_line_string_literal | **NOT in the literal set** | `calls trimmed` (bare) — PRESERVE | +| `5.times()` / `[1,2].reduce(…)` | integer_literal / array_literal | literal set | NOTHING | +| `["k":1].lookup()` | dictionary_literal | **NOT in the set** (`dictionary` is, `dictionary_literal` isn't) | `calls lookup` — PRESERVE | +| `(freestanding)()` | tuple_expression | else raw text `(freestanding)` → **parenthesized-conversion regex :4530 FIRES** | `calls freestanding` | +| `closureTaking { }` / multi-trailing | simple_identifier (lambda in call_suffix) | else | `calls closureTaking` | +| `arr[0]` (subscript READ) | simple_identifier (bracket call_suffix) | else | **`calls arr`** — every subscript access parses as call_expression; huge-volume quirk, PRESERVE | +| `m[i][j]` | inner call_expression | receiver is call but func = call_expression not nav → else raw text | **`calls m[i]`** (garbage, PRESERVE) | +| `self.items[k] = 1` | nav self.items | member, self receiver | `calls items` | +| `defer { cleanup() }` | simple_identifier `defer` | else | **`calls defer`** + inner `calls cleanup` — defer parses as a trailing-closure call (both arms, probed) | +| `try f()` / `try? f()` / `await f()` | (wrapped in try_expression/await_expression) | recursion reaches the inner call_expression | normal ref, position = the CALL node (after the keyword) | +| `"count \(counter.next())"` | (interpolated_expression inside the literal) | recursion descends into string literals | `calls counter.next` — interpolation calls DO emit | +| `.make()` (implicit member call) | prefix_expression | else raw text | **`calls .make`** (leading dot, unresolvable — PRESERVE) | +| macro `#Preview { ContentView() }` (NEW) | (macro_invocation unhandled) | recursion | inner `calls ContentView` from the enclosing scope | + +Post-processing: parenthesized-conversion (:4529) as noted; template-strip +(:4542) and cpp fn-ptr fan-out (:4556) are c/cpp-gated. Final ref: {callerId += nodeStack top, name, line = call startRow+1, column = call startColumn +(UTF-16)}. Inner nav/call children are ALSO visited after extractCall +(callTypes doesn't skipChildren; body walker recurses) — chains emit inner +refs, and the callee-position navigation_expression is exempted from +static-member refs by the :4771 callee-of-call check. + +## Static-member / value-read refs (:4750-4808) — swift IS in STATIC_MEMBER_LANGS (:345) + +Called from the body walker ONLY (:5218) plus the property branch's +walkAttrArgs. `navigation_expression` ∈ MEMBER_ACCESS_TYPES (:326). Mechanics +for swift: callee-of-call skip (:4771-4779 — parent ∈ callTypes and +parent.namedChild(0).startIndex === node.startIndex → the callee nav of a +call emits nothing); recv = object/expression/scope fields (all null for +swift — nav's fields are `target`/`suffix`) → **namedChild(0)** = the target. +Accepted recv types (:4791): identifier/type_identifier/simple_identifier/ +name/scoped_type_identifier — swift targets are `simple_identifier` → +capitalized regex `^[A-Z][A-Za-z0-9_]*$` → `references ` from the +enclosing symbol at the RECEIVER's position. Probed rows: `Color.red` → +`references Color`; `Suit.hearts.rawValue` → outer nav recv = inner nav → +nothing, inner nav → `references Suit`; `UserModel.self` → `references +UserModel`; `Deep.Nested.leaf` → `references Deep` (inner nav only); +`.implicitMember` → prefix_expression, not a nav → NOTHING; `lowercase.field` +→ nothing; keypath `\Foo.bar` → recv = key_path_expression → nothing (the +type_identifier inside the keypath is never read). Remember the visitNode +gap: class-level initializer reads and init/deinit/subscript bodies emit NO +static-member refs (dispatch table). + +## Type-annotation references — swift ∈ TYPE_ANNOTATION_LANGUAGES (:5753) + +For every function/method (extractTypeAnnotations :5788, called at +:1594/:1816): params = `getChildByField(node, 'parameter')` → **NULL → NO +parameter type refs, ever** (probed: `@escaping (Int) -> Void` param emits +nothing — `Void` would have shown). returnType = `getChildByField(node, +'return_type')` → **WORKS** (field table) → extractTypeRefsFromSubtree over +the return node → one `references` per type_identifier leaf not in +BUILTIN_TYPES: `-> DataRequest` → ref; `-> KF.Builder` → refs `KF` AND +`Builder`; `-> Session?` → `Session`; `-> Result` → `Result`, +`Foo`, `Err` (leaves); builtins suppressed per the §property-branch nuance +list (`Bool` NOT suppressed). The trailing direct `type_annotation` find +(:5873) is null for function_declarations. extractVariableTypeAnnotation +(:6074): the dedicated property branch (owner-attributed) and the body +walker's `variable_declarator` gate (:5230-5236 — **dead for swift**, no such +node type; body-local `let x: Foo` property_declarations emit NO type refs — +PRESERVE). property_signature/method_signature (:1282) — TS-only types. + +## Decorators — extractDecoratorsFor (:4897), swift = `attribute` nodes + +consider() (:4898) accepts type `attribute`; the target scan (:4937) finds +the attribute's first namedChild of accepted types — **swift attribute → +`user_type`** (:4950) → name = user_type text, strip `<…>` generic suffix, +strip to last `.`/`::` segment, trim → `decorates` ref {from the decorated +node id (or the OWNER for the property branch), name, line/col of the +ATTRIBUTE node}. Attributes live INSIDE the declaration's `modifiers` child → +found via the modifiers descent (:4983); the preceding-sibling scan (:5013) +finds nothing for swift (attributes are never siblings) and stops at the +first non-decorator sibling. Coverage matrix (probed): function ✓ (`@objc` → +`decorates objc`), method ✓, class ✓ (`@Observable`), dedicated-branch +property ✓ (owner-attributed) — **struct/enum/interface ✗ NO decorates** +(extractStruct/extractEnum/extractInterface never call it — `@main struct`, +`@objc enum`, attributed protocols emit nothing, probed). Attribute ARGUMENTS +are never walked here — only walkAttrArgs (property branch) reads them, and +only for static-member shapes. Parameter attributes (`@escaping` etc. inside +`parameter`/`parameter_modifiers`) are never reached by any pass. + +## Docstrings (tree-sitter-helpers.ts:95) + +`///` doc lines AND `//` plain comments are node type `comment` — accepted by +the sibling scan; consecutive runs accumulate (unshift → source order) and +`//` vs `///` are NOT distinguished (a plain comment right above a decl IS +its docstring). **`/** */` and `/* */` block comments are `multiline_comment` +— NOT in the accepted set (comment/line_comment/block_comment/ +documentation_comment) → block docs are IGNORED and BREAK the accumulation +chain** (probed: `/** block doc */ func blockDoc` → doc=null). PRESERVE. +DOCSTRING_WRAPPER_TYPES: no swift wrappers → no climbing. Attributes do NOT +break the chain (they're inside the declaration node — `/// doc` + +`@objc func` keeps its doc, probed). cleanCommentMarkers (:77): swift hits +`^\/\/[/!]?\s?` (gm) and — only if a multiline_comment ever reached it, which +it can't — the block strips. **The `gm` per-line strips are the ONLY +CRLF-sensitive regexes on the swift path (#1329): use `js_multiline_strip` +in docstring.rs.** Docstrings attach to: functions, methods, classes +(incl. extensions/actors), structs, enums, interfaces, top-level +constants/variables (extractVariable), type_aliases. NOT to: dedicated-branch +properties/fields/constants (extras carry no docstring — probed), enum +members, import nodes. + +## Value-reference edges (:398-931) — swift IS in VALUE_REF_LANGS (:401) + +Port the full machinery (crib go.rs/java.rs): `CODEGRAPH_VALUE_REFS=0` kill; +MAX_VALUE_REF_NODES = 20,000 caps the prune DFS and each reader scan; +isGeneratedFile skip. + +- **Targets** (captureValueRefScope :735): kind constant|variable, name ≥3 + chars AND `/[A-Z_]/`, parent id prefix ∈ {file:, class:, module:, + **struct:, enum:**} — the struct:/enum: rows exist FOR swift's + static-let-namespacing idiom (`enum Constants { static let X }`, comment at + :748-750). Swift targets: top-level `let`/`var` (under file:) and in-class + `static let`/`static var` (constant/variable under class:/struct:/enum:). + `interface:` NOT accepted → protocol statics (hypothetical) excluded. + Instance `field`s and computed `property`s are NOT targets. +- **Reader scopes** (:764): function/method/constant/variable nodes — + **`property` and `field` are NOT readers** (probed: `isCloudProxy`'s read + of SHARED_MAX emits no edge; `method request`'s does). +- **Shadow prune** (:803-878): the declarator switch's + **`property_declaration` case (:856-869) RESOLVES for swift** (unlike + php): vd = find `variable_declaration` (Kotlin) — absent for swift → else + `firstSimpleIdentifier(childForField('name') ?? find(value_binding_pattern + | pattern))` — the swift shape → bump() counts it when the text is a + target name (bump accepts identifier|simple_identifier :807). EVERY + property_declaration in the tree bumps — targets' own declarations, body + locals (`let SHARED_MAX = 5` in a method — the shadow source), and + same-named instance properties. `declCount > fileScopeCount` → target + deleted. **guard-let/if-let bindings do NOT bump** (guard_statement/ + if_statement hold bound_identifier directly, no property_declaration — + probed) → a `guard let X = …` shadow does NOT prune. PRESERVE both sides. +- **Emission** (:880-930): per reader scope DFS (bodies are children — the + Dart/Pascal sibling pull :891 is inert); match node type + `simple_identifier` (:908 — swift's every name reference) whose text maps + to a target, target ≠ self, name ≠ scope's own name, dedupe per + (scope,target) → EDGE {source: scopeId, target, kind:'references', + metadata:{valueRef:true}}, appended AFTER all other edges. Because every + `simple_identifier` matches — nav suffixes included — `Session.SHARED_MAX` + AND a bare `SHARED_MAX` both emit (probed: the single torture valueRef + edge method:request → constant:SHARED_MAX). + +## Function-as-value capture (#756) — SWIFT_SPEC (function-ref.ts:288) + +``` +idTypes: { simple_identifier } +dispatch: value_arguments → args + assignment → rhs (field 'result') + array_literal → list + property_declaration → varinit (field 'value') +layers: value_argument → 'value' // FIELD 'value', not null +special: { selector_expression } +``` +No unwrap/ungatedModes/addressOfOnly. Mechanics (function-ref.ts:408-597 + +:685-696), all probed: + +- **args/list**: every namedChild → normalizeValue. Bare `simple_identifier` + → candidate (NAME_STOPLIST drops self/true/nil/…). `reg2(onFire)` → + `onFire` ✓; `[cbA, cbB]` → both ✓ (the array_literal's OWN dispatch — + varinit's normalizeValue over an array_literal yields [], the capture + happens when the walker/scan VISITS the array node). +- **value_argument layer** (:547-557): the **label-forward skip** — label = + childForField('name') (a `value_argument_label`), value = + childForField('value') ?? last namedChild; label text === value text → + DROPPED (`forward(value: value)` → nothing; the Alamofire A/B finding). + Else descend the `value` field. +- **rhs** (assignment, field `result`): param-storage skip — lhs = + left/lhs/**target** fields ?? namedChild(0) (swift's field is `target`, a + directly_assignable_expression); lhs text's last identifier === rhs text → + skip (`self.raw = raw` → nothing, probed). `o.cb = handler` → `handler` ✓. +- **varinit** (property_declaration, field `value`): destructuring check + reads childForField('name') — swift's is type `pattern`, NOT in + {object_pattern, array_pattern, tuple_pattern, struct_pattern} → never + skipped; tuple-let values are non-normalizable expressions anyway. + Computed properties have no `value` field → nothing. +- **selector_expression special** (:685-696): namedChild(0) is + identifier/simple_identifier → its text (`#selector(fire)` → `fire`); else + rightmost simple_identifier descendant (`#selector(Holder.fire)` → `fire`; + QUIRK: `#selector(onNote(_:))` → the rightmost simple_identifier is the + argument label `_` → candidate `_`, dropped by the gate in practice); else + trimmed inner text. explicitRef=true (not an idType). +- Capture fires from visitNode:990 (incl. BEFORE the dedicated property + branch and on init/deinit/subscript descents), visitFunctionBody:5137, and + scanFnRefSubtree (top-level initializer scan; halt list :606-612 includes + `lambda_literal` — closures halt the scan — and functionTypes). +- **Flush gate** (:639): definedHere (same-file function/method names) ∪ + importedNames. Swift import refs are module names — `Foundation` (SIMPLE) + and `UIKit.UIView` (QUALIFIED_IMPORT → last segment `UIView`) both land in + importedNames but almost never match a candidate → **the swift gate is + effectively "defined in this file"** (probed: `#selector(Holder.fire)`'s + `fire` dropped; `onFire`/`handler`/`cbA`/`cbB` survive as same-file + functions). Survivors dedupe on `${fromNodeId}|${name}` → + {referenceKind:'function_ref'}, appended after all walk refs. + +## Closure-collection pass & other synthesis consumers (no port — pin the contract) + +- **swift IS in CC_LANGUAGES** (resolution/callback-synthesizer.ts:77, with + kotlin — the #1235 gate). The pass re-reads **function/method nodes' + filePath + startLine..endLine source slices** (callback-synthesizer.ts:270- + 297) and regexes for `.forEach`/`.append(`/`.add(`/`.push(`/`.insert(` + dispatch/registration pairs. **Input contract on the walker: node kinds, + languages, and LINE EXTENTS byte-match** — a wrong endLine silently changes + synthesis. The dump gate covers this; nothing extra to build. +- swift-objc bridge (`swiftObjcBridgeResolver`) + the `sendEvent` scan + (callback-synthesizer.ts:1387-1438) read raw `.swift` file text — file-set + contract only. +- The :811 and :3507 language gates consume node kinds/names — covered by + parity. + +## Frameworks (stay TS-side — behavior pinned in §Architecture #2) + +swiftUIResolver / uikitResolver / vaporResolver (resolution/frameworks/ +swift.ts:11/:136/:269): extract() hooks emit `component`/`class`/`route` +nodes with LITERAL ids (`view:${filePath}:${name}:${line}`, +`route:${filePath}:${line}:${METHOD}:${path}` — NOT hashed) + vapor handler +refs (which DO carry filePath+language — framework refs, not extraction +refs). resolve() consumes plain `references` names by suffix + kind + dir +conventions (`getNodesByName` — walker's node names/kinds are the contract). +Vapor's `@Siblings` metatype refs (§property branch step 5) are the +extraction-side feed that keeps pivot models un-orphaned on Fluent repos. + +## Parity mechanics (all have bitten before) + +- **Emission order** per §Node creation — file → source-order walk → fn-refs + → value-ref edges. Refs interleave with nodes exactly as the TS call sites + do: extends before members; per-property decorates → type-refs → attr-arg + refs → initializer-descent refs; per-function/method the return-type refs + come FIRST (extractTypeAnnotations :1594/:1816 runs before + extractDecoratorsFor :1599/:1819), then decorates, then body refs. +- **generateNodeId inputs**: (filePath, kind, name, startRow+1) — name is the + bare bound identifier for properties (no pattern text), the LAST segment + for multi-segment extensions, raw sugar text (`[ServerTrustEvaluating]`) + for sugar extensions, `<+>` for operator functions, the full dotted module + (`UIKit.UIView`) for import nodes; line = declaration start (= the + `modifiers`/attribute start when attributes precede the keyword — the + declaration node INCLUDES its modifiers). +- **UTF-16 columns + slices** (textutil::col16/slice_utf16): every ref/node + column, `startIndex/endIndex` substrings (getNodeText — getVisibility/ + isStatic read `child.text`, same substring), and the `.slice(0,100)`-class + truncations (unused on the swift path — no signature/initializer capture). + Swift sources are emoji/CJK-heavy in tests — the torture fixture needs a + non-ASCII line before a symbol. +- **CRLF**: the ONLY multiline regexes on the swift path are + cleanCommentMarkers' `gm` strips (§Docstrings) → `js_multiline_strip` in + docstring.rs. `trimStart()`/`startsWith('let')` in swiftPropertyInfo are + whitespace-semantics-identical in Rust (`trim_start`). CRLF fixture + variants derived in-memory, per the tsjs pattern. +- **Defer policy**: per-file `has_error()` → `defer:`; **expected incidence + 9–27% (§table); sweep with `--max-deferral 0.3`** — the c/cpp-style + exemption, justified by both-arm measurement, NOT a walker allowance: a + JUMP vs the table is a walker bug. +- Refs carry NO filePath/language (§Architecture #4 — REF_FLAG_FILE_PATH + unused); the wire contract is exactly extractFromSource's return. +- No POST_PASS; no preParse; `sourceIsPreParsed` never set for swift. + +## Gates (per plan §5, no exceptions) + +- **Grammar bump lands FIRST, standalone** (php pattern): vendor wasm + + `=0.7.3` crate pin + VENDORED_WASM_LANGS + kernel-grammar-parity + `GRAMMAR_LANGUAGES += 'swift'` in one change, full suite green, before any + walker exists. Old-wasm vs new-wasm **full-init dump diff on all three gate + repos** (`scripts/dump-graph.mjs`, cmp): expected NON-empty; **every + diffing file must be in the union of the two arms' hasError lists** + (regenerate with `svy-swift/error-incidence.cjs`; categories in + §Grammar-bump deltas — macro/testing/package/typed-throws fixes, the three + NEW-regression classes, both-arm recovery drift); prove residual + resolution ripple mechanically by parked-ref↔edge pairing (php's + ripple-proof pattern). Any clean-on-both-arms file diffing blocks the bump. +- **Torture fixtures** per `## Fixtures to build` (+ CRLF variants derived + in-memory), exercised by the new parity suite. +- **Parity sweeps** (`scripts/kernel-parity.mjs `, order-sensitive + full-object, **`--max-deferral 0.3`**): + - `…/scratchpad/gate-repos/Alamofire` (small, 98 files — **the mandatory + #1020 gate**, decoded path) + - `…/scratchpad/gate-repos/vapor` (medium, 247 files, decoded path, + Fluent/@Siblings + route shapes) + - `…/scratchpad/gate-repos/swift-nio` (large, 554 files, **raw-buffers + path** — no framework detects) + (all three cloned at survey time; re-clone fresh if gone). Then **full-init + dump-diffs byte-identical** (kernel arm vs `CODEGRAPH_KERNEL=0`, + dump-graph.mjs, cmp) on the same three. +- **Alamofire #1020 spot-check** (belt to the dump gate's suspenders): after + a kernel-arm index, node-kind census must match the wasm arm EXACTLY — + survey baseline at `a6c62d7` + current Alamofire HEAD: **property = 348** + (the #1020 number, re-measured), field 588, method 1801, class 379 + (extensions!), constant 97, struct 111, enum 77, enum_member 230, + interface 27, type_alias 39, function 10, import 183 (98 files, 3,988 + nodes, 16,426 refs — `svy-swift/count-props.cjs`). A missing dedicated + branch shows up here as property→0 / field→0 before the dump diff even + runs. +- **Suite**: new `__tests__/kernel-swift-parity.test.ts` — torture + CRLF + variants + an intentionally-erroring defer fixture (use a NEW-only + regression construct — e.g. `#if DEBUG` between enum cases — asserting the + kernel defers and wasm output is served); full suite ×2 green with + `CODEGRAPH_KERNEL_EXPECT=1`. +- **`DEFAULT_ROUTED += 'swift'`** (kernel/index.ts:37) only after ALL of the + above; changelog rides the existing kernel entry. +- Post-route sanity: §Architecture #2 — Alamofire/vapor ride the decoded + path, swift-nio the raw transport; measure the parse loop accordingly. + +## Fixtures to build + +**`torture.swift`** (seed: the survey's `svy-swift/torture.swift`, already +validated against the built extractor — extend it with the rows below), +**a CRLF variant derived in-memory**, **one defer fixture** (a NEW-only +regression construct, above), and keep every line traceable to a branch: + +- class family: plain class; `public final class C: Base, Proto1, Proto2` + (extends ×3, all 'extends'); struct + bodiless-skip N/A; enum backed + (`: String` → extends String) + `case a = "H"` + **multi-case `case put, + delete` (ONLY `put` minted)** + associated values (no refs) + indirect + + computed property + static method in enum; actor (→ class); `extension + Point: Hashable` (second class node, extends); `extension KF.Builder` + (resolveName → `Builder`); `extension Array where Element: Equatable` + (class `Array`, NO constraint refs); **`extension [Proto]` (class named + `[Proto]`)**; protocol with inheritance + var requirement {get set} (→ + property node, isLet=false via the nested-binding miss) + static var + requirement + **func/init/associatedtype requirements (NO nodes)**. +- the dedicated branch, exhaustively: stored let with type+initializer + (field + owner type-ref + owner-attributed initializer call); untyped var; + `static let SHARED_MAX` (constant, value-ref target); `static var` + (variable); `class var` computed (property, isStatic via 'class'); + `lazy var x: Cache = Cache.build()` (field + `calls Cache.build` + from class); `public private(set)` (→ 'public'); `@Published private var` + (decorates from OWNER + vis 'private'); **`@Siblings(through: Pivot.self, + from: \.$left) var siblings: [Tag]`** (decorates Siblings + walkAttrArgs + `references Pivot` + type-ref `Tag`, all from OWNER); computed + `var isCloudProxy: Bool { check() }` (property + `calls check` FROM the + property + `references Bool` — Bool not builtin); **SwiftUI-shaped + `var body: some View { VStack { Text(label) } }`** (property; VStack/Text + calls from the property; `references View`); observed `var x = 0 { + willSet{prepare(newValue)} didSet{react(oldValue)} }` (**field**, observer + calls from the CLASS); `weak var delegate: SessionDelegate?`; tuple + `let (a, b) = makePair()` (ONE node `a`, `calls makePair` from class); + `open` visibility (→ 'internal'). +- functions/methods: free func with params+return (`sig=null`, return-type + ref, NO param refs — include a `Void`-bearing param type to prove the + negative); `-> KF.Builder` (returnType 'Builder' + refs KF AND Builder); + `-> Result` (returnType 'Result'); `-> Result, E>`-shaped + nested generic (returnType undefined); `-> Foo?` / `-> [Foo]` / `-> (A,B)` + / `-> (Int) -> Foo` / `-> Void`; `func f() async throws` (isAsync FALSE); + `static func` / `open class func` (isStatic true, vis 'internal'); + operator `func <+> (lhs:…)` (node named `<+>`); nested named func in a + body; `@objc func` (decorates objc); `@main struct` + `@objc enum` + + attributed protocol (NO decorates). +- init/deinit/subscript: `init(raw:) { self.raw = raw; setupMonitor() }` + (no node; `calls setupMonitor` from class; NO fn-ref for the param-storage + assignment); `convenience init?` (`calls init` bare from class); `deinit`; + subscript with get/set (`calls store` ×2 from class). +- calls: every row of the §extractCall matrix, verbatim — bare, `Foo()`, + `Foo.init()`, member, self/super (bare), 2-hop (bare), `x?.m()` + (receiver kept), `y!.m()` (bare), `Foo.make().draw()` re-encode + inner, + lowercase chain (bare + inner), `"lit".upper()` (nothing), + `"""m""".t()` (bare t), `5.times()` / `[1,2].reduce` (nothing), + `["k":1].lookup()` (bare), `(f)()` (conv-regex → f), trailing + multi- + trailing closures, `arr[0]` (`calls arr`), `m[i][j]` (`calls m[i]`), + `defer {}` (`calls defer`), try/try?/await wraps, string-interpolation + call, implicit-member call `.make()` (`calls .make`), `Task { await f() }`. +- static-member reads (in a BODY): `Color.red`, `Suit.hearts.rawValue` + (`Suit` only), `UserModel.self`, `Deep.Nested.leaf` (`Deep` only), + `.implicit` (nothing), `lowercase.f` (nothing), keypath `\Foo.bar` + (nothing) — plus the SAME reads at class-initializer scope and inside + `init` (nothing — the visitNode gap). +- value refs: `static let SHARED_MAX` in a class/struct/enum read from a + method (edge) and from a computed property (NO edge — property not a + reader); a method-local `let SHARED_MAX = 5` in a SECOND fixture variant + (prune kills the target); a `guard let SHARED_MAX` variant (NO prune); + top-level `let TOP_LEVEL_MAX` + reader. +- fn-refs: `reg(onFire)`, `reg(cb: onFire)` (label≠value → survives), + `forward(value: value)` (label-forward skip), `o.cb = handler`, + `self.x = x` (param-storage skip), `let table = [cbA, cbB]`, + `#selector(fire)` / `#selector(Holder.fire)` / `#selector(onNote(_:))` + (the `_` gate-drop), an undefined-name arg (gate-drop). +- imports: `import Foundation`, dotted `import UIKit.UIView`, kinded + `import class Darwin.FILE`, `@testable import`. +- typealias: function-type value (refs Data+Void) + member-type value + (refs KF+Builder). +- docstrings: `///` run (joined), `//` plain (IS a docstring), `/** */` + (**ignored**), `/* */` between `///` and decl (breaks chain), doc over an + attributed decl (kept), doc on top-level const (kept) vs in-class property + (dropped). +- misc: `#if os(iOS)` around members (both branches extracted), `#warning`, + a macro_invocation file (NEW arm; on OLD this file is a defer candidate — + keep it in the DEFER fixture instead), a non-ASCII (UTF-16) line before a + symbol, guard/if-let/for-await bodies with calls. + +## Probe artifacts (session scratchpad `svy-swift/`) + +`probe-swift.cjs` + `shape-{OLD,NEW}.txt` + `shape.diff` (the 53-line +classified battery diff), `mini-probes.cjs` + `mini-probes.out` (node-type +inventory, per-construct error matrix, defer/subscript/#if/async-let/regex +shapes), `field-probe.cjs` (the childForFieldName truth table), +`regress-probe.cjs` (NEW-regression minimal repros), `error-incidence.cjs` +(the §incidence table + per-file lists), `error-diag.cjs` (first-ERROR +diagnosis used for the delta classification), `extract-probe.cjs` + +`torture.swift` + `extract-probe.out` (the built-extractor emission pin), +`sugar-probe.cjs` (extension sugar/decorates asymmetry/implicit-member call), +`count-props.cjs` (the Alamofire census), `tree-sitter-swift.wasm` (the +staged-candidate 0.7.3 build), `tree-sitter-swift-0.7.3/` (crate extract) + +`tag-clone/` (0.7.3-with-generated-files) with the sha evidence. diff --git a/scripts/kernel-parity.mjs b/scripts/kernel-parity.mjs index 4bec261..577cdb0 100644 --- a/scripts/kernel-parity.mjs +++ b/scripts/kernel-parity.mjs @@ -48,7 +48,7 @@ if (paths.length === 0) { process.exit(2); } -const KERNEL_LANGS = new Set(['typescript', 'tsx', 'javascript', 'jsx', 'java', 'python', 'go', 'c', 'cpp', 'rust', 'csharp', 'ruby', 'php']); +const KERNEL_LANGS = new Set(['typescript', 'tsx', 'javascript', 'jsx', 'java', 'python', 'go', 'c', 'cpp', 'rust', 'csharp', 'ruby', 'php', 'swift']); const EXTS = new Map([ ['.ts', 'typescript'], ['.mts', 'typescript'], ['.cts', 'typescript'], ['.tsx', 'tsx'], ['.js', 'javascript'], ['.mjs', 'javascript'], @@ -62,6 +62,7 @@ const EXTS = new Map([ ['.cs', 'csharp'], // R7b ['.rb', 'ruby'], ['.rake', 'ruby'], // R7b ['.php', 'php'], ['.module', 'php'], ['.install', 'php'], ['.theme', 'php'], ['.inc', 'php'], // R7b + ['.swift', 'swift'], // R7b ]); /** Collect candidate files. */ diff --git a/src/extraction/grammars.ts b/src/extraction/grammars.ts index 6fcd80d..fcd359a 100644 --- a/src/extraction/grammars.ts +++ b/src/extraction/grammars.ts @@ -313,6 +313,15 @@ const VENDORED_WASM_LANGS: ReadonlySet = new Set([ // tarball. Replaces the ^0.22 tree-sitter-wasms build (ABI 14 → 15). NOT // graph-neutral — the classified delta list lives in the php checklist doc. 'php', + // R7b (Swift kernel port prep): tree-sitter-swift crate 0.7.3. Built from + // the CRATE TARBALL's src/ (NOT a tag sha-match: alex-pinkus keeps + // generated files off main and the 0.7.3-with-generated-files tag ships an + // older ABI-14 generation; grammar.json rules are JSON-equal, and the crate + // tarball is byte-for-byte what the kernel's cargo build compiles — table + // identity by construction). Replaces the ^0.4.0 tree-sitter-wasms build + // (ABI 13 → 15). NOT graph-neutral — delta is error-set membership only; + // classified list in the swift checklist doc. + 'swift', ]); /** Absolute path of a language's grammar WASM (vendored or tree-sitter-wasms). */ diff --git a/src/extraction/kernel/index.ts b/src/extraction/kernel/index.ts index 82ff3b6..ef4a037 100644 --- a/src/extraction/kernel/index.ts +++ b/src/extraction/kernel/index.ts @@ -68,6 +68,12 @@ const DEFAULT_ROUTED: ReadonlySet = new Set([ // symfony (13,950 files byte-parity) + full-init dump-diffs byte-identical // ×3. Deferral ≈0–0.1% (genuinely-broken fixtures) — default sweep guard. 'php', + // R7b (2026-07-20): parity swept 0-diff on Alamofire/vapor/swift-nio (720 + // clean files byte-parity; Alamofire's 348 #1020 property nodes reproduced + // exactly) + full-init dump-diffs byte-identical ×3. Swift error incidence + // is structurally 9–27% on BOTH arms (heavy #if conditionalization) — + // sweeps run --max-deferral 0.3; a deferral-rate JUMP is the bug signal. + 'swift', ]); /** diff --git a/src/extraction/wasm/tree-sitter-swift.wasm b/src/extraction/wasm/tree-sitter-swift.wasm new file mode 100755 index 0000000000000000000000000000000000000000..a05fa7a12a50103c178744a4efd6201036ad023c GIT binary patch literal 3726622 zcmeFadwf*cc`c~(sP~I@?8J}67POOe9NTR>Z#y^c%G~Zwax?d4?z}vAJk##jow4bT z-4BvDGoG{%0t5&ULVy4PLI@BbK!5-N0)!ACK!6Ye1PBm9fB*qP2oNA(_WmBHYM)(Y zDwX^-zjpuJty+8SZ?CoXtubiA8exzY$&@BH*1y+3^W zz4w0h!yHS#u>bDEcizd#kze|M^3gwi^#0pFd?&}|mv6uK(|`DTd>MP|t&hgN{lj

tm=Ce(SAqZ~yIk?<8Yhq?tLt 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

$_;}9$u5Bz6YQr3<~{u-XlfUk4q1296B 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%0AFWN7zFh)d1o3t} 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

>VHkFK*I_v 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 z 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