const base_array = [
	1,
	2,
]

const base_strings = ['a', 'b']

struct Point {
	x int
	y int
}

const base_points = [Point{1, 2}, Point{3, 4}]

fn test_array_init_with_spread() {
	complete := [...base_array,
		3,
		4,
	]
	assert base_array == [1, 2]
	assert complete == [1, 2, 3, 4]
	assert complete.len == 4

	second := [...base_array, 5, 6, 7]
	assert second == [1, 2, 5, 6, 7]
}

fn test_array_init_with_only_spread() {
	mut copy := [...base_array]
	assert copy == [1, 2]
	copy << 99
	// spread produces an independent copy
	assert base_array == [1, 2]
	assert copy == [1, 2, 99]
}

fn test_array_spread_strings() {
	merged := [...base_strings, 'c', 'd']
	assert merged == ['a', 'b', 'c', 'd']
}

fn test_array_spread_structs() {
	pts := [...base_points, Point{5, 6}]
	assert pts.len == 3
	assert pts[0] == Point{1, 2}
	assert pts[1] == Point{3, 4}
	assert pts[2] == Point{5, 6}
}

fn test_array_spread_local_var() {
	v_arr := [7, 8, 9]
	x := [...v_arr, 100]
	assert v_arr == [7, 8, 9]
	assert x == [7, 8, 9, 100]
}

fn test_array_spread_chained() {
	first := [...base_array, 3]
	second := [...first, 4]
	assert second == [1, 2, 3, 4]
}

// Regression: `[...base]` should produce an independent deep copy. Modifying
// an inner []int after the spread must not affect the base.
fn test_array_spread_nested_arrays_are_deep_cloned() {
	mut base := [[1, 2], [3, 4]]
	mut copy := [...base]
	copy[0] << 99
	assert base[0] == [1, 2]
	assert copy[0] == [1, 2, 99]
}

// Regression: assigning into a nested element of the spread copy must not
// mutate the base. Catches shallow-copy regressions in any backend that
// reuses the base's inner storage.
fn test_array_spread_nested_element_assignment_isolated() {
	mut base := [[1, 2]]
	mut b := [...base]
	b[0][0] = 9
	assert base[0][0] == 1
	assert b[0][0] == 9
}

// Regression: indexing a spread literal inline (`[...base, 3][0]`) must keep
// the spread base in the AST instead of dropping it during parsing.
fn test_array_spread_indexed_inline() {
	assert [...base_array, 3][0] == 1
	assert [...base_array, 3][1] == 2
	assert [...base_array, 3][2] == 3
}

// Regression: appended string variables must be cloned, matching the
// behavior of the regular `[s1, s2]` array-literal path.
fn test_array_spread_appended_string_variable() {
	base := ['a', 'b']
	mut s := 'c'
	arr := [...base, s]
	s = 'mutated'
	assert arr == ['a', 'b', 'c']
}

type Ints = []int

// Regression: type-alias of an array should be accepted as a spread base.
fn test_array_spread_alias_base() {
	a := Ints([10, 20, 30])
	b := [...a, 40]
	assert b.len == 4
	assert b[0] == 10
	assert b[3] == 40
	c := [...a]
	assert c.len == 3
}