v3: tighten fastc direct inference

Author: medvednikov

vlib/v3/README.md

@@ -112,15 +112,15 @@ Integer-range bounds in the direct lane are evaluated once, from left to right.
 C-string and embedded-NUL string literals, assertions, `sizeof`, comparison/logical, shift,
 division, and modulo expressions, and functions with narrow integer signatures are promoted to
 the complete lane. Expressions containing decimal `2147483648`, including composite minimum-`int`
-expressions, are promoted as well, as are expressions containing hexadecimal literals above the
-signed 32-bit range. Parallel assignments and indexing expressions are promoted, preserving
+expressions, are promoted as well, as are hexadecimal and binary literals above the signed 32-bit
+range. Parallel assignments and indexing expressions are promoted, preserving
 simultaneous assignment, V layouts, inferred types, element types, and bounds checks. Together these
 promotions preserve V's formatting, byte-length, diagnostics, boolean typing, integer-wrapping,
 safe-shift, and zero-divisor behavior instead of relying on incompatible raw C semantics.
 
-The direct path is limited to host-target, non-production, non-test, non-shared single-file builds.
-Compiler/self-host, strict C, and other non-direct modes enter the complete lane before source
-scanning.
+The direct path is limited to host-target, non-debug, non-production, non-test, non-shared
+single-file builds. Compiler/self-host, strict C, 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;
 otherwise it emits the complete `v3.gen.fastc` translation unit. Direct C-only output is published
 only after both V semantic checking and TinyCC validation succeed.

vlib/v3/driver/driver.v

@@ -7349,11 +7349,12 @@ pub fn run(args []string) {
 		fastc_eligible := input_file.ends_with('.v') && os.is_file(input_file) && file_list.len == 0
 			&& target.os == fastc_host.os && target.arch == fastc_host.arch && !is_test_command
 			&& !building_v && !is_selfhost && !is_checker_fixture && !is_prod && !is_shared
-			&& !is_livemain && !is_liveshared && !is_o && !is_prof && coverage_dir.len == 0
-			&& !ownership_mode && !only_check_syntax && !check_only && print_fn_names.len == 0
-			&& !print_v_files && !print_watched_files && dump_c_flags.len == 0
-			&& generate_c_project.len == 0 && !c99_explicit && !c_compiler_explicit && !no_builtin
-			&& !no_preludes && !check_overflow && !translated_mode && !is_repl && !is_strict
+			&& !is_livemain && !is_liveshared && !is_o && !is_prof && !is_debug
+			&& coverage_dir.len == 0 && !ownership_mode && !only_check_syntax && !check_only
+			&& print_fn_names.len == 0 && !print_v_files && !print_watched_files
+			&& dump_c_flags.len == 0 && generate_c_project.len == 0 && !c99_explicit
+			&& !c_compiler_explicit && !no_builtin && !no_preludes && !check_overflow
+			&& !translated_mode && !is_repl && !is_strict
 		mut generated_fastc := false
 		mut fastc_source := ''
 		if fastc_eligible {

vlib/v3/gen/fastc/fastc.v

@@ -589,18 +589,24 @@ fn (g &DirectGen) expression_token() !string {
 	}
 }
 
-fn fastc_hex_literal_requires_checked_type(literal string) bool {
+fn fastc_nondecimal_literal_requires_checked_type(literal string) bool {
 	clean := literal.replace('_', '')
-	if clean.len <= 2 || clean[0] != `0` || clean[1] !in [`x`, `X`] {
+	if clean.len <= 2 || clean[0] != `0` {
 		return false
 	}
 	digits := clean[2..].trim_left('0')
-	if digits.len > 8 {
-		return true
+	if clean[1] in [`x`, `X`] {
+		if digits.len > 8 {
+			return true
+		}
+		return digits.len == 8 && ((digits[0] >= `8` && digits[0] <= `9`)
+			|| (digits[0] >= `a` && digits[0] <= `f`)
+			|| (digits[0] >= `A` && digits[0] <= `F`))
 	}
-	return digits.len == 8 && ((digits[0] >= `8` && digits[0] <= `9`)
-		|| (digits[0] >= `a` && digits[0] <= `f`)
-		|| (digits[0] >= `A` && digits[0] <= `F`))
+	if clean[1] in [`b`, `B`] {
+		return digits.len >= 32
+	}
+	return false
 }
 
 fn fastc_c_number(literal string) !string {
@@ -611,8 +617,8 @@ fn fastc_c_number(literal string) !string {
 		// int, so only the checked lane can preserve its inferred type and wrapping.
 		return error('minimum int literal expressions require checked fastc')
 	}
-	if fastc_hex_literal_requires_checked_type(literal) {
-		return error('high-bit hexadecimal literals require checked fastc')
+	if fastc_nondecimal_literal_requires_checked_type(literal) {
+		return error('high-bit nondecimal literals require checked fastc')
 	}
 	if clean.len < 2 || clean[0] != `0` || !clean[1].is_digit() || clean.contains_any('.eE') {
 		return clean

vlib/v3/gen/fastc/fastc_test.v

@@ -174,6 +174,7 @@ fn test_type_sensitive_expressions_request_checked_lane() {
 		'module main\nfn main() { for i := -2_147_483_648; true; i-- { println(i); break } }\n',
 		'module main\nfn main() { mut x := -2_147_483_648 - 1; println(x) }\n',
 		'module main\nfn main() { x := 0xffff_ffff | 0; println(x) }\n',
+		'module main\nfn main() { x := 0b11111111111111111111111111111111 | 0; println(x) }\n',
 		'module main\nfn main() { mut a := 1; mut b := 2; a, b = b, a; println(a); println(b) }\n',
 	] {
 		mut failed := false
@@ -191,6 +192,9 @@ fn test_type_sensitive_expressions_request_checked_lane() {
 	low_hex_c := generate('module main\nfn main() { x := 0x7fff_ffff | 0; println(x) }\n',
 		'low_hex_literal.v', prefs) or { panic(err) }
 	assert low_hex_c.contains('__typeof__((0x7fffffff|0)) x = (0x7fffffff|0);')
+	low_binary_c := generate('module main\nfn main() { x := 0b01111111111111111111111111111111 | 0; println(x) }\n',
+		'low_binary_literal.v', prefs) or { panic(err) }
+	assert low_binary_c.contains('__typeof__((0b01111111111111111111111111111111|0))')
 	max_int_c := generate('module main\nfn main() { x := 2_147_483_647 - 1; println(x) }\n',
 		'max_int_expression.v', prefs) or { panic(err) }
 	assert max_int_c.contains('__typeof__((2147483647-1)) x = (2147483647-1);')

vlib/v3/tests/fastc_backend_test.v

@@ -55,6 +55,17 @@ fn main() {
 	assert strict_run.exit_code == 0, strict_run.output
 	assert strict_run.output.trim_space() == '42'
 
+	debug_binary := os.join_path(root, 'debug')
+	debug_compile := cmdexec.run(v3_bin, ['-silent', '-g', '-b', 'fastc', '-o', debug_binary,
+		valid_source])
+	assert debug_compile.exit_code == 0, debug_compile.output
+	debug_c := os.read_file(debug_binary + '.c') or { panic(err) }
+	assert !debug_c.contains('__typeof__((twice(21))) value = (twice(21));')
+	assert !debug_c.contains('V_FASTC_PRINT_SELECT')
+	debug_run := cmdexec.run(debug_binary, [])
+	assert debug_run.exit_code == 0, debug_run.output
+	assert debug_run.output.trim_space() == '42'
+
 	invalid_source := os.join_path(root, 'invalid.v')
 	os.write_file(invalid_source, 'module main
 
@@ -298,6 +309,26 @@ fn main() {
 	assert high_hex_run.exit_code == 0, high_hex_run.output
 	assert high_hex_run.output.trim_space() == '-1'
 
+	high_binary_source := os.join_path(root, 'inferred_high_binary.v')
+	os.write_file(high_binary_source, 'module main
+
+fn main() {
+	x := 0b11111111111111111111111111111111 | 0
+	println(x)
+}
+') or {
+		panic(err)
+	}
+	high_binary_binary := os.join_path(root, 'inferred_high_binary')
+	high_binary_compile := cmdexec.run(v3_bin, ['-silent', '-b', 'fastc', '-o', high_binary_binary,
+		high_binary_source])
+	assert high_binary_compile.exit_code == 0, high_binary_compile.output
+	high_binary_c := os.read_file(high_binary_binary + '.c') or { panic(err) }
+	assert !high_binary_c.contains('V_FASTC_PRINT_SELECT')
+	high_binary_run := cmdexec.run(high_binary_binary, [])
+	assert high_binary_run.exit_code == 0, high_binary_run.output
+	assert high_binary_run.output.trim_space() == '-1'
+
 	parallel_assign_source := os.join_path(root, 'parallel_assign.v')
 	os.write_file(parallel_assign_source, 'module main