codegraph/docs/design/rust-lang-kernel-port-checklist.md

# Rust-language kernel port (R7b) — the bug-for-bug checklist

("rust-lang" in the filename to avoid confusion with the kernel's own
implementation language.)

**Status: PORT COMPLETE (2026-07-20)** — walker `codegraph-kernel/src/rustlang.rs`,
all gates below passed (parity sweeps 0-diff on ripgrep/tokio/rust-analyzer,
dump gates byte-identical ×3, DEFAULT_ROUTED += rust). This doc remains the
quirk reference for the walker. Survey basis: every TS-side branch a
`.rs` file exercises, with file:line anchors as of `ce0ae30` (HEAD at survey
time). Every grammar-shape claim below was **probed against the vendored
tree-sitter-rust v0.24.2 wasm** (probe scripts in the session scratchpad), not
assumed. Read WITH `docs/design/rust-kernel-migration-plan.md` (§0a recipe, §5
gates) and `docs/design/ccpp-kernel-port-checklist.md` (format precedent).

**Grammar prep is ALREADY STAGED (uncommitted at survey time):** Cargo.toml
pins `tree-sitter-rust = "=0.24.2"`, `src/extraction/wasm/tree-sitter-rust.wasm`
is vendored from tag `77a3747` (parser.c/scanner.c sha-matched against the
crates.io tarball), and `rust` is in `VENDORED_WASM_LANGS` (grammars.ts:291) —
replacing the 2023-era tree-sitter-wasms build (ABI 14 → 15). Per the recipe:
land the grammar bump FIRST and get the full suite green before the walker
exists. Probing showed the 0.24.2 shapes match the old build on every branch
below (function_modifiers nesting, token trees, impl fields, use shapes), so no
TS-side behavior change is expected from the bump — but the suite run is the
proof.

## Architecture decisions

1. **No preParse.** `rustExtractor` has no `preParse` hook, so the route
   point's `preParsedSource` (kernel/index.ts:76) is a no-op for rust — both
   arms parse raw bytes. Nothing to hoist, nothing to port.
2. **Cargo repos take the DECODED path, not raw buffers.** `rustResolver`
   (resolution/frameworks/rust.ts:22, `languages: ['rust']`, detect =
   `Cargo.toml` exists) has an `extract()` hook, and parse-worker.ts:93 forces
   any language with an applicable framework `extract()` onto the decoded
   `extractFromSource` path (framework nodes/refs merge into the decoded
   result). So on real Rust repos the kernel win is parse+walk+decode, never
   the buffers-to-store transport. Don't chase a raw-path number on
   ripgrep/tokio and conclude the port is broken.
3. **The framework extractor itself needs NO port.** It is regex-over-raw-source
   TS (see §Frameworks below) and runs identically after either arm inside
   `extractFromSource` (tree-sitter.ts:6736-6758). Only the tree-sitter-walk
   emissions below move to Rust.
4. **One walker module** (suggest `codegraph-kernel/src/rustlang.rs` — "rust"
   alone collides with the crate language), registered in `langs.rs`; per-file
   `has_error()` → `defer:` like every walker.
5. **`.rs` → `rust`** at detectLanguage (grammars.ts:78), no content sniffing,
   no dialect. MAX_FILE_SIZE (1 MiB, extraction/index.ts:132) and generated-file
   skips are orchestrator/TS-side and shared.

## Extractor config (languages/rust.ts — 151 lines, read it whole)

Types: functionTypes=[`function_item`, **`function_signature_item`**] (the
latter = a trait method DECLARATION `fn render(&self);` — extracted so a
trait's method set is first-class); classTypes=[] (impl blocks instead);
methodTypes = same two; interfaceTypes=[`trait_item`] with
**interfaceKind:'trait'**; structTypes=[`struct_item`];
unionTypes=[`union_item`] (same body walk, distinct `union` node kind);
enumTypes=[`enum_item`];
enumMemberTypes=[`enum_variant`]; typeAliasTypes=[`type_item`];
importTypes=[`use_declaration`]; callTypes=[`call_expression`];
variableTypes=[`let_declaration`, `const_item`, `static_item`].
nameField=`name`, bodyField=`body`, paramsField=`parameters`,
returnField=`return_type`.

Hooks PRESENT (port each exactly):

- **getReturnType = extractRustReturnType (rust.ts:14)** — reads the
  `return_type` field; if `reference_type`, unwrap to the first namedChild of
  type `type_identifier`/`scoped_type_identifier`/`generic_type` (`?? rt` —
  falls back to the reference_type itself); then if type ∈
  {`primitive_type`,`unit_type`,`tuple_type`} → undefined. Else:
  `text.trim().replace(/<[^>]*>/g, '')`, take last `::` segment, trim; must
  match `/^[A-Za-z_]\w*$/` else undefined; `'Self'` → the marker **`'self'`**
  (resolved to the impl's own type at resolution time). QUIRKS: the
  non-greedy-ish `/<[^>]*>/g` strip breaks on NESTED generics —
  `Result<Vec<Foo>, E>` → `"Result, E>"` → regex fails → **undefined** (only
  single-level generics like `Vec<Foo>` → `Vec` survive). `-> &Foo` unwraps to
  `Foo`; `-> fmt::Result` → `Result`.
- **getSignature (rust.ts:57)** — `undefined` if no `parameters` field; else
  raw text of params, plus `' -> ' + <return_type raw text>` when present.
  Raw `getNodeText` — multi-line params keep their newlines.
- **isAsync (rust.ts:67) — DEAD CODE BUG, PRESERVE:** scans DIRECT children for
  `child.type === 'async'`. Probed on v0.24.2: `async` nests inside a
  `function_modifiers` child (`pub async fn` children:
  `visibility_modifier, function_modifiers, fn, identifier, parameters, ->,
  <ret>, block`), so **isAsync always returns false** — no rust node ever gets
  `isAsync: true`. The walker must reproduce false.
- **getVisibility (rust.ts:74)** — direct child of type `visibility_modifier`:
  text `.includes('pub')` → `'public'` else `'private'`; no modifier →
  `'private'` (so `pub(crate)`/`pub(super)` are all `'public'`).
- **getReceiverType (rust.ts)** — walk PARENT chain to the nearest
  `impl_item`; there, read the grammar's `type` field through
  `rustImplTypeName` (kernel: `impl_type_name`): `type_identifier`/`identifier`
  → text; `generic_type` → its `type` field (bare name, never the args);
  `scoped_type_identifier`/`scoped_identifier` → its `name` field (last
  segment); `reference_type` → its `type` field; anything else (tuple, `dyn`,
  pointer, primitive, fn type) → undefined. Never an impl parent → undefined.
  **Changed in #1588 on both sides together**: the original rule took the LAST
  direct `type_identifier` child, so for `impl Trait for Generic<T>` /
  `Parents<'a>` / `&Foo` the only bare identifier was the TRAIT's (probe:
  `impl Render for Container<T>` → receiver **`Render`** → methods
  `Render::render`, colliding with the trait declaration and feeding the
  interface-impl synthesizer a phantom declaration). Now `Container`.
  `impl fmt::Display for Fields` → `Fields`; `impl<T> Container<T>` →
  `Container`; `impl Tr for m::Foo` → `Foo` (was: no receiver).
  Note `<T>` type_parameters is its own child, its inner T is NOT a direct
  impl child.
- **extractImport (rust.ts:120)** — signature = trimmed full `use …;` text.
  `useArg` = FIRST namedChild of type `scoped_use_list` | `scoped_identifier` |
  `use_list` | `identifier` (a leading `visibility_modifier` on `pub use` is
  skipped by the find). moduleName = `getRootModule(useArg)`: recurse into
  `namedChild(0)` — if type ∈ {identifier, crate, super, self} return its text;
  if `scoped_identifier` recurse; else return the child's text; no child →
  whole node text. So `use crate::m::Item` → import node named **`crate`**;
  `pub use self::sub::read` → **`self`**; `use foo;` → `foo`. QUIRK:
  `use std::fmt::*;` parses as `use_wildcard`, which is NOT in the useArg list
  → hook returns null → and because the hook exists, extractImport's
  `if (this.extractor.extractImport) return;` (tree-sitter.ts:3350) fires →
  **wildcard uses create NO import node and NO refs at all**. `handledRefs` is
  not set → the generic path ALSO pushes one `imports` ref for the root module
  name (`crate`/`self`/`std`/…) from the file node (tree-sitter.ts:3183-3194).

Hooks ABSENT (the walker must NOT do these): `preParse`, `resolveName`,
`recoverMangledName`, `isMisparsedFunction`, `isConst`, `isStatic`,
`isExported`, `resolveBody`, `classifyClassNode`, `classifyMethodNode`,
`extractPropertyName`, `propertyTypes`, `fieldTypes`, `extraClassNodeTypes`,
`packageTypes`/`extractPackage`, `extractModifiers`, `synthesizeMembers`,
`extractBareCall`, `visitNode` hook, `skipBodilessClass`, `methodsAreTopLevel`.
Consequences: every function/struct/enum/trait has `isExported` undefined
(file node `false`; extractVariable's `?? false` → `false`); `isStatic`
undefined; **no isConst means `const_item`/`static_item` extract as kind
`'variable'`, never `'constant'`** (see extractVariable below).

## tree-sitter.ts branches (anchors as of `ce0ae30`)

### visitNode dispatch — what each top-level rust node hits

| Node | Branch | Behavior |
|---|---|---|
| `function_item` (top level) | functionTypes, tree-sitter.ts:994 → extractFunction:1517 | not inside class-like at file scope → extractFunction; **first line of extractFunction (1522): if getReceiverType returns a value → extractMethod instead** (this is how impl-block fns become methods — impl_item does NOT push a scope) |
| `function_signature_item` | same | in a trait body (trait pushed, class-like) → extractMethod; no `body` field → no body walk |
| `struct_item` | structTypes:1059 → extractStruct:1869 | `body` field required: **unit structs `struct Unit;` have no body → NO node minted** (1876, `record_declaration` exemption is C#-only). Tuple structs have body `ordered_field_declaration_list` → extracted. `field_declaration` children make NO nodes (rust has no fieldTypes) — visitNode recurses into them and finds nothing |
| `enum_item` | enumTypes:1064 → extractEnum:1914 | body `enum_variant_list`; `enum_variant` children → extractEnumMembers:1958 — **`name` field path: one `enum_member` node from `getChildByField(node,'name')`, then return** (variant payload bodies `B(u32)` / `C { x }` are never walked). Non-variant children (e.g. `attribute_item`) → visitNode (no-op) |
| `trait_item` | interfaceTypes:1054 → extractInterface:1834 | kind `'trait'` (interfaceKind); extractInheritance sees the `trait_bounds` child (see below); body `declaration_list` children visited with the trait pushed → fn items become methods with QN `Trait::name` via nodeStack |
| `impl_item` | dedicated branch:1273-1276 → extractRustImplItem:5690 | emits the implements back-reference (below); **skipChildren stays false** → the `declaration_list` is then visited normally by the loop at 1295 (that's how impl members are reached; impl pushes NOTHING on the nodeStack) |
| `mod_item` | no branch | falls through → children visited. **No `module` node, no qualifiedName prefix** — items inside `mod tests { }` index as if at file scope. (frameworks/rust.ts:329 looks for `kind === 'module'` nodes and finds none from extraction — its `nodes[0]` fallback carries module resolution.) |
| `use_declaration` | importTypes:1209 → extractImport:3170 | import node + root-module ref (hook, above) + `emitRustUseBindingRefs` (3217-3219, rust-only, below) |
| `const_item` / `static_item` (top level) | variableTypes:1098 → extractVariable:2538 | **generic fallback branch (2863-2881)**: kind = `'variable'` ALWAYS (no isConst); iterate DIRECT namedChildren; **every child of type `identifier` mints a node** — for `const MAX: u32 = OTHER;` the children are identifier(MAX), primitive_type, identifier(OTHER) → **TWO `variable` nodes, `MAX` and the phantom `OTHER`** (probed). A non-identifier value (call, literal, array, struct_expression) → one node. Nodes get docstring + isExported:false, NO signature (unlike TS/Go branches). skipChildren=true, then `scanFnRefSubtree` (1110) capture-only. **No instantiates/calls refs from top-level initializers** — the value is never walked as a body |
| `let_declaration` (top level) | variableTypes | only legal inside bodies, so effectively never taken (bodies don't route through extractVariable); it's in variableTypes for the fn-ref dispatch + shadow prune. A body `let` is plain recursion inside visitFunctionBody |
| `type_item` | typeAliasTypes:1071 → extractTypeAlias:2890 | no resolveTypeAliasKind → plain `type_alias` node. QUIRK: the alias-value ref walk (2976) reads `getChildByField(node,'value')` — rust type_item's field is **`type`**, not `value` → null → **a rust type alias emits NO reference to its aliased type** |
| associated `const_item` inside `impl` | variableTypes | impl pushes nothing → `!isInsideClassLikeNode()` is true → extracted as a FILE-level `variable` node (contains edge from the file), e.g. `impl Fields { const CAP … }` → variable `CAP`. PRESERVE |
| associated `const_item` inside `trait` body | variableTypes gate FAILS | trait is pushed (class-like) and `isClassScopeConstantAssignment` needs node.type `assignment` → false → **no node**, but the else-ladder falls through with skipChildren=false → the const's value expression IS visited (a call in it emits a `calls` ref from the trait node) |
| `associated_type` in trait, `macro_definition`, `attribute_item`, `extern_crate_declaration` | no branch | recursed, nothing extracted |
| `macro_invocation` (top level) | no branch in visitNode | recursed into token_tree (raw tokens — nothing matches). **Route macros are only extracted inside function bodies** (visitFunctionBody:5141) — a top-level `routes![…]` emits nothing |
| `struct_expression` | INSTANTIATION_KINDS:359, visitNode:1255 + body walker:5145 | extractInstantiation (below). In practice struct_expressions live in bodies |

### 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). The FILE node id is the literal
  `file:${filePath}` (tree-sitter.ts:509), NOT hashed. **Dedupe/self-checks
  compare ID STRINGS** (same-(kind,name,line) collisions are routine — `node_ids`
  vec pattern in every walker).
- endLine extension via resolveBody (1329) is a no-op for rust (no hook).
- contains edge from nodeStack top for every created node (1363).
- qualifiedName = nodeStack names joined `::` (buildQualifiedName:1447;
  namespacePrefix is always empty outside C/C++). Methods with a receiver
  override it: `composeReceiverQualifiedName` (1435) = `` `${receiverType}::${name}` ``
  verbatim for rust (prefix empty → passes through, per the 1433 comment).
- File node: kind `file`, name basename, qualifiedName = filePath, endLine =
  `source.split('\n').length`, isExported false.

### extractFunction / extractMethod for rust (1517 / 1737)

- extractFunction: receiverType present → extractMethod (1522). Name via
  `extractName` → nameField `name` (identifier). No misparse hook. Node gets
  docstring, signature, visibility, isExported:undefined, isAsync:false (bug
  above), isStatic:undefined, returnType. Then extractTypeAnnotations,
  extractDecoratorsFor (rust `attribute_item`s are SIBLINGS, not children, and
  aren't `decorator`/`annotation`/`marker_annotation`/`attribute` types → **no
  decorates refs for rust**, and the backward-sibling scan at 5013 stops at the
  first attribute_item anyway). Push node, walk `body` field (block), pop.
- extractMethod (reached for impl fns + trait members): receiverType computed
  again (1742). Gate at 1747: not class-like AND no methodsAreTopLevel AND no
  receiver → back to extractFunction (trait members pass via class-like; impl
  fns via receiver). extraProps.qualifiedName = `Type::name` when receiver
  (1790). **Contains edge from the owner (1798-1813): only when receiver
  present AND not class-like — finds the FIRST node in `this.nodes` with
  `name === receiverType && filePath === this.filePath && kind ∈
  {struct,class,enum,trait}`. Source-order dependent: an impl ABOVE its struct
  gets no contains edge. Since #1588 `impl Trait for Generic<T>` links to the
  implementing TYPE's node (it used to link to the TRAIT node, the receiver
  bug).** Then type annotations, decorators
  (no-op), body walk with the method pushed.
- **Nested `fn` inside an impl-method's body**: visitFunctionBody:5245 →
  named → extractFunction → getReceiverType walks parents THROUGH the outer fn
  to the impl_item → receiver found → extractMethod → a nested helper indexes
  as a METHOD with QN `Type::inner` + contains edge from the type. PRESERVE.
- structs/enums/traits declared inside a body are extracted there
  (5255-5275), contained by the enclosing function node.

### extractCall (3684) — the rust paths

Generic else-branch (4312+), `func = childForFieldName('function') ?? namedChild(0)`:

1. `func.type === 'field_expression'` (method call `x.foo()`): property =
   `field` field (`property` misses). receiver = object/operand/argument
   fields → all null for rust → `func.namedChild(0)` (the `value`).
   - receiver type in LITERAL_RECEIVER_TYPES (373) → emit NOTHING (#1230).
     Rust members of the set: `string_literal`, `raw_string_literal`,
     `integer_literal`, `float_literal`, `char_literal`, `boolean_literal`.
     QUIRK: rust `array_expression`/`tuple_expression`/`struct_expression`
     receivers are NOT in the set (it has `array`/`array_literal`, other
     grammars' names) — `[1,2].len()` falls through to the bare-name path and
     emits `calls` ref `len`. PRESERVE.
   - receiver `identifier` (not in SKIP_RECEIVERS {self,this,cls,super}) →
     `recv.method`. NOTE rust `self` is node type `self`, NOT `identifier`,
     so `self.own()` skips this branch and lands on the fallthrough → bare
     `own` (same net effect as SKIP, different path — probed).
   - receiver `call_expression` + rust in the gate list (4413) →
     chained-call re-encode: `innerFn = receiver.childForFieldName('function')`,
     `innerCallee = text(innerFn).replace(/->/g,'.').replace(/\s+/g,'')`;
     **rust re-encodes ONLY when `innerFn.type === 'scoped_identifier'`**
     (4455) → `Foo::new().bar()` → ref `Foo::new().bar`; an instance chain
     `x.foo().bar()` (innerFn field_expression) → bare `bar`. When not
     re-encoding, calleeName = bare methodName.
   - receiver anything else (`field_expression` 2-hop `v.field.method()`,
     `parenthesized_expression`, `await_expression`, `self`) → bare
     methodName (probed all four).
2. `func.type === 'scoped_identifier'` (4499) → calleeName = FULL text
   (`Foo::new`, `m::helper2`, `std::mem::swap` — whatever the source spells,
   whitespace included).
3. else → calleeName = raw func text: bare `helper` for identifier;
   **`generic_function` (turbofish `helper::<T>`) keeps the full
   `helper::<T>` text — unresolvable downstream, PRESERVE** (probed).

Post-processing: the parenthesized-conversion regex (4530) can in principle
match `(Foo)(x)` shapes — rust parses a parenthesized callee as
`parenthesized_expression` so text starts `(` → regex CAN fire; harmless and
must match. Template-arg strip (4542) and cpp fn-ptr fan-out (4556) are
c/cpp-gated — NOT for rust. Finally one `calls` ref {callerId, name, line =
call startRow+1, column = call startColumn (UTF-16)}. Inner calls of a chain
are ALSO visited (the body walker recurses after extractCall), so
`Foo::new().bar()` emits BOTH `Foo::new().bar` and `Foo::new`.

`extractCall` returns immediately when the nodeStack is empty — never the case
in practice (file node is pushed).

### extractInstantiation — `struct_expression` (359, 4610)

ctor = constructor/type/**name**(rust)/namedChild(0). Not
composite_literal/instance_expression → generic path: text; strip from first
`<`; then `lastDot = max(lastIndexOf('.'), lastIndexOf('::'))` → keep trailing
segment (`m::Widget { }` → `Widget`); trim; emit `instantiates` ref at the
struct_expression's position. Fires from visitNode (top-level expressions) AND
visitFunctionBody (5145). Top-level const/static initializers never reach it
(extractVariable skips walking — quirk noted above).

### Rocket route macros — extractRustRouteMacro (5048), body-walker-only (5141)

Gate: `this.language === 'rust'`; macroName = `node.namedChild(0)` (the
`macro` field identifier); name must be EXACTLY `routes` or `catchers` — a
scoped `rocket::routes![…]` has a scoped_identifier there whose text doesn't
match → skipped (PRESERVE). tokenTree = first namedChild of type `token_tree`.
fromId = nodeStack top. Walk `tokenTree.child(i)` (ALL children, anonymous
included): `identifier` tokens accumulate into `parts` (first one records
line/column); a `,` token flushes `parts.join('::')` as ONE ref
{referenceKind: **`references`**}; final flush after the loop (the closing `]`
is not a flush trigger — the trailing path flushes at end). Probed token
stream: `[ id :: id :: id , id ]` — `::` are anonymous and skipped by the
identifier/`,` switch. Consumed by `resolveRustPathReference`
(import-resolver.ts:1781).

### emitRustUseBindingRefs (3451) — one `imports` ref per use binding

Called from extractImport for every `use_declaration` (3217). Recursive
`collect(n, prefix)` over the declaration's namedChildren:

- `identifier` → push `join(prefix, text)` (`join` = `prefix ? prefix+'::'+seg : seg`)
- `scoped_identifier` → push `prefix ? prefix+'::'+trim(fullText) : trim(fullText)`
  (the FULL path text — `crate::m::Item`, `self::sub::read`)
- `scoped_use_list` → prefix' = join(prefix, trim(text of `path` field));
  recurse into `list` field (`?? namedChildren.find(type==='use_list')`)
- `use_list` → recurse each namedChild with same prefix
- `use_as_clause` → recurse the `path` field (`?? namedChild(0)`) — links the
  SOURCE path, not the alias (probed: fields are path/alias)
- everything else (visibility_modifier, `use_wildcard`, bare `crate`/`self`/
  `super` nodes) → ignored

Then per collected path: leaf = last `::` segment; skip if leaf ∈
{self, super, crate, *} or empty; push {fromNodeId: file, referenceName: FULL
path, referenceKind:'imports', line/col of the collected node}. So
`use crate::m::{A, B as C, sub::D}` emits `crate::m::A`, `crate::m::B`,
`crate::m::sub::D` (plus the hook's root-module ref `crate` and the import
node named `crate`).

### Inheritance — extractInheritance for rust (5291)

Only ONE child type matters for rust nodes: **`trait_bounds`** (5515, on
trait_item — supertraits `trait Sub: Super + Display`). Per bound child:

- `type_identifier` → name = text
- `generic_type` (`Deserialize<'de>`) → inner namedChild of type
  `type_identifier` → its text
- `higher_ranked_trait_bound` (`for<'de> Deserialize<'de>`) → its
  `generic_type` child's inner type_identifier, else its own direct
  `type_identifier`
- **QUIRK, PRESERVE: `scoped_type_identifier` (`fmt::Debug`) matches NO case →
  a path-qualified supertrait emits NOTHING** (probed: `trait Render: Base +
  fmt::Debug` → only `Base`).

Each yields an `extends` ref from the trait node at the bound's position.
Struct/enum extraction also calls extractInheritance; rust struct_item children
include `field_declaration_list` → the 5652 recursion descends, but rust
`field_declaration` always carries a `field_identifier` name so the Go
struct-embedding branch (5496) never fires. Verify with the torture fixture
anyway.

### impl Trait for Type — extractRustImplItem (5690)

- hasFor = any child (ALL children) with `type === 'for' && !isNamed` — plain
  `impl Type { }` → return (no edge; getReceiverType handles member attachment).
- typeIdents = DIRECT namedChildren of type `type_identifier` | `generic_type`
  | `scoped_type_identifier`; need ≥2 else return (v0.24.2 has `trait:` and
  `type:` FIELDS, but the code deliberately uses positional filtering —
  PRESERVE the positional logic).
- traitNode = FIRST, typeNode = LAST. traitName: scoped_type_identifier →
  `source.substring(startIndex,endIndex)` (full `fmt::Display`); else
  getNodeText. typeName: generic_type → inner type_identifier text (`Container`)
  else text.
- targetId = `findNodeByName(typeName)` (5740): FIRST node in `this.nodes`
  with that name and kind ∈ {struct, enum, class} — **NOT trait**, and
  source-order dependent (the type must be defined EARLIER in the same file;
  cross-file impls emit nothing). If found: push
  {fromNodeId: **the TYPE's node id** (a back-reference), referenceName:
  traitName (full path text), referenceKind:'implements', line/col of the
  trait node}.

### Type-annotation references (5752-6112)

`rust` ∈ TYPE_ANNOTATION_LANGUAGES (5753). For every function/method:
extractTypeAnnotations (5788) walks (a) the `parameters` field subtree and
(b) the `return_type` field subtree with extractTypeRefsFromSubtree (6090),
emitting one `references` ref per **`type_identifier` leaf** whose text isn't
in BUILTIN_TYPES (5768). The set includes the rust primitives (`str bool
i8…u128 usize isize f32 f64 char`) — mostly redundant since rust primitives
parse as `primitive_type`, not `type_identifier` — plus cross-language rows
(`error`, `String` via the Scala block, `Int`/`Any`/…). Port the WHOLE set
verbatim: a rust `type_identifier` named `String` IS suppressed (Scala row),
while `Vec`/`Option`/`Box`/`Self` are NOT. QUIRKS, PRESERVE:

- Generic parameters are emitted: `fn get(&self) -> &T` → ref `T`;
  `Result<Baz, E>` → refs `Result`, `Baz`, `E`.
- `-> Self` → ref `Self` (type_identifier, not builtin).
- `scoped_type_identifier` (`fmt::Formatter`) → only the inner
  `type_identifier` leaf `Formatter` (the `path` identifier is not a
  type_identifier); the ref is UNQUALIFIED.
- `where` clauses and `type_parameters` bounds are NOT walked (params +
  return_type fields only; the type_parameters walk at 5863 is scala-gated).
- The trailing `type_annotation` child lookup (5873, and
  extractVariableTypeAnnotation:6074 whose comment says "covers … Rust
  `: Type`") is a NO-OP for rust — the grammar has no `type_annotation` node
  (let/const types are direct `type` fields). Dead comment, no behavior.
- property_signature/method_signature branch (1283) — TS-only node types,
  never rust.

### Static-member refs, cpp-isms — NOT rust

`rust` ∉ STATIC_MEMBER_LANGS (345) → extractStaticMemberRef no-ops (its call
in the body walker at 5218 must be a no-op in the walker too — cheap early
return). namespacePrefix, cppLocalFnPtrs, stack-construction, operator calls,
template strip: all c/cpp-gated, none apply.

### Docstrings (tree-sitter-helpers.ts:95)

`///` and `//!` are `line_comment` nodes; consecutive preceding named siblings
of the item accumulate (unshift → source order), then cleanCommentMarkers
strips `^\/\/[/!]?\s?` per line (multiline `gm` — the CRLF `^`-after-`\r` trap
from #1329 applies; use `js_multiline_strip` in docstring.rs). QUIRK,
PRESERVE: **an `attribute_item` between the doc comment and the item breaks
the sibling chain** — `/// doc` + `#[derive(Debug)]` + `struct Doc` → NO
docstring (probed; attribute_item is a named sibling and not a comment type).
DOCSTRING_WRAPPER_TYPES contains no rust wrappers → no climbing. Block
`/** */`-style (`block_comment`) is also accepted by the sibling scan and
`/*`-stripped.

### Value-reference edges (398-931) — rust IS in VALUE_REF_LANGS (401)

Port the full machinery (crib go.rs/tsjs): `CODEGRAPH_VALUE_REFS=0` kill;
MAX_VALUE_REF_NODES=20_000 caps BOTH the prune scan and each reader scan;
`isGeneratedFile` skip.

- Targets (captureValueRefScope:735): created nodes of kind
  constant/**variable** (rust consts are `variable` — still targets), name
  length ≥3 AND `/[A-Z_]/` test, parent scope id starting `file:` (also
  class:/module:/struct:/enum: — rust consts always land under file:). Count
  per name in fileScopeValueCounts.
- Reader scopes: every function/method/constant/variable node.
- Shadow prune (803-878): DFS of the whole tree counting declarators of
  target names — rust cases: `const_item`/`static_item` → bump
  `childForFieldName('name')` (823-825); **`let_declaration`** (the shadow
  source, 827) → left ?? `pattern` ?? namedChild(0); if the pattern is an
  `identifier` bump it, else bump every namedChild of the pattern (tuple
  patterns). bump() only counts `identifier`/`simple_identifier` nodes whose
  text is a target. After the scan: `declCount > fileScopeCount` → target
  deleted (a local `let MAX = …` shadows the file `const MAX`).
- Emission (880-930): per reader scope, DFS its node subtree (rust bodies are
  children — the Dart/Pascal sibling pull at 891 is inert); each
  `identifier` (also constant/name/simple_identifier — non-rust) whose text
  maps to a target and target ≠ self-id and name ≠ scope's own name and not
  yet seen → EDGE (not unresolved ref): {source: scopeId, target: targetId,
  kind:'references', metadata:{valueRef:true}}, deduped per (scope,target).

### Function-as-value capture (#756) — RUST_SPEC (function-ref.ts:217)

idTypes={identifier}; dispatch:
`arguments`→args, `assignment_expression`→rhs(field `right`),
`field_initializer`→value(field `value`), `array_expression`→list,
`static_item`→varinit(field `value`), `let_declaration`→varinit(field `value`).
NO layers/unwrap/special/ungatedModes/addressOfOnly. QUIRK: **`const_item` is
NOT in the dispatch** — a `const TABLE: [fn(); 2] = [a, b];` captures via the
inner `array_expression`, but `const CB: fn() = handler;` captures nothing
(static_item does). Capture mechanics (function-ref.ts:408-597):

- args/list: every namedChild is a candidate value.
- rhs: the `right` field, with the param-storage skip — if the LHS's last
  identifier (`/([A-Za-z_$][A-Za-z0-9_$]*)\s*$/` on LHS text) EQUALS the RHS
  text, skip (`o.cb = cb`).
- varinit: name/pattern field of type object_pattern/array_pattern/
  **tuple_pattern/struct_pattern** → skip whole container (destructuring);
  else the `value` field.
- normalizeValue: bare `identifier` → candidate (NAME_STOPLIST drops
  this/self/true/None/…). No unwrap → `&handler` (a rust `reference_expression`)
  yields NOTHING — rust captures only bare identifiers. explicitRef = false
  always (idTypes hit).
- Capture fires from visitNode:990 AND visitFunctionBody:5137 AND
  scanFnRefSubtree (top-level initializers, halts at nested functionTypes,
  depth ≤12).
- Flush gate (flushFnRefCandidates:639): generated-file skip; candidate name
  must be in definedHere (same-file function/method NAMES) ∪ importedNames.
  QUIRK, PRESERVE: importedNames admits `SIMPLE_NAME` (`/^[A-Za-z_$][A-Za-z0-9_$]*$/`)
  or `QUALIFIED_IMPORT` with `.`/`\` separators only — **rust's `::`-separated
  import refs (`crate::m::helper`) match NEITHER, so rust use-imports
  contribute nothing to the gate** except single-segment ones (`use foo;` →
  `foo`, and every root-module ref `crate`/`self`/`std`). Net: the rust fn-ref
  gate is effectively "defined in this file". Survivors dedupe on
  `${fromNodeId}|${name}` and push {referenceKind:'function_ref'}.

### Misc shared paths

- Import/refs positions: `line = startPosition.row + 1`,
  `column = startPosition.column` — **UTF-16 code units** (textutil::col16),
  as are `startIndex/endIndex` substrings and `.slice(0,100)` truncations.
- Refs carry NO filePath/language (the store denormalizes) — kernel wire
  contract is exactly extractFromSource's return.
- `extract()` wraps everything: file node first, nodeStack=[fileId], no
  packageNode for rust; flushFnRefCandidates then flushValueRefs at the end.
- Parse errors: the walker defers `has_error()` files (`defer:` signal);
  wasm's error recovery is canonical. tree.delete()/source-release are
  wasm-side concerns.

## Frameworks that consume rust extraction artifacts (stay TS-side)

`rustResolver` (resolution/frameworks/rust.ts) — detect: `Cargo.toml`.

- **`extract()` (regex over raw source, runs in extractFromSource AFTER either
  arm — NO port needed, but its INPUT contract must hold):** emits `route`
  nodes with id `` `route:${filePath}:${line}:${METHOD}:${path}` `` (NOT
  hashed), kind `route`, name `` `${METHOD} ${path}` ``, qualifiedName
  `` `${filePath}::route:${path}` ``, language `rust`; plus one
  `references` ref per handler FROM the route node (these framework refs DO
  carry filePath+language — resolution/types' UnresolvedRef, unlike extraction
  refs). Covers `#[get("/…")]` attributes (Actix/Rocket), Axum
  `.route("/p", get(h))` chains, Actix builder `web::resource(...).to(h)`.
- **Extraction-side emissions the port MUST reproduce for rust resolution to
  keep working:** (a) `emitRustUseBindingRefs`'s FULL-path `imports` refs and
  (b) `extractRustRouteMacro`'s `::`-joined `references` refs — both consumed
  by `resolveRustPathReference` (import-resolver.ts:1446/1781); (c) the
  root-module `imports` ref that `resolveModule`/cargo-workspace mapping
  resolves (module refs like `use foo;` → `src/foo.rs` / workspace crates).
- `cargo-workspace.ts` (path-aliases §) reads Cargo.toml manifests only —
  untouched.

## Gates (per plan §5, no exceptions)

- **Torture fixture `torture.rs`** (+ CRLF variant, derived in-memory), pinning
  at minimum: unit struct (NO node) / tuple struct / field struct; enum with
  unit+tuple+struct variants; trait with supertraits incl. a SCOPED one
  (`fmt::Debug` — dropped) + `function_signature_item` + default method +
  associated type/const (no node; const value call attributes to trait);
  inherent impl (methods, associated const → file-level `variable`); `impl
  Trait for Type`; `impl fmt::Display for Type` (scoped trait name text);
  `impl<T> Generic<T>` (generic-branch receiver); **`impl Trait for
  Generic<T>` (receiver = TRAIT bug)**; impl ABOVE its struct (no contains
  edge); nested fn inside an impl method (becomes a method); `pub async fn`
  (isAsync stays false); `-> Self` / `-> &Foo` / `-> Vec<Foo>` /
  `-> Result<Vec<Foo>, E>` (returnType undefined) / `-> fmt::Result`;
  turbofish call; `Foo::new().bar()` chain + instance chain `x.foo().bar()`;
  `self.method()`; 2-hop `v.field.method()`; literal receiver `"x".len()`
  (nothing); `m::helper()` scoped call; struct_expression plain + `m::Widget`
  + inside fn args; use forms: single, grouped, `as` alias, nested group
  path, `pub use`, wildcard (NO import node), bare `use foo;`;
  `const X: T = OTHER;` (phantom second node) + static with array value;
  file-scope const read + `let`-shadowed const (value-ref prune); fn-ref
  shapes: `register(handler)`, `obj.cb = handler2`, `Widget { cb: handler }`,
  `[cb_a, cb_b]`, `static CB: fn() = handler`, `let cb = handler`, tuple-let
  skip; `routes![a::b::h1, h2]` + `catchers![x]` + `rocket::routes![…]`
  (skipped) inside a body AND one at top level (skipped); doc comments incl.
  `//!`, a `/* */` block, and the attribute-breaks-docstring case; a mod
  with items (no module node, bare QNs).
- **Parity sweeps** (`scripts/kernel-parity.mjs`, order-sensitive full-object):
  **ripgrep (small), tokio (medium), rust-analyzer (large)** — all three also
  exercise heavy `pub use` re-export hubs and macro use. Then **full-init
  dump-diffs byte-identical** (kernel arm vs `CODEGRAPH_KERNEL=0`,
  `dump-graph.mjs`, cmp) on the same three.
- **Deferral-rate guard: default `--max-deferral 0.1` and expect FAR under it**
  — rust is not macro-mangled C; parse-error incidence should sit in the
  ts/java/py/go norm (0–0.42%). Double-digit deferral on a rust sweep means a
  broken walker, not grammar reality (the c/cpp 0.5 exemption does NOT carry
  over).
- Grammar-bump isolation: the vendored v0.24.2 wasm + `=0.24.2` crate pin land
  FIRST with the full suite green (kernel-grammar-parity sha-matches parser.c;
  crate + wasm move together or it fails).
- Suite green with `CODEGRAPH_KERNEL_EXPECT=1`; unit tests for the walker in
  `__tests__/kernel-rustlang-parity.test.ts` (or folded into the existing
  parity suites); changelog rides the existing kernel entry.
- `DEFAULT_ROUTED += rust` (kernel/index.ts:37) only after ALL of the above.
- Post-route perf sanity: remember decision §arch-2 — Cargo repos take the
  decoded path (framework extract()), so measure the parse-loop, not the
  raw-buffer transport.