// Copyright (c) 2020-2024 Joe Conigliaro. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module ast

import v2.token

// to_files materializes a FlatAst back into legacy []File. This is the
// inverse of flatten_files() and is used for round-trip verification.
// Reading happens lazily (one node at a time) so callers can also walk a
// flat AST without ever rehydrating the legacy form.
pub fn (flat &FlatAst) to_files() []File {
	r := FlatReader{
		flat: unsafe { flat }
	}
	mut files := []File{cap: flat.files.len}
	for ff in flat.files {
		files << r.read_file(ff)
	}
	return files
}

// to_files_range rehydrates the FlatFiles in [start, end) without touching
// the rest of the FlatAst. Used by the streaming builder, where each
// parse_batch appends to a shared FlatBuilder and only needs to return the
// freshly added files to the caller.
pub fn (flat &FlatAst) to_files_range(start int, end int) []File {
	mut lo := start
	mut hi := end
	if lo < 0 {
		lo = 0
	}
	if hi > flat.files.len {
		hi = flat.files.len
	}
	if hi <= lo {
		return []File{}
	}
	r := FlatReader{
		flat: unsafe { flat }
	}
	mut files := []File{cap: hi - lo}
	for i in lo .. hi {
		files << r.read_file(flat.files[i])
	}
	return files
}

// FlatReader is a thin cursor over a FlatAst that reconstructs legacy nodes.
struct FlatReader {
	flat &FlatAst
}

@[inline]
fn (r &FlatReader) node(id FlatNodeId) FlatNode {
	return r.flat.nodes[id]
}

@[inline]
fn (r &FlatReader) edge(n FlatNode, i int) FlatNodeId {
	return r.flat.edges[n.first_edge + i].child_id
}

@[inline]
fn (r &FlatReader) get_str(idx int) string {
	if idx < 0 || idx >= r.flat.strings.len {
		return ''
	}
	return r.flat.strings[idx]
}

// list_children returns the child ids of an aux_list node.
fn (r &FlatReader) list_children(id FlatNodeId) []FlatNodeId {
	if id < 0 {
		return []FlatNodeId{}
	}
	n := r.node(id)
	mut out := []FlatNodeId{cap: n.edge_count}
	for i in 0 .. n.edge_count {
		out << r.edge(n, i)
	}
	return out
}

fn (r &FlatReader) read_file(ff FlatFile) File {
	n := r.node(ff.file_id)
	attrs_id := r.edge(n, 0)
	imports_id := r.edge(n, 1)
	stmts_id := r.edge(n, 2)
	mut attrs := []Attribute{}
	attr_children := r.list_children(attrs_id)
	for cid in attr_children {
		attrs << r.read_attribute(cid)
	}
	mut imports := []ImportStmt{}
	import_children := r.list_children(imports_id)
	for cid in import_children {
		c := Cursor{
			flat: r.flat
			id:   cid
		}
		if c.kind() == .stmt_import {
			imports << c.import_stmt()
		}
	}
	mut stmts := []Stmt{}
	stmt_children := r.list_children(stmts_id)
	for cid in stmt_children {
		stmts << r.read_stmt(cid)
	}
	return File{
		name:           r.get_str(ff.name_idx)
		mod:            r.get_str(ff.mod_idx)
		selector_names: ff.selector_names
		attributes:     attrs
		imports:        imports
		stmts:          stmts
	}
}

// decode_stmt rehydrates a single legacy ast.Stmt from a FlatNodeId. Useful
// for cursor-driven consumers that walk the flat graph via Cursor and only
// need to materialize a typed Stmt for the specific decls they hand to
// helpers still keyed on legacy ADTs. Returns empty_stmt for invalid ids.
pub fn (flat &FlatAst) decode_stmt(id FlatNodeId) Stmt {
	r := FlatReader{
		flat: unsafe { flat }
	}
	return r.read_stmt(id)
}

// decode_expr is the Expr analogue of decode_stmt.
pub fn (flat &FlatAst) decode_expr(id FlatNodeId) Expr {
	r := FlatReader{
		flat: unsafe { flat }
	}
	return r.read_expr(id)
}

// decode_fn_decl_signature rehydrates a FnDecl with `stmts = []` — the body
// is left empty. Callers that walk the body via Cursor (e.g. markused) can
// use this to avoid the per-fn body decode, which dominates collect_defs
// time in flat mode. Returns an empty FnDecl for ids that don't point at a
// stmt_fn_decl node.
pub fn (flat &FlatAst) decode_fn_decl_signature(id FlatNodeId) FnDecl {
	if id < 0 || id >= flat.nodes.len {
		return FnDecl{}
	}
	n := flat.nodes[id]
	if n.kind != .stmt_fn_decl {
		return FnDecl{}
	}
	r := FlatReader{
		flat: unsafe { flat }
	}
	recv_id := r.edge(n, 0)
	typ_id := r.edge(n, 1)
	attrs_id := r.edge(n, 2)
	fn_typ := r.read_fn_type(typ_id)
	return FnDecl{
		attributes: r.read_attr_list(attrs_id)
		is_public:  (n.flags & flag_is_public) != 0
		is_method:  (n.flags & flag_is_method) != 0
		is_static:  (n.flags & flag_is_static) != 0
		receiver:   r.read_parameter(recv_id)
		language:   unsafe { Language(int(n.aux)) }
		name:       r.get_str(n.name_id)
		typ:        fn_typ
		pos:        n.pos
	}
}

// file_mod returns the module name for a FlatFile via the interned strings.
@[inline]
pub fn (flat &FlatAst) file_mod(ff FlatFile) string {
	if ff.mod_idx < 0 || ff.mod_idx >= flat.strings.len {
		return ''
	}
	return flat.strings[ff.mod_idx]
}

// file_name returns the source filename for a FlatFile.
@[inline]
pub fn (flat &FlatAst) file_name(ff FlatFile) string {
	if ff.name_idx < 0 || ff.name_idx >= flat.strings.len {
		return ''
	}
	return flat.strings[ff.name_idx]
}

fn (r &FlatReader) read_attribute(id FlatNodeId) Attribute {
	n := r.node(id)
	return Attribute{
		name:          r.get_str(n.name_id)
		value:         r.read_expr(r.edge(n, 0))
		comptime_cond: r.read_expr(r.edge(n, 1))
	}
}

fn (r &FlatReader) read_field_init(id FlatNodeId) FieldInit {
	n := r.node(id)
	return FieldInit{
		name:  r.get_str(n.name_id)
		value: r.read_expr(r.edge(n, 0))
	}
}

fn (r &FlatReader) read_field_decl(id FlatNodeId) FieldDecl {
	n := r.node(id)
	attrs_id := r.edge(n, 2)
	mut attrs := []Attribute{}
	attr_children := r.list_children(attrs_id)
	for cid in attr_children {
		attrs << r.read_attribute(cid)
	}
	return FieldDecl{
		name:                r.get_str(n.name_id)
		typ:                 r.read_expr(r.edge(n, 0))
		value:               r.read_expr(r.edge(n, 1))
		attributes:          attrs
		is_public:           (n.flags & flag_is_public) != 0
		is_mut:              (n.flags & flag_is_mut) != 0
		is_module_mut:       (n.flags & flag_field_is_module_mut) != 0
		is_interface_method: (n.flags & flag_field_is_interface_method) != 0
	}
}

fn (r &FlatReader) read_parameter(id FlatNodeId) Parameter {
	n := r.node(id)
	return Parameter{
		name:   r.get_str(n.name_id)
		typ:    r.read_expr(r.edge(n, 0))
		is_mut: (n.flags & flag_is_mut) != 0
		pos:    n.pos
	}
}

fn (r &FlatReader) read_match_branch(id FlatNodeId) MatchBranch {
	n := r.node(id)
	cond_id := r.edge(n, 0)
	stmts_id := r.edge(n, 1)
	mut cond := []Expr{}
	cond_children := r.list_children(cond_id)
	for cid in cond_children {
		cond << r.read_expr(cid)
	}
	mut stmts := []Stmt{}
	stmt_children := r.list_children(stmts_id)
	for cid in stmt_children {
		stmts << r.read_stmt(cid)
	}
	return MatchBranch{
		cond:  cond
		stmts: stmts
		pos:   n.pos
	}
}

fn (r &FlatReader) read_string_inter(id FlatNodeId) StringInter {
	n := r.node(id)
	mut width := 0
	mut precision := 0
	if n.edge_count >= 4 {
		width = r.read_int(r.edge(n, 2))
		precision = r.read_int(r.edge(n, 3))
	} else {
		packed := n.extra
		width = (packed >> 16) & 0xFFFF
		// sign-extend the low 16 bits to recover negative precision values
		precision = packed & 0xFFFF
		if precision & 0x8000 != 0 {
			precision |= ~0xFFFF
		}
		// sign-extend width as well
		if width & 0x8000 != 0 {
			width |= ~0xFFFF
		}
	}
	return StringInter{
		format:       unsafe { StringInterFormat(int(n.aux)) }
		width:        width
		precision:    precision
		expr:         r.read_expr(r.edge(n, 0))
		format_expr:  r.read_expr(r.edge(n, 1))
		resolved_fmt: r.get_str(n.name_id)
	}
}

fn (r &FlatReader) read_int(id FlatNodeId) int {
	return r.node(id).extra
}

fn (r &FlatReader) read_expr_list(id FlatNodeId) []Expr {
	mut out := []Expr{}
	children := r.list_children(id)
	for cid in children {
		out << r.read_expr(cid)
	}
	return out
}

fn (r &FlatReader) read_stmt_list(id FlatNodeId) []Stmt {
	mut out := []Stmt{}
	children := r.list_children(id)
	for cid in children {
		out << r.read_stmt(cid)
	}
	return out
}

fn (r &FlatReader) read_attr_list(id FlatNodeId) []Attribute {
	mut out := []Attribute{}
	children := r.list_children(id)
	for cid in children {
		out << r.read_attribute(cid)
	}
	return out
}

fn (r &FlatReader) read_field_decl_list(id FlatNodeId) []FieldDecl {
	mut out := []FieldDecl{}
	children := r.list_children(id)
	for cid in children {
		out << r.read_field_decl(cid)
	}
	return out
}

fn (r &FlatReader) read_field_init_list(id FlatNodeId) []FieldInit {
	mut out := []FieldInit{}
	children := r.list_children(id)
	for cid in children {
		out << r.read_field_init(cid)
	}
	return out
}

fn (r &FlatReader) read_parameter_list(id FlatNodeId) []Parameter {
	mut out := []Parameter{}
	children := r.list_children(id)
	for cid in children {
		out << r.read_parameter(cid)
	}
	return out
}

// read_fn_type (s252) decodes a `.typ_fn` node straight into a FnType, without
// the read_type→`Type(FnType{...})`→`is FnType` round-trip. Boxing a large
// struct into the Type sum type and then unboxing it via smartcast corrupts the
// FnType's slice headers (generic_params/params) on the arm64 self-host (the
// documented chained-access/smartcast bug). This path is only ever exercised by
// the flat decode, so the default self-host never hit it. Edge layout matches
// the encoder's FnType arm and read_type's `.typ_fn`: 0=generics, 1=params,
// 2=return_type.
fn (r &FlatReader) read_fn_type(id FlatNodeId) FnType {
	if id < 0 {
		return FnType{}
	}
	n := r.node(id)
	if n.kind != .typ_fn {
		return FnType{}
	}
	return FnType{
		generic_params: r.read_expr_list(r.edge(n, 0))
		params:         r.read_parameter_list(r.edge(n, 1))
		return_type:    r.read_expr(r.edge(n, 2))
	}
}

// read_ident (s254) decodes an expr_ident node straight into an Ident, avoiding
// the read_expr→Expr→`is Ident` smartcast-unbox. Copying a struct out of the Expr
// sum type via smartcast corrupts its fields (here the `name` string header) on
// the arm64 self-host (same chained-access/smartcast bug as the FnType unbox in
// s252). Returns an empty Ident for ids that don't point at an expr_ident.
fn (r &FlatReader) read_ident(id FlatNodeId) Ident {
	if id < 0 || id >= r.flat.nodes.len {
		return Ident{}
	}
	n := r.node(id)
	if n.kind != .expr_ident {
		return Ident{}
	}
	return Ident{
		pos:  n.pos
		name: r.get_str(n.name_id)
	}
}

// read_assign_stmt (s254) decodes a stmt_assign node straight into an AssignStmt,
// avoiding the read_stmt→Stmt→`is AssignStmt` unbox (which corrupts the lhs/rhs
// slice headers on arm64). Mirrors the `.stmt_assign` arm of read_stmt. Returns
// an empty AssignStmt for ids that don't point at a stmt_assign.
fn (r &FlatReader) read_assign_stmt(id FlatNodeId) AssignStmt {
	if id < 0 || id >= r.flat.nodes.len {
		return AssignStmt{}
	}
	n := r.node(id)
	if n.kind != .stmt_assign {
		return AssignStmt{}
	}
	lhs_len := n.extra
	mut lhs := []Expr{cap: lhs_len}
	for i in 0 .. lhs_len {
		lhs << r.read_expr(r.edge(n, i))
	}
	mut rhs := []Expr{cap: n.edge_count - lhs_len}
	for i in lhs_len .. n.edge_count {
		rhs << r.read_expr(r.edge(n, i))
	}
	return AssignStmt{
		op:  unsafe { token.Token(int(n.aux)) }
		lhs: lhs
		rhs: rhs
		pos: n.pos
	}
}

fn (r &FlatReader) read_string_list(id FlatNodeId) []string {
	if id < 0 {
		return []string{}
	}
	n := r.node(id)
	mut out := []string{cap: n.edge_count}
	for i in 0 .. n.edge_count {
		child := r.node(r.edge(n, i))
		out << r.get_str(child.name_id)
	}
	return out
}

fn (r &FlatReader) read_string_inter_list(id FlatNodeId) []StringInter {
	mut out := []StringInter{}
	children := r.list_children(id)
	for cid in children {
		out << r.read_string_inter(cid)
	}
	return out
}

fn (r &FlatReader) read_stmt(id FlatNodeId) Stmt {
	if id < 0 {
		return empty_stmt
	}
	n := r.node(id)
	match n.kind {
		.stmt_asm {
			return Stmt(AsmStmt{
				arch: r.get_str(n.name_id)
			})
		}
		.stmt_assert {
			return Stmt(AssertStmt{
				expr:  r.read_expr(r.edge(n, 0))
				extra: r.read_expr(r.edge(n, 1))
			})
		}
		.stmt_assign {
			lhs_len := n.extra
			mut lhs := []Expr{cap: lhs_len}
			for i in 0 .. lhs_len {
				lhs << r.read_expr(r.edge(n, i))
			}
			mut rhs := []Expr{cap: n.edge_count - lhs_len}
			for i in lhs_len .. n.edge_count {
				rhs << r.read_expr(r.edge(n, i))
			}
			return Stmt(AssignStmt{
				op:  unsafe { token.Token(int(n.aux)) }
				lhs: lhs
				rhs: rhs
				pos: n.pos
			})
		}
		.stmt_block {
			mut stmts := []Stmt{cap: n.edge_count}
			for i in 0 .. n.edge_count {
				stmts << r.read_stmt(r.edge(n, i))
			}
			return Stmt(BlockStmt{
				stmts: stmts
			})
		}
		.stmt_comptime {
			return Stmt(ComptimeStmt{
				stmt: r.read_stmt(r.edge(n, 0))
			})
		}
		.stmt_const_decl {
			fields_id := r.edge(n, 0)
			return Stmt(ConstDecl{
				is_public: (n.flags & flag_is_public) != 0
				fields:    r.read_field_init_list(fields_id)
			})
		}
		.stmt_defer {
			mode := if (n.flags & flag_defer_func) != 0 {
				DeferMode.function
			} else {
				DeferMode.scoped
			}
			mut stmts := []Stmt{cap: n.edge_count}
			for i in 0 .. n.edge_count {
				stmts << r.read_stmt(r.edge(n, i))
			}
			return Stmt(DeferStmt{
				mode:  mode
				stmts: stmts
			})
		}
		.stmt_directive {
			mut ct_cond := ''
			if n.edge_count > 0 {
				cc_node := r.node(r.edge(n, 0))
				ct_cond = r.get_str(cc_node.name_id)
			}
			return Stmt(Directive{
				name:    r.get_str(n.name_id)
				value:   r.get_str(n.extra)
				ct_cond: ct_cond
			})
		}
		.stmt_empty {
			return Stmt(EmptyStmt(u8(n.extra)))
		}
		.stmt_enum_decl {
			as_type := r.read_expr(r.edge(n, 0))
			attrs_id := r.edge(n, 1)
			fields_id := r.edge(n, 2)
			return Stmt(EnumDecl{
				is_public:  (n.flags & flag_is_public) != 0
				name:       r.get_str(n.name_id)
				as_type:    as_type
				attributes: r.read_attr_list(attrs_id)
				fields:     r.read_field_decl_list(fields_id)
			})
		}
		.stmt_expr {
			return Stmt(ExprStmt{
				expr: r.read_expr(r.edge(n, 0))
			})
		}
		.stmt_flow_control {
			return Stmt(FlowControlStmt{
				op:    unsafe { token.Token(int(n.aux)) }
				label: r.get_str(n.name_id)
			})
		}
		.stmt_fn_decl {
			recv_id := r.edge(n, 0)
			typ_id := r.edge(n, 1)
			attrs_id := r.edge(n, 2)
			stmts_id := r.edge(n, 3)
			fn_typ := r.read_fn_type(typ_id)
			return Stmt(FnDecl{
				attributes: r.read_attr_list(attrs_id)
				is_public:  (n.flags & flag_is_public) != 0
				is_method:  (n.flags & flag_is_method) != 0
				is_static:  (n.flags & flag_is_static) != 0
				receiver:   r.read_parameter(recv_id)
				language:   unsafe { Language(int(n.aux)) }
				name:       r.get_str(n.name_id)
				typ:        fn_typ
				stmts:      r.read_stmt_list(stmts_id)
				pos:        n.pos
			})
		}
		.stmt_for_in {
			return Stmt(ForInStmt{
				key:   r.read_expr(r.edge(n, 0))
				value: r.read_expr(r.edge(n, 1))
				expr:  r.read_expr(r.edge(n, 2))
			})
		}
		.stmt_for {
			init := r.read_stmt(r.edge(n, 0))
			cond := r.read_expr(r.edge(n, 1))
			post := r.read_stmt(r.edge(n, 2))
			mut stmts := []Stmt{cap: n.edge_count - 3}
			for i in 3 .. n.edge_count {
				stmts << r.read_stmt(r.edge(n, i))
			}
			return Stmt(ForStmt{
				init:  init
				cond:  cond
				post:  post
				stmts: stmts
			})
		}
		.stmt_global_decl {
			attrs_id := r.edge(n, 0)
			fields_id := r.edge(n, 1)
			return Stmt(GlobalDecl{
				attributes: r.read_attr_list(attrs_id)
				fields:     r.read_field_decl_list(fields_id)
				is_public:  (n.flags & flag_is_public) != 0
			})
		}
		.stmt_import {
			mut symbols := []Expr{cap: n.edge_count}
			for i in 0 .. n.edge_count {
				symbols << r.read_expr(r.edge(n, i))
			}
			return Stmt(ImportStmt{
				name:       r.get_str(n.name_id)
				alias:      r.get_str(n.extra)
				is_aliased: (n.flags & flag_is_aliased) != 0
				symbols:    symbols
			})
		}
		.stmt_interface_decl {
			attrs_id := r.edge(n, 0)
			generic_params_id := r.edge(n, 1)
			embedded_id := r.edge(n, 2)
			fields_id := r.edge(n, 3)
			return Stmt(InterfaceDecl{
				is_public:      (n.flags & flag_is_public) != 0
				attributes:     r.read_attr_list(attrs_id)
				name:           r.get_str(n.name_id)
				generic_params: r.read_expr_list(generic_params_id)
				embedded:       r.read_expr_list(embedded_id)
				fields:         r.read_field_decl_list(fields_id)
			})
		}
		.stmt_label {
			return Stmt(LabelStmt{
				name: r.get_str(n.name_id)
				stmt: r.read_stmt(r.edge(n, 0))
			})
		}
		.stmt_module {
			return Stmt(ModuleStmt{
				name: r.get_str(n.name_id)
			})
		}
		.stmt_return {
			mut exprs := []Expr{cap: n.edge_count}
			for i in 0 .. n.edge_count {
				exprs << r.read_expr(r.edge(n, i))
			}
			return Stmt(ReturnStmt{
				exprs: exprs
			})
		}
		.stmt_struct_decl {
			attrs_id := r.edge(n, 0)
			implements_id := r.edge(n, 1)
			embedded_id := r.edge(n, 2)
			generic_params_id := r.edge(n, 3)
			fields_id := r.edge(n, 4)
			return Stmt(StructDecl{
				attributes:     r.read_attr_list(attrs_id)
				is_public:      (n.flags & flag_is_public) != 0
				is_union:       (n.flags & flag_is_union) != 0
				implements:     r.read_expr_list(implements_id)
				embedded:       r.read_expr_list(embedded_id)
				language:       unsafe { Language(int(n.aux)) }
				name:           r.get_str(n.name_id)
				generic_params: r.read_expr_list(generic_params_id)
				fields:         r.read_field_decl_list(fields_id)
				pos:            n.pos
			})
		}
		.stmt_type_decl {
			base_type := r.read_expr(r.edge(n, 0))
			generic_params_id := r.edge(n, 2)
			variants_id := r.edge(n, 3)
			return Stmt(TypeDecl{
				is_public:      (n.flags & flag_is_public) != 0
				language:       unsafe { Language(int(n.aux)) }
				name:           r.get_str(n.name_id)
				generic_params: r.read_expr_list(generic_params_id)
				base_type:      base_type
				variants:       r.read_expr_list(variants_id)
			})
		}
		.stmt_attributes {
			list_id := r.edge(n, 0)
			return Stmt(r.read_attr_list(list_id))
		}
		else {
			return empty_stmt
		}
	}
}

fn (r &FlatReader) read_expr(id FlatNodeId) Expr {
	if id < 0 {
		return empty_expr
	}
	n := r.node(id)
	// Types and aux nodes can appear where an Expr is expected.
	match n.kind {
		.typ_anon_struct, .typ_array_fixed, .typ_array, .typ_channel, .typ_fn, .typ_generic,
		.typ_map, .typ_nil, .typ_none, .typ_option, .typ_pointer, .typ_result, .typ_thread,
		.typ_tuple {
			return Expr(r.read_type(id))
		}
		.aux_field_init {
			return Expr(r.read_field_init(id))
		}
		else {}
	}

	match n.kind {
		.expr_array_init {
			typ := r.read_expr(r.edge(n, 0))
			init := r.read_expr(r.edge(n, 1))
			cap := r.read_expr(r.edge(n, 2))
			len := r.read_expr(r.edge(n, 3))
			update_expr := r.read_expr(r.edge(n, 4))
			mut exprs := []Expr{cap: n.edge_count - 5}
			for i in 5 .. n.edge_count {
				exprs << r.read_expr(r.edge(n, i))
			}
			return Expr(ArrayInitExpr{
				typ:         typ
				exprs:       exprs
				init:        init
				cap:         cap
				len:         len
				update_expr: update_expr
				pos:         n.pos
			})
		}
		.expr_as_cast {
			return Expr(AsCastExpr{
				expr: r.read_expr(r.edge(n, 0))
				typ:  r.read_expr(r.edge(n, 1))
				pos:  n.pos
			})
		}
		.expr_assoc {
			typ := r.read_expr(r.edge(n, 0))
			expr := r.read_expr(r.edge(n, 1))
			mut fields := []FieldInit{cap: n.edge_count - 2}
			for i in 2 .. n.edge_count {
				fields << r.read_field_init(r.edge(n, i))
			}
			return Expr(AssocExpr{
				typ:    typ
				expr:   expr
				fields: fields
				pos:    n.pos
			})
		}
		.expr_basic_literal {
			return Expr(BasicLiteral{
				kind:  unsafe { token.Token(int(n.aux)) }
				value: r.get_str(n.name_id)
				pos:   n.pos
			})
		}
		.expr_call {
			lhs := r.read_expr(r.edge(n, 0))
			mut args := []Expr{cap: n.edge_count - 1}
			for i in 1 .. n.edge_count {
				args << r.read_expr(r.edge(n, i))
			}
			return Expr(CallExpr{
				lhs:  lhs
				args: args
				pos:  n.pos
			})
		}
		.expr_call_or_cast {
			return Expr(CallOrCastExpr{
				lhs:  r.read_expr(r.edge(n, 0))
				expr: r.read_expr(r.edge(n, 1))
				pos:  n.pos
			})
		}
		.expr_cast {
			return Expr(CastExpr{
				typ:  r.read_expr(r.edge(n, 0))
				expr: r.read_expr(r.edge(n, 1))
				pos:  n.pos
			})
		}
		.expr_comptime {
			return Expr(ComptimeExpr{
				expr: r.read_expr(r.edge(n, 0))
				pos:  n.pos
			})
		}
		.expr_empty {
			return Expr(EmptyExpr(u8(n.extra)))
		}
		.expr_fn_literal {
			fn_typ_id := r.edge(n, 0)
			fn_typ := r.read_fn_type(fn_typ_id)
			cap_len := n.extra
			mut captured := []Expr{cap: cap_len}
			for i in 0 .. cap_len {
				captured << r.read_expr(r.edge(n, 1 + i))
			}
			mut stmts := []Stmt{cap: n.edge_count - 1 - cap_len}
			for i in (1 + cap_len) .. n.edge_count {
				stmts << r.read_stmt(r.edge(n, i))
			}
			return Expr(FnLiteral{
				typ:           fn_typ
				captured_vars: captured
				stmts:         stmts
				pos:           n.pos
			})
		}
		.expr_generic_arg_or_index {
			return Expr(GenericArgOrIndexExpr{
				lhs:  r.read_expr(r.edge(n, 0))
				expr: r.read_expr(r.edge(n, 1))
				pos:  n.pos
			})
		}
		.expr_generic_args {
			lhs := r.read_expr(r.edge(n, 0))
			mut args := []Expr{cap: n.edge_count - 1}
			for i in 1 .. n.edge_count {
				args << r.read_expr(r.edge(n, i))
			}
			return Expr(GenericArgs{
				lhs:  lhs
				args: args
				pos:  n.pos
			})
		}
		.expr_ident {
			return Expr(Ident{
				pos:  n.pos
				name: r.get_str(n.name_id)
			})
		}
		.expr_if {
			cond := r.read_expr(r.edge(n, 0))
			else_expr := r.read_expr(r.edge(n, 1))
			mut stmts := []Stmt{cap: n.edge_count - 2}
			for i in 2 .. n.edge_count {
				stmts << r.read_stmt(r.edge(n, i))
			}
			return Expr(IfExpr{
				cond:      cond
				else_expr: else_expr
				stmts:     stmts
				pos:       n.pos
			})
		}
		.expr_if_guard {
			// s254: read the assign straight into an AssignStmt; the old
			// `read_stmt → if child is AssignStmt { child }` unbox corrupted its
			// lhs/rhs slice headers on arm64.
			return Expr(IfGuardExpr{
				stmt: r.read_assign_stmt(r.edge(n, 0))
				pos:  n.pos
			})
		}
		.expr_index {
			return Expr(IndexExpr{
				lhs:      r.read_expr(r.edge(n, 0))
				expr:     r.read_expr(r.edge(n, 1))
				is_gated: (n.flags & flag_is_gated) != 0
				pos:      n.pos
			})
		}
		.expr_infix {
			return Expr(InfixExpr{
				op:  unsafe { token.Token(int(n.aux)) }
				lhs: r.read_expr(r.edge(n, 0))
				rhs: r.read_expr(r.edge(n, 1))
				pos: n.pos
			})
		}
		.expr_init {
			typ := r.read_expr(r.edge(n, 0))
			mut fields := []FieldInit{cap: n.edge_count - 1}
			for i in 1 .. n.edge_count {
				fields << r.read_field_init(r.edge(n, i))
			}
			return Expr(InitExpr{
				typ:    typ
				fields: fields
				pos:    n.pos
			})
		}
		.expr_keyword {
			return Expr(Keyword{
				tok: unsafe { token.Token(int(n.aux)) }
			})
		}
		.expr_keyword_operator {
			mut exprs := []Expr{cap: n.edge_count}
			for i in 0 .. n.edge_count {
				exprs << r.read_expr(r.edge(n, i))
			}
			return Expr(KeywordOperator{
				op:    unsafe { token.Token(int(n.aux)) }
				exprs: exprs
				pos:   n.pos
			})
		}
		.expr_lambda {
			expr := r.read_expr(r.edge(n, 0))
			mut args := []Ident{cap: n.edge_count - 1}
			for i in 1 .. n.edge_count {
				// s254: read each arg straight into an Ident (the old
				// `read_expr → if e is Ident { args << e }` unbox corrupted the
				// Ident's `name` on arm64).
				arg_id := r.edge(n, i)
				if arg_id >= 0 && arg_id < r.flat.nodes.len && r.node(arg_id).kind == .expr_ident {
					args << r.read_ident(arg_id)
				}
			}
			return Expr(LambdaExpr{
				args: args
				expr: expr
				pos:  n.pos
			})
		}
		.expr_lifetime {
			return Expr(LifetimeExpr{
				name: r.get_str(n.name_id)
				pos:  n.pos
			})
		}
		.expr_lock {
			packed := u32(n.extra)
			lock_len := int(packed & 0xFFFF)
			rlock_len := int((packed >> 16) & 0xFFFF)
			mut lock_exprs := []Expr{cap: lock_len}
			for i in 0 .. lock_len {
				lock_exprs << r.read_expr(r.edge(n, i))
			}
			mut rlock_exprs := []Expr{cap: rlock_len}
			for i in lock_len .. (lock_len + rlock_len) {
				rlock_exprs << r.read_expr(r.edge(n, i))
			}
			mut stmts := []Stmt{cap: n.edge_count - lock_len - rlock_len}
			for i in (lock_len + rlock_len) .. n.edge_count {
				stmts << r.read_stmt(r.edge(n, i))
			}
			return Expr(LockExpr{
				lock_exprs:  lock_exprs
				rlock_exprs: rlock_exprs
				stmts:       stmts
				pos:         n.pos
			})
		}
		.expr_map_init {
			typ := r.read_expr(r.edge(n, 0))
			keys_len := n.extra
			mut keys := []Expr{cap: keys_len}
			for i in 0 .. keys_len {
				keys << r.read_expr(r.edge(n, 1 + i))
			}
			mut vals := []Expr{cap: n.edge_count - 1 - keys_len}
			for i in (1 + keys_len) .. n.edge_count {
				vals << r.read_expr(r.edge(n, i))
			}
			return Expr(MapInitExpr{
				typ:  typ
				keys: keys
				vals: vals
				pos:  n.pos
			})
		}
		.expr_match {
			expr := r.read_expr(r.edge(n, 0))
			mut branches := []MatchBranch{cap: n.edge_count - 1}
			for i in 1 .. n.edge_count {
				branches << r.read_match_branch(r.edge(n, i))
			}
			return Expr(MatchExpr{
				expr:     expr
				branches: branches
				pos:      n.pos
			})
		}
		.expr_modifier {
			return Expr(ModifierExpr{
				kind: unsafe { token.Token(int(n.aux)) }
				expr: r.read_expr(r.edge(n, 0))
				pos:  n.pos
			})
		}
		.expr_or {
			expr := r.read_expr(r.edge(n, 0))
			mut stmts := []Stmt{cap: n.edge_count - 1}
			for i in 1 .. n.edge_count {
				stmts << r.read_stmt(r.edge(n, i))
			}
			return Expr(OrExpr{
				expr:  expr
				stmts: stmts
				pos:   n.pos
			})
		}
		.expr_paren {
			return Expr(ParenExpr{
				expr: r.read_expr(r.edge(n, 0))
				pos:  n.pos
			})
		}
		.expr_postfix {
			return Expr(PostfixExpr{
				op:   unsafe { token.Token(int(n.aux)) }
				expr: r.read_expr(r.edge(n, 0))
				pos:  n.pos
			})
		}
		.expr_prefix {
			return Expr(PrefixExpr{
				op:   unsafe { token.Token(int(n.aux)) }
				expr: r.read_expr(r.edge(n, 0))
				pos:  n.pos
			})
		}
		.expr_range {
			return Expr(RangeExpr{
				op:    unsafe { token.Token(int(n.aux)) }
				start: r.read_expr(r.edge(n, 0))
				end:   r.read_expr(r.edge(n, 1))
				pos:   n.pos
			})
		}
		.expr_select {
			stmt := r.read_stmt(r.edge(n, 0))
			next := r.read_expr(r.edge(n, 1))
			mut stmts := []Stmt{cap: n.edge_count - 2}
			for i in 2 .. n.edge_count {
				stmts << r.read_stmt(r.edge(n, i))
			}
			return Expr(SelectExpr{
				pos:   n.pos
				stmt:  stmt
				stmts: stmts
				next:  next
			})
		}
		.expr_selector {
			// s254: read the rhs straight into an Ident; the previous
			// `read_expr → if rhs is Ident { rhs }` unbox corrupted the Ident's
			// `name` on the arm64 self-host, yielding garbage `missing X.<name>`
			// checker errors for selector types like `strings.Builder`.
			return Expr(SelectorExpr{
				lhs: r.read_expr(r.edge(n, 0))
				rhs: r.read_ident(r.edge(n, 1))
				pos: n.pos
			})
		}
		.expr_sql {
			return Expr(SqlExpr{
				expr:       r.read_expr(r.edge(n, 0))
				table_name: r.get_str(n.name_id)
				is_count:   (n.flags & flag_is_count) != 0
				is_create:  (n.flags & flag_is_create) != 0
				pos:        n.pos
			})
		}
		.expr_string_inter {
			values_id := r.edge(n, 0)
			inters_id := r.edge(n, 1)
			return Expr(StringInterLiteral{
				kind:   unsafe { StringLiteralKind(int(n.aux)) }
				values: r.read_string_list(values_id)
				inters: r.read_string_inter_list(inters_id)
				pos:    n.pos
			})
		}
		.expr_string {
			return Expr(StringLiteral{
				kind:  unsafe { StringLiteralKind(int(n.aux)) }
				value: r.get_str(n.name_id)
				pos:   n.pos
			})
		}
		.expr_tuple {
			mut exprs := []Expr{cap: n.edge_count}
			for i in 0 .. n.edge_count {
				exprs << r.read_expr(r.edge(n, i))
			}
			return Expr(Tuple{
				exprs: exprs
				pos:   n.pos
			})
		}
		.expr_unsafe {
			mut stmts := []Stmt{cap: n.edge_count}
			for i in 0 .. n.edge_count {
				stmts << r.read_stmt(r.edge(n, i))
			}
			return Expr(UnsafeExpr{
				stmts: stmts
				pos:   n.pos
			})
		}
		else {
			return empty_expr
		}
	}
}

fn (r &FlatReader) read_type(id FlatNodeId) Type {
	if id < 0 {
		return Type(NilType{})
	}
	n := r.node(id)
	match n.kind {
		.typ_anon_struct {
			generic_params_id := r.edge(n, 0)
			embedded_id := r.edge(n, 1)
			fields_id := r.edge(n, 2)
			return Type(AnonStructType{
				generic_params: r.read_expr_list(generic_params_id)
				embedded:       r.read_expr_list(embedded_id)
				fields:         r.read_field_decl_list(fields_id)
			})
		}
		.typ_array_fixed {
			return Type(ArrayFixedType{
				len:       r.read_expr(r.edge(n, 0))
				elem_type: r.read_expr(r.edge(n, 1))
			})
		}
		.typ_array {
			return Type(ArrayType{
				elem_type: r.read_expr(r.edge(n, 0))
			})
		}
		.typ_channel {
			return Type(ChannelType{
				cap:       r.read_expr(r.edge(n, 0))
				elem_type: r.read_expr(r.edge(n, 1))
			})
		}
		.typ_fn {
			generic_params_id := r.edge(n, 0)
			params_id := r.edge(n, 1)
			return Type(FnType{
				generic_params: r.read_expr_list(generic_params_id)
				params:         r.read_parameter_list(params_id)
				return_type:    r.read_expr(r.edge(n, 2))
			})
		}
		.typ_generic {
			name := r.read_expr(r.edge(n, 0))
			mut params := []Expr{cap: n.edge_count - 1}
			for i in 1 .. n.edge_count {
				params << r.read_expr(r.edge(n, i))
			}
			return Type(GenericType{
				name:   name
				params: params
			})
		}
		.typ_map {
			return Type(MapType{
				key_type:   r.read_expr(r.edge(n, 0))
				value_type: r.read_expr(r.edge(n, 1))
			})
		}
		.typ_nil {
			return Type(NilType{})
		}
		.typ_none {
			return Type(NoneType{})
		}
		.typ_option {
			return Type(OptionType{
				base_type: r.read_expr(r.edge(n, 0))
			})
		}
		.typ_pointer {
			return Type(PointerType{
				base_type: r.read_expr(r.edge(n, 0))
				lifetime:  r.get_str(n.name_id)
			})
		}
		.typ_result {
			return Type(ResultType{
				base_type: r.read_expr(r.edge(n, 0))
			})
		}
		.typ_thread {
			return Type(ThreadType{
				elem_type: r.read_expr(r.edge(n, 0))
			})
		}
		.typ_tuple {
			mut types := []Expr{cap: n.edge_count}
			for i in 0 .. n.edge_count {
				types << r.read_expr(r.edge(n, i))
			}
			return Type(TupleType{
				types: types
			})
		}
		else {
			return Type(NilType{})
		}
	}
}