v2: lots of arm64 fixes: v2 compiled with arm64 can now compile hello world!; v2.eval; v2.cleanc fixes to compile viper engine

Author: medvednikov

cmd/v2/README.md

@@ -33,6 +33,15 @@
   ./v2 -nomarkused -backend cleanc file.v
 ```
 
+# Eval backend
+```
+  # Execute a small V program directly from the v2 AST:
+  ./v2 -backend eval file.v
+
+  # Current scope: literals, locals/consts, plain fn calls, if/for/range,
+  # arrays, indexing, len, println/print, and basic string interpolation.
+```
+
 # SSA C backend (restored)
 ```
   # Run the SSA -> C backend directly:

cmd/v2/test_all.sh

@@ -3,33 +3,33 @@ set -euo pipefail
 
 cd "$(dirname "$0")"
 
-echo "=== 1/11: Self-host test ==="
+echo "=== 1/12: Self-host test ==="
 bash test_v2_self.sh
 
 echo ""
-echo "=== 2/11: Rebuild v2 and run builtin test files ==="
+echo "=== 2/12: Rebuild v2 and run builtin test files ==="
 rm -rf /tmp/v2_cleanc_obj_cache
 v self && v -o v2 v2.v
 ./v2 ../../vlib/builtin/array_test.v
 ./v2 ../../vlib/builtin/string_test.v
 ./v2 ../../vlib/builtin/map_test.v
 
 echo ""
-echo "=== 3/11: Builtin test files (arm64) ==="
+echo "=== 3/12: Builtin test files (arm64) ==="
 ./v2 -backend arm64 ../../vlib/builtin/array_test.v
 ./v2 -backend arm64 ../../vlib/builtin/string_test.v
 ./v2 -backend arm64 ../../vlib/builtin/map_test.v
 
 echo ""
-echo "=== 4/11: Math test ==="
+echo "=== 4/12: Math test ==="
 ./v2 ../../vlib/math/math_test.v
 
 echo ""
-echo "=== 5/11: Math test (arm64) ==="
+echo "=== 5/12: Math test (arm64) ==="
 ./v2 -backend arm64 ../../vlib/math/math_test.v
 
 echo ""
-echo "=== 6/11: Sumtype tests ==="
+echo "=== 6/12: Sumtype tests ==="
 ./v2 test_sumtype.v
 ./v2 test_sumtype2.v
 ./v2 test_sumtype3.v
@@ -42,23 +42,36 @@ echo "=== 6/11: Sumtype tests ==="
 ./v2 test_sumtype_global.v
 
 echo ""
-echo "=== 7/11: SSA backends test (arm64) ==="
+echo "=== 7/12: Sumtype tests (arm64) ==="
+./v2 -backend arm64 test_sumtype.v
+./v2 -backend arm64 test_sumtype2.v
+./v2 -backend arm64 test_sumtype3.v
+./v2 -backend arm64 test_sumtype4.v
+./v2 -backend arm64 test_sumtype_pos.v
+./v2 -backend arm64 test_sumtype_data.v
+./v2 -backend arm64 test_sumtype_ifexpr.v
+./v2 -backend arm64 test_sumtype_nested.v
+./v2 -backend arm64 test_sumtype_many.v
+./v2 -backend arm64 test_sumtype_global.v
+
+echo ""
+echo "=== 8/12: SSA backends test (arm64) ==="
 v -gc none run test_ssa_backends.v arm64
 
 echo ""
-echo "=== 8/11: SSA backends test (cleanc) ==="
+echo "=== 9/12: SSA backends test (cleanc) ==="
 v -gc none run test_ssa_backends.v cleanc
 
 echo ""
-echo "=== 9/11: Transformer unit tests ==="
+echo "=== 10/12: Transformer unit tests ==="
 v ../../vlib/v2/transformer/transformer_test.v
 
 echo ""
-echo "=== 10/11: Transformer integration test ==="
+echo "=== 11/12: Transformer integration test ==="
 v ../../vlib/v2/transformer/transformer_v2_darwin_test.v
 
 echo ""
-echo "=== 11/11: Cleanc runtime tests ==="
+echo "=== 12/12: Cleanc runtime tests ==="
 v -gc none run ../../vlib/v2/gen/cleanc/tests/run_tests.v
 
 echo ""

cmd/v2/test_sumtype_nested.v

@@ -1,63 +1,107 @@
-struct Pos {
-	x int
-	y int
+// Test sum type with struct variants (not just primitives)
+// This mirrors the AST's Expr sum type pattern
+
+struct BasicLit {
+	kind  int
+	value string
 }
 
 struct Ident {
-	pos  Pos
 	name string
 }
 
-struct EmptyExpr {
-	dummy u8
+struct CallOrCast {
+	lhs  Expr
+	expr Expr
 }
 
-type Expr = EmptyExpr | Ident
+type Expr = BasicLit | CallOrCast | Ident
 
-fn (e Expr) get_pos() Pos {
-	return match e {
-		Ident { e.pos }
-		EmptyExpr { Pos{} }
+fn make_basic_lit(val string) Expr {
+	return BasicLit{
+		kind:  1
+		value: val
 	}
 }
 
-fn parse_a() Expr {
-	return Expr(Ident{
-		pos:  Pos{
-			x: 42
-			y: 99
-		}
-		name: 'aaa'
-	})
+fn make_ident(name string) Expr {
+	return Ident{
+		name: name
+	}
 }
 
-fn parse_b() Expr {
-	return Expr(Ident{
-		pos:  Pos{
-			x: 10
-			y: 20
-		}
-		name: 'bbb'
-	})
+fn make_call_or_cast(lhs Expr, expr Expr) Expr {
+	return CallOrCast{
+		lhs:  lhs
+		expr: expr
+	}
+}
+
+fn test_basic_lit() {
+	e := make_basic_lit('42')
+	if e is BasicLit {
+		assert e.value == '42'
+		assert e.kind == 1
+	} else {
+		assert false
+	}
 }
 
-fn test_nested(is_lcbr bool, is_comptime bool) {
-	// This mirrors the parser pattern exactly
-	mut cond := if is_lcbr {
-		Expr(EmptyExpr{})
+fn test_ident() {
+	e := make_ident('hello')
+	if e is Ident {
+		assert e.name == 'hello'
 	} else {
-		if is_comptime { parse_a() } else { parse_b() }
+		assert false
 	}
-	p := cond.get_pos()
-	println(p.x.str())
-	println(p.y.str())
 }
 
-fn main() {
-	println('case 1: lcbr=false comptime=true')
-	test_nested(false, true) // should print 42, 99
-	println('case 2: lcbr=false comptime=false')
-	test_nested(false, false) // should print 10, 20
-	println('case 3: lcbr=true comptime=true')
-	test_nested(true, true) // should print 0, 0
+fn test_call_or_cast() {
+	lhs := make_ident('int')
+	arg := make_basic_lit('0')
+	e := make_call_or_cast(lhs, arg)
+	if e is CallOrCast {
+		if e.lhs is Ident {
+			assert e.lhs.name == 'int'
+		} else {
+			assert false
+		}
+		if e.expr is BasicLit {
+			assert e.expr.value == '0'
+		} else {
+			assert false
+		}
+	} else {
+		assert false
+	}
+}
+
+fn test_nested_sum_field_access() {
+	// Create CallOrCast{lhs: Ident("int"), expr: BasicLit("0")}
+	// This mirrors: __global g_main_argc = int(0)
+	lhs := Expr(Ident{
+		name: 'int'
+	})
+	arg := Expr(BasicLit{
+		kind:  1
+		value: '0'
+	})
+	coce := CallOrCast{
+		lhs:  lhs
+		expr: arg
+	}
+	e := Expr(coce)
+	if e is CallOrCast {
+		// Access the nested Expr fields
+		inner_expr := e.expr
+		if inner_expr is BasicLit {
+			assert inner_expr.value == '0'
+		} else {
+			eprintln('ERROR: inner_expr is not BasicLit')
+			assert false
+		}
+	} else {
+		eprintln('ERROR: e is not CallOrCast')
+		assert false
+	}
 }

cmd/v2/v2.v

@@ -85,7 +85,8 @@ fn is_test_file(files []string) bool {
 
 // get_files extracts source files from args, excluding options and their values
 fn get_files(args []string) []string {
-	options_with_values := ['-backend', '-b', '-o', '-output', '-arch', '-printfn', '-gc', '-d']
+	options_with_values := ['-backend', '-b', '-o', '-output', '-arch', '-printfn', '-gc', '-d',
+		'-hot-fn']
 	mut files := []string{}
 	mut skip_next := false
 	for arg in args {

vlib/builtin/array.v

@@ -263,9 +263,9 @@ pub fn (a array) repeat_to_depth(count int, depth int) array {
 				for _ in 0 .. count {
 					if depth > 0 {
 						ary_clone := a.clone_to_depth(depth)
-						vmemcpy(eptr, &u8(ary_clone.data), a_total_size)
+						vmemcpy(eptr, ary_clone.data, a_total_size)
 					} else {
-						vmemcpy(eptr, &u8(a.data), a_total_size)
+						vmemcpy(eptr, a.data, a_total_size)
 					}
 					eptr += arr_step_size
 				}
@@ -733,7 +733,7 @@ pub fn (a &array) clone_to_depth(depth int) array {
 		return arr
 	} else {
 		if a.data != 0 && source_capacity_in_bytes > 0 {
-			unsafe { vmemcpy(&u8(arr.data), a.data, source_capacity_in_bytes) }
+			unsafe { vmemcpy(arr.data, a.data, source_capacity_in_bytes) }
 		}
 		return arr
 	}
@@ -976,14 +976,9 @@ pub fn (mut a array) sort_with_compare(callback fn (voidptr, voidptr) int) {
 // It uses the results of the given function to determine sort order.
 // See also .sort_with_compare()
 pub fn (a &array) sorted_with_compare(callback fn (voidptr, voidptr) int) array {
-	$if freestanding {
-		panic('sorted_with_compare does not work with -freestanding')
-	} $else {
-		mut r := a.clone()
-		unsafe { vqsort(r.data, usize(r.len), usize(r.element_size), callback) }
-		return r
-	}
-	return array{}
+	mut r := a.clone()
+	unsafe { C.qsort(r.data, usize(r.len), usize(r.element_size), voidptr(callback)) }
+	return r
 }
 
 // contains determines whether an array includes a certain value among its elements.
@@ -1046,7 +1041,7 @@ pub fn (b []u8) hex() string {
 	if b.len == 0 {
 		return ''
 	}
-	return unsafe { data_to_hex_string(&u8(b.data), b.len) }
+	return unsafe { data_to_hex_string(b.data, b.len) }
 }
 
 // copy copies the `src` byte array elements to the `dst` byte array.
@@ -1057,7 +1052,7 @@ pub fn (b []u8) hex() string {
 pub fn copy(mut dst []u8, src []u8) int {
 	min := if dst.len < src.len { dst.len } else { src.len }
 	if min > 0 {
-		unsafe { vmemmove(&u8(dst.data), src.data, min) }
+		unsafe { vmemmove(dst.data, src.data, min) }
 	}
 	return min
 }

vlib/builtin/builtin.v

@@ -35,3 +35,13 @@ fn __as_cast(obj voidptr, obj_type int, expected_type int) voidptr {
 	}
 	return obj
 }
+
+@[inline]
+fn __v2_flag_has_int(receiver int, flag int) bool {
+	return (receiver & flag) != 0
+}
+
+@[inline]
+fn __v2_flag_all_int(receiver int, flags int) bool {
+	return (receiver & flags) == flags
+}

vlib/builtin/chan_option_result.v

@@ -55,20 +55,10 @@ fn _result_ok(data voidptr, mut res _result, size int) {
 
 // str returns the message of IError.
 pub fn (err IError) str() string {
-	return match err {
-		None__ {
-			'none'
-		}
-		Error {
-			err.msg()
-		}
-		MessageError {
-			(*err).str()
-		}
-		else {
-			'${err.type_name()}: ${err.msg()}'
-		}
+	if err is None__ {
+		return 'none'
 	}
+	return err.msg()
 }
 
 // Error is the empty default implementation of `IError`.