v3/wasm: buffer multi-decls, fix narrow >>> and ~

Address PR review:

- Multi-declaration: gen_decl_assign bound each new local before later
  initializers were emitted, so `x, y := x+1, x+2` read the rebound x for
  the second RHS (y==8). Buffer every RHS into temporaries first, then
  bind the new locals, matching v3's evaluator (y==7).

- Unsigned right shift on narrow operands: a signed i8/i16 is stored
  sign-extended in i32, so `i8(-5) >>> 1` shifted 0xfffffffb and produced
  -3. Mask the lhs to its declared width before `>>>` so it operates on
  the 8/16-bit pattern (125 / 32765).

- Bit-not on narrow operands: `~` returned the full i32 xor without
  applying the result width, so `~u8(0)` left -1 (printed as 4294967295
  via the unsigned path, and wrong for a u8 return). Narrow the `~`
  result to its resolved type; the same narrowing is applied to unary
  minus on narrow types.

Adds regression tests for all three (verified against the v1 runtime and
v3's eval backend).

Author: medvednikov

vlib/v3/gen/wasm/gen.v

@@ -491,23 +491,59 @@ fn (mut g Gen) gen_stmt(id flat.NodeId) {
 }
 
 fn (mut g Gen) gen_decl_assign(node flat.Node) {
+	// Multi-declaration (`x, y := a, b`): evaluate every RHS against the outer
+	// scope before binding any new name, so a shadowing `x, y := x+1, x+2`
+	// reads the outer x for both initializers.
+	if node.children_count > 2 {
+		g.gen_multi_decl(node)
+		return
+	}
+	lhs := g.a.child_node(&node, 0)
+	rhs_id := g.a.child(&node, 1)
+	w := g.expr_wtype(rhs_id, node.typ)
+	uns := g.decl_is_unsigned(rhs_id, node.typ)
+	width := g.decl_width(rhs_id, node.typ)
+	if lhs.kind == .ident {
+		// Emit the initializer before binding the new name, so a shadowing
+		// `x := x + 1` reads the outer x rather than the fresh zero local.
+		g.gen_expr_as(rhs_id, w)
+		idx := g.new_local(lhs.value, w, uns, width)
+		g.narrow_for_local(lhs.value)
+		g.cur.local_set(idx)
+	}
+}
+
+fn (mut g Gen) gen_multi_decl(node flat.Node) {
+	mut temps := []int{}
+	mut names := []string{}
+	mut ws := []WType{}
+	mut unss := []bool{}
+	mut widths := []int{}
+	// Phase 1: buffer every RHS into a temporary (outer bindings still in scope).
 	mut i := 0
 	for i + 1 < node.children_count {
 		lhs := g.a.child_node(&node, i)
 		rhs_id := g.a.child(&node, i + 1)
-		w := g.expr_wtype(rhs_id, node.typ)
-		uns := g.decl_is_unsigned(rhs_id, node.typ)
-		width := g.decl_width(rhs_id, node.typ)
 		if lhs.kind == .ident {
-			// Emit the initializer before binding the new name, so a shadowing
-			// `x := x + 1` reads the outer x rather than the fresh zero local.
+			w := g.expr_wtype(rhs_id, node.typ)
 			g.gen_expr_as(rhs_id, w)
-			idx := g.new_local(lhs.value, w, uns, width)
-			g.narrow_for_local(lhs.value)
-			g.cur.local_set(idx)
+			t := g.alloc_temp(w)
+			g.cur.local_set(t)
+			temps << t
+			names << lhs.value
+			ws << w
+			unss << g.decl_is_unsigned(rhs_id, node.typ)
+			widths << g.decl_width(rhs_id, node.typ)
 		}
 		i += 2
 	}
+	// Phase 2: bind each new local and store its buffered value.
+	for k, name in names {
+		idx := g.new_local(name, ws[k], unss[k], widths[k])
+		g.cur.local_get(temps[k])
+		g.narrow_for_local(name)
+		g.cur.local_set(idx)
+	}
 }
 
 fn (mut g Gen) gen_assign(node flat.Node) {
@@ -786,7 +822,7 @@ fn (mut g Gen) gen_expr(id flat.NodeId) WType {
 			return g.gen_infix(id, node)
 		}
 		.prefix {
-			return g.gen_prefix(node)
+			return g.gen_prefix(id, node)
 		}
 		.postfix {
 			g.gen_postfix(node)
@@ -852,10 +888,17 @@ fn (mut g Gen) gen_infix(id flat.NodeId, node flat.Node) WType {
 		}
 		signed := !g.is_unsigned(lhs_id)
 		g.gen_expr_as(lhs_id, value_w)
+		if op == .right_shift_unsigned && value_w == .i32 {
+			// A narrow signed lhs is stored sign-extended in i32; mask it to its
+			// width so the upper bits don't feed into the logical shift.
+			lw := narrow_width(g.tc.resolve_type(lhs_id))
+			if lw != 32 {
+				g.emit_narrow(lw, true)
+			}
+		}
 		g.emit_shift_with_count(op, value_w, rhs_id, signed)
 		if value_w == .i32 {
-			rt := g.tc.resolve_type(id)
-			g.emit_narrow(narrow_width(rt), type_is_unsigned(rt))
+			g.narrow_result(id)
 		}
 		return value_w
 	}
@@ -869,12 +912,18 @@ fn (mut g Gen) gen_infix(id flat.NodeId, node flat.Node) WType {
 	g.emit_arith(op, ow, signed)
 	// Sub-32-bit results (e.g. u8 + u8) wrap to their declared width in V.
 	if ow == .i32 {
-		rt := g.tc.resolve_type(id)
-		g.emit_narrow(narrow_width(rt), type_is_unsigned(rt))
+		g.narrow_result(id)
 	}
 	return ow
 }
 
+// narrow_result masks/sign-extends the i32 on the stack to the resolved type's
+// sub-32-bit width (a no-op for 32/64-bit types).
+fn (mut g Gen) narrow_result(id flat.NodeId) {
+	rt := g.tc.resolve_type(id)
+	g.emit_narrow(narrow_width(rt), type_is_unsigned(rt))
+}
+
 fn (mut g Gen) gen_logical(node flat.Node) WType {
 	lhs_id := g.a.child(&node, 0)
 	rhs_id := g.a.child(&node, 1)
@@ -896,7 +945,7 @@ fn (mut g Gen) gen_logical(node flat.Node) WType {
 	return .i32
 }
 
-fn (mut g Gen) gen_prefix(node flat.Node) WType {
+fn (mut g Gen) gen_prefix(id flat.NodeId, node flat.Node) WType {
 	child_id := g.a.child(&node, 0)
 	match node.op {
 		.minus {
@@ -922,6 +971,7 @@ fn (mut g Gen) gen_prefix(node flat.Node) WType {
 					g.cur.i32_const(0)
 					g.gen_expr_as(child_id, .i32)
 					g.cur.raw(0x6b) // i32.sub
+					g.narrow_result(id) // negation of a narrow type wraps to its width
 					return .i32
 				}
 			}
@@ -940,6 +990,7 @@ fn (mut g Gen) gen_prefix(node flat.Node) WType {
 			}
 			g.cur.i32_const(-1)
 			g.cur.raw(0x73) // i32.xor
+			g.narrow_result(id) // ~ of a narrow type keeps its width (e.g. ~u8(0)=255)
 			return .i32
 		}
 		else {

vlib/v3/tests/wasm_codegen_test.v

@@ -380,6 +380,36 @@ fn test_wasm_shift_keeps_lhs_width() {
 	run_wasi_expect(wasm, ['0', '1099511627776', '0'])
 }
 
+fn test_wasm_multi_decl_buffers_rhs() {
+	v3_bin := v3_binary()
+	// Both initializers must read the outer x before either new local is bound,
+	// so y == 7 (outer x + 2), not 8 (rebound x + 2).
+	src := 'fn main() {\n\tx := 5\n\t{\n\t\tx, y := x + 1, x + 2\n\t\tprintln(x)\n\t\tprintln(y)\n\t}\n}\n'
+	wasm := compile_to_wasm(v3_bin, src, 'wasm_multidecl')
+	assert_valid_wasm(wasm)
+	run_wasi_expect(wasm, ['6', '7'])
+}
+
+fn test_wasm_unsigned_right_shift_masks_narrow() {
+	v3_bin := v3_binary()
+	// `>>>` on a signed narrow operand works on the 8/16-bit pattern, so the
+	// sign-extension bits must be masked off first.
+	src := 'fn main() {\n\tprintln(int(i8(-5) >>> 1))\n\tprintln(int(i16(-5) >>> 1))\n\tprintln(int(u8(250) >>> 1))\n}\n'
+	wasm := compile_to_wasm(v3_bin, src, 'wasm_urshift')
+	assert_valid_wasm(wasm)
+	run_wasi_expect(wasm, ['125', '32765', '125'])
+}
+
+fn test_wasm_bit_not_narrows_result() {
+	v3_bin := v3_binary()
+	// ~ keeps the operand width: ~u8(0) is 255, ~u16(0) is 65535, and a u8
+	// return carries the narrowed value.
+	src := 'fn allset() u8 {\n\treturn ~u8(0)\n}\n\nfn main() {\n\tprintln(~u8(0))\n\tprintln(~u16(0))\n\tprintln(allset())\n}\n'
+	wasm := compile_to_wasm(v3_bin, src, 'wasm_bitnot')
+	assert_valid_wasm(wasm)
+	run_wasi_expect(wasm, ['255', '65535', '255'])
+}
+
 const wasi_runner_js = "import { WASI } from 'node:wasi';
 import { readFile } from 'node:fs/promises';
 const wasi = new WASI({ version: 'preview1', args: [], env: {} });