codegraph/docs/design/kotlin-kernel-port-checklist.md

Kotlin kernel port (R7b) — the bug-for-bug checklist

Status: PORT COMPLETE (2026-07-20) — walker codegraph-kernel/src/kotlin.rs

• the vendored-grammar-C build (codegraph-kernel/grammars/kotlin via build.rs cc — the mechanism's first use), all gates passed (bump dumps byte-identical old-vs-new ×3 as predicted; parity sweeps 0-diff okio 299/322 / okhttp 531/580 / kotlinx.coroutines 1031/1082 with exactly the predicted 23/49/51 deferrals; kernel-arm dumps byte-identical ×3; KMP expect/actual synthesis IDENTICAL — 412 edges both arms; kernel-kotlin-parity suite; DEFAULT_ROUTED += kotlin — 15 languages). One fixture note: the survey's torture.kt itself tripped the PHANTOM-error class (one-line class/object bodies) and deferred — the checked-in parity fixture reflows those to multi-line, and the phantom shape is pinned in the defer test instead. 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 <repo> --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:

    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-<repo>.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 on its own. The hook itself then walks the property's RHS under the property's scope — the named child after the = token plus a property_delegate — via ctx.visitFunctionBody, so val SHARED = WidgetK(0), val cb = Runnable { hit() } and by lazy { compute() } all emit their calls FROM the property node (Go's #693 initializer walk, ported). The declaration's own children — modifiers, val/var, the name+type, an extension receiver's type and type parameters, getter/setter — are NOT walked: a same-line val c get() = f() still emits nothing, a next-line accessor still attributes to the class, and a hook-DECLINED destructuring RHS is still invisible. 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 <T> List<T>.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 itself; inside a PROPERTY initializer the hook's walk reaches its funs, which leak out as FUNCTIONS under the property (see §Body walker for the same 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`"). <anonymous> 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_expressions → 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<Int>(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 — EXCEPT a property initializer, which the hook now walks through visitFunctionBody under the property's own scope (§Properties). 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_specifiers 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<SubK> → 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_literals 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.<member> (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), but the hook's own initializer walk (§Properties) covers the same subtree with the PROPERTY on the stack, so refs inside by lazy { }/trailing lambdas are captured there — a shallow ::ref reachable by BOTH is emitted twice, once from the class and once from the property). NOT captured anywhere: local initializer callable refs — 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 funs 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 <dir>, 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, initializer + delegate refs attributed TO the property) + 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<Int>(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.