// Regression test for a static method used as a first-class value in the
// builtin array methods (`map`/`filter`/...). It is parsed as an `ast.EnumVal`
// (same syntax as an enum value, e.g. `Color.red`); when the static method is
// not yet registered while parsing the call site (forward reference here, or a
// cross-module reference), the parser cannot emit a function `ast.Ident`, so the
// checker has to rewrite the resolved value into one. See issue #27328.

fn test_static_method_as_map_arg() {
	nums := [1, 2, 3]
	foos := nums.map(Foo.from)
	assert foos.map(it.x) == [1, 2, 3]
}

fn test_static_method_as_map_arg_explicit_call() {
	nums := [1, 2, 3]
	foos := nums.map(Foo.from(it))
	assert foos.map(it.x) == [1, 2, 3]
}

fn test_static_method_as_filter_arg() {
	nums := [1, 2, 3, 4]
	odds := nums.filter(is_odd)
	assert odds == [1, 3]
}

fn test_aliased_static_method_as_map_arg() {
	// the static method is reached through a type alias, so it must be resolved
	// by its real fkey (`Foo__static__from`), not the alias name
	nums := [1, 2, 3]
	foos := nums.map(FooAlias.from)
	assert foos.map(it.x) == [1, 2, 3]
}

type FooAlias = Foo

// Defined *after* the call sites on purpose, to exercise the forward-reference
// path (the function is not in the table yet when the calls above are parsed).
struct Foo {
	x int
}

fn Foo.from(n int) Foo {
	return Foo{
		x: n
	}
}

fn is_odd(n int) bool {
	return n % 2 == 1
}