module main

import wasm

// A funcref table populated by an active element segment, dispatched through
// `call_indirect`.
fn test_call_indirect() {
	mut m := wasm.Module{}

	mut f0 := m.new_function('f0', [], [.i32_t])
	{
		f0.i32_const(10)
	}
	m.commit(f0, false)

	mut f1 := m.new_function('f1', [], [.i32_t])
	{
		f1.i32_const(20)
	}
	m.commit(f1, false)

	tidx := m.assign_table('__indirect_function_table', true, .funcref_t, 2, none)
	m.new_active_element(tidx, 0, ['f0', 'f1'])

	sig := m.new_functype(wasm.FuncType{
		parameters: []wasm.ValType{}
		results:    [.i32_t]
	})

	mut dispatch := m.new_function('dispatch', [.i32_t], [.i32_t])
	{
		dispatch.local_get(0) // table index argument
		dispatch.call_indirect(sig, tidx)
	}
	m.commit(dispatch, true)

	validate(m.compile()) or { panic(err) }
}

// A growable externref table exercised with table.size/grow/set/get.
fn test_externref_table() {
	mut m := wasm.Module{}

	tidx := m.assign_table('refs', true, .externref_t, 1, none)

	// grow by 3 (filling with null); leaves the previous size on the stack
	mut grow := m.new_function('grow_refs', [], [.i32_t])
	{
		grow.ref_null(.externref_t) // init value
		grow.i32_const(3) // n
		grow.table_grow(tidx)
	}
	m.commit(grow, true)

	mut size := m.new_function('refs_size', [], [.i32_t])
	{
		size.table_size(tidx)
	}
	m.commit(size, true)

	// refs[0] = null, then read it back and report whether it is null
	mut roundtrip := m.new_function('roundtrip', [], [.i32_t])
	{
		roundtrip.i32_const(0) // index
		roundtrip.ref_null(.externref_t) // value
		roundtrip.table_set(tidx)
		roundtrip.i32_const(0) // index
		roundtrip.table_get(tidx)
		roundtrip.ref_is_null(.externref_t)
	}
	m.commit(roundtrip, true)

	validate(m.compile()) or { panic(err) }
}

// A declarative element segment makes `ref.func` to a non-exported, non-tabled
// function validate. Without the segment, validation would fail.
fn test_declarative_element() {
	mut m := wasm.Module{}

	mut hidden := m.new_function('f_hidden', [], [.i32_t])
	{
		hidden.i32_const(42)
	}
	m.commit(hidden, false) // NOT exported

	m.new_declarative_element(['f_hidden'])

	mut probe := m.new_function('probe', [], [.i32_t])
	{
		probe.ref_func('f_hidden')
		probe.ref_is_null(.funcref_t)
	}
	m.commit(probe, true)

	validate(m.compile()) or { panic(err) }
}