v3: address PR review batch 13 — unsigned shift in fixed-array lengths, copy generic method-value map to cgen workers

The const fixed-array-length evaluators now handle V's unsigned right shift `>>>`. The
string evaluator gains it as a three-char operator (matched before `>>`), and the cgen
fixed-array dimension (fixed_array_len_raw) folds any const expression to an integer
literal first — `>>>` has no C form, so a digit-leading expression like `[8 >>> 1]int`
must not pass through raw. The literal-length guard rejects a wrong element count and the
emitted C dimension is valid. (The AST evaluator already handled `.right_shift_unsigned`.)

clone_parallel_type_checker now copies generic_method_value_info into each parallel-cgen
worker checker. It is the read-only map cgen uses to recover substituted signatures for
generic-receiver method values (`Box[int].method` as a callback); without it a worker on
a large enough non-Windows build saw an empty map and gen_method_value_closure fell
through instead of emitting the wrapper/specialized call. (fn_d_parallel.v was also
brought to vfmt formatting.)

Author: medvednikov

vlib/v3/gen/c/cleanc.v

@@ -1555,15 +1555,17 @@ fn (mut g FlatGen) fixed_array_len_raw(raw_len string, fallback int) string {
 	if raw_len.len == 0 {
 		return '${fallback}'
 	}
+	// A literal or const-expression size (`8`, `SEGS + 1`, `1 << 2`, `8 >>> 1`) folds to an
+	// integer; emit that literal so the C dimension is always valid — `>>>` has no C form,
+	// so a digit-leading expression like `8 >>> 1` must not be passed through raw — and a
+	// non-numeric expr isn't c_name-mangled (`SEGS_+_1`) into an undeclared identifier.
+	if v := g.tc.const_int_value(raw_len, []string{}) {
+		return v.str()
+	}
 	clean_len := raw_len.replace('_', '')
 	if clean_len.len > 0 && clean_len[0] >= `0` && clean_len[0] <= `9` {
 		return clean_len
 	}
-	// A const-expression size (`SEGS + 1`) evaluates to a literal; otherwise the whole
-	// string would be c_name-mangled (`SEGS_+_1`) into an undeclared identifier.
-	if v := g.tc.const_int_value(raw_len, []string{}) {
-		return v.str()
-	}
 	const_name := g.const_ref_name(raw_len)
 	if const_name.len > 0 {
 		expr := g.const_expr_to_string(g.const_vals[const_name], []string{})

vlib/v3/gen/c/fn_d_parallel.v

@@ -352,54 +352,54 @@ fn (mut g FlatGen) fn_ptr_type_key(typ types.FnType) string {
 // worker and, under -gc none, never freed.
 fn (g &FlatGen) new_parallel_worker(worker_id int) &FlatGen {
 	return &FlatGen{
-		sb:                      strings.new_builder(64_000)
-		a:                       unsafe { g.a }
-		used_fns:                g.used_fns
-		used_fn_names:           g.used_fn_names
-		str_lits:                g.str_lits.clone()
-		str_lit_ids:             g.str_lit_ids.clone()
-		global_types:            g.global_types
-		enum_vals:               g.enum_vals
-		interfaces:              g.interfaces
-		const_vals:              g.const_vals
-		const_modules:           g.const_modules
-		const_init_order:        g.const_init_order
-		global_modules:          g.global_modules
-		global_inits:            g.global_inits
-		global_init_order:       g.global_init_order
-		iface_impls:             g.iface_impls
-		iface_type_ids:          g.iface_type_ids
-		module_init_fns:         g.module_init_fns
-		module_init_fn_modules:  g.module_init_fn_modules
-		module_imports:          g.module_imports
-		tc:                      g.clone_parallel_type_checker()
-		has_builtins:            g.has_builtins
-		tmp_count:               (worker_id + 1) * 100_000
-		line_start:              true
-		modules:                 g.modules
-		fn_ptr_types:            g.fn_ptr_types.clone()
+		sb:                       strings.new_builder(64_000)
+		a:                        unsafe { g.a }
+		used_fns:                 g.used_fns
+		used_fn_names:            g.used_fn_names
+		str_lits:                 g.str_lits.clone()
+		str_lit_ids:              g.str_lit_ids.clone()
+		global_types:             g.global_types
+		enum_vals:                g.enum_vals
+		interfaces:               g.interfaces
+		const_vals:               g.const_vals
+		const_modules:            g.const_modules
+		const_init_order:         g.const_init_order
+		global_modules:           g.global_modules
+		global_inits:             g.global_inits
+		global_init_order:        g.global_init_order
+		iface_impls:              g.iface_impls
+		iface_type_ids:           g.iface_type_ids
+		module_init_fns:          g.module_init_fns
+		module_init_fn_modules:   g.module_init_fn_modules
+		module_imports:           g.module_imports
+		tc:                       g.clone_parallel_type_checker()
+		has_builtins:             g.has_builtins
+		tmp_count:                (worker_id + 1) * 100_000
+		line_start:               true
+		modules:                  g.modules
+		fn_ptr_types:             g.fn_ptr_types.clone()
 		fixed_array_ret_wrappers: g.fixed_array_ret_wrappers
-		fn_decl_param_types:     g.fn_decl_param_types
-		fn_decl_ret_types:       g.fn_decl_ret_types
-		struct_decl_infos:       g.struct_decl_infos
-		struct_decl_short_infos: g.struct_decl_short_infos
-		runtime_inits:           g.runtime_inits.clone()
-		compiler_vroot:          g.compiler_vroot
-		cur_param_names:         g.cur_param_names.clone()
-		cur_param_type_values:   g.cur_param_type_values.clone()
-		cur_param_types:         g.cur_param_types.clone()
-		cur_fn_ret:              g.cur_fn_ret
-		cur_fn_ret_is_optional:  g.cur_fn_ret_is_optional
-		cur_fn_ret_base:         g.cur_fn_ret_base
-		expected_expr_type:      g.expected_expr_type
-		expected_enum:           g.expected_enum
-		needed_optional_types:   g.needed_optional_types.clone()
-		emitted_optional_types:  g.emitted_optional_types.clone()
-		emitted_fns:             g.emitted_fns.clone()
-		array_method_cache:      g.array_method_cache.clone()
-		param_types_cache:       g.param_types_cache.clone()
-		embedded_fields_by_type: g.embedded_fields_by_type
-		param_types_by_short:    g.param_types_by_short
+		fn_decl_param_types:      g.fn_decl_param_types
+		fn_decl_ret_types:        g.fn_decl_ret_types
+		struct_decl_infos:        g.struct_decl_infos
+		struct_decl_short_infos:  g.struct_decl_short_infos
+		runtime_inits:            g.runtime_inits.clone()
+		compiler_vroot:           g.compiler_vroot
+		cur_param_names:          g.cur_param_names.clone()
+		cur_param_type_values:    g.cur_param_type_values.clone()
+		cur_param_types:          g.cur_param_types.clone()
+		cur_fn_ret:               g.cur_fn_ret
+		cur_fn_ret_is_optional:   g.cur_fn_ret_is_optional
+		cur_fn_ret_base:          g.cur_fn_ret_base
+		expected_expr_type:       g.expected_expr_type
+		expected_enum:            g.expected_enum
+		needed_optional_types:    g.needed_optional_types.clone()
+		emitted_optional_types:   g.emitted_optional_types.clone()
+		emitted_fns:              g.emitted_fns.clone()
+		array_method_cache:       g.array_method_cache.clone()
+		param_types_cache:        g.param_types_cache.clone()
+		embedded_fields_by_type:  g.embedded_fields_by_type
+		param_types_by_short:     g.param_types_by_short
 	}
 }
 
@@ -461,6 +461,10 @@ fn (g &FlatGen) clone_parallel_type_checker() &types.TypeChecker {
 		diagnostic_files:              g.tc.diagnostic_files
 		cur_fn_ret_type:               g.tc.cur_fn_ret_type
 		smartcasts:                    g.tc.smartcasts
+		// Read-only map cgen uses to recover substituted signatures for generic-receiver
+		// method values (`Box[int].method` as a callback); without it a parallel worker
+		// sees an empty map and gen_method_value_closure falls through.
+		generic_method_value_info: g.tc.generic_method_value_info
 	}
 }
 

vlib/v3/tests/type_checker_errors_test.v

@@ -643,3 +643,21 @@ fn test_pr_review_codegen_batch_twelve() {
 		'struct Point {\n\tx int\n\ty int\n}\nfn main() {\n\tmut arr := []&Point{}\n\tarr << &Point{1, 2}\n\tprintln(int_str(arr[0].x + arr[0].y))\n}\n')
 	assert pos == '3'
 }
+
+// Regression tests for the thirteenth PR-review batch (vlang/v#27557).
+fn test_pr_review_codegen_batch_thirteen() {
+	v3_bin := build_v3()
+	// V's unsigned right shift `>>>` is a valid constant-length operator. It must fold in
+	// the const evaluator (so the array dimension is emitted as a numeric literal, since
+	// `>>>` has no C form) and in the literal-length guard. `8 >>> 1` = 4, `16 >>> 2` = 4,
+	// `(1 << 5) >>> 2` = 8.
+	ushift := run_good(v3_bin, 'good_unsigned_shift_fixed_array_len',
+		'const shamt = 16 >>> 2\nfn main() {\n\ta := [8 >>> 1]int{}\n\tb := [shamt]int{}\n\tc := [(1 << 5) >>> 2]int{}\n\tprintln(int_str(a.len + b.len + c.len))\n}\n')
+	// 4 + 4 + 8 = 16
+	assert ushift == '16'
+	// The fixed-array literal-length guard evaluates `>>>` too: `[1, 2]` (two elements)
+	// does not match an expected `[8 >>> 1]int` (four), so it is rejected.
+	run_bad(v3_bin, 'bad_unsigned_shift_fixed_array_literal_len',
+		'fn take(a [8 >>> 1]int) int {\n\treturn a[0]\n}\nfn main() {\n\t_ := take([1, 2]!)\n}\n',
+		'cannot use')
+}

vlib/v3/types/checker.v

@@ -5370,10 +5370,10 @@ pub fn (tc &TypeChecker) const_int_value(name string, seen []string) ?int {
 		return tc.const_int_value(expr[1..expr.len - 1].trim_space(), seen)
 	}
 	// Operators grouped by precedence level, lowest first: `+ - | ^` (additive/bitwise),
-	// then `* / % & << >>` (multiplicative/shift), matching V/Go precedence. Split on the
-	// rightmost top-level operator of the lowest level present. Two-character operators
-	// (`<<`, `>>`) are matched before single characters; `idx + op.len` skips the operator.
-	for level in [['+', '-', '|', '^'], ['*', '/', '%', '&', '<<', '>>']] {
+	// then `* / % & << >> >>>` (multiplicative/shift), matching V/Go precedence. Split on
+	// the rightmost top-level operator of the lowest level present. Longer operators are
+	// matched first (`>>>` before `>>`, two-char before one); `idx + op.len` skips it.
+	for level in [['+', '-', '|', '^'], ['*', '/', '%', '&', '<<', '>>', '>>>']] {
 		mut idx := -1
 		mut op := ''
 		mut depth := 0
@@ -5391,6 +5391,13 @@ pub fn (tc &TypeChecker) const_int_value(name string, seen []string) ?int {
 				continue
 			}
 			if depth == 0 {
+				three := if i + 3 <= expr.len { expr[i..i + 3] } else { '' }
+				if three.len == 3 && three in level {
+					idx = i
+					op = three
+					i += 3
+					continue
+				}
 				two := if i + 2 <= expr.len { expr[i..i + 2] } else { '' }
 				if two.len == 2 && two in level {
 					idx = i
@@ -5418,7 +5425,7 @@ pub fn (tc &TypeChecker) const_int_value(name string, seen []string) ?int {
 		if (op == '/' || op == '%') && r == 0 {
 			return none
 		}
-		if (op == '<<' || op == '>>') && (r < 0 || r >= 64) {
+		if (op == '<<' || op == '>>' || op == '>>>') && (r < 0 || r >= 64) {
 			return none
 		}
 		return match op {
@@ -5431,7 +5438,8 @@ pub fn (tc &TypeChecker) const_int_value(name string, seen []string) ?int {
 			'^' { l ^ r }
 			'&' { l & r }
 			'<<' { l << r }
-			else { l >> r }
+			'>>' { l >> r }
+			else { int(u64(l) >> r) }
 		}
 	}
 	return none