v3: add WebAssembly backend (#27545)

Author: medvednikov

vlib/v3/README.md

@@ -3,10 +3,11 @@
 Clean rewrite of the V compiler. Reuses v2's scanner, uses a flat AST parser
 with Pratt parsing, a structured type system with sum-type variants, lexical
 scoping, a transformer for AST simplification, a shared type-checking phase, a
-markused pass for dead-code elimination, recursive import resolution, and two
-backends: a direct flat-AST-to-C backend and a native ARM64 backend via SSA IR
-with a built-in linker. With `-prod`, the ARM64 backend runs SSA optimization,
-MIR lowering, and instruction selection.
+markused pass for dead-code elimination, recursive import resolution, and three
+backends: a direct flat-AST-to-C backend, a native ARM64 backend via SSA IR with
+a built-in linker, and a direct flat-AST-to-WebAssembly backend. With `-prod`,
+the ARM64 backend runs SSA optimization, MIR lowering, and instruction
+selection.
 
 Imports all `vlib/builtin/` V source files, both pure V (`.v`) and C-interop
 (`.c.v`), for struct, enum, type alias, interface, C function declarations, and
@@ -63,9 +64,25 @@ repeats until no new imports are found.
 source + vlib/builtin -> scanner -> flat parser -> flat AST -> imports
   -> check -> transform -> annotate types -> markused -> gen C -> cc
                                           \-> SSA build -> ARM64 gen -> link
-                                                       \-> optimize -> MIR -> insel (-prod)
+                                          |            \-> optimize -> MIR -> insel (-prod)
+                                          \-> gen WASM -> .wasm
 ```
 
+The WebAssembly backend (`-b wasm`) walks the flat AST directly, like the C
+backend, since WASM's structured control flow (`block`/`loop`/`if`/`br`) maps
+cleanly from the tree and needs no relooping. It emits a self-contained `.wasm`
+module via its own minimal binary encoder (LEB128 + section assembly, mirroring
+how the ARM64 backend ships its own `asm`/`macho`/`linker`), so v3 stays
+self-contained. The current scope is the integer/float core: functions with
+numeric/bool params and locals, arithmetic, comparison, logical (short-circuit),
+bitwise and shift operators, casts, `if`/`else`/`else if`, all `for` forms with
+`break`/`continue`, direct calls, and recursion. `print`/`println` of string
+literals, integers, and booleans is provided through WASI `fd_write` with a
+built-in `itoa` helper. The module is a WASI command (`_start` calls `main`) and
+also exports every compiled function for direct testing. Generics, strings as
+values, structs, arrays, and maps are out of scope for now. Output runs under any
+WASI runtime (e.g. `node:wasi`).
+
 The parser directly emits a flat AST. There is no recursive AST intermediate and
 no flatten step. All nodes live in a single `[]Node` array with children as
 indices into a separate `[]NodeId` array. No pointer chasing, no recursive sum

vlib/v3/gen/wasm/code.v

@@ -0,0 +1,155 @@
+module wasm
+
+// code.v emits the WASM instruction stream for a single function body. It is a
+// thin layer over a []u8 buffer with one method per opcode used by the backend,
+// analogous to the arm64 backend's asm.v instruction encoders.
+
+pub struct Code {
+pub mut:
+	bytes []u8
+}
+
+@[inline]
+pub fn (mut c Code) raw(b u8) {
+	c.bytes << b
+}
+
+// ---- constants ----
+
+pub fn (mut c Code) i32_const(v i64) {
+	c.bytes << 0x41
+	// Wrap to a signed 32-bit value so the LEB128 stays in i32 range; e.g.
+	// u32(4000000000) must encode as the 32-bit pattern, not a 5-byte i64.
+	leb_i(mut c.bytes, i64(i32(v)))
+}
+
+pub fn (mut c Code) i64_const(v i64) {
+	c.bytes << 0x42
+	leb_i(mut c.bytes, v)
+}
+
+pub fn (mut c Code) f32_const(v f32) {
+	c.bytes << 0x43
+	bits := u32(f32_bits(v))
+	for i in 0 .. 4 {
+		c.bytes << u8((bits >> (8 * i)) & 0xff)
+	}
+}
+
+pub fn (mut c Code) f64_const(v f64) {
+	c.bytes << 0x44
+	bits := f64_bits(v)
+	for i in 0 .. 8 {
+		c.bytes << u8((bits >> (8 * i)) & 0xff)
+	}
+}
+
+fn f32_bits(v f32) u32 {
+	return unsafe { *(&u32(&v)) }
+}
+
+fn f64_bits(v f64) u64 {
+	return unsafe { *(&u64(&v)) }
+}
+
+// ---- locals / globals ----
+
+pub fn (mut c Code) local_get(idx int) {
+	c.bytes << 0x20
+	leb_u(mut c.bytes, u64(idx))
+}
+
+pub fn (mut c Code) local_set(idx int) {
+	c.bytes << 0x21
+	leb_u(mut c.bytes, u64(idx))
+}
+
+pub fn (mut c Code) local_tee(idx int) {
+	c.bytes << 0x22
+	leb_u(mut c.bytes, u64(idx))
+}
+
+pub fn (mut c Code) global_get(idx int) {
+	c.bytes << 0x23
+	leb_u(mut c.bytes, u64(idx))
+}
+
+pub fn (mut c Code) global_set(idx int) {
+	c.bytes << 0x24
+	leb_u(mut c.bytes, u64(idx))
+}
+
+// ---- memory ----
+
+pub fn (mut c Code) load(op u8, align int, offset int) {
+	c.bytes << op
+	leb_u(mut c.bytes, u64(align))
+	leb_u(mut c.bytes, u64(offset))
+}
+
+pub fn (mut c Code) store(op u8, align int, offset int) {
+	c.bytes << op
+	leb_u(mut c.bytes, u64(align))
+	leb_u(mut c.bytes, u64(offset))
+}
+
+// i32_store / i32_load with natural alignment for a full i32.
+pub fn (mut c Code) i32_store(offset int) {
+	c.store(0x36, 2, offset)
+}
+
+pub fn (mut c Code) i32_store8(offset int) {
+	c.store(0x3a, 0, offset)
+}
+
+pub fn (mut c Code) i32_load(offset int) {
+	c.load(0x28, 2, offset)
+}
+
+// ---- control flow ----
+
+pub fn (mut c Code) block_void() {
+	c.bytes << 0x02
+	c.bytes << 0x40
+}
+
+pub fn (mut c Code) loop_void() {
+	c.bytes << 0x03
+	c.bytes << 0x40
+}
+
+pub fn (mut c Code) if_void() {
+	c.bytes << 0x04
+	c.bytes << 0x40
+}
+
+pub fn (mut c Code) else_() {
+	c.bytes << 0x05
+}
+
+pub fn (mut c Code) end() {
+	c.bytes << 0x0b
+}
+
+pub fn (mut c Code) br(depth int) {
+	c.bytes << 0x0c
+	leb_u(mut c.bytes, u64(depth))
+}
+
+pub fn (mut c Code) br_if(depth int) {
+	c.bytes << 0x0d
+	leb_u(mut c.bytes, u64(depth))
+}
+
+pub fn (mut c Code) ret() {
+	c.bytes << 0x0f
+}
+
+pub fn (mut c Code) call(idx int) {
+	c.bytes << 0x10
+	leb_u(mut c.bytes, u64(idx))
+}
+
+pub fn (mut c Code) drop() {
+	c.bytes << 0x1a
+}