// 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

pub type FlatNodeId = int

pub const invalid_flat_node_id = FlatNodeId(-1)

// FlatNodeKind is a dense tag for every stored AST node variant.
pub enum FlatNodeKind {
	file
	stmt_asm
	stmt_assert
	stmt_assign
	stmt_block
	stmt_comptime
	stmt_const_decl
	stmt_defer
	stmt_directive
	stmt_empty
	stmt_enum_decl
	stmt_expr
	stmt_flow_control
	stmt_fn_decl
	stmt_for_in
	stmt_for
	stmt_global_decl
	stmt_import
	stmt_interface_decl
	stmt_label
	stmt_module
	stmt_return
	stmt_struct_decl
	stmt_type_decl
	stmt_attributes
	expr_array_init
	expr_as_cast
	expr_assoc
	expr_basic_literal
	expr_call
	expr_call_or_cast
	expr_cast
	expr_comptime
	expr_empty
	expr_fn_literal
	expr_generic_arg_or_index
	expr_generic_args
	expr_ident
	expr_if
	expr_if_guard
	expr_index
	expr_infix
	expr_init
	expr_keyword
	expr_keyword_operator
	expr_lambda
	expr_lock
	expr_map_init
	expr_match
	expr_modifier
	expr_or
	expr_paren
	expr_postfix
	expr_prefix
	expr_range
	expr_select
	expr_selector
	expr_sql
	expr_string_inter
	expr_string
	expr_tuple
	expr_unsafe
	typ_anon_struct
	typ_array_fixed
	typ_array
	typ_channel
	typ_fn
	typ_generic
	typ_map
	typ_nil
	typ_none
	typ_option
	typ_result
	typ_thread
	typ_tuple
	aux_attribute
	aux_field_init
	aux_field_decl
	aux_parameter
	aux_match_branch
	aux_string_inter
}

// FlatEdge represents a parent->child relationship.
pub struct FlatEdge {
pub:
	child_id FlatNodeId
}

// FlatNode stores a compact, index-based AST node.
pub struct FlatNode {
pub:
	kind       FlatNodeKind
	data_idx   int = -1
	first_edge int
	edge_count int
}

// FlatFile maps a source file to its flat root node.
pub struct FlatFile {
pub:
	file_id  FlatNodeId
	name_idx int
	mod_idx  int
}

// FlatAst is a contiguous AST graph representation.
pub struct FlatAst {
pub mut:
	files   []FlatFile
	nodes   []FlatNode
	edges   []FlatEdge
	strings []string
}

// FlatAstStats captures high-level memory and shape metrics.
pub struct FlatAstStats {
pub:
	file_roots     int
	nodes          int
	edges          int
	strings        int
	string_bytes   u64
	bytes_estimate u64
}

// LegacyAstStats captures estimated dynamic memory and node shape for the existing AST.
pub struct LegacyAstStats {
pub mut:
	files          int
	expr_nodes     int
	stmt_nodes     int
	type_nodes     int
	aux_nodes      int
	node_bytes     u64
	array_bytes    u64
	string_entries int
	string_bytes   u64
	bytes_estimate u64
}

// flatten_files converts recursive v2 AST files into a flat, index-based graph.
pub fn flatten_files(files []File) FlatAst {
	mut b := new_flat_builder()
	for file in files {
		file_id := b.add_file(file)
		b.flat.files << FlatFile{
			file_id:  file_id
			name_idx: b.intern(file.name)
			mod_idx:  b.intern(file.mod)
		}
	}
	return b.flat
}

// legacy_ast_stats estimates dynamic memory and node counts for the recursive AST.
pub fn legacy_ast_stats(files []File) LegacyAstStats {
	mut w := LegacyAstWalker{}
	w.walk_files(files)
	return w.stats
}

// count_legacy_nodes returns the total legacy node count used by the walker.
pub fn count_legacy_nodes(files []File) int {
	stats := legacy_ast_stats(files)
	return stats.files + stats.expr_nodes + stats.stmt_nodes + stats.type_nodes + stats.aux_nodes
}

// stats returns aggregate shape and estimated memory usage for FlatAst.
pub fn (flat &FlatAst) stats() FlatAstStats {
	mut string_bytes := u64(0)
	for s in flat.strings {
		string_bytes += u64(s.len)
	}
	mut bytes := u64(flat.files.len) * u64(sizeof(FlatFile))
	bytes += u64(flat.nodes.len) * u64(sizeof(FlatNode))
	bytes += u64(flat.edges.len) * u64(sizeof(FlatEdge))
	bytes += u64(flat.strings.len) * u64(sizeof(string))
	bytes += string_bytes
	return FlatAstStats{
		file_roots:     flat.files.len
		nodes:          flat.nodes.len
		edges:          flat.edges.len
		strings:        flat.strings.len
		string_bytes:   string_bytes
		bytes_estimate: bytes
	}
}

// count_reachable_nodes traverses from file roots and counts unique reachable nodes.
pub fn (flat &FlatAst) count_reachable_nodes() int {
	if flat.nodes.len == 0 || flat.files.len == 0 {
		return 0
	}
	mut seen := []bool{len: flat.nodes.len}
	mut stack := []int{cap: flat.files.len}
	for file in flat.files {
		stack << file.file_id
	}
	mut count := 0
	for stack.len > 0 {
		node_id := stack.pop()
		if node_id < 0 || node_id >= flat.nodes.len {
			continue
		}
		if seen[node_id] {
			continue
		}
		seen[node_id] = true
		count++
		node := flat.nodes[node_id]
		for i in 0 .. node.edge_count {
			edge := flat.edges[node.first_edge + i]
			stack << edge.child_id
		}
	}
	return count
}

// node_type_name returns the short type-name tag associated with a flat node.
pub fn (flat &FlatAst) node_type_name(node_id FlatNodeId) string {
	if node_id < 0 || node_id >= flat.nodes.len {
		return ''
	}
	return flat.nodes[node_id].kind.str()
}

struct FlatBuilder {
mut:
	flat       FlatAst
	string_ids map[string]int
}

fn new_flat_builder() FlatBuilder {
	return FlatBuilder{
		flat:       FlatAst{
			files:   []FlatFile{}
			nodes:   []FlatNode{cap: 1024}
			edges:   []FlatEdge{cap: 2048}
			strings: []string{cap: 512}
		}
		string_ids: map[string]int{}
	}
}

fn (mut b FlatBuilder) intern(s string) int {
	if idx := b.string_ids[s] {
		return idx
	}
	idx := b.flat.strings.len
	b.flat.strings << s
	b.string_ids[s] = idx
	return idx
}

fn (mut b FlatBuilder) add_node(kind FlatNodeKind, data string, edges []FlatEdge) FlatNodeId {
	first_edge := b.flat.edges.len
	if edges.len > 0 {
		b.flat.edges << edges
	}
	node_id := FlatNodeId(b.flat.nodes.len)
	b.flat.nodes << FlatNode{
		kind:       kind
		data_idx:   if data.len > 0 { b.intern(data) } else { -1 }
		first_edge: first_edge
		edge_count: edges.len
	}
	return node_id
}

fn (mut b FlatBuilder) push_edge(mut edges []FlatEdge, child FlatNodeId) {
	if child == invalid_flat_node_id {
		return
	}
	edges << FlatEdge{
		child_id: child
	}
}

fn (mut b FlatBuilder) push_expr(mut edges []FlatEdge, expr Expr) {
	b.push_edge(mut edges, b.add_expr(expr))
}

fn (mut b FlatBuilder) push_stmt(mut edges []FlatEdge, stmt Stmt) {
	b.push_edge(mut edges, b.add_stmt(stmt))
}

fn (mut b FlatBuilder) push_type(mut edges []FlatEdge, typ Type) {
	b.push_edge(mut edges, b.add_type(typ))
}

fn (mut b FlatBuilder) push_attribute(mut edges []FlatEdge, attr Attribute) {
	b.push_edge(mut edges, b.add_attribute(attr))
}

fn (mut b FlatBuilder) push_field_init(mut edges []FlatEdge, field FieldInit) {
	b.push_edge(mut edges, b.add_field_init(field))
}

fn (mut b FlatBuilder) push_field_decl(mut edges []FlatEdge, field FieldDecl) {
	b.push_edge(mut edges, b.add_field_decl(field))
}

fn (mut b FlatBuilder) push_parameter(mut edges []FlatEdge, param Parameter) {
	b.push_edge(mut edges, b.add_parameter(param))
}

fn (mut b FlatBuilder) push_match_branch(mut edges []FlatEdge, branch MatchBranch) {
	b.push_edge(mut edges, b.add_match_branch(branch))
}

fn (mut b FlatBuilder) push_string_inter(mut edges []FlatEdge, inter StringInter) {
	b.push_edge(mut edges, b.add_string_inter(inter))
}

fn (mut b FlatBuilder) collect_children[T](node T, mut edges []FlatEdge) {
	$for field in T.fields {
		$if field.typ is Expr {
			b.push_expr(mut edges, node.$(field.name))
		} $else $if field.typ is []Expr {
			for child in node.$(field.name) {
				b.push_expr(mut edges, child)
			}
		} $else $if field.typ is Stmt {
			b.push_stmt(mut edges, node.$(field.name))
		} $else $if field.typ is []Stmt {
			for child in node.$(field.name) {
				b.push_stmt(mut edges, child)
			}
		} $else $if field.typ is Type {
			b.push_type(mut edges, node.$(field.name))
		} $else $if field.typ is []Type {
			for child in node.$(field.name) {
				b.push_type(mut edges, child)
			}
		} $else $if field.typ is Attribute {
			b.push_attribute(mut edges, node.$(field.name))
		} $else $if field.typ is []Attribute {
			for child in node.$(field.name) {
				b.push_attribute(mut edges, child)
			}
		} $else $if field.typ is FieldInit {
			b.push_field_init(mut edges, node.$(field.name))
		} $else $if field.typ is []FieldInit {
			for child in node.$(field.name) {
				b.push_field_init(mut edges, child)
			}
		} $else $if field.typ is FieldDecl {
			b.push_field_decl(mut edges, node.$(field.name))
		} $else $if field.typ is []FieldDecl {
			for child in node.$(field.name) {
				b.push_field_decl(mut edges, child)
			}
		} $else $if field.typ is Parameter {
			b.push_parameter(mut edges, node.$(field.name))
		} $else $if field.typ is []Parameter {
			for child in node.$(field.name) {
				b.push_parameter(mut edges, child)
			}
		} $else $if field.typ is MatchBranch {
			b.push_match_branch(mut edges, node.$(field.name))
		} $else $if field.typ is []MatchBranch {
			for child in node.$(field.name) {
				b.push_match_branch(mut edges, child)
			}
		} $else $if field.typ is StringInter {
			b.push_string_inter(mut edges, node.$(field.name))
		} $else $if field.typ is []StringInter {
			for child in node.$(field.name) {
				b.push_string_inter(mut edges, child)
			}
		} $else $if field.typ is Ident {
			b.push_expr(mut edges, Expr(node.$(field.name)))
		} $else $if field.typ is []Ident {
			for child in node.$(field.name) {
				b.push_expr(mut edges, Expr(child))
			}
		} $else $if field.typ is ImportStmt {
			b.push_stmt(mut edges, Stmt(node.$(field.name)))
		} $else $if field.typ is []ImportStmt {
			for child in node.$(field.name) {
				b.push_stmt(mut edges, Stmt(child))
			}
		} $else $if field.typ is AnonStructType {
			b.push_type(mut edges, Type(node.$(field.name)))
		} $else $if field.typ is ArrayFixedType {
			b.push_type(mut edges, Type(node.$(field.name)))
		} $else $if field.typ is ArrayType {
			b.push_type(mut edges, Type(node.$(field.name)))
		} $else $if field.typ is ChannelType {
			b.push_type(mut edges, Type(node.$(field.name)))
		} $else $if field.typ is FnType {
			b.push_type(mut edges, Type(node.$(field.name)))
		} $else $if field.typ is GenericType {
			b.push_type(mut edges, Type(node.$(field.name)))
		} $else $if field.typ is MapType {
			b.push_type(mut edges, Type(node.$(field.name)))
		} $else $if field.typ is NilType {
			b.push_type(mut edges, Type(node.$(field.name)))
		} $else $if field.typ is NoneType {
			b.push_type(mut edges, Type(node.$(field.name)))
		} $else $if field.typ is OptionType {
			b.push_type(mut edges, Type(node.$(field.name)))
		} $else $if field.typ is ResultType {
			b.push_type(mut edges, Type(node.$(field.name)))
		} $else $if field.typ is ThreadType {
			b.push_type(mut edges, Type(node.$(field.name)))
		} $else $if field.typ is TupleType {
			b.push_type(mut edges, Type(node.$(field.name)))
		}
	}
}

fn (mut b FlatBuilder) add_file(file File) FlatNodeId {
	mut edges := []FlatEdge{}
	for attr in file.attributes {
		b.push_attribute(mut edges, attr)
	}
	for imp in file.imports {
		b.push_stmt(mut edges, Stmt(imp))
	}
	for stmt in file.stmts {
		b.push_stmt(mut edges, stmt)
	}
	return b.add_node(.file, file.name, edges)
}

fn (mut b FlatBuilder) add_stmt(stmt Stmt) FlatNodeId {
	if stmt is []Attribute {
		mut edges := []FlatEdge{}
		for attr in stmt {
			b.push_attribute(mut edges, attr)
		}
		return b.add_node(.stmt_attributes, '', edges)
	}

	mut edges := []FlatEdge{}
	mut data := ''
	mut kind := FlatNodeKind.stmt_empty

	match stmt {
		AsmStmt {
			kind = .stmt_asm
			data = stmt.arch
		}
		AssertStmt {
			kind = .stmt_assert
			b.collect_children(stmt, mut edges)
		}
		AssignStmt {
			kind = .stmt_assign
			data = stmt.op.str()
			b.collect_children(stmt, mut edges)
		}
		BlockStmt {
			kind = .stmt_block
			b.collect_children(stmt, mut edges)
		}
		ComptimeStmt {
			kind = .stmt_comptime
			b.collect_children(stmt, mut edges)
		}
		ConstDecl {
			kind = .stmt_const_decl
			if stmt.is_public {
				data = 'pub'
			}
			b.collect_children(stmt, mut edges)
		}
		DeferStmt {
			kind = .stmt_defer
			data = stmt.mode.str()
			b.collect_children(stmt, mut edges)
		}
		Directive {
			kind = .stmt_directive
			data = '${stmt.name}:${stmt.value}'
		}
		EmptyStmt {
			kind = .stmt_empty
		}
		EnumDecl {
			kind = .stmt_enum_decl
			data = stmt.name
			if stmt.is_public {
				data = 'pub ${stmt.name}'
			}
			b.collect_children(stmt, mut edges)
		}
		ExprStmt {
			kind = .stmt_expr
			b.collect_children(stmt, mut edges)
		}
		FlowControlStmt {
			kind = .stmt_flow_control
			data = '${stmt.op.str()}:${stmt.label}'
		}
		FnDecl {
			kind = .stmt_fn_decl
			data = stmt.name
			if stmt.is_public {
				data = 'pub ${data}'
			}
			if stmt.is_method {
				data = 'method ${data}'
			}
			if stmt.is_static {
				data = 'static ${data}'
			}
			b.collect_children(stmt, mut edges)
		}
		ForInStmt {
			kind = .stmt_for_in
			b.collect_children(stmt, mut edges)
		}
		ForStmt {
			kind = .stmt_for
			b.collect_children(stmt, mut edges)
		}
		GlobalDecl {
			kind = .stmt_global_decl
			b.collect_children(stmt, mut edges)
		}
		ImportStmt {
			kind = .stmt_import
			data = if stmt.alias.len > 0 { '${stmt.name}:${stmt.alias}' } else { stmt.name }
			b.collect_children(stmt, mut edges)
		}
		InterfaceDecl {
			kind = .stmt_interface_decl
			data = stmt.name
			if stmt.is_public {
				data = 'pub ${stmt.name}'
			}
			b.collect_children(stmt, mut edges)
		}
		LabelStmt {
			kind = .stmt_label
			data = stmt.name
			b.collect_children(stmt, mut edges)
		}
		ModuleStmt {
			kind = .stmt_module
			data = stmt.name
		}
		ReturnStmt {
			kind = .stmt_return
			b.collect_children(stmt, mut edges)
		}
		StructDecl {
			kind = .stmt_struct_decl
			data = stmt.name
			if stmt.is_public {
				data = 'pub ${data}'
			}
			if stmt.is_union {
				data = 'union ${data}'
			}
			b.collect_children(stmt, mut edges)
		}
		TypeDecl {
			kind = .stmt_type_decl
			data = stmt.name
			if stmt.is_public {
				data = 'pub ${data}'
			}
			b.collect_children(stmt, mut edges)
		}
		[]Attribute {}
	}

	return b.add_node(kind, data, edges)
}

fn (mut b FlatBuilder) add_expr(expr Expr) FlatNodeId {
	match expr {
		Type {
			return b.add_type(expr)
		}
		FieldInit {
			return b.add_field_init(expr)
		}
		else {}
	}

	mut edges := []FlatEdge{}
	mut data := ''
	mut kind := FlatNodeKind.expr_empty

	match expr {
		ArrayInitExpr {
			kind = .expr_array_init
			b.collect_children(expr, mut edges)
		}
		AsCastExpr {
			kind = .expr_as_cast
			b.collect_children(expr, mut edges)
		}
		AssocExpr {
			kind = .expr_assoc
			b.collect_children(expr, mut edges)
		}
		BasicLiteral {
			kind = .expr_basic_literal
			data = '${expr.kind.str()}:${expr.value}'
		}
		CallExpr {
			kind = .expr_call
			b.collect_children(expr, mut edges)
		}
		CallOrCastExpr {
			kind = .expr_call_or_cast
			b.collect_children(expr, mut edges)
		}
		CastExpr {
			kind = .expr_cast
			b.collect_children(expr, mut edges)
		}
		ComptimeExpr {
			kind = .expr_comptime
			b.collect_children(expr, mut edges)
		}
		EmptyExpr {
			kind = .expr_empty
		}
		FnLiteral {
			kind = .expr_fn_literal
			b.collect_children(expr, mut edges)
		}
		GenericArgOrIndexExpr {
			kind = .expr_generic_arg_or_index
			b.collect_children(expr, mut edges)
		}
		GenericArgs {
			kind = .expr_generic_args
			b.collect_children(expr, mut edges)
		}
		Ident {
			kind = .expr_ident
			data = expr.name
		}
		IfExpr {
			kind = .expr_if
			b.collect_children(expr, mut edges)
		}
		IfGuardExpr {
			kind = .expr_if_guard
			b.collect_children(expr, mut edges)
		}
		IndexExpr {
			kind = .expr_index
			if expr.is_gated {
				data = 'gated'
			}
			b.collect_children(expr, mut edges)
		}
		InfixExpr {
			kind = .expr_infix
			data = expr.op.str()
			b.collect_children(expr, mut edges)
		}
		InitExpr {
			kind = .expr_init
			b.collect_children(expr, mut edges)
		}
		Keyword {
			kind = .expr_keyword
			data = expr.tok.str()
		}
		KeywordOperator {
			kind = .expr_keyword_operator
			data = expr.op.str()
			b.collect_children(expr, mut edges)
		}
		LambdaExpr {
			kind = .expr_lambda
			b.collect_children(expr, mut edges)
		}
		LockExpr {
			kind = .expr_lock
			b.collect_children(expr, mut edges)
		}
		MapInitExpr {
			kind = .expr_map_init
			b.collect_children(expr, mut edges)
		}
		MatchExpr {
			kind = .expr_match
			b.collect_children(expr, mut edges)
		}
		ModifierExpr {
			kind = .expr_modifier
			data = expr.kind.str()
			b.collect_children(expr, mut edges)
		}
		OrExpr {
			kind = .expr_or
			b.collect_children(expr, mut edges)
		}
		ParenExpr {
			kind = .expr_paren
			b.collect_children(expr, mut edges)
		}
		PostfixExpr {
			kind = .expr_postfix
			data = expr.op.str()
			b.collect_children(expr, mut edges)
		}
		PrefixExpr {
			kind = .expr_prefix
			data = expr.op.str()
			b.collect_children(expr, mut edges)
		}
		RangeExpr {
			kind = .expr_range
			data = expr.op.str()
			b.collect_children(expr, mut edges)
		}
		SelectExpr {
			kind = .expr_select
			b.collect_children(expr, mut edges)
		}
		SelectorExpr {
			kind = .expr_selector
			b.collect_children(expr, mut edges)
		}
		SqlExpr {
			kind = .expr_sql
			b.collect_children(expr, mut edges)
		}
		StringInterLiteral {
			kind = .expr_string_inter
			if expr.values.len > 0 {
				data = '${expr.values[0]}:${expr.values.len}'
			}
			b.collect_children(expr, mut edges)
		}
		StringLiteral {
			kind = .expr_string
			data = '${expr.kind.str()}:${expr.value}'
		}
		Tuple {
			kind = .expr_tuple
			b.collect_children(expr, mut edges)
		}
		Type {}
		UnsafeExpr {
			kind = .expr_unsafe
			b.collect_children(expr, mut edges)
		}
		FieldInit {}
	}

	return b.add_node(kind, data, edges)
}

fn (mut b FlatBuilder) add_type(typ Type) FlatNodeId {
	mut edges := []FlatEdge{}
	mut data := ''
	mut kind := FlatNodeKind.typ_nil

	match typ {
		AnonStructType {
			kind = .typ_anon_struct
			b.collect_children(typ, mut edges)
		}
		ArrayFixedType {
			kind = .typ_array_fixed
			b.collect_children(typ, mut edges)
		}
		ArrayType {
			kind = .typ_array
			b.collect_children(typ, mut edges)
		}
		ChannelType {
			kind = .typ_channel
			b.collect_children(typ, mut edges)
		}
		FnType {
			kind = .typ_fn
			b.collect_children(typ, mut edges)
		}
		GenericType {
			kind = .typ_generic
			data = typ.name.name()
			b.collect_children(typ, mut edges)
		}
		MapType {
			kind = .typ_map
			b.collect_children(typ, mut edges)
		}
		NilType {
			kind = .typ_nil
		}
		NoneType {
			kind = .typ_none
		}
		OptionType {
			kind = .typ_option
			b.collect_children(typ, mut edges)
		}
		ResultType {
			kind = .typ_result
			b.collect_children(typ, mut edges)
		}
		ThreadType {
			kind = .typ_thread
			b.collect_children(typ, mut edges)
		}
		TupleType {
			kind = .typ_tuple
			b.collect_children(typ, mut edges)
		}
	}

	return b.add_node(kind, data, edges)
}

fn (mut b FlatBuilder) add_attribute(attr Attribute) FlatNodeId {
	mut edges := []FlatEdge{}
	b.collect_children(attr, mut edges)
	return b.add_node(.aux_attribute, attr.name, edges)
}

fn (mut b FlatBuilder) add_field_init(field FieldInit) FlatNodeId {
	mut edges := []FlatEdge{}
	b.collect_children(field, mut edges)
	return b.add_node(.aux_field_init, field.name, edges)
}

fn (mut b FlatBuilder) add_field_decl(field FieldDecl) FlatNodeId {
	mut edges := []FlatEdge{}
	b.collect_children(field, mut edges)
	return b.add_node(.aux_field_decl, field.name, edges)
}

fn (mut b FlatBuilder) add_parameter(param Parameter) FlatNodeId {
	mut edges := []FlatEdge{}
	b.collect_children(param, mut edges)
	name := if param.is_mut { 'mut ${param.name}' } else { param.name }
	return b.add_node(.aux_parameter, name, edges)
}

fn (mut b FlatBuilder) add_match_branch(branch MatchBranch) FlatNodeId {
	mut edges := []FlatEdge{}
	b.collect_children(branch, mut edges)
	return b.add_node(.aux_match_branch, '', edges)
}

fn (mut b FlatBuilder) add_string_inter(inter StringInter) FlatNodeId {
	mut edges := []FlatEdge{}
	b.collect_children(inter, mut edges)
	data := '${inter.format.str()}:${inter.width}:${inter.precision}'
	return b.add_node(.aux_string_inter, data, edges)
}

struct LegacyAstWalker {
mut:
	stats LegacyAstStats
}

fn (mut w LegacyAstWalker) walk_files(files []File) {
	w.stats.files = files.len
	w.stats.node_bytes += u64(files.len) * u64(sizeof(File))
	w.add_array_storage(sizeof(File), files.len)
	for file in files {
		w.walk_file(file)
	}
	w.stats.bytes_estimate = w.stats.node_bytes + w.stats.array_bytes + w.stats.string_bytes
}

fn (mut w LegacyAstWalker) add_array_storage(elem_size u32, len int) {
	if len <= 0 || elem_size == 0 {
		return
	}
	w.stats.array_bytes += u64(elem_size) * u64(len)
}

fn (mut w LegacyAstWalker) add_string(s string) {
	w.stats.string_entries++
	w.stats.string_bytes += u64(s.len)
}

fn (mut w LegacyAstWalker) walk_file(file File) {
	w.scan_dynamic(file)
}

fn (mut w LegacyAstWalker) walk_stmt(stmt Stmt) {
	if stmt is []Attribute {
		w.add_array_storage(sizeof(Attribute), stmt.len)
		for attr in stmt {
			w.walk_attribute(attr)
		}
		return
	}
	w.stats.stmt_nodes++
	w.stats.node_bytes += u64(sizeof(Stmt))
	match stmt {
		AssignStmt {
			w.scan_dynamic(stmt)
		}
		AssertStmt {
			w.scan_dynamic(stmt)
		}
		AsmStmt {
			w.scan_dynamic(stmt)
		}
		BlockStmt {
			w.scan_dynamic(stmt)
		}
		ComptimeStmt {
			w.scan_dynamic(stmt)
		}
		ConstDecl {
			w.scan_dynamic(stmt)
		}
		DeferStmt {
			w.scan_dynamic(stmt)
		}
		Directive {
			w.scan_dynamic(stmt)
		}
		EmptyStmt {}
		EnumDecl {
			w.scan_dynamic(stmt)
		}
		ExprStmt {
			w.scan_dynamic(stmt)
		}
		FlowControlStmt {
			w.scan_dynamic(stmt)
		}
		FnDecl {
			w.scan_dynamic(stmt)
		}
		ForInStmt {
			w.scan_dynamic(stmt)
		}
		ForStmt {
			w.scan_dynamic(stmt)
		}
		GlobalDecl {
			w.scan_dynamic(stmt)
		}
		ImportStmt {
			w.scan_dynamic(stmt)
		}
		InterfaceDecl {
			w.scan_dynamic(stmt)
		}
		LabelStmt {
			w.scan_dynamic(stmt)
		}
		ModuleStmt {
			w.scan_dynamic(stmt)
		}
		ReturnStmt {
			w.scan_dynamic(stmt)
		}
		StructDecl {
			w.scan_dynamic(stmt)
		}
		TypeDecl {
			w.scan_dynamic(stmt)
		}
		[]Attribute {}
	}
}

fn (mut w LegacyAstWalker) walk_expr(expr Expr) {
	match expr {
		Type {
			w.walk_type(expr)
			return
		}
		FieldInit {
			w.walk_field_init(expr)
			return
		}
		else {}
	}
	w.stats.expr_nodes++
	w.stats.node_bytes += u64(sizeof(Expr))
	match expr {
		ArrayInitExpr {
			w.scan_dynamic(expr)
		}
		AsCastExpr {
			w.scan_dynamic(expr)
		}
		AssocExpr {
			w.scan_dynamic(expr)
		}
		BasicLiteral {
			w.scan_dynamic(expr)
		}
		CallExpr {
			w.scan_dynamic(expr)
		}
		CallOrCastExpr {
			w.scan_dynamic(expr)
		}
		CastExpr {
			w.scan_dynamic(expr)
		}
		ComptimeExpr {
			w.scan_dynamic(expr)
		}
		EmptyExpr {}
		FnLiteral {
			w.scan_dynamic(expr)
		}
		GenericArgOrIndexExpr {
			w.scan_dynamic(expr)
		}
		GenericArgs {
			w.scan_dynamic(expr)
		}
		Ident {
			w.scan_dynamic(expr)
		}
		IfExpr {
			w.scan_dynamic(expr)
		}
		IfGuardExpr {
			w.scan_dynamic(expr)
		}
		IndexExpr {
			w.scan_dynamic(expr)
		}
		InfixExpr {
			w.scan_dynamic(expr)
		}
		InitExpr {
			w.scan_dynamic(expr)
		}
		Keyword {}
		KeywordOperator {
			w.scan_dynamic(expr)
		}
		LambdaExpr {
			w.scan_dynamic(expr)
		}
		LockExpr {
			w.scan_dynamic(expr)
		}
		MapInitExpr {
			w.scan_dynamic(expr)
		}
		MatchExpr {
			w.scan_dynamic(expr)
		}
		ModifierExpr {
			w.scan_dynamic(expr)
		}
		OrExpr {
			w.scan_dynamic(expr)
		}
		ParenExpr {
			w.scan_dynamic(expr)
		}
		PostfixExpr {
			w.scan_dynamic(expr)
		}
		PrefixExpr {
			w.scan_dynamic(expr)
		}
		RangeExpr {
			w.scan_dynamic(expr)
		}
		SelectExpr {
			w.scan_dynamic(expr)
		}
		SelectorExpr {
			w.scan_dynamic(expr)
		}
		SqlExpr {
			w.scan_dynamic(expr)
		}
		StringInterLiteral {
			w.scan_dynamic(expr)
		}
		StringLiteral {
			w.scan_dynamic(expr)
		}
		Tuple {
			w.scan_dynamic(expr)
		}
		Type {}
		UnsafeExpr {
			w.scan_dynamic(expr)
		}
		FieldInit {}
	}
}

fn (mut w LegacyAstWalker) walk_type(typ Type) {
	w.stats.type_nodes++
	w.stats.node_bytes += u64(sizeof(Type))
	match typ {
		AnonStructType {
			w.scan_dynamic(typ)
		}
		ArrayFixedType {
			w.scan_dynamic(typ)
		}
		ArrayType {
			w.scan_dynamic(typ)
		}
		ChannelType {
			w.scan_dynamic(typ)
		}
		FnType {
			w.scan_dynamic(typ)
		}
		GenericType {
			w.scan_dynamic(typ)
		}
		MapType {
			w.scan_dynamic(typ)
		}
		NilType {}
		NoneType {}
		OptionType {
			w.scan_dynamic(typ)
		}
		ResultType {
			w.scan_dynamic(typ)
		}
		ThreadType {
			w.scan_dynamic(typ)
		}
		TupleType {
			w.scan_dynamic(typ)
		}
	}
}

fn (mut w LegacyAstWalker) walk_attribute(attr Attribute) {
	w.stats.aux_nodes++
	w.stats.node_bytes += u64(sizeof(Attribute))
	w.scan_dynamic(attr)
}

fn (mut w LegacyAstWalker) walk_field_init(field FieldInit) {
	w.stats.aux_nodes++
	w.stats.node_bytes += u64(sizeof(FieldInit))
	w.scan_dynamic(field)
}

fn (mut w LegacyAstWalker) walk_field_decl(field FieldDecl) {
	w.stats.aux_nodes++
	w.stats.node_bytes += u64(sizeof(FieldDecl))
	w.scan_dynamic(field)
}

fn (mut w LegacyAstWalker) walk_parameter(param Parameter) {
	w.stats.aux_nodes++
	w.stats.node_bytes += u64(sizeof(Parameter))
	w.scan_dynamic(param)
}

fn (mut w LegacyAstWalker) walk_match_branch(branch MatchBranch) {
	w.stats.aux_nodes++
	w.stats.node_bytes += u64(sizeof(MatchBranch))
	w.scan_dynamic(branch)
}

fn (mut w LegacyAstWalker) walk_string_inter(inter StringInter) {
	w.stats.aux_nodes++
	w.stats.node_bytes += u64(sizeof(StringInter))
	w.scan_dynamic(inter)
}

fn (mut w LegacyAstWalker) scan_dynamic[T](node T) {
	$for field in T.fields {
		$if field.typ is string {
			w.add_string(node.$(field.name))
		} $else $if field.typ is []string {
			arr := node.$(field.name)
			w.add_array_storage(sizeof(string), arr.len)
			for v in arr {
				w.add_string(v)
			}
		} $else $if field.typ is Expr {
			w.walk_expr(node.$(field.name))
		} $else $if field.typ is []Expr {
			arr := node.$(field.name)
			w.add_array_storage(sizeof(Expr), arr.len)
			for v in arr {
				w.walk_expr(v)
			}
		} $else $if field.typ is Stmt {
			w.walk_stmt(node.$(field.name))
		} $else $if field.typ is []Stmt {
			arr := node.$(field.name)
			w.add_array_storage(sizeof(Stmt), arr.len)
			for v in arr {
				w.walk_stmt(v)
			}
		} $else $if field.typ is Type {
			w.walk_type(node.$(field.name))
		} $else $if field.typ is []Type {
			arr := node.$(field.name)
			w.add_array_storage(sizeof(Type), arr.len)
			for v in arr {
				w.walk_type(v)
			}
		} $else $if field.typ is Attribute {
			w.walk_attribute(node.$(field.name))
		} $else $if field.typ is []Attribute {
			arr := node.$(field.name)
			w.add_array_storage(sizeof(Attribute), arr.len)
			for v in arr {
				w.walk_attribute(v)
			}
		} $else $if field.typ is FieldInit {
			w.walk_field_init(node.$(field.name))
		} $else $if field.typ is []FieldInit {
			arr := node.$(field.name)
			w.add_array_storage(sizeof(FieldInit), arr.len)
			for v in arr {
				w.walk_field_init(v)
			}
		} $else $if field.typ is FieldDecl {
			w.walk_field_decl(node.$(field.name))
		} $else $if field.typ is []FieldDecl {
			arr := node.$(field.name)
			w.add_array_storage(sizeof(FieldDecl), arr.len)
			for v in arr {
				w.walk_field_decl(v)
			}
		} $else $if field.typ is Parameter {
			w.walk_parameter(node.$(field.name))
		} $else $if field.typ is []Parameter {
			arr := node.$(field.name)
			w.add_array_storage(sizeof(Parameter), arr.len)
			for v in arr {
				w.walk_parameter(v)
			}
		} $else $if field.typ is MatchBranch {
			w.walk_match_branch(node.$(field.name))
		} $else $if field.typ is []MatchBranch {
			arr := node.$(field.name)
			w.add_array_storage(sizeof(MatchBranch), arr.len)
			for v in arr {
				w.walk_match_branch(v)
			}
		} $else $if field.typ is StringInter {
			w.walk_string_inter(node.$(field.name))
		} $else $if field.typ is []StringInter {
			arr := node.$(field.name)
			w.add_array_storage(sizeof(StringInter), arr.len)
			for v in arr {
				w.walk_string_inter(v)
			}
		} $else $if field.typ is Ident {
			w.walk_expr(Expr(node.$(field.name)))
		} $else $if field.typ is []Ident {
			arr := node.$(field.name)
			w.add_array_storage(sizeof(Ident), arr.len)
			for v in arr {
				w.walk_expr(Expr(v))
			}
		} $else $if field.typ is ImportStmt {
			w.walk_stmt(Stmt(node.$(field.name)))
		} $else $if field.typ is []ImportStmt {
			arr := node.$(field.name)
			w.add_array_storage(sizeof(ImportStmt), arr.len)
			for v in arr {
				w.walk_stmt(Stmt(v))
			}
		}
	}
}