// Copyright (c) 2026 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
// vtest build: macos
//
// Bit-equality pin for the cursor-native rewrite of `build_array_init_from_flat`.
// The previous helper rehydrated every ArrayInitExpr field via `decode_expr`
// (typ, init, cap, len, update_expr, and each element) and dispatched to
// legacy `build_array_init_expr`. The cursor-native rewrite mirrors
// `build_array_init_expr` directly: elements walk `c.edge(5)..edge_count()` via
// `build_expr_from_flat`; the declared element type is resolved from `typ_c`
// using a `.typ_array` / `.typ_array_fixed` kind match (`edge(0)` / `edge(1)`
// for elem_type) plus an `ast_type_to_ssa_from_flat` call; the fixed-array
// marker check inspects `len_c.kind() == .expr_postfix` with `aux == .not`
// (the `!` suffix) or `typ_c.kind() == .typ_array_fixed`. Empty dynamic
// arrays with explicit `len`/`cap` now read those edges and lower to the same
// runtime allocation call as the legacy builder. Pin asserts module-count
// parity for the common literal `[1, 2, 3]` path and the dynamic
// `[]int{len: 3, cap: 5}` path.
module ssa

import v2.ast
import v2.types

fn ai_ident(name string) ast.Expr {
	return ast.Expr(ast.Ident{
		name: name
	})
}

fn ai_num(value string) ast.Expr {
	return ast.Expr(ast.BasicLiteral{
		kind:  .number
		value: value
	})
}

fn ai_array_type(elem ast.Expr) ast.Expr {
	return ast.Expr(ast.Type(ast.ArrayType{
		elem_type: elem
	}))
}

fn ai_field(name string, typ string) ast.FieldDecl {
	return ast.FieldDecl{
		name: name
		typ:  ai_ident(typ)
	}
}

fn make_array_init_fixture() []ast.File {
	mut stmts := [
		ast.Stmt(ast.ModuleStmt{
			name: 'main'
		}),
	]
	// fn make_arr() { a := [1, 2, 3] _ = a }
	stmts << ast.Stmt(ast.FnDecl{
		name:  'make_arr'
		typ:   ast.FnType{
			return_type: ast.empty_expr
		}
		stmts: [
			ast.Stmt(ast.AssignStmt{
				op:  .decl_assign
				lhs: [ai_ident('a')]
				rhs: [
					ast.Expr(ast.ArrayInitExpr{
						exprs: [ai_num('1'), ai_num('2'), ai_num('3')]
					}),
				]
			}),
		]
	})
	// fn make_dynamic_arr() { a := []int{len: 3, cap: 5} _ = a }
	stmts << ast.Stmt(ast.FnDecl{
		name:  'make_dynamic_arr'
		typ:   ast.FnType{
			return_type: ast.empty_expr
		}
		stmts: [
			ast.Stmt(ast.AssignStmt{
				op:  .decl_assign
				lhs: [ai_ident('a')]
				rhs: [
					ast.Expr(ast.ArrayInitExpr{
						typ: ai_array_type(ai_ident('int'))
						len: ai_num('3')
						cap: ai_num('5')
					}),
				]
			}),
		]
	})
	return [
		ast.File{
			name:  'main.v'
			mod:   'main'
			stmts: stmts
		},
	]
}

fn make_dynamic_array_init_fixture() []ast.File {
	builtin_file := ast.File{
		name:  'builtin.v'
		mod:   'builtin'
		stmts: [
			ast.Stmt(ast.ModuleStmt{
				name: 'builtin'
			}),
			ast.Stmt(ast.StructDecl{
				name:   'array'
				fields: [
					ai_field('data', 'voidptr'),
					ai_field('offset', 'int'),
					ai_field('len', 'int'),
					ai_field('cap', 'int'),
					ai_field('flags', 'int'),
					ai_field('element_size', 'int'),
				]
			}),
			ast.Stmt(ast.FnDecl{
				name:     'builtin____new_array_noscan'
				language: .c
				typ:      ast.FnType{
					params:      [
						ast.Parameter{
							name: 'len'
							typ:  ai_ident('int')
						},
						ast.Parameter{
							name: 'cap'
							typ:  ai_ident('int')
						},
						ast.Parameter{
							name: 'elem_size'
							typ:  ai_ident('int')
						},
					]
					return_type: ai_ident('array')
				}
			}),
		]
	}
	main_file := ast.File{
		name:  'main.v'
		mod:   'main'
		stmts: [
			ast.Stmt(ast.ModuleStmt{
				name: 'main'
			}),
			ast.Stmt(ast.FnDecl{
				name:  'make_dynamic'
				typ:   ast.FnType{
					return_type: ai_array_type(ai_ident('int'))
				}
				stmts: [
					ast.Stmt(ast.ReturnStmt{
						exprs: [
							ast.Expr(ast.ArrayInitExpr{
								typ: ai_array_type(ai_ident('int'))
								len: ai_num('3')
								cap: ai_num('5')
							}),
						]
					}),
				]
			}),
		]
	}
	return [builtin_file, main_file]
}

fn build_via_legacy_array_init(files []ast.File, env &types.Environment, name string) &Module {
	mut mod := Module.new(name)
	mut b := Builder.new_with_env(mod, env)
	b.register_fn_signatures(files[0])
	b.build_fn_bodies(files[0])
	return mod
}

fn build_via_flat_array_init(files []ast.File, env &types.Environment, name string) &Module {
	flat := ast.flatten_files(files)
	mut mod := Module.new(name)
	mut b := Builder.new_with_env(mod, env)
	b.register_fn_signatures_from_flat(flat.file_cursor(0))
	b.build_fn_bodies_from_flat(flat.file_cursor(0))
	return mod
}

fn build_all_via_legacy_array_init(files []ast.File, env &types.Environment, name string) &Module {
	mut mod := Module.new(name)
	mut b := Builder.new_with_env(mod, env)
	b.minimal_runtime_roots = true
	b.build_all(files)
	return mod
}

fn build_all_via_flat_array_init(files []ast.File, env &types.Environment, name string) &Module {
	flat := ast.flatten_files(files)
	mut mod := Module.new(name)
	mut b := Builder.new_with_env(mod, env)
	b.minimal_runtime_roots = true
	b.build_all_from_flat(&flat)
	return mod
}

fn ai_call_operands(m &Module, func_name string, callee_name string) []ValueID {
	for func in m.funcs {
		if func.name != func_name {
			continue
		}
		for block_id in func.blocks {
			for value_id in m.blocks[block_id].instrs {
				value := m.values[value_id]
				if value.kind != .instruction {
					continue
				}
				instr := m.instrs[value.index]
				if instr.op != .call || instr.operands.len == 0 {
					continue
				}
				callee_id := instr.operands[0]
				if callee_id > 0 && callee_id < m.values.len
					&& m.values[callee_id].name == callee_name {
					return instr.operands
				}
			}
		}
	}
	assert false, 'missing call to ${callee_name} in ${func_name}'
	return []ValueID{}
}

fn ai_assert_dynamic_array_operands(m &Module) {
	operands := ai_call_operands(m, 'make_dynamic', 'builtin____new_array_noscan')
	assert operands.len == 4
	assert m.values[operands[1]].name == '3'
	assert m.values[operands[2]].name == '5'
	assert m.values[operands[3]].name == '4'
}

fn test_build_array_init_from_flat_matches_legacy() {
	files := make_array_init_fixture()
	env := types.Environment.new()
	mod_legacy := build_via_legacy_array_init(files, env, 'array_init_legacy')
	mod_flat := build_via_flat_array_init(files, env, 'array_init_flat')

	assert mod_legacy.funcs.len == mod_flat.funcs.len
	assert mod_legacy.blocks.len == mod_flat.blocks.len
	assert mod_legacy.instrs.len == mod_flat.instrs.len
	assert mod_legacy.values.len == mod_flat.values.len
}

fn test_build_array_init_from_flat_dynamic_len_cap_operands_match_legacy() {
	files := make_dynamic_array_init_fixture()
	env := types.Environment.new()
	mod_legacy := build_all_via_legacy_array_init(files, env, 'array_init_dynamic_legacy')
	mod_flat := build_all_via_flat_array_init(files, env, 'array_init_dynamic_flat')

	ai_assert_dynamic_array_operands(mod_legacy)
	ai_assert_dynamic_array_operands(mod_flat)
}