v2: major improvements to cleanc, transformer, SSA builder, and ARM64 backend; hello world with builtin compiles and runs!

  - Replace transform module with new transformer module for better AST transformations
  - Expand cleanc C code generator with significantly improved code generation
  - Enhance SSA builder with additional IR construction capabilities
  - Fix ARM64 native backend - now passes all tests
  - Add ARM64 test infrastructure (run_tests.v, string_concat.v)
  - Add comptime evaluation fixes
  - Add README with ARM64 testing instructions
  - Minor fixes to scanner, ast, types, and pref modules

Author: medvednikov

cmd/v2/README.md

@@ -0,0 +1,15 @@
+# Run all ARM64 tests
+```
+  ./v run vlib/v2/gen/arm64/tests/run_tests.v
+
+```
+  # Run specific test with test_ssa_backends
+```
+  cd cmd/v2
+  ./test_ssa_backends arm64 ../../vlib/v2/gen/arm64/tests/string_concat.v
+```
+
+  # Or directly with v2
+```
+  ./v2 -backend arm64 ../../vlib/v2/gen/arm64/tests/string_concat.v
+```

cmd/v2/test.v

@@ -33,6 +33,14 @@ enum Status {
 	done    = 2
 }
 
+// Flag enum for bitfield operations
+@[flag]
+enum Permissions {
+	read
+	write
+	execute
+}
+
 // Interface declaration
 interface Drawable {
 	draw() int
@@ -336,6 +344,131 @@ fn defer_fn_test() int {
 	return x // returns 3, but defer(fn) adds 300 at function end
 }
 
+// ===================== FLAG ENUM TEST =====================
+
+fn flag_enum_test() int {
+	// Test flag enum .has() method
+	// Use fully qualified enum values (shorthand in | expr needs type inference)
+	perms := Permissions.read | Permissions.write
+	mut result := 0
+	if perms.has(.read) {
+		result += 1
+	}
+	if perms.has(.write) {
+		result += 2
+	}
+	if perms.has(.execute) {
+		result += 4 // Should NOT execute
+	}
+	// Test .all() method - use fully qualified for | in argument
+	if perms.all(Permissions.read | Permissions.write) {
+		result += 10
+	}
+	if perms.all(Permissions.read | Permissions.execute) {
+		result += 20 // Should NOT execute
+	}
+	return result // Expected: 1 + 2 + 10 = 13
+}
+
+// Debug test for flag enum - returns raw value of perms
+fn flag_enum_debug() int {
+	// This should be: read (1) | write (2) = 3
+	perms := Permissions.read | Permissions.write
+	return int(perms) // Expected: 3
+}
+
+// Debug test - return has(.read) as int
+fn flag_enum_has_read() int {
+	perms := Permissions.read | Permissions.write
+	if perms.has(.read) {
+		return 1
+	}
+	return 0
+}
+
+// Debug test - return has(.execute) as int
+fn flag_enum_has_execute() int {
+	perms := Permissions.read | Permissions.write
+	if perms.has(.execute) {
+		return 1 // Should NOT return this
+	}
+	return 0 // Expected: 0
+}
+
+// Debug test - return values of individual enum members
+fn flag_enum_values() int {
+	r := int(Permissions.read) // Expected: 1
+	w := int(Permissions.write) // Expected: 2
+	e := int(Permissions.execute) // Expected: 4
+	return r + w * 10 + e * 100 // Expected: 1 + 20 + 400 = 421
+}
+
+// Debug test - raw AND operation
+fn flag_enum_and_test() int {
+	perms := Permissions.read | Permissions.write // 3
+	exec := Permissions.execute // 4
+	result := int(perms) & int(exec) // 3 & 4 = 0
+	return result // Expected: 0
+}
+
+// Debug test - manual has check without calling has() method
+fn flag_enum_manual_has() int {
+	perms := Permissions.read | Permissions.write // 3
+	exec := Permissions.execute // 4
+	anded := int(perms) & int(exec) // 3 & 4 = 0
+	if anded != 0 {
+		return 1 // Should NOT return this
+	}
+	return 0 // Expected: 0
+}
+
+// Debug test - return has() result directly as int (no if)
+fn flag_enum_has_result() int {
+	perms := Permissions.read | Permissions.write
+	result := perms.has(.execute)
+	return int(result) // Expected: 0 (false)
+}
+
+// Debug test - manual implementation of has() logic
+fn flag_enum_manual_has_impl(self int, flag int) int {
+	anded := self & flag
+	if anded != 0 {
+		return 1
+	}
+	return 0
+}
+
+// Debug test - call manual has impl
+fn flag_enum_manual_call() int {
+	perms := Permissions.read | Permissions.write // 3
+	exec := Permissions.execute // 4
+	return flag_enum_manual_has_impl(int(perms), int(exec)) // Expected: 0
+}
+
+// Debug test - check what values the has() gets
+// This is exactly like has() but returns the args
+fn flag_enum_debug_args(self Permissions, flag Permissions) int {
+	// Return self * 100 + flag so we can see both values
+	return int(self) * 100 + int(flag)
+}
+
+// Debug test - call debug_args (without shorthand)
+fn flag_enum_check_args() int {
+	perms := Permissions.read | Permissions.write // 3
+	exec := Permissions.execute // 4
+	return flag_enum_debug_args(perms, exec) // Expected: 304 (3 * 100 + 4)
+}
+
+// Debug test - simple 2-arg function with ints
+fn simple_two_arg(a int, b int) int {
+	return a * 100 + b
+}
+
+// Debug test - call simple 2-arg function
+fn flag_enum_check_int_args() int {
+	return simple_two_arg(3, 4) // Expected: 304
+}
+
 // ===================== IF-GUARD HELPERS =====================
 
 // Returns the value if positive, none otherwise
@@ -2065,6 +2198,30 @@ fn main() {
 	// 38.6 Test defer(fn) - function-level defer
 	print_int(defer_fn_test()) // 303 (3 from loop + 300 from function-level defers)
 
+	// 38.7 Test flag enum .has() and .all() methods
+	print_str('enum vals (exp 421):')
+	print_int(flag_enum_values()) // Expected: 421 (1 + 20 + 400)
+	print_str('AND test (exp 0):')
+	print_int(flag_enum_and_test()) // Expected: 0 (3 & 4 = 0)
+	print_str('manual has (exp 0):')
+	print_int(flag_enum_manual_has()) // Expected: 0 (manual has check)
+	print_str('flag debug (exp 3):')
+	print_int(flag_enum_debug()) // Expected: 3 (read=1 | write=2)
+	print_str('has read (exp 1):')
+	print_int(flag_enum_has_read()) // Expected: 1
+	print_str('has exec (exp 0):')
+	print_int(flag_enum_has_execute()) // Expected: 0
+	print_str('has result (exp 0):')
+	print_int(flag_enum_has_result()) // Expected: 0 (direct bool->int)
+	print_str('manual call (exp 0):')
+	print_int(flag_enum_manual_call()) // Expected: 0 (manual has impl)
+	print_str('check args (exp 304):')
+	print_int(flag_enum_check_args()) // Expected: 304 (perms=3, exec=4)
+	print_str('int args (exp 304):')
+	print_int(flag_enum_check_int_args()) // Expected: 304
+	print_str('full test (exp 13):')
+	print_int(flag_enum_test()) // Expected: 13 (1 + 2 + 10)
+
 	// ==================== 39. ENUMS ====================
 	print_str('--- 39. Enums ---')
 

cmd/v2/test_ssa_backends.v

@@ -30,17 +30,27 @@ fn main() {
 	}
 
 	// Parse test file from args or default to test.v
-	input_file := 'test.v'
+	// Support: ./test_ssa_backends arm64 path/to/file.v
+	mut input_file := 'test.v'
+	for arg in os.args {
+		if arg.ends_with('.v') && arg != @FILE {
+			input_file = arg
+			break
+		}
+	}
 	if !os.exists(input_file) {
 		eprintln('Error: ${input_file} not found')
 		return
 	}
 
+	// Derive output binary name from input file
+	base_name := os.file_name(input_file).replace('.v', '')
+
 	// Run v2 with selected backend
 	println('[*] Running v2 -backend ${backend} ${input_file}...')
-	mut v2_cmd := '${v2_binary} -backend ${backend} ${input_file}'
+	mut v2_cmd := '${v2_binary} -backend ${backend} ${input_file} -o ${base_name}'
 	if os.args.contains('--skip-builtin') {
-		v2_cmd = '${v2_binary} -backend ${backend} --skip-builtin ${input_file}'
+		v2_cmd = '${v2_binary} -backend ${backend} --skip-builtin ${input_file} -o ${base_name}'
 	}
 	v2_res := os.execute(v2_cmd)
 	if v2_res.exit_code != 0 {
@@ -51,6 +61,12 @@ fn main() {
 	println(v2_res.output)
 	println('compilation took ${time.since(t0)}')
 
+	// Save the v2-produced binary before running reference (which would overwrite it)
+	os.cp('./${base_name}', './${base_name}_v2') or {
+		eprintln('Error: Failed to save v2 binary')
+		return
+	}
+
 	// Run Reference (v run test.v)
 	println('[*] Running reference: v -enable-globals run ${input_file}...')
 	ref_res := os.execute('v -n -w -enable-globals run ${input_file}')
@@ -62,16 +78,11 @@ fn main() {
 	// Normalize newlines
 	expected_out := ref_res.output.trim_space().replace('\r\n', '\n')
 
-	// Run Generated Binary
+	// Run Generated Binary (the v2-produced one we saved earlier)
 	println('[*] Running generated binary...')
-	// Use script command to create a pty (fixes output buffering issues with printf)
-	// The -q flag suppresses "Script started" messages, /dev/null discards the typescript file
-	mut cmd := 'script -q /dev/null ./out_bin'
+	mut cmd := './${base_name}_v2'
 	if os.user_os() == 'windows' {
-		cmd = 'out_bin.exe'
-	} else if os.user_os() != 'macos' {
-		// Linux version of script has different syntax
-		cmd = 'script -q -c ./out_bin /dev/null'
+		cmd = '${base_name}_v2.exe'
 	}
 	gen_res := os.execute(cmd)
 	if gen_res.exit_code != 0 {
@@ -98,6 +109,9 @@ fn main() {
 		println('\n[FAILURE] Outputs differ')
 		expected_lines := expected_out.split('\n')
 		actual_lines := actual_out.split('\n')
+
+		// Find first differing line
+		mut first_diff := -1
 		max_lines := if expected_lines.len > actual_lines.len {
 			expected_lines.len
 		} else {
@@ -107,9 +121,30 @@ fn main() {
 			exp := if i < expected_lines.len { expected_lines[i] } else { '<missing>' }
 			act := if i < actual_lines.len { actual_lines[i] } else { '<missing>' }
 			if exp != act {
-				println('line ${i + 1}:')
-				println('  expected: ${exp}')
-				println('       got: ${act}')
+				first_diff = i
+				break
+			}
+		}
+
+		if first_diff >= 0 {
+			context := 2
+			start := if first_diff > context { first_diff - context } else { 0 }
+			end := if first_diff + context + 1 < max_lines {
+				first_diff + context + 1
+			} else {
+				max_lines
+			}
+
+			println('\nExpected (reference compiler):')
+			for i in start .. end {
+				line := if i < expected_lines.len { expected_lines[i] } else { '<missing>' }
+				println('${i + 1}: ${line}')
+			}
+
+			println('\nGot (v2 ${backend}):')
+			for i in start .. end {
+				line := if i < actual_lines.len { actual_lines[i] } else { '<missing>' }
+				println('${i + 1}: ${line}')
 			}
 		}
 	}

vlib/v2/ast/ast.v

@@ -651,6 +651,12 @@ pub fn (attributes []Attribute) has(name string) bool {
 		if attribute.name == name {
 			return true
 		}
+		// Also check value when it's a simple identifier (e.g., @[flag])
+		if attribute.name == '' {
+			if attribute.value is Ident && attribute.value.name == name {
+				return true
+			}
+		}
 	}
 	return false
 }