module ssa

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

fn mut_array_param_append_source() string {
	return r'
module main

fn add_seen(mut seen []string, name string) {
	seen << name
}

fn push_path(mut patterns [][]string, path []string) {
	patterns << path
}

fn push_many_paths(mut patterns [][]string, paths [][]string) {
	patterns << paths
}

fn push_literal_path(mut patterns [][]string, path []string) {
	patterns << [path]
}

fn main() {
	mut seen := []string{}
	add_seen(mut seen, "A")
	path := ["A", "B"]
	mut patterns := [][]string{}
	push_path(mut patterns, path)
	push_many_paths(mut patterns, [path])
	push_literal_path(mut patterns, path)
}
'
}

fn mut_array_param_append_parse(source string) ([]ast.File, &types.Environment, &token.FileSet) {
	tmp_file := os.join_path(os.vtmp_dir(), 'v2_ssa_mut_array_param_append_${os.getpid()}.v')
	os.write_file(tmp_file, source) or { panic('failed to write temp file') }
	defer {
		os.rm(tmp_file) or {}
	}
	prefs := &vpref.Preferences{
		backend:     .x64
		arch:        .x64
		no_parallel: true
	}
	mut file_set := token.FileSet.new()
	mut par := parser.Parser.new(prefs)
	files := par.parse_files([tmp_file], mut file_set)
	env := types.Environment.new()
	mut checker := types.Checker.new(prefs, file_set, env)
	checker.check_files(files)
	return files, env, file_set
}

fn mut_array_param_append_build_legacy(source string) &Module {
	files, env, file_set := mut_array_param_append_parse(source)
	prefs := &vpref.Preferences{
		backend:     .x64
		arch:        .x64
		no_parallel: true
	}
	mut trans := transformer.Transformer.new_with_pref(env, prefs)
	trans.set_file_set(file_set)
	transformed := trans.transform_files(files)
	mut mod := Module.new('mut_array_param_append_legacy')
	mut b := Builder.new_with_env(mod, env)
	b.build_all(transformed)
	return mod
}

fn mut_array_param_append_build_flat(source string) &Module {
	files, env, file_set := mut_array_param_append_parse(source)
	prefs := &vpref.Preferences{
		backend:     .x64
		arch:        .x64
		no_parallel: true
	}
	mut trans := transformer.Transformer.new_with_pref(env, prefs)
	trans.set_file_set(file_set)
	transformed := trans.transform_files(files)
	flat := ast.flatten_files(transformed)
	mut mod := Module.new('mut_array_param_append_flat')
	mut b := Builder.new_with_env(mod, env)
	b.build_all_from_flat(&flat)
	return mod
}

fn mut_array_param_append_func_index(m &Module, fn_name string) int {
	for i, func in m.funcs {
		if func.name == fn_name {
			return i
		}
	}
	assert false, 'missing SSA function ${fn_name}'
	return 0
}

fn mut_array_param_append_calls(m &Module, fn_name string, callee_name string) [][]ValueID {
	func_idx := mut_array_param_append_func_index(m, fn_name)
	mut calls := [][]ValueID{}
	for block_id in m.funcs[func_idx].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 {
				calls << instr.operands
			}
		}
	}
	return calls
}

fn mut_array_param_append_assert_arg_uses_local_storage(m &Module, fn_name string, arg_id ValueID) {
	assert arg_id > 0 && arg_id < m.values.len, '${fn_name} append argument is out of range'
	mut cur_id := arg_id
	for _ in 0 .. 6 {
		assert cur_id > 0 && cur_id < m.values.len
		value := m.values[cur_id]
		assert value.kind == .instruction
		instr := m.instrs[value.index]
		if instr.op == .alloca {
			return
		}
		assert instr.op in [.bitcast, .load]
		assert instr.operands.len == 1
		cur_id = instr.operands[0]
	}
	assert false, '${fn_name} append argument does not resolve to local storage'
}

fn mut_array_param_append_assert_module(m &Module) {
	add_push_calls := mut_array_param_append_calls(m, 'add_seen', 'builtin__array_push_noscan')
	assert add_push_calls.len == 1
	assert add_push_calls[0].len >= 2
	mut_array_param_append_assert_arg_uses_local_storage(m, 'add_seen', add_push_calls[0][1])

	path_push_calls := mut_array_param_append_calls(m, 'push_path', 'builtin__array_push_noscan')
	assert path_push_calls.len == 1
	assert path_push_calls[0].len >= 2
	mut_array_param_append_assert_arg_uses_local_storage(m, 'push_path', path_push_calls[0][1])

	many_push_calls := mut_array_param_append_calls(m, 'push_many_paths', 'array__push_many')
	assert many_push_calls.len == 1
	assert many_push_calls[0].len >= 2
	mut_array_param_append_assert_arg_uses_local_storage(m, 'push_many_paths',
		many_push_calls[0][1])

	literal_push_calls := mut_array_param_append_calls(m, 'push_literal_path',
		'builtin__array_push_noscan')
	assert literal_push_calls.len == 1
	assert literal_push_calls[0].len >= 2
	mut_array_param_append_assert_arg_uses_local_storage(m, 'push_literal_path',
		literal_push_calls[0][1])
}

fn test_mut_array_param_append_uses_local_storage_legacy_and_flat() {
	source := mut_array_param_append_source()
	legacy := mut_array_param_append_build_legacy(source)
	mut_array_param_append_assert_module(legacy)
	flat := mut_array_param_append_build_flat(source)
	mut_array_param_append_assert_module(flat)
}