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

import os
import v2.ast
import v2.parser
import v2.pref as vpref
import v2.token

fn should_expand_single_file_input(input string) bool {
	if os.file_name(input).ends_with('_test.v') {
		return true
	}
	module_name := file_module_name(input) or { return false }
	return module_name != 'main'
}

fn is_module_line_space(ch u8) bool {
	return ch == ` ` || ch == `\t` || ch == `\v` || ch == `\f`
}

fn is_module_source_space(ch u8) bool {
	return is_module_line_space(ch) || ch == `\n` || ch == `\r`
}

fn file_module_name(path string) ?string {
	content := os.read_file(path) or { return none }
	mut start := 0
	for start < content.len {
		if is_module_source_space(content[start]) {
			start++
			continue
		}
		if start + 1 < content.len && content[start] == `/` && content[start + 1] == `/` {
			start += 2
			for start < content.len && content[start] != `\n` && content[start] != `\r` {
				start++
			}
			continue
		}
		if start + 1 < content.len && content[start] == `/` && content[start + 1] == `*` {
			start += 2
			for start + 1 < content.len {
				if content[start] == `*` && content[start + 1] == `/` {
					start += 2
					break
				}
				start++
			}
			if start >= content.len {
				break
			}
			continue
		}
		break
	}
	if content.len - start >= 7 && content[start] == `m` && content[start + 1] == `o`
		&& content[start + 2] == `d` && content[start + 3] == `u` && content[start + 4] == `l`
		&& content[start + 5] == `e` && is_module_line_space(content[start + 6]) {
		mut name_start := start + 7
		for name_start < content.len && is_module_line_space(content[name_start]) {
			name_start++
		}
		mut name_end := name_start
		for name_end < content.len && !is_module_source_space(content[name_end]) {
			name_end++
		}
		if name_start < name_end {
			return content[name_start..name_end]
		}
		return none
	}
	return none
}

fn directory_primary_module(files []string) string {
	for file in files {
		if module_name := file_module_name(file) {
			return module_name
		}
	}
	return 'main'
}

fn collect_same_module_subdir_files(root string, dir string, module_name string, user_defines []string, target_os string, mut files []string, mut seen map[string]bool) {
	for entry in list_dir_entries(dir) {
		if entry == '' || entry.starts_with('.') {
			continue
		}
		path := os.join_path(dir, entry)
		if !os.is_dir(path) {
			continue
		}
		if path != root && os.exists(os.join_path(path, 'v.mod')) {
			continue
		}
		for file in get_v_files_from_dir(path, user_defines, target_os) {
			if file in seen {
				continue
			}
			if file_module_name(file) or { 'main' } != module_name {
				continue
			}
			files << file
			seen[file] = true
		}
		collect_same_module_subdir_files(root, path, module_name, user_defines, target_os, mut
			files, mut seen)
	}
}

fn get_user_v_files_from_dir(dir string, user_defines []string, target_os string) []string {
	mut files := get_v_files_from_dir(dir, user_defines, target_os)
	module_name := directory_primary_module(files)
	mut seen := map[string]bool{}
	for file in files {
		seen[file] = true
	}
	collect_same_module_subdir_files(dir, dir, module_name, user_defines, target_os, mut files, mut
		seen)
	return files
}

fn ast_comptime_flag_matches(name string, user_defines []string, target_os string) bool {
	lower_name := name.to_lower()
	match lower_name {
		'macos', 'darwin', 'mac', 'linux', 'windows', 'bsd', 'freebsd', 'openbsd', 'netbsd',
		'dragonfly', 'android', 'termux', 'ios', 'solaris', 'qnx', 'serenity', 'plan9', 'vinix',
		'none' {
			return flag_os_matches(lower_name, target_os)
		}
		'cross' {
			return flag_os_matches(lower_name, target_os) || lower_name in user_defines
		}
		'freestanding', 'bare' {
			return lower_name in user_defines
		}
		else {}
	}

	return lower_name in user_defines
}

fn ast_comptime_cond_matches(cond ast.Expr, user_defines []string, target_os string) bool {
	return ast_comptime_cond_matches_with_explicit(cond, user_defines, user_defines, target_os)
}

fn ast_comptime_cond_matches_with_explicit(cond ast.Expr, user_defines []string, explicit_user_defines []string, target_os string) bool {
	return ast_comptime_cond_matches_with_options(cond, user_defines, explicit_user_defines,
		target_os, true)
}

fn ast_comptime_cond_matches_with_options(cond ast.Expr, user_defines []string, explicit_user_defines []string, target_os string, allow_pkgconfig bool) bool {
	match cond {
		ast.Ident {
			return ast_comptime_flag_matches(cond.name, user_defines, target_os)
		}
		ast.ComptimeExpr {
			return ast_comptime_cond_matches_with_options(cond.expr, user_defines,
				explicit_user_defines, target_os, allow_pkgconfig)
		}
		ast.CallExpr {
			if pkg_name := ast_pkgconfig_call_name(cond) {
				if !allow_pkgconfig {
					return false
				}
				return vpref.comptime_pkgconfig_value(pkg_name)
			}
		}
		ast.CallOrCastExpr {
			if pkg_name := ast_pkgconfig_call_name(cond) {
				if !allow_pkgconfig {
					return false
				}
				return vpref.comptime_pkgconfig_value(pkg_name)
			}
		}
		ast.PrefixExpr {
			if cond.op == .not {
				return !ast_comptime_cond_matches_with_options(cond.expr, user_defines,
					explicit_user_defines, target_os, allow_pkgconfig)
			}
		}
		ast.InfixExpr {
			if cond.op == .and {
				return
					ast_comptime_cond_matches_with_options(cond.lhs, user_defines, explicit_user_defines, target_os, allow_pkgconfig)
					&& ast_comptime_cond_matches_with_options(cond.rhs, user_defines, explicit_user_defines, target_os, allow_pkgconfig)
			}
			if cond.op == .logical_or {
				return
					ast_comptime_cond_matches_with_options(cond.lhs, user_defines, explicit_user_defines, target_os, allow_pkgconfig)
					|| ast_comptime_cond_matches_with_options(cond.rhs, user_defines, explicit_user_defines, target_os, allow_pkgconfig)
			}
		}
		ast.PostfixExpr {
			if cond.op == .question && cond.expr is ast.Ident {
				return vpref.comptime_optional_define_value(cond.expr.name, user_defines,
					explicit_user_defines)
			}
		}
		ast.ParenExpr {
			return ast_comptime_cond_matches_with_options(cond.expr, user_defines,
				explicit_user_defines, target_os, allow_pkgconfig)
		}
		else {}
	}

	return false
}

fn ast_pkgconfig_call_name(expr ast.Expr) ?string {
	match expr {
		ast.CallExpr {
			if expr.lhs is ast.Ident && expr.lhs.name == 'pkgconfig' && expr.args.len == 1 {
				return ast_string_literal_value(expr.args[0])
			}
		}
		ast.CallOrCastExpr {
			if expr.lhs is ast.Ident && expr.lhs.name == 'pkgconfig' {
				return ast_string_literal_value(expr.expr)
			}
		}
		else {}
	}

	return none
}

fn ast_string_literal_value(expr ast.Expr) ?string {
	if expr is ast.StringLiteral {
		return unquote_ast_string_literal_value(expr.value)
	}
	return none
}

fn unquote_ast_string_literal_value(value string) string {
	if value.len >= 2 && ((value[0] == `"` && value[value.len - 1] == `"`)
		|| (value[0] == `'` && value[value.len - 1] == `'`)) {
		return value[1..value.len - 1]
	}
	return value
}

fn collect_active_imports_from_if_expr(node ast.IfExpr, user_defines []string, target_os string, mut imports []ast.ImportStmt) {
	collect_active_imports_from_if_expr_with_explicit(node, user_defines, user_defines, target_os, mut
		imports)
}

fn collect_active_imports_from_if_expr_with_explicit(node ast.IfExpr, user_defines []string, explicit_user_defines []string, target_os string, mut imports []ast.ImportStmt) {
	collect_active_imports_from_if_expr_with_options(node, user_defines, explicit_user_defines,
		target_os, true, mut imports)
}

fn collect_active_imports_from_if_expr_with_options(node ast.IfExpr, user_defines []string, explicit_user_defines []string, target_os string, allow_pkgconfig bool, mut imports []ast.ImportStmt) {
	if ast_comptime_cond_matches_with_options(node.cond, user_defines, explicit_user_defines,
		target_os, allow_pkgconfig)
	{
		collect_active_imports_from_stmts_with_options(node.stmts, user_defines,
			explicit_user_defines, target_os, allow_pkgconfig, mut imports)
		return
	}
	match node.else_expr {
		ast.IfExpr {
			if node.else_expr.cond is ast.EmptyExpr {
				collect_active_imports_from_stmts_with_options(node.else_expr.stmts, user_defines,
					explicit_user_defines, target_os, allow_pkgconfig, mut imports)
			} else {
				collect_active_imports_from_if_expr_with_options(node.else_expr, user_defines,
					explicit_user_defines, target_os, allow_pkgconfig, mut imports)
			}
		}
		else {}
	}
}

fn collect_active_imports_from_stmts(stmts []ast.Stmt, user_defines []string, target_os string, mut imports []ast.ImportStmt) {
	collect_active_imports_from_stmts_with_explicit(stmts, user_defines, user_defines, target_os, mut
		imports)
}

fn collect_active_imports_from_stmts_with_explicit(stmts []ast.Stmt, user_defines []string, explicit_user_defines []string, target_os string, mut imports []ast.ImportStmt) {
	collect_active_imports_from_stmts_with_options(stmts, user_defines, explicit_user_defines,
		target_os, true, mut imports)
}

fn collect_active_imports_from_stmts_with_options(stmts []ast.Stmt, user_defines []string, explicit_user_defines []string, target_os string, allow_pkgconfig bool, mut imports []ast.ImportStmt) {
	for stmt in stmts {
		match stmt {
			ast.ImportStmt {
				imports << stmt
			}
			ast.ExprStmt {
				if stmt.expr is ast.ComptimeExpr && stmt.expr.expr is ast.IfExpr {
					collect_active_imports_from_if_expr_with_options(stmt.expr.expr, user_defines,
						explicit_user_defines, target_os, allow_pkgconfig, mut imports)
				}
			}
			else {}
		}
	}
}

fn imports_contain(imports []ast.ImportStmt, name string) bool {
	for imp in imports {
		if imp.name == name {
			return true
		}
	}
	return false
}

fn add_implicit_sync_import_if_needed(mut imports []ast.ImportStmt, current_module string, uses_channel bool) {
	if !uses_channel || current_module == 'sync' || imports_contain(imports, 'sync') {
		return
	}
	imports << ast.ImportStmt{
		name: 'sync'
	}
}

fn field_decl_uses_channel(field ast.FieldDecl) bool {
	return type_expr_uses_channel(field.typ) || expr_type_slots_use_channel(field.value)
}

fn fields_use_channel(fields []ast.FieldDecl) bool {
	for field in fields {
		if field_decl_uses_channel(field) {
			return true
		}
	}
	return false
}

struct ChannelScanOptions {
	user_defines          []string
	explicit_user_defines []string
	target_os             string
	allow_pkgconfig       bool
	filter_comptime       bool
}

fn field_inits_use_channel(fields []ast.FieldInit) bool {
	return field_inits_use_channel_with_options(fields, ChannelScanOptions{
		allow_pkgconfig: true
	})
}

fn field_inits_use_channel_with_options(fields []ast.FieldInit, options ChannelScanOptions) bool {
	for field in fields {
		if expr_type_slots_use_channel_with_options(field.value, options) {
			return true
		}
	}
	return false
}

fn fn_type_uses_channel(typ ast.FnType) bool {
	for gp in typ.generic_params {
		if type_expr_uses_channel(gp) {
			return true
		}
	}
	for param in typ.params {
		if type_expr_uses_channel(param.typ) {
			return true
		}
	}
	return type_expr_uses_channel(typ.return_type)
}

fn stmts_use_channel(stmts []ast.Stmt) bool {
	return stmts_use_channel_with_options(stmts, ChannelScanOptions{
		allow_pkgconfig: true
	})
}

fn stmts_use_channel_with_options(stmts []ast.Stmt, options ChannelScanOptions) bool {
	for stmt in stmts {
		if stmt_uses_channel_with_options(stmt, options) {
			return true
		}
	}
	return false
}

fn stmt_uses_channel(stmt ast.Stmt) bool {
	return stmt_uses_channel_with_options(stmt, ChannelScanOptions{
		allow_pkgconfig: true
	})
}

fn fn_decl_body_is_active_for_channel_scan(decl ast.FnDecl, options ChannelScanOptions) bool {
	for attr in decl.attributes {
		if attr.comptime_cond is ast.EmptyExpr {
			continue
		}
		if !ast_comptime_cond_matches_with_options(attr.comptime_cond, options.user_defines,
			options.explicit_user_defines, options.target_os, options.allow_pkgconfig) {
			return false
		}
	}
	return true
}

fn stmt_uses_channel_with_options(stmt ast.Stmt, options ChannelScanOptions) bool {
	match stmt {
		ast.AssertStmt {
			return expr_type_slots_use_channel_with_options(stmt.expr, options)
				|| expr_type_slots_use_channel_with_options(stmt.extra, options)
		}
		ast.AssignStmt {
			return exprs_type_slots_use_channel_with_options(stmt.lhs, options)
				|| exprs_type_slots_use_channel_with_options(stmt.rhs, options)
		}
		ast.BlockStmt {
			return stmts_use_channel_with_options(stmt.stmts, options)
		}
		ast.ComptimeStmt {
			return stmt_uses_channel_with_options(stmt.stmt, options)
		}
		ast.ConstDecl {
			return field_inits_use_channel_with_options(stmt.fields, options)
		}
		ast.DeferStmt {
			return stmts_use_channel_with_options(stmt.stmts, options)
		}
		ast.EnumDecl {
			for field in stmt.fields {
				if expr_type_slots_use_channel_with_options(field.value, options) {
					return true
				}
			}
		}
		ast.ExprStmt {
			if options.filter_comptime && stmt.expr is ast.ComptimeExpr
				&& stmt.expr.expr is ast.IfExpr {
				return comptime_if_expr_uses_channel_with_options(stmt.expr.expr, options)
			}
			return expr_type_slots_use_channel_with_options(stmt.expr, options)
		}
		ast.FnDecl {
			signature_uses_channel := type_expr_uses_channel(stmt.receiver.typ)
				|| fn_type_uses_channel(stmt.typ)
			if !fn_decl_body_is_active_for_channel_scan(stmt, options) {
				return signature_uses_channel
			}
			return signature_uses_channel || stmts_use_channel_with_options(stmt.stmts, options)
		}
		ast.ForInStmt {
			return expr_type_slots_use_channel_with_options(stmt.expr, options)
		}
		ast.ForStmt {
			return stmt_uses_channel_with_options(stmt.init, options)
				|| expr_type_slots_use_channel_with_options(stmt.cond, options)
				|| stmt_uses_channel_with_options(stmt.post, options)
				|| stmts_use_channel_with_options(stmt.stmts, options)
		}
		ast.GlobalDecl {
			return fields_use_channel(stmt.fields)
		}
		ast.InterfaceDecl {
			return fields_use_channel(stmt.fields) || type_exprs_use_channel(stmt.embedded)
		}
		ast.LabelStmt {
			return stmt_uses_channel_with_options(stmt.stmt, options)
		}
		ast.ReturnStmt {
			return exprs_type_slots_use_channel_with_options(stmt.exprs, options)
		}
		ast.StructDecl {
			return type_exprs_use_channel(stmt.implements) || type_exprs_use_channel(stmt.embedded)
				|| type_exprs_use_channel(stmt.generic_params) || fields_use_channel(stmt.fields)
		}
		ast.TypeDecl {
			return type_expr_uses_channel(stmt.base_type) || type_exprs_use_channel(stmt.variants)
				|| type_exprs_use_channel(stmt.generic_params)
		}
		else {}
	}

	return false
}

fn type_exprs_use_channel(exprs []ast.Expr) bool {
	for expr in exprs {
		if type_expr_uses_channel(expr) {
			return true
		}
	}
	return false
}

fn exprs_type_slots_use_channel(exprs []ast.Expr) bool {
	return exprs_type_slots_use_channel_with_options(exprs, ChannelScanOptions{
		allow_pkgconfig: true
	})
}

fn exprs_type_slots_use_channel_with_options(exprs []ast.Expr, options ChannelScanOptions) bool {
	for expr in exprs {
		if expr_type_slots_use_channel_with_options(expr, options) {
			return true
		}
	}
	return false
}

fn string_inters_use_channel(inters []ast.StringInter) bool {
	return string_inters_use_channel_with_options(inters, ChannelScanOptions{
		allow_pkgconfig: true
	})
}

fn string_inters_use_channel_with_options(inters []ast.StringInter, options ChannelScanOptions) bool {
	for inter in inters {
		if expr_type_slots_use_channel_with_options(inter.expr, options)
			|| expr_type_slots_use_channel_with_options(inter.format_expr, options) {
			return true
		}
	}
	return false
}

fn comptime_if_expr_uses_channel_with_options(node ast.IfExpr, options ChannelScanOptions) bool {
	if ast_comptime_cond_matches_with_options(node.cond, options.user_defines,
		options.explicit_user_defines, options.target_os, options.allow_pkgconfig)
	{
		return stmts_use_channel_with_options(node.stmts, options)
	}
	match node.else_expr {
		ast.IfExpr {
			if node.else_expr.cond is ast.EmptyExpr {
				return stmts_use_channel_with_options(node.else_expr.stmts, options)
			}
			return comptime_if_expr_uses_channel_with_options(node.else_expr, options)
		}
		else {
			return expr_type_slots_use_channel_with_options(node.else_expr, options)
		}
	}
}

fn expr_type_slots_use_channel(expr ast.Expr) bool {
	return expr_type_slots_use_channel_with_options(expr, ChannelScanOptions{
		allow_pkgconfig: true
	})
}

fn expr_type_slots_use_channel_with_options(expr ast.Expr, options ChannelScanOptions) bool {
	match expr {
		ast.ArrayInitExpr {
			return type_expr_uses_channel(expr.typ)
				|| expr_type_slots_use_channel_with_options(expr.init, options)
				|| exprs_type_slots_use_channel_with_options(expr.exprs, options)
				|| expr_type_slots_use_channel_with_options(expr.cap, options)
				|| expr_type_slots_use_channel_with_options(expr.len, options)
				|| expr_type_slots_use_channel_with_options(expr.update_expr, options)
		}
		ast.AsCastExpr {
			return type_expr_uses_channel(expr.typ)
				|| expr_type_slots_use_channel_with_options(expr.expr, options)
		}
		ast.AssocExpr {
			return type_expr_uses_channel(expr.typ)
				|| expr_type_slots_use_channel_with_options(expr.expr, options)
				|| field_inits_use_channel_with_options(expr.fields, options)
		}
		ast.CallExpr {
			return expr_type_slots_use_channel_with_options(expr.lhs, options)
				|| exprs_type_slots_use_channel_with_options(expr.args, options)
		}
		ast.CallOrCastExpr {
			return type_expr_uses_channel(expr.lhs)
				|| expr_type_slots_use_channel_with_options(expr.expr, options)
		}
		ast.CastExpr {
			return type_expr_uses_channel(expr.typ)
				|| expr_type_slots_use_channel_with_options(expr.expr, options)
		}
		ast.ComptimeExpr {
			if options.filter_comptime && expr.expr is ast.IfExpr {
				return comptime_if_expr_uses_channel_with_options(expr.expr, options)
			}
			return expr_type_slots_use_channel_with_options(expr.expr, options)
		}
		ast.FieldInit {
			return expr_type_slots_use_channel_with_options(expr.value, options)
		}
		ast.FnLiteral {
			return fn_type_uses_channel(expr.typ)
				|| stmts_use_channel_with_options(expr.stmts, options)
		}
		ast.GenericArgOrIndexExpr {
			return type_expr_uses_channel(expr.lhs) || type_expr_uses_channel(expr.expr)
		}
		ast.GenericArgs {
			return type_expr_uses_channel(expr.lhs) || type_exprs_use_channel(expr.args)
		}
		ast.IfExpr {
			return expr_type_slots_use_channel_with_options(expr.cond, options)
				|| stmts_use_channel_with_options(expr.stmts, options)
				|| expr_type_slots_use_channel_with_options(expr.else_expr, options)
		}
		ast.IfGuardExpr {
			return stmt_uses_channel_with_options(ast.Stmt(expr.stmt), options)
		}
		ast.IndexExpr {
			return expr_type_slots_use_channel_with_options(expr.lhs, options)
				|| expr_type_slots_use_channel_with_options(expr.expr, options)
		}
		ast.InfixExpr {
			return expr_type_slots_use_channel_with_options(expr.lhs, options)
				|| expr_type_slots_use_channel_with_options(expr.rhs, options)
		}
		ast.InitExpr {
			return type_expr_uses_channel(expr.typ)
				|| field_inits_use_channel_with_options(expr.fields, options)
		}
		ast.KeywordOperator {
			return exprs_type_slots_use_channel_with_options(expr.exprs, options)
		}
		ast.LambdaExpr {
			return expr_type_slots_use_channel_with_options(expr.expr, options)
		}
		ast.ModifierExpr {
			return expr_type_slots_use_channel_with_options(expr.expr, options)
		}
		ast.LockExpr {
			return exprs_type_slots_use_channel_with_options(expr.lock_exprs, options)
				|| exprs_type_slots_use_channel_with_options(expr.rlock_exprs, options)
				|| stmts_use_channel_with_options(expr.stmts, options)
		}
		ast.MapInitExpr {
			return type_expr_uses_channel(expr.typ)
				|| exprs_type_slots_use_channel_with_options(expr.keys, options)
				|| exprs_type_slots_use_channel_with_options(expr.vals, options)
		}
		ast.MatchExpr {
			if expr_type_slots_use_channel_with_options(expr.expr, options) {
				return true
			}
			for branch in expr.branches {
				if exprs_type_slots_use_channel_with_options(branch.cond, options)
					|| stmts_use_channel_with_options(branch.stmts, options) {
					return true
				}
			}
		}
		ast.OrExpr {
			return expr_type_slots_use_channel_with_options(expr.expr, options)
				|| stmts_use_channel_with_options(expr.stmts, options)
		}
		ast.ParenExpr {
			return expr_type_slots_use_channel_with_options(expr.expr, options)
		}
		ast.PostfixExpr {
			return expr_type_slots_use_channel_with_options(expr.expr, options)
		}
		ast.PrefixExpr {
			return expr_type_slots_use_channel_with_options(expr.expr, options)
		}
		ast.RangeExpr {
			return expr_type_slots_use_channel_with_options(expr.start, options)
				|| expr_type_slots_use_channel_with_options(expr.end, options)
		}
		ast.SelectExpr {
			return stmt_uses_channel_with_options(expr.stmt, options)
				|| stmts_use_channel_with_options(expr.stmts, options)
				|| expr_type_slots_use_channel_with_options(expr.next, options)
		}
		ast.SelectorExpr {
			return expr_type_slots_use_channel_with_options(expr.lhs, options)
		}
		ast.SqlExpr {
			return expr_type_slots_use_channel_with_options(expr.expr, options)
		}
		ast.StringInterLiteral {
			return string_inters_use_channel_with_options(expr.inters, options)
		}
		ast.Tuple {
			return exprs_type_slots_use_channel_with_options(expr.exprs, options)
		}
		ast.UnsafeExpr {
			return stmts_use_channel_with_options(expr.stmts, options)
		}
		ast.Type {
			return type_expr_uses_channel(expr)
		}
		else {}
	}

	return false
}

fn type_expr_uses_channel(expr ast.Expr) bool {
	match expr {
		ast.Type {
			match expr {
				ast.ChannelType {
					return true
				}
				ast.ArrayType {
					return type_expr_uses_channel(expr.elem_type)
				}
				ast.ArrayFixedType {
					return type_expr_uses_channel(expr.elem_type)
				}
				ast.FnType {
					return fn_type_uses_channel(expr)
				}
				ast.GenericType {
					return type_expr_uses_channel(expr.name) || type_exprs_use_channel(expr.params)
				}
				ast.MapType {
					return type_expr_uses_channel(expr.key_type)
						|| type_expr_uses_channel(expr.value_type)
				}
				ast.OptionType {
					return type_expr_uses_channel(expr.base_type)
				}
				ast.PointerType {
					return type_expr_uses_channel(expr.base_type)
				}
				ast.ResultType {
					return type_expr_uses_channel(expr.base_type)
				}
				ast.ThreadType {
					return type_expr_uses_channel(expr.elem_type)
				}
				ast.TupleType {
					return type_exprs_use_channel(expr.types)
				}
				ast.AnonStructType {
					return type_exprs_use_channel(expr.generic_params)
						|| type_exprs_use_channel(expr.embedded) || fields_use_channel(expr.fields)
				}
				else {}
			}
		}
		else {}
	}

	return false
}

fn active_file_imports(file ast.File, user_defines []string, target_os string) []ast.ImportStmt {
	return active_file_imports_with_explicit(file, user_defines, user_defines, target_os)
}

fn active_file_imports_with_explicit(file ast.File, user_defines []string, explicit_user_defines []string, target_os string) []ast.ImportStmt {
	return active_file_imports_with_options(file, user_defines, explicit_user_defines, target_os,
		true)
}

fn active_file_imports_with_options(file ast.File, user_defines []string, explicit_user_defines []string, target_os string, allow_pkgconfig bool) []ast.ImportStmt {
	mut imports := file.imports.clone()
	collect_active_imports_from_stmts_with_options(file.stmts, user_defines, explicit_user_defines,
		target_os, allow_pkgconfig, mut imports)
	add_implicit_sync_import_if_needed(mut imports, file.mod, stmts_use_channel_with_options(file.stmts, ChannelScanOptions{
		user_defines:          user_defines
		explicit_user_defines: explicit_user_defines
		target_os:             target_os
		allow_pkgconfig:       allow_pkgconfig
		filter_comptime:       true
	}))
	return imports
}

// active_file_imports_from_flat mirrors active_file_imports but reads the
// import list and top-level stmts straight from the FlatAst, so import
// discovery can run without rehydrating an ast.File.
fn active_file_imports_from_flat(flat &ast.FlatAst, ff ast.FlatFile, user_defines []string, explicit_user_defines []string, target_os string) []ast.ImportStmt {
	return active_file_imports_from_flat_with_options(flat, ff, user_defines,
		explicit_user_defines, target_os, true)
}

fn active_file_imports_from_flat_with_options(flat &ast.FlatAst, ff ast.FlatFile, user_defines []string, explicit_user_defines []string, target_os string, allow_pkgconfig bool) []ast.ImportStmt {
	// s253: walk the FlatAst via cursors instead of rehydrating the whole file to
	// legacy ast.Stmt with a top-level decode. The decode-then-walk path (a) costs a
	// full legacy-AST materialisation per file just to answer "does this file use a
	// channel / which comptime imports are active?", and (b) crashes on the arm64
	// self-host — the legacy `*_use_channel` walkers pass `[]Expr`/sum types by
	// value through deep recursion over decoded nodes, hitting the arm64
	// chained-access bug. Cursor reads are plain int-array lookups, so the walk is
	// cheap and arm64-safe; only the tiny comptime-condition sub-exprs are decoded
	// (reusing the exact legacy evaluator) so semantics match the AST path.
	mut imports := ast.Cursor{
		flat: unsafe { flat }
		id:   ff.file_id
	}.list_at(1).import_stmts()
	options := ChannelScanOptions{
		user_defines:          user_defines
		explicit_user_defines: explicit_user_defines
		target_os:             target_os
		allow_pkgconfig:       allow_pkgconfig
		filter_comptime:       true
	}
	file_node := ast.Cursor{
		flat: unsafe { flat }
		id:   ff.file_id
	}
	stmts := file_node.list_at(2) // file node edge 2 = top-level statement list
	flat_collect_active_imports(stmts, options, mut imports)
	module_name := if ff.mod_idx >= 0 && ff.mod_idx < flat.strings.len {
		flat.strings[ff.mod_idx]
	} else {
		'main'
	}
	add_implicit_sync_import_if_needed(mut imports, module_name, flat_stmts_use_channel(stmts,
		options))
	return imports
}

// flat_collect_active_imports is the cursor-native mirror of
// `collect_active_imports_from_stmts_with_options`: it appends top-level
// `import` statements and the imports of active comptime `$if` branches.
fn flat_collect_active_imports(stmts ast.CursorList, options ChannelScanOptions, mut imports []ast.ImportStmt) {
	for i in 0 .. stmts.len() {
		flat_collect_active_imports_stmt(stmts.at(i), options, mut imports)
	}
}

fn flat_collect_active_imports_stmt(s ast.Cursor, options ChannelScanOptions, mut imports []ast.ImportStmt) {
	match s.kind() {
		.stmt_import {
			imports << s.import_stmt()
		}
		.stmt_expr {
			inner := s.edge(0)
			if inner.kind() == .expr_comptime {
				cif := inner.edge(0)
				if cif.kind() == .expr_if {
					flat_collect_active_imports_from_if(cif, options, mut imports)
				}
			}
		}
		else {}
	}
}

// flat_collect_active_imports_from_if mirrors
// `collect_active_imports_from_if_expr_with_options`. expr_if layout:
// edge0 = cond, edge1 = else_expr, edge2.. = then-branch statements.
fn flat_collect_active_imports_from_if(if_c ast.Cursor, options ChannelScanOptions, mut imports []ast.ImportStmt) {
	if flat_comptime_cond_matches(if_c.edge(0), options) {
		for i in 2 .. if_c.edge_count() {
			flat_collect_active_imports_stmt(if_c.edge(i), options, mut imports)
		}
		return
	}
	else_c := if_c.edge(1)
	if else_c.kind() == .expr_if {
		if else_c.edge(0).kind() == .expr_empty {
			for i in 2 .. else_c.edge_count() {
				flat_collect_active_imports_stmt(else_c.edge(i), options, mut imports)
			}
		} else {
			flat_collect_active_imports_from_if(else_c, options, mut imports)
		}
	}
}

// flat_stmts_use_channel is the cursor-native mirror of
// `stmts_use_channel_with_options`.
fn flat_stmts_use_channel(stmts ast.CursorList, options ChannelScanOptions) bool {
	for i in 0 .. stmts.len() {
		if flat_node_uses_channel(stmts.at(i), options) {
			return true
		}
	}
	return false
}

// flat_node_uses_channel returns true if the active subtree rooted at `c`
// references a channel type. Channel types are always encoded as `.typ_channel`
// nodes, so a generic structural recursion over every edge finds them without
// per-kind edge knowledge (aux_list nodes are transparent — their edges are the
// list items). Two arms must prune to match the legacy scan's comptime
// filtering: a FnDecl body is scanned only when its comptime attributes keep it
// active, and a comptime `$if` (ComptimeExpr wrapping an IfExpr) scans only the
// branch selected by the condition.
fn flat_node_uses_channel(c ast.Cursor, options ChannelScanOptions) bool {
	if !c.is_valid() {
		return false
	}
	k := c.kind()
	if k == .typ_channel {
		return true
	}
	if k == .stmt_fn_decl {
		// stmt_fn_decl layout: edge0 = receiver, edge1 = fn type, edge2 = attrs,
		// edge3 = body. Signature (receiver + fn type) is always active; the body
		// only when comptime-active. Attributes never hold a channel type (matches
		// the legacy FnDecl arm, which scans only receiver.typ + fn_type + body).
		if flat_node_uses_channel(c.edge(0), options) {
			return true
		}
		if flat_node_uses_channel(c.edge(1), options) {
			return true
		}
		if flat_fn_decl_body_active_for_channel_scan(c, options) {
			return flat_node_uses_channel(c.edge(3), options)
		}
		return false
	}
	if k == .expr_comptime && options.filter_comptime {
		inner := c.edge(0)
		if inner.kind() == .expr_if {
			return flat_comptime_if_uses_channel(inner, options)
		}
		return flat_node_uses_channel(inner, options)
	}
	for i in 0 .. c.edge_count() {
		if flat_node_uses_channel(c.edge(i), options) {
			return true
		}
	}
	return false
}

// flat_comptime_if_uses_channel mirrors
// `comptime_if_expr_uses_channel_with_options`: only the branch selected by the
// comptime condition is scanned for channel usage.
fn flat_comptime_if_uses_channel(if_c ast.Cursor, options ChannelScanOptions) bool {
	if flat_comptime_cond_matches(if_c.edge(0), options) {
		for i in 2 .. if_c.edge_count() {
			if flat_node_uses_channel(if_c.edge(i), options) {
				return true
			}
		}
		return false
	}
	else_c := if_c.edge(1)
	if else_c.kind() == .expr_if {
		if else_c.edge(0).kind() == .expr_empty {
			for i in 2 .. else_c.edge_count() {
				if flat_node_uses_channel(else_c.edge(i), options) {
					return true
				}
			}
			return false
		}
		return flat_comptime_if_uses_channel(else_c, options)
	}
	return flat_node_uses_channel(else_c, options)
}

// flat_fn_decl_body_active_for_channel_scan mirrors
// `fn_decl_body_is_active_for_channel_scan`: a FnDecl whose comptime attributes
// (`@[if ...]`) don't match the current target is inactive, so its body is
// skipped. aux_attribute layout: edge0 = value, edge1 = comptime_cond.
fn flat_fn_decl_body_active_for_channel_scan(fn_c ast.Cursor, options ChannelScanOptions) bool {
	attrs := fn_c.list_at(2)
	for i in 0 .. attrs.len() {
		cond := attrs.at(i).edge(1)
		if !cond.is_valid() || cond.kind() == .expr_empty {
			continue
		}
		if !flat_comptime_cond_matches(cond, options) {
			return false
		}
	}
	return true
}

// flat_comptime_cond_matches evaluates a comptime condition from FlatAst
// cursors. Call/pkgconfig conditions still fall back to the legacy expression
// evaluator until call argument cursors are ported.
fn flat_comptime_cond_matches(cond ast.Cursor, options ChannelScanOptions) bool {
	if !cond.is_valid() {
		return false
	}
	match cond.kind() {
		.expr_ident {
			return ast_comptime_flag_matches(cond.name(), options.user_defines, options.target_os)
		}
		.expr_comptime, .expr_paren {
			return flat_comptime_cond_matches(cond.edge(0), options)
		}
		.expr_prefix {
			op := unsafe { token.Token(int(cond.aux())) }
			if op == .not {
				return !flat_comptime_cond_matches(cond.edge(0), options)
			}
		}
		.expr_infix {
			op := unsafe { token.Token(int(cond.aux())) }
			if op == .and {
				return flat_comptime_cond_matches(cond.edge(0), options)
					&& flat_comptime_cond_matches(cond.edge(1), options)
			}
			if op == .logical_or {
				return flat_comptime_cond_matches(cond.edge(0), options)
					|| flat_comptime_cond_matches(cond.edge(1), options)
			}
		}
		.expr_postfix {
			op := unsafe { token.Token(int(cond.aux())) }
			inner := cond.edge(0)
			if op == .question && inner.kind() == .expr_ident {
				return vpref.comptime_optional_define_value(inner.name(), options.user_defines,
					options.explicit_user_defines)
			}
		}
		.expr_call, .expr_call_or_cast {
			if pkg_name := flat_pkgconfig_call_name(cond) {
				if !options.allow_pkgconfig {
					return false
				}
				return vpref.comptime_pkgconfig_value(pkg_name)
			}
		}
		else {}
	}

	return false
}

fn flat_pkgconfig_call_name(expr ast.Cursor) ?string {
	match expr.kind() {
		.expr_call {
			lhs := expr.edge(0)
			if lhs.is_valid() && lhs.kind() == .expr_ident && lhs.name() == 'pkgconfig'
				&& expr.edge_count() == 2 {
				return flat_string_literal_value(expr.edge(1))
			}
		}
		.expr_call_or_cast {
			lhs := expr.edge(0)
			if lhs.is_valid() && lhs.kind() == .expr_ident && lhs.name() == 'pkgconfig' {
				return flat_string_literal_value(expr.edge(1))
			}
		}
		else {}
	}

	return none
}

fn flat_string_literal_value(expr ast.Cursor) ?string {
	if !expr.is_valid() || expr.kind() != .expr_string {
		return none
	}
	return unquote_ast_string_literal_value(expr.name())
}

// parse_batch routes normal parsing through the streaming-into-shared-
// FlatBuilder path.
fn (mut b Builder) parse_batch(mut parser_reused parser.Parser, files []string) {
	b.ensure_flat_builder_inited()
	parser_reused.parse_files_into_flat(files, mut b.file_set, mut b.flat_builder)
}

// ensure_flat_builder_inited lazily seeds b.flat_builder on first use.
// Use init_flat_builder_for_paths upfront when the input set is known to
// avoid arena reallocs; this fallback only kicks in when the streaming
// path is entered without that pre-sizing pass.
fn (mut b Builder) ensure_flat_builder_inited() {
	if b.flat_builder_inited {
		return
	}
	b.flat_builder = ast.new_flat_builder()
	b.flat_builder_inited = true
}

// init_flat_builder_for_paths sizes the persistent flat_builder arenas
// from the total source bytes of the supplied paths. Used by parse_files
// to pre-size before any parse_batch call so the streaming path avoids
// the geometric realloc churn the one-shot flatten_files() side-steps.
// The 2x scale factor accounts for imports, which the caller does not
// yet know — empirically core+user is ~half of the final byte total.
fn (mut b Builder) init_flat_builder_for_paths(paths []string) {
	if b.flat_builder_inited {
		return
	}
	mut total_bytes := i64(0)
	for path in paths {
		if path == '' {
			continue
		}
		total_bytes += os.file_size(path)
	}
	nodes_cap, edges_cap, strings_cap := ast.arena_caps_for_bytes(total_bytes * 2)
	b.flat_builder = ast.new_flat_builder_with_capacity(nodes_cap, edges_cap, strings_cap)
	b.flat_builder_inited = true
}

fn (mut b Builder) parse_files(files []string) []ast.File {
	mut parser_reused := parser.Parser.new(b.pref)
	skip_builtin := b.pref.skip_builtin
	target_os := b.pref.source_filter_target_os()
	allow_pkgconfig_imports := !b.pref.is_cross_target()
	mut use_core_headers := false
	// Resolve core-source paths upfront so the pre-size pass below can
	// stat them alongside user files. We still parse in the same batch
	// shape as before so module-init ordering is unchanged.
	mut core_module_files := [][]string{}
	mut cached_core_files := []string{}
	if !skip_builtin {
		use_core_headers = b.can_use_cached_core_headers_for_parse()
		b.used_vh_for_parse = use_core_headers
		if use_core_headers {
			cached_core_files = b.core_cached_parse_paths()
		} else {
			for module_path in core_cached_module_paths {
				vlib_path := b.pref.get_vlib_module_path(module_path)
				core_module_files << get_v_files_from_dir(vlib_path, b.pref.user_defines, target_os)
			}
		}
	}
	// Expand user input paths: allow compiling module directories (e.g. `v2 .`).
	mut expanded_user_files := []string{}
	mut seen_user_files := map[string]bool{}
	for input in files {
		if input == '' {
			continue
		}
		if os.is_dir(input) {
			dir_files := get_user_v_files_from_dir(input, b.pref.user_defines, target_os)
			for dir_file in dir_files {
				if dir_file != '' && dir_file !in seen_user_files {
					expanded_user_files << dir_file
					seen_user_files[dir_file] = true
				}
			}
			continue
		}
		if should_expand_single_file_input(input) {
			if input !in seen_user_files {
				expanded_user_files << input
				seen_user_files[input] = true
			}
			dir_files := get_v_files_from_dir(os.dir(input), b.pref.user_defines, target_os)
			for dir_file in dir_files {
				if dir_file != '' && dir_file !in seen_user_files {
					expanded_user_files << dir_file
					seen_user_files[dir_file] = true
				}
			}
			continue
		}
		if input !in seen_user_files {
			expanded_user_files << input
			seen_user_files[input] = true
		}
	}
	// Directory inputs and non-main module files were expanded above. Single-file
	// `main` programs stay isolated, so `v2 hello.v` parses only `hello.v`,
	// while `v2 .` and `v2 vlib/math/math_test.v` still parse their module files.
	virtual_main_modules := b.collect_virtual_main_modules_from_paths(expanded_user_files)
	if b.can_use_cached_virtual_headers_for_parse(virtual_main_modules) {
		expanded_user_files = b.replace_virtual_sources_with_headers(expanded_user_files,
			virtual_main_modules)
		b.used_virtual_vh_for_parse = true
	}
	mut pre_size_paths := []string{}
	pre_size_paths << cached_core_files
	for module_files in core_module_files {
		pre_size_paths << module_files
	}
	pre_size_paths << expanded_user_files
	b.init_flat_builder_for_paths(pre_size_paths)
	if !skip_builtin {
		if use_core_headers {
			b.parse_batch(mut parser_reused, cached_core_files)
		} else {
			for module_files in core_module_files {
				b.parse_batch(mut parser_reused, module_files)
			}
		}
	}
	b.parse_batch(mut parser_reused, expanded_user_files)
	skip_imports := b.pref.skip_imports
	if skip_imports {
		// Flat path: b.flat_builder is the canonical store; build() derives
		// b.flat from it after parse completes.
		return []ast.File{}
	}
	// parse imports
	use_import_headers := b.can_use_cached_import_headers_for_parse()
	b.used_import_vh_for_parse = use_import_headers
	mut parsed_imports := []string{}
	if !skip_builtin {
		parsed_imports << core_cached_module_paths
	}
	// Walk the flat store directly. parse_batch may append new files to
	// b.flat_builder, so re-read the length each iteration.
	for afi := 0; afi < b.flat_builder.flat.files.len; afi++ {
		ff := b.flat_builder.flat.files[afi]
		ast_file_name := b.flat_builder.flat.file_name(ff)
		for mod in active_file_imports_from_flat_with_options(&b.flat_builder.flat, ff,
			b.pref.user_defines, b.pref.explicit_user_defines, target_os, allow_pkgconfig_imports) {
			if mod.name in parsed_imports {
				continue
			}
			if use_core_headers || use_import_headers {
				if cached_path := b.cached_import_parse_path(mod.name) {
					b.parse_batch(mut parser_reused, [cached_path])
					parsed_imports << mod.name
					continue
				}
			}
			mod_path := b.pref.get_module_path(mod.name, ast_file_name)
			module_files := get_v_files_from_dir(mod_path, b.pref.user_defines, target_os)
			if module_files.len == 0 {
				continue
			}
			b.parse_batch(mut parser_reused, module_files)
			parsed_imports << mod.name
		}
	}
	return []ast.File{}
}