v3: keep pointer-bearing generic args from parsing as fixed-array lengths (fix #28884)

`is_fixed_array_len_text` treated every non-leading `&` as a bitwise-and
length operator, so `Foo[fn (&Baz) int]` (and `Foo[[]&T]`, `Foo[?&T]`,
`Foo[&&T]`, `Foo[Box[&T]]`, ...) was parsed as a fixed array of `Foo`
with length `fn (&Baz) int`. Field access then failed with
"`[fn (&Baz) int]foo.Foo` has no property `value`", and fn-field calls
became "unknown function".

Reject argument text that starts with type-only syntax (`&`, `?`, `!`,
`[`, `...`, `map[`, `fn`, `chan`, `thread`, `shared`, `atomic`, `mut`)
and ignore `&`/`-` nested in brackets. The transform and cgen typeof
helpers get the same `&`/`?`/`!` prefix check so `?&T` and `&&T`
instances are not mangled as fixed arrays later on.

Author: medvednikov

vlib/v/gen/c/cleanc.v

@@ -17206,7 +17206,7 @@ fn typeof_display_fixed_array_len_text(text string) bool {
 	if clean.len == 0 || clean.contains(',') || clean.contains('[') || clean.contains(']') {
 		return false
 	}
-	if clean.starts_with('fn(') || clean.starts_with('fn (') || clean.starts_with('chan ') || clean.starts_with('shared ') || clean.starts_with('atomic ') || clean.starts_with('mut ') || clean.starts_with('thread ') {
+	if clean[0] in [`&`, `?`, `!`] || clean.starts_with('fn(') || clean.starts_with('fn (') || clean.starts_with('chan ') || clean.starts_with('shared ') || clean.starts_with('atomic ') || clean.starts_with('mut ') || clean.starts_with('thread ') {
 		return false
 	}
 	if clean[0] >= `0` && clean[0] <= `9` {

vlib/v/tests/generic_fn_ptr_arg_28884/generic_fn_ptr_arg_28884_test.v

@@ -0,0 +1,89 @@
+@[has_globals]
+module main
+
+import generics28884 { Box, Foo }
+
+struct Baz {
+	n int
+}
+
+type Bar = fn (&Baz) int
+
+__global alias_global generics28884.Foo[Bar]
+__global inline_global generics28884.Foo[fn (&Baz) int]
+
+struct Holder {
+mut:
+	f generics28884.Foo[fn (&Baz) int]
+}
+
+fn double(b &Baz) int {
+	return b.n * 2
+}
+
+fn triple(b &Baz) int {
+	return b.n * 3
+}
+
+fn make_baz() &Baz {
+	return &Baz{9}
+}
+
+fn call_stored(mut f generics28884.Foo[fn (&Baz) int], n int) int {
+	return f.value(&Baz{n})
+}
+
+// https://github.com/vlang/v/issues/28884
+fn test_global_generic_container_of_fn_alias() {
+	alias_global.set(double)
+	alias_global.set(alias_global.value)
+	assert alias_global.value(&Baz{21}) == 42
+	mut local := generics28884.Foo[Bar]{}
+	local.set(alias_global.value)
+	assert local.value(&Baz{5}) == 10
+}
+
+fn test_global_generic_container_of_inline_fn_type() {
+	inline_global.set(triple)
+	inline_global.set(inline_global.value)
+	assert inline_global.value(&Baz{4}) == 12
+	stored := inline_global.value
+	assert stored(&Baz{5}) == 15
+}
+
+fn test_local_generic_container_of_inline_fn_type() {
+	mut local := generics28884.Foo[fn (&Baz) int]{}
+	local.set(double)
+	local.set(local.value)
+	assert local.value(&Baz{6}) == 12
+	mut holder := Holder{}
+	holder.f.set(triple)
+	assert holder.f.value(&Baz{7}) == 21
+	assert call_stored(mut holder.f, 2) == 6
+	mut named := Foo[fn (b &Baz) int]{}
+	named.set(double)
+	assert named.value(&Baz{8}) == 16
+	mut returning := Foo[fn () &Baz]{}
+	returning.set(make_baz)
+	assert returning.value().n == 9
+}
+
+fn test_generic_args_with_nested_pointer_types() {
+	b := &Baz{3}
+	mut arr := Foo[[]&Baz]{}
+	arr.set([b])
+	assert arr.value[0].n == 3
+	mut opt := Foo[?&Baz]{}
+	opt.set(b)
+	got := opt.value or { &Baz{0} }
+	assert got.n == 3
+	mut ptr_ptr := Foo[&&Baz]{}
+	ptr_ptr.set(&b)
+	assert (**ptr_ptr.value).n == 3
+	mut boxed := Foo[Box[&Baz]]{}
+	boxed.set(Box[&Baz]{b})
+	assert boxed.value.v.n == 3
+	mut boxed_fn := Foo[Box[fn (&Baz) int]]{}
+	boxed_fn.set(Box[fn (&Baz) int]{double})
+	assert boxed_fn.value.v(b) == 6
+}

vlib/v/tests/generic_fn_ptr_arg_28884/generics28884/generics28884.v

@@ -0,0 +1,16 @@
+module generics28884
+
+pub struct Foo[T] {
+pub mut:
+	value T
+}
+
+// set stores `value` in the container.
+pub fn (mut self Foo[T]) set(value T) {
+	self.value = value
+}
+
+pub struct Box[T] {
+pub:
+	v T
+}

vlib/v/tests/generic_fn_ptr_arg_28884/v.mod

@@ -22219,9 +22219,9 @@ fn typeof_display_is_fixed_array_len_text(text string) bool {
 	if clean.len == 0 || clean.contains(',') || clean.contains('[') || clean.contains(']') {
 		return false
 	}
-	if clean.starts_with('fn(') || clean.starts_with('fn (') || clean.starts_with('chan ')
-		|| clean.starts_with('shared ') || clean.starts_with('atomic ') || clean.starts_with('mut ')
-		|| clean.starts_with('thread ') {
+	if clean[0] in [`&`, `?`, `!`] || clean.starts_with('fn(') || clean.starts_with('fn (')
+		|| clean.starts_with('chan ') || clean.starts_with('shared ') || clean.starts_with('atomic ')
+		|| clean.starts_with('mut ') || clean.starts_with('thread ') {
 		return false
 	}
 	if is_decimal_text(clean) || (clean[0] >= `0` && clean[0] <= `9`) {

vlib/v/transform/transform.v

@@ -14398,14 +14398,30 @@ fn is_fixed_array_len_text(inner string) bool {
 	if v_int_literal_value(s) != none {
 		return true
 	}
+	// A type argument can hold a pointer type after its first character (`&&Node`, `?&Node`,
+	// `[]&Node`, `map[string]&Node`, `fn (&Node) int`, `chan &Node`). No integer length
+	// expression starts with such type syntax, so its `&` is never a bitwise-and.
+	if s[0] in [`&`, `?`, `!`, `[`] || s.starts_with('...') || s.starts_with('map[')
+		|| s.starts_with('fn(') || s.starts_with('fn ') || s.starts_with('chan ')
+		|| s.starts_with('thread ') || s.starts_with('shared ') || s.starts_with('atomic ')
+		|| s.starts_with('mut ') {
+		return false
+	}
+	mut depth := 0
 	for i in 0 .. s.len {
 		c := s[i]
+		if c == `[` {
+			depth++
+		} else if c == `]` {
+			depth--
+		}
 		if c in [`+`, `*`, `/`, `%`, `|`, `^`, `<`, `>`] {
 			return true
 		}
-		// A leading `-`/`&` is a negative literal / pointer-type argument; elsewhere they are the
-		// subtraction / bitwise-and operators of a length expression.
-		if (c == `-` || c == `&`) && i > 0 {
+		// A leading `-`/`&` is a negative literal / pointer-type argument, and one inside
+		// brackets belongs to a nested type argument (`Box[&Node]`, `Box[fn (&Node) int]`);
+		// elsewhere they are the subtraction / bitwise-and operators of a length expression.
+		if (c == `-` || c == `&`) && i > 0 && depth == 0 {
 			return true
 		}
 	}