vfmt: add support for 64bit int with -new_int (part 2) (#25298)

Author: kbkpbot

cmd/tools/vfmt.v

@@ -27,6 +27,7 @@ struct FormatOptions {
 	is_worker  bool // true *only* in the worker processes. Note: workers can crash.
 	is_backup  bool // make a `file.v.bak` copy *before* overwriting a `file.v` in place with `-w`
 	in_process bool // do not fork a worker process; potentially faster, but more prone to crashes for invalid files
+	is_new_int bool // Forcefully cast the `int` type in @[translated] modules or in the definition of `C.func` to the `i32` type.
 mut:
 	diff_cmd string // filled in when -diff or -verify is passed
 }
@@ -55,6 +56,7 @@ fn main() {
 		is_verify:  '-verify' in args
 		is_backup:  '-backup' in args
 		in_process: '-inprocess' in args
+		is_new_int: '-new_int' in args
 	}
 	if term_colors {
 		os.setenv('VCOLORS', 'always', true)
@@ -184,6 +186,7 @@ fn (foptions &FormatOptions) vlog(msg string) {
 fn (foptions &FormatOptions) formated_content_from_file(prefs &pref.Preferences, file string) string {
 	mut table := ast.new_table()
 	file_ast := parser.parse_file(file, mut table, .parse_comments, prefs)
+	table.new_int = foptions.is_new_int
 	formated_content := fmt.fmt(file_ast, mut table, prefs, foptions.is_debug)
 	return formated_content
 }
@@ -202,6 +205,7 @@ fn (foptions &FormatOptions) format_file(file string) {
 	prefs, mut table := setup_preferences_and_table()
 	file_ast := parser.parse_file(file, mut table, .parse_comments, prefs)
 	// checker.new_checker(table, prefs).check(file_ast)
+	table.new_int = foptions.is_new_int
 	formatted_content := fmt.fmt(file_ast, mut table, prefs, foptions.is_debug)
 	os.write_file(vfmt_output_path, formatted_content) or { panic(err) }
 	foptions.vlog('fmt.fmt worked and ${formatted_content.len} bytes were written to ${vfmt_output_path} .')
@@ -214,6 +218,7 @@ fn (foptions &FormatOptions) format_pipe() {
 	input_text := os.get_raw_lines_joined()
 	file_ast := parser.parse_text(input_text, '', mut table, .parse_comments, prefs)
 	// checker.new_checker(table, prefs).check(file_ast)
+	table.new_int = foptions.is_new_int
 	formatted_content := fmt.fmt(file_ast, mut table, prefs, foptions.is_debug,
 		source_text: input_text
 	)

vlib/v/ast/str.v

@@ -119,6 +119,9 @@ pub fn (t &Table) stringify_fn_decl(node &FnDecl, cur_mod string, m2a map[string
 		}
 		f.write_string(node.receiver.name + ' ')
 		styp = util.no_cur_mod(styp, cur_mod)
+		if t.new_int_fmt_fix && styp == 'int' {
+			styp = 'i32'
+		}
 		f.write_string(styp + ') ')
 	} else if node.is_static_type_method {
 		mut styp := util.no_cur_mod(t.type_to_code(node.receiver.typ.clear_flag(.shared_f)),
@@ -176,6 +179,7 @@ fn (t &Table) stringify_fn_after_name(node &FnDecl, mut f strings.Builder, cur_m
 		if param.is_hidden {
 			continue
 		}
+		param_typ := if t.new_int_fmt_fix && param.typ == int_type { i32_type } else { param.typ }
 		is_last_param := i == node.params.len - 1
 		is_type_only := param.name == ''
 		if param.on_newline {
@@ -187,19 +191,24 @@ fn (t &Table) stringify_fn_after_name(node &FnDecl, mut f strings.Builder, cur_m
 			f.write_string(' ')
 		}
 		if param.is_mut {
-			f.write_string(param.typ.share().str() + ' ')
+			f.write_string(param_typ.share().str() + ' ')
 		}
 		f.write_string(param.name)
-		param_sym := t.sym(param.typ)
+		param_sym := t.sym(param_typ)
 		if param_sym.info is Struct && param_sym.info.is_anon {
-			if param.typ.has_flag(.option) {
+			if param_typ.has_flag(.option) {
 				f.write_string(' ?')
 			} else {
 				f.write_string(' ')
 			}
 			f.write_string('struct {')
 			for field in param_sym.info.fields {
-				f.write_string(' ${field.name} ${t.type_to_str(field.typ)}')
+				field_typ := if t.new_int_fmt_fix && field.typ == int_type {
+					i32_type
+				} else {
+					field.typ
+				}
+				f.write_string(' ${field.name} ${t.type_to_str(field_typ)}')
 				if field.has_default_expr {
 					f.write_string(' = ${field.default_expr}')
 				}
@@ -209,14 +218,14 @@ fn (t &Table) stringify_fn_after_name(node &FnDecl, mut f strings.Builder, cur_m
 			}
 			f.write_string('}')
 		} else {
-			mut s := t.type_to_str(param.typ.clear_flag(.shared_f))
+			mut s := t.type_to_str(param_typ.clear_flag(.shared_f))
 			if param.is_mut {
 				if s.starts_with('&') && ((!param_sym.is_number() && param_sym.kind != .bool)
 					|| node.language != .v
-					|| (param.typ.is_ptr() && param_sym.kind == .struct)) {
+					|| (param_typ.is_ptr() && param_sym.kind == .struct)) {
 					s = s[1..]
-				} else if param.typ.is_ptr() && param_sym.kind == .struct && !s.contains('[') {
-					s = t.type_to_str(param.typ.clear_flag(.shared_f).deref())
+				} else if param_typ.is_ptr() && param_sym.kind == .struct && !s.contains('[') {
+					s = t.type_to_str(param_typ.clear_flag(.shared_f).deref())
 				}
 			}
 			s = util.no_cur_mod(s, cur_mod)
@@ -239,7 +248,12 @@ fn (t &Table) stringify_fn_after_name(node &FnDecl, mut f strings.Builder, cur_m
 	}
 	f.write_string(')')
 	if node.return_type != void_type {
-		sreturn_type := util.no_cur_mod(t.type_to_str(node.return_type), cur_mod)
+		return_type := if t.new_int_fmt_fix && node.return_type == int_type {
+			i32_type
+		} else {
+			node.return_type
+		}
+		sreturn_type := util.no_cur_mod(t.type_to_str(return_type), cur_mod)
 		short_sreturn_type := shorten_full_name_based_on_aliases(sreturn_type, m2a)
 		f.write_string(' ${short_sreturn_type}')
 	}

vlib/v/ast/table.v

@@ -99,6 +99,8 @@ pub mut:
 	anon_union_names    map[string]int // anon union name -> union sym idx
 	anon_union_counter  int
 	comptime_is_true    map[string]ComptTimeCondResult // The evaluate cond results for different generic types combination, such as `comptime_is_true['T=int,X=string|main.v|pos ...'] = {true, '!DEFINED(WINDOWS)'}`
+	new_int             bool // use 64bit/32bit platform dependent `int`
+	new_int_fmt_fix     bool // vfmt will fix `int` to `i32`
 }
 
 pub struct ComptTimeCondResult {

vlib/v/fmt/fm_new_int_test.v

@@ -0,0 +1,70 @@
+// Copyright (c) 2019-2024 Alexander Medvednikov. All rights reserved.
+// Use of this source code is governed by an MIT license
+// that can be found in the LICENSE file.
+import os
+import term
+import benchmark
+import v.ast
+import v.fmt
+import v.parser
+import v.pref
+import v.util.diff
+import v.util.vtest
+
+const vroot = @VEXEROOT
+const tdir = os.join_path(vroot, 'vlib', 'v', 'fmt')
+const fpref = &pref.Preferences{
+	is_fmt: true
+}
+
+fn run_fmt(mut input_files []string) {
+	fmt_message := 'vfmt new_int tests'
+	eprintln(term.header(fmt_message, '-'))
+	tmpfolder := os.temp_dir()
+	assert input_files.len > 0
+	input_files = vtest.filter_vtest_only(input_files)
+	if input_files.len == 0 {
+		// No need to produce a failing test here.
+		eprintln('no tests found with VTEST_ONLY filter set to: ' + os.getenv('VTEST_ONLY'))
+		exit(0)
+	}
+	mut fmt_bench := benchmark.new_benchmark()
+	fmt_bench.set_total_expected_steps(input_files.len)
+	for istep, ipath in input_files {
+		fmt_bench.cstep = istep
+		fmt_bench.step()
+		opath := ipath.replace('_input.vv', '_expected_new_int.vv')
+		if !os.exists(opath) {
+			// skip not exist files
+			continue
+		}
+		expected_ocontent := os.read_file(opath) or {
+			fmt_bench.fail()
+			eprintln(fmt_bench.step_message_fail('cannot read from ${opath}'))
+			continue
+		}
+		mut table := ast.new_table()
+		file_ast := parser.parse_file(ipath, mut table, .parse_comments, fpref)
+		table.new_int = true
+		result_ocontent := fmt.fmt(file_ast, mut table, fpref, false)
+		if expected_ocontent != result_ocontent {
+			fmt_bench.fail()
+			eprintln(fmt_bench.step_message_fail('file ${ipath} after formatting, does not look as expected.'))
+			vfmt_result_file := os.join_path(tmpfolder, 'vfmt_run_over_${os.file_name(ipath)}')
+			os.write_file(vfmt_result_file, result_ocontent) or { panic(err) }
+			println(diff.compare_files(opath, vfmt_result_file) or { err.msg() })
+			continue
+		}
+		fmt_bench.ok()
+		eprintln(fmt_bench.step_message_ok(ipath))
+	}
+	fmt_bench.stop()
+	eprintln(term.h_divider('-'))
+	eprintln(fmt_bench.total_message(fmt_message))
+	assert fmt_bench.nfail == 0
+}
+
+fn test_new_int_fmt() {
+	mut input_files := os.walk_ext(os.join_path(tdir, 'tests'), '_input.vv')
+	run_fmt(mut input_files)
+}