v2: fix arm64 self-host, improve transformer type handling, and harden cleanc backend

ARM64 backend:
- Fix null pointer dereference when returning none (zero-fill return area)
- Add branch trampoline for CBNZ/CBZ 19-bit range overflow
- Fix large struct truthiness check in conditional branches
- Fix logical NOT to use (x == 0) instead of (x XOR 1)

SSA builder:
- Register sum types as {_tag, _data} struct pairs
- Resolve Option/Result types to their base type instead of i64 fallback
- Handle pointer type names (Type*), address-of non-addressable values
- Fix array struct field indices for offset field (data=0, offset=1, len=2)
- Prefer SSA struct field type over type environment for selectors

Transformer:
- Add post-transform type propagation pass (new type_propagation.v)
- Fix sumtype option returns to check _data field instead of raw truthiness
- Execute or-block side effects in else path, not unconditionally
- Skip uninstantiated generic functions (unchecked bodies)
- Fix smartcast: check variant has method before applying, disable when
  passing sumtype args to sumtype params
- Use _data directly for native backend smartcasts (no union variants)
- Fix map index assignment scope-escape with prefix temp variables
- Lower `return none` to `return 0` for native backends
- Resolve enum shorthands in non-sumtype match expressions

Parser:
- Add in_top_level flag to prevent parsing declarations inside fn bodies

Cleanc:
- Fix &T(x) pointer type in assignments
- Use shallow clone (depth 0) to avoid type misidentification by size
- Implement BlockStmt recursion instead of TODO placeholder

Type checker:
- Check struct field defaults and enum values after all declarations
- Add comptime flags: little_endian, big_endian, debug, native, user-defined
- Check assert extras, comptime stmts, label stmts

Misc:
- Flush libc stdio before write() syscall to prevent output reordering
- Fix tcc fallback to check compiler binary, not full command string

Author: medvednikov

vlib/builtin/printing.c.v

@@ -179,6 +179,9 @@ fn _write_buf_to_fd(fd int, buf &u8, buf_len int) {
 	mut remaining_bytes := isize(buf_len)
 	mut x := isize(0)
 	$if freestanding || vinix || builtin_write_buf_to_fd_should_use_c_write ? {
+		// Flush any pending libc stdio output (from C.puts, C.putchar, etc.)
+		// before writing directly via write() syscall to prevent output reordering.
+		C.fflush(unsafe { nil })
 		unsafe {
 			for remaining_bytes > 0 {
 				x = C.write(fd, ptr, remaining_bytes)

vlib/v2/builder/builder.v

@@ -547,11 +547,14 @@ fn run_cc_cmd_or_exit(cmd string, stage string, show_cc bool) {
 	result := os.execute(cmd)
 	if result.exit_code != 0 {
 		// If tcc failed, fall back to cc.
-		if cmd.contains('tcc') {
+		// Check only the compiler binary (before the first space), not the full
+		// command string which contains tcc in include/library flag paths.
+		cc_binary := cmd.all_before(' ')
+		if cc_binary.contains('tcc') {
 			eprintln('Failed to compile with tcc, falling back to cc')
 			eprintln('tcc cmd: ${cmd}')
 			eprintln(result.output)
-			fallback_cmd := cmd.replace_once(cmd.all_before(' '), 'cc')
+			fallback_cmd := cmd.replace_once(cc_binary, 'cc')
 			run_cc_cmd_or_exit(fallback_cmd, stage, show_cc)
 			return
 		}

vlib/v2/gen/arm64/arm64.v

@@ -1401,35 +1401,47 @@ fn (mut g Gen) gen_instr(val_id int) {
 						g.emit_ldr_reg_offset(8, 29, g.x8_save_offset)
 					}
 
-					// string_literal values need to be materialized on the stack
-					// before we can copy them to the return pointer.
-					if ret_val.kind == .string_literal {
-						g.load_val_to_reg(9, ret_val_id)
-					}
+					// Check if returning a zero/none value (e.g., `return 0` from `return none`).
+					// In this case, zero-fill the return area instead of trying to copy
+					// from address 0 (which would be a null pointer dereference).
+					is_zero_const := ret_val.kind == .constant && ret_val.name == '0'
+					if is_zero_const {
+						num_fields := (fn_ret_size + 7) / 8
+						for i in 0 .. num_fields {
+							// STR xzr, [x8, #i*8]
+							g.emit(asm_str_imm(Reg(31), Reg(8), u32(i)))
+						}
+					} else {
+						// string_literal values need to be materialized on the stack
+						// before we can copy them to the return pointer.
+						if ret_val.kind == .string_literal {
+							g.load_val_to_reg(9, ret_val_id)
+						}
 
-					// Get the source address of the struct
-					if is_indirect_struct_return {
-						// Return value is a pointer to struct - use it as source
-						g.load_val_to_reg(9, ret_val_id)
-					} else if ret_offset := g.stack_map[ret_val_id] {
-						if g.large_struct_stack_value_is_pointer(ret_val_id) {
-							// Some large-struct temporaries are represented as pointers in stack slots.
-							g.emit_ldr_reg_offset(9, 29, ret_offset)
+						// Get the source address of the struct
+						if is_indirect_struct_return {
+							// Return value is a pointer to struct - use it as source
+							g.load_val_to_reg(9, ret_val_id)
+						} else if ret_offset := g.stack_map[ret_val_id] {
+							if g.large_struct_stack_value_is_pointer(ret_val_id) {
+								// Some large-struct temporaries are represented as pointers in stack slots.
+								g.emit_ldr_reg_offset(9, 29, ret_offset)
+							} else {
+								// Struct is materialized by value on stack.
+								g.emit_add_fp_imm(9, ret_offset)
+							}
 						} else {
-							// Struct is materialized by value on stack.
-							g.emit_add_fp_imm(9, ret_offset)
+							// Fallback
+							g.load_val_to_reg(9, ret_val_id)
+						}
+						// Copy struct from [x9] to [x8] (x8 was restored from saved location)
+						num_fields := (fn_ret_size + 7) / 8
+						for i in 0 .. num_fields {
+							// LDR x10, [x9, #i*8]
+							g.emit(asm_ldr_imm(Reg(10), Reg(9), u32(i)))
+							// STR x10, [x8, #i*8]
+							g.emit(asm_str_imm(Reg(10), Reg(8), u32(i)))
 						}
-					} else {
-						// Fallback
-						g.load_val_to_reg(9, ret_val_id)
-					}
-					// Copy struct from [x9] to [x8] (x8 was restored from saved location)
-					num_fields := (fn_ret_size + 7) / 8
-					for i in 0 .. num_fields {
-						// LDR x10, [x9, #i*8]
-						g.emit(asm_ldr_imm(Reg(10), Reg(9), u32(i)))
-						// STR x10, [x8, #i*8]
-						g.emit(asm_str_imm(Reg(10), Reg(8), u32(i)))
 					}
 				} else if (ret_typ.kind == .struct_t && ret_typ.fields.len > 1)
 					|| is_indirect_struct_return {
@@ -1454,6 +1466,15 @@ fn (mut g Gen) gen_instr(val_id int) {
 					} else {
 						g.load_val_to_reg(0, ret_val_id)
 					}
+				} else if fn_ret_typ.kind == .struct_t && ret_val.kind == .constant
+					&& ret_val.name == '0' {
+					// Returning zero/none from a function that returns a small struct.
+					// Zero all return registers for the struct to avoid garbage in x1+.
+					for i in 0 .. fn_ret_typ.fields.len {
+						if i < 8 {
+							g.emit_mov_reg(i, 31) // xN = xzr (zero)
+						}
+					}
 				} else {
 					g.load_val_to_reg(0, ret_val_id)
 				}
@@ -1502,7 +1523,21 @@ fn (mut g Gen) gen_instr(val_id int) {
 			}
 		}
 		.br {
-			g.load_val_to_reg(8, instr.operands[0])
+			// Load condition value into x8 for branch.
+			// For large structs (> 16 bytes), load_val_to_reg returns the *address*
+			// (which is always non-zero). For truthiness checks on option struct returns,
+			// we need to load the first word of the struct instead.
+			cond_val := g.mod.values[instr.operands[0]]
+			cond_is_large_struct := cond_val.typ > 0 && cond_val.typ < g.mod.type_store.types.len
+				&& g.mod.type_store.types[cond_val.typ].kind == .struct_t
+				&& g.type_size(cond_val.typ) > 16
+			if cond_is_large_struct {
+				// Large struct: load the address, then dereference first word
+				g.load_val_to_reg(8, instr.operands[0])
+				g.emit(asm_ldr_imm(Reg(8), Reg(8), 0)) // x8 = [x8] (first word)
+			} else {
+				g.load_val_to_reg(8, instr.operands[0])
+			}
 
 			true_blk := g.mod.values[instr.operands[1]].index
 			false_blk := g.mod.values[instr.operands[2]].index
@@ -1512,10 +1547,20 @@ fn (mut g Gen) gen_instr(val_id int) {
 
 			if off := g.block_offsets[true_blk] {
 				rel := (off - (g.macho.text_data.len - g.curr_offset)) / 4
-				g.emit(asm_cbnz(Reg(8), rel))
+				if rel >= -262144 && rel < 262144 {
+					g.emit(asm_cbnz(Reg(8), rel))
+				} else {
+					// Branch target too far for CBNZ (19-bit range).
+					// Use trampoline: CBZ skip; B target; skip:
+					g.emit(asm_cbz(Reg(8), 2)) // skip over next B instruction
+					g.emit(asm_b(rel - 1)) // adjust for the extra CBZ instruction
+				}
 			} else {
+				// Forward reference: use trampoline pattern to avoid 19-bit overflow.
+				// CBZ x8, skip; B target; skip:
+				g.emit(asm_cbz(Reg(8), 2)) // skip over next B instruction
 				g.record_pending_label(true_blk)
-				g.emit(asm_cbnz(Reg(8), 0))
+				g.emit(asm_b(0))
 			}
 
 			if false_blk == g.next_blk {
@@ -1545,10 +1590,18 @@ fn (mut g Gen) gen_instr(val_id int) {
 
 				if off := g.block_offsets[target_blk_idx] {
 					rel := (off - (g.macho.text_data.len - g.curr_offset)) / 4
-					g.emit(asm_b_cond(cond_eq, rel))
+					if rel >= -262144 && rel < 262144 {
+						g.emit(asm_b_cond(cond_eq, rel))
+					} else {
+						// Trampoline: b.ne skip; B target; skip:
+						g.emit(asm_b_cond(cond_ne, 2)) // skip over next B
+						g.emit(asm_b(rel - 1))
+					}
 				} else {
+					// Forward reference: use trampoline for safety
+					g.emit(asm_b_cond(cond_ne, 2)) // skip over next B
 					g.record_pending_label(target_blk_idx)
-					g.emit(asm_b_cond(cond_eq, 0))
+					g.emit(asm_b(0))
 				}
 			}
 

vlib/v2/gen/cleanc/assign.v

@@ -221,6 +221,14 @@ fn (mut g Gen) gen_assign_stmt(node ast.AssignStmt) {
 			}
 		}
 		mut typ := g.get_expr_type(rhs)
+		// Fix: &T(x) pattern - the checker may assign only the inner type T instead of T*.
+		// Derive the pointer type directly from the expression structure.
+		if rhs is ast.PrefixExpr && rhs.op == .amp && rhs.expr is ast.CastExpr {
+			target_type := g.expr_type_to_c(rhs.expr.typ)
+			if target_type != '' {
+				typ = target_type + '*'
+			}
+		}
 		mut elem_type_from_array := false
 		if rhs is ast.CallExpr {
 			if rhs.lhs is ast.Ident

vlib/v2/gen/cleanc/fn.v

@@ -1412,11 +1412,13 @@ fn (mut g Gen) call_expr(lhs ast.Expr, args []ast.Expr) {
 		g.sb.write_string(', 3)')
 		return
 	}
-	// array__clone → array__clone_to_depth with automatic depth for deep clone
+	// array__clone → array__clone_to_depth with depth 0 (shallow memcpy clone).
+	// Depth > 0 uses element_size heuristics that misidentify non-string types
+	// of the same size (e.g. tagged unions like ast.Expr are 16 bytes == sizeof(string)).
 	if name == 'array__clone' && call_args.len == 1 {
 		g.sb.write_string('array__clone_to_depth(')
 		g.gen_call_arg(name, 0, call_args[0])
-		g.sb.write_string(', 3)')
+		g.sb.write_string(', 0)')
 		return
 	}
 	// array__insert with array arg → array__insert_many

vlib/v2/gen/cleanc/stmt.v

@@ -301,8 +301,9 @@ fn (mut g Gen) gen_stmt(node ast.Stmt) {
 			panic('bug in v2 compiler: ComptimeStmt should have been handled in v2.transformer')
 		}
 		ast.BlockStmt {
-			g.write_indent()
-			g.sb.writeln('/* [TODO] BlockStmt */')
+			for bs in node.stmts {
+				g.gen_stmt(bs)
+			}
 		}
 		ast.LabelStmt {
 			g.write_indent()

vlib/v2/parser/parser.v

@@ -17,8 +17,9 @@ mut:
 	file    &token.File = &token.File{}
 	scanner &scanner.Scanner
 	// track state
-	exp_lcbr bool // expecting `{` parsing `x` in `for|if|match x {` etc
-	exp_pt   bool // expecting (p)ossible (t)ype from `p.expr()`
+	exp_lcbr     bool // expecting `{` parsing `x` in `for|if|match x {` etc
+	exp_pt       bool // expecting (p)ossible (t)ype from `p.expr()`
+	in_top_level bool // inside top-level context (file scope / top-level comptime block)
 	// token info : start
 	line      int
 	lit       string
@@ -120,13 +121,15 @@ pub fn (mut p Parser) parse_file(filename string, mut file_set token.FileSet) as
 		imports << import_stmt
 		top_stmts << import_stmt
 	}
+	p.in_top_level = true
 	for p.tok != .eof {
 		top_stmt := p.top_stmt()
 		// if top_stmt is ast.Decl {
 		// 	decls << top_stmt
 		// }
 		top_stmts << top_stmt
 	}
+	p.in_top_level = false
 	if p.pref.verbose {
 		parse_time := sw.elapsed()
 		println('scan & parse ${filename} (${p.file.line_count()} LOC): ${parse_time.milliseconds()}ms (${parse_time.microseconds()}µs)')
@@ -209,54 +212,59 @@ fn (mut p Parser) top_stmt() ast.Stmt {
 
 fn (mut p Parser) stmt() ast.Stmt {
 	// p.log('STMT: ${p.tok} - ${p.file.name}:${p.line}')
+	// Top-level declarations that can appear inside comptime $if blocks at
+	// file scope. Only parsed when in_top_level is set (file-level context),
+	// not inside regular function bodies where they would be invalid.
+	if p.in_top_level {
+		match p.tok {
+			.key_const {
+				return p.const_decl(false)
+			}
+			.key_enum {
+				return p.enum_decl(false, [])
+			}
+			.key_fn {
+				// `fn name(...)` or `fn C.name(...)` is a declaration;
+				// `fn (recv Type) method(...)` is a method declaration.
+				next := p.peek()
+				if next == .name || next == .lpar {
+					return p.fn_decl(false, [])
+				}
+			}
+			.key_global {
+				return p.global_decl([])
+			}
+			.key_interface {
+				return p.interface_decl(false, [])
+			}
+			.key_pub {
+				p.next()
+				match p.tok {
+					.key_const { return p.const_decl(true) }
+					.key_enum { return p.enum_decl(true, []) }
+					.key_fn { return p.fn_decl(true, []) }
+					.key_interface { return p.interface_decl(true, []) }
+					.key_struct, .key_union { return p.struct_decl(true, []) }
+					.key_type { return p.type_decl(true) }
+					else { p.error('not implemented: pub ${p.tok}') }
+				}
+			}
+			.key_struct, .key_union {
+				return p.struct_decl(false, [])
+			}
+			.key_type {
+				return p.type_decl(false)
+			}
+			else {}
+		}
+	}
 	match p.tok {
 		.dollar {
 			return p.comptime_stmt()
 		}
 		.hash {
 			return p.directive()
 		}
-		// Top-level declarations that can appear inside comptime $if blocks.
-		.key_const {
-			return p.const_decl(false)
-		}
-		.key_enum {
-			return p.enum_decl(false, [])
-		}
-		.key_fn {
-			// `fn name(...)` or `fn C.name(...)` is a declaration;
-			// `fn (...)` or `fn [captures](...)` is a literal (handled by else/expr).
-			if p.peek() == .name {
-				return p.fn_decl(false, [])
-			}
-			// fall through to expression (fn literal)
-			expr := p.expr(.lowest)
-			return p.complete_simple_stmt(expr, false)
-		}
-		.key_global {
-			return p.global_decl([])
-		}
-		.key_interface {
-			return p.interface_decl(false, [])
-		}
-		.key_pub {
-			p.next()
-			match p.tok {
-				.key_const { return p.const_decl(true) }
-				.key_enum { return p.enum_decl(true, []) }
-				.key_fn { return p.fn_decl(true, []) }
-				.key_interface { return p.interface_decl(true, []) }
-				.key_struct, .key_union { return p.struct_decl(true, []) }
-				.key_type { return p.type_decl(true) }
-				else { p.error('not implemented: pub ${p.tok}') }
-			}
-		}
-		.key_struct, .key_union {
-			return p.struct_decl(false, [])
-		}
-		.key_type {
-			return p.type_decl(false)
-		}
 		.key_asm {
 			return p.asm_stmt()
 		}
@@ -1960,11 +1968,14 @@ fn (mut p Parser) fn_decl(is_public bool, attributes []ast.Attribute) ast.FnDecl
 			if p.tok != .lcbr {
 				return_type = p.expect_type()
 			}
+			prev_top_level := p.in_top_level
+			p.in_top_level = false
 			stmts := if p.tok == .lcbr {
 				p.block()
 			} else {
 				[]ast.Stmt{}
 			}
+			p.in_top_level = prev_top_level
 			p.expect(.semicolon)
 			return ast.FnDecl{
 				attributes: attributes
@@ -2010,11 +2021,14 @@ fn (mut p Parser) fn_decl(is_public bool, attributes []ast.Attribute) ast.FnDecl
 	typ := p.fn_type()
 	// p.log('ast.FnDecl: ${name} ${p.lit} - ${p.tok} (${p.lit}) - ${p.tok_next_}')
 	// also check line for better error detection
+	prev_top_level := p.in_top_level
+	p.in_top_level = false
 	stmts := if p.tok == .lcbr {
 		p.block()
 	} else {
 		[]ast.Stmt{}
 	}
+	p.in_top_level = prev_top_level
 	p.expect(.semicolon)
 	return ast.FnDecl{
 		attributes: attributes