v3: preserve fastc language semantics

Author: medvednikov

vlib/v3/README.md

@@ -108,6 +108,9 @@ parser or type-checker diagnostics rather than a speculative C diagnostic. The c
 the same language and ownership/autofree coverage as the C backend. A successfully compiled `run`
 program keeps its exit status and is never retried.
 
+Integer-range bounds in the direct lane are evaluated once, from left to right. Float printing is
+promoted to the complete lane so it uses V's `strconv` formatting rather than C `printf` rules.
+
 The direct path is limited to host-target, non-production, non-test, non-shared single-file builds.
 Compiler/self-host and other non-direct modes enter the complete lane before source scanning.
 `-o file.c` emits the standalone fast C translation unit when the direct lane supports the input;

vlib/v3/gen/fastc/fastc.v

@@ -37,17 +37,18 @@ static void v_fastc_print_bool(bool value) { fputs(value ? "true" : "false", std
 static void v_fastc_print_char(char value) { fputc(value, stdout); }
 static void v_fastc_print_signed(long long value) { printf("%lld", value); }
 static void v_fastc_print_unsigned(unsigned long long value) { printf("%llu", value); }
-static void v_fastc_print_float(double value) { printf("%g", value); }
 static void v_fastc_println_string(const char *value) { puts(value); }
 static void v_fastc_println_bool(bool value) { puts(value ? "true" : "false"); }
 static void v_fastc_println_char(char value) { fputc(value, stdout); fputc(10, stdout); }
 static void v_fastc_println_signed(long long value) { printf("%lld\n", value); }
 static void v_fastc_println_unsigned(unsigned long long value) { printf("%llu\n", value); }
-static void v_fastc_println_float(double value) { printf("%g\n", value); }
 
-#define V_FASTC_PRINT_SELECT(value, string_fn, bool_fn, char_fn, signed_fn, unsigned_fn, float_fn) _Generic((value), char *: string_fn, const char *: string_fn, bool: bool_fn, char: char_fn, signed char: signed_fn, short: signed_fn, int: signed_fn, long: signed_fn, long long: signed_fn, unsigned char: unsigned_fn, unsigned short: unsigned_fn, unsigned int: unsigned_fn, unsigned long: unsigned_fn, unsigned long long: unsigned_fn, float: float_fn, double: float_fn)(value)
-#define print(value) V_FASTC_PRINT_SELECT(value, v_fastc_print_string, v_fastc_print_bool, v_fastc_print_char, v_fastc_print_signed, v_fastc_print_unsigned, v_fastc_print_float)
-#define println(value) V_FASTC_PRINT_SELECT(value, v_fastc_println_string, v_fastc_println_bool, v_fastc_println_char, v_fastc_println_signed, v_fastc_println_unsigned, v_fastc_println_float)
+/* Float formatting belongs to the V strconv routines. Leaving float and double
+ * unmatched makes TinyCC reject this speculative candidate so the driver uses
+ * the checked FastC lane instead of silently applying printf %g semantics. */
+#define V_FASTC_PRINT_SELECT(value, string_fn, bool_fn, char_fn, signed_fn, unsigned_fn) _Generic((value), char *: string_fn, const char *: string_fn, bool: bool_fn, char: char_fn, signed char: signed_fn, short: signed_fn, int: signed_fn, long: signed_fn, long long: signed_fn, unsigned char: unsigned_fn, unsigned short: unsigned_fn, unsigned int: unsigned_fn, unsigned long: unsigned_fn, unsigned long long: unsigned_fn)(value)
+#define print(value) V_FASTC_PRINT_SELECT(value, v_fastc_print_string, v_fastc_print_bool, v_fastc_print_char, v_fastc_print_signed, v_fastc_print_unsigned)
+#define println(value) V_FASTC_PRINT_SELECT(value, v_fastc_println_string, v_fastc_println_bool, v_fastc_println_char, v_fastc_println_signed, v_fastc_println_unsigned)
 #define assert(value) do { if (!(value)) { fprintf(stderr, "assertion failed: %s\n", #value); abort(); } } while (0)
 
 '
@@ -62,6 +63,7 @@ mut:
 	protos  strings.Builder
 	indent  int
 	in_main bool
+	temp_id int
 }
 
 // generate scans V source and emits C as each declaration and statement is consumed. It does
@@ -114,6 +116,12 @@ fn (mut g DirectGen) next() {
 	g.lit = g.s.lit
 }
 
+fn (mut g DirectGen) temporary_name(kind string) string {
+	name := '__v_fastc_${kind}_${g.temp_id}'
+	g.temp_id++
+	return name
+}
+
 fn (mut g DirectGen) skip_semicolons() {
 	for g.tok == .semicolon {
 		g.next()
@@ -355,7 +363,12 @@ fn (mut g DirectGen) parse_for() ! {
 			g.expect(.dotdot)!
 			end := g.read_expression([token.Token.lcbr])!
 			g.expect(.lcbr)!
-			g.write_line('for (__typeof__((${start})) ${name} = (${start}); ${name} < (${end}); ${name}++) {')
+			start_name := g.temporary_name('range_start')
+			end_name := g.temporary_name('range_end')
+			// V evaluates both range bounds exactly once, from left to right.
+			g.write_line('__typeof__((${start})) ${start_name} = (${start});')
+			g.write_line('__typeof__((${end})) ${end_name} = (${end});')
+			g.write_line('for (__typeof__((${start_name})) ${name} = (${start_name}); ${name} < (${end_name}); ${name}++) {')
 			g.indent++
 			g.parse_block_body()!
 			g.indent--

vlib/v3/gen/fastc/fastc_test.v

@@ -78,3 +78,28 @@ fn main() {
 	assert c_source.contains('void stop(void) {\n\treturn;\n}')
 	assert c_source.contains('if (true) {\n\t\treturn 0;\n\t}')
 }
+
+fn test_integer_range_caches_bounds() {
+	prefs := pref.new_preferences()
+	c_source := generate('module main
+
+fn start() int {
+	return 0
+}
+
+fn limit() int {
+	return 3
+}
+
+fn main() {
+	for i in start() .. limit() {
+		println(i)
+	}
+}
+',
+		'range_bounds.v', prefs) or { panic(err) }
+	assert c_source.contains('__v_fastc_range_start_0 = (start());')
+	assert c_source.contains('__v_fastc_range_end_1 = (limit());')
+	assert c_source.contains('i < (__v_fastc_range_end_1)')
+	assert !c_source.contains('i < (limit())')
+}

vlib/v3/gen/fastc/fn.v

@@ -2983,6 +2983,11 @@ fn (mut g FlatGen) gen_mut_sum_lvalue_arg(arg_id flat.NodeId, expected types.Typ
 	mut lvalue_id := arg_id
 	if int(arg_id) >= 0 && int(arg_id) < g.a.nodes.len {
 		arg_node := g.a.nodes[int(arg_id)]
+		// Interface values use the sum-value ABI, and some call paths reach this
+		// helper before the general argument handling below.
+		if g.gen_lowered_mut_value_storage_arg(arg_id, arg_node, expected) {
+			return true
+		}
 		if arg_node.kind == .prefix && arg_node.op == .amp && arg_node.children_count > 0 {
 			lvalue_id = g.a.child(&arg_node, 0)
 		}
@@ -7068,6 +7073,11 @@ fn (mut g FlatGen) gen_call(id flat.NodeId, node flat.Node) {
 					g.expected_enum = ''
 					continue
 				}
+				if !is_c_call && arg_idx < typed_param_count
+					&& g.gen_lowered_mut_value_storage_arg(arg_id, arg_node, param_types[arg_idx]) {
+					g.expected_enum = ''
+					continue
+				}
 				if !is_c_call && arg_idx < typed_param_count
 					&& g.gen_mut_pointer_slot_arg(arg_id, arg_node, param_types[arg_idx]) {
 					g.expected_enum = ''
@@ -12918,6 +12928,10 @@ fn (mut g FlatGen) gen_call_args(fn_name string, node flat.Node, start int) {
 		if arg_idx < typed_param_count && g.gen_mut_sum_lvalue_arg(arg_id, param_types[arg_idx]) {
 			continue
 		}
+		if arg_idx < typed_param_count
+			&& g.gen_lowered_mut_value_storage_arg(arg_id, arg_node, param_types[arg_idx]) {
+			continue
+		}
 		if arg_idx < typed_param_count
 			&& g.gen_mut_pointer_slot_arg(arg_id, arg_node, param_types[arg_idx]) {
 			continue
@@ -14031,6 +14045,25 @@ fn (mut g FlatGen) gen_mut_pointer_slot_arg(arg_id flat.NodeId, arg_node flat.No
 	return true
 }
 
+fn (mut g FlatGen) gen_lowered_mut_value_storage_arg(arg_id flat.NodeId, arg_node flat.Node, expected types.Type) bool {
+	if arg_node.kind != .prefix || arg_node.op != .mul || arg_node.children_count != 1 {
+		return false
+	}
+	child_id := g.a.child(&arg_node, 0)
+	child := g.a.nodes[int(child_id)]
+	// Mutable array iteration stores the value as `T*` and lowers an ordinary
+	// expression to `*value`. In a source `mut value` argument the callee expects
+	// that storage pointer itself, including when T is an interface value.
+	if child.kind != .ident || !child.is_mut || !g.local_storage_is_pointer(child.value) {
+		return false
+	}
+	if g.tc.c_type(g.usable_expr_type(arg_id)) != g.tc.c_type(expected) {
+		return false
+	}
+	g.gen_expr(child_id)
+	return true
+}
+
 fn (g &FlatGen) c_typedef_nil_call(id flat.NodeId) bool {
 	if int(id) < 0 || int(id) >= g.a.nodes.len {
 		return false

vlib/v3/tests/fastc_backend_test.v

@@ -111,6 +111,64 @@ fn main() {
 	early_return_run := cmdexec.run(early_return_binary, [])
 	assert early_return_run.exit_code == 0, early_return_run.output
 
+	range_source := os.join_path(root, 'range.v')
+	os.write_file(range_source, 'module main
+
+fn start() int {
+	println("start")
+	return 0
+}
+
+fn limit() int {
+	println("limit")
+	return 3
+}
+
+fn main() {
+	for i in start() .. limit() {
+		println(i)
+	}
+}
+') or {
+		panic(err)
+	}
+	range_binary := os.join_path(root, 'range')
+	range_compile := cmdexec.run(v3_bin,
+		['-silent', '-b', 'fastc', '-o', range_binary, range_source])
+	assert range_compile.exit_code == 0, range_compile.output
+	range_c := os.read_file(range_binary + '.c') or { panic(err) }
+	assert range_c.contains('__v_fastc_range_start_0 = (start());')
+	assert range_c.contains('__v_fastc_range_end_1 = (limit());')
+	range_run := cmdexec.run(range_binary, [])
+	assert range_run.exit_code == 0, range_run.output
+	assert range_run.output.trim_space() == 'start\nlimit\n0\n1\n2'
+
+	float_source := os.join_path(root, 'float.v')
+	os.write_file(float_source, 'module main
+
+fn main() {
+	println(2.0)
+	println(12.3456789)
+}
+') or {
+		panic(err)
+	}
+	float_binary := os.join_path(root, 'float')
+	float_compile := cmdexec.run(v3_bin,
+		['-silent', '-b', 'fastc', '-o', float_binary, float_source])
+	assert float_compile.exit_code == 0, float_compile.output
+	float_run := cmdexec.run(float_binary, [])
+	assert float_run.exit_code == 0, float_run.output
+	assert float_run.output.trim_space() == '2.0\n12.3456789'
+
+	mutable_interface_source := os.join_path(os.dir(@FILE), 'mutable_interface_array_value_test.v')
+	mutable_interface_binary := os.join_path(root, 'mutable_interface_array_value_test')
+	mutable_interface_compile := cmdexec.run(v3_bin, ['-silent', '-b', 'fastc', '-o',
+		mutable_interface_binary, mutable_interface_source])
+	assert mutable_interface_compile.exit_code == 0, mutable_interface_compile.output
+	mutable_interface_run := cmdexec.run(mutable_interface_binary, [])
+	assert mutable_interface_run.exit_code == 0, mutable_interface_run.output
+
 	old_vjobs := os.getenv('VJOBS')
 	os.setenv('VJOBS', '4', true)
 	mut selfhosted_v3 := v3_bin