cgen: route integer interpolation through str_intp

Author: medvednikov

vlib/v/gen/c/coutput_test.v

@@ -339,7 +339,7 @@ fn test_simple_string_interpolation_does_not_emit_str_intp_runtime() {
 	os.chdir(vroot) or {}
 	test_source := os.join_path(os.vtmp_dir(), 'coutput_simple_interpolation_no_str_intp.vv')
 	os.write_file(test_source,
-		"module main\n\nimport time\n\nfn main() {\n\tt := time.now()\n\tprintln('elapsed \${time.since(t)}')\n}\n")!
+		"module main\n\nfn label() string {\n\treturn 'V'\n}\n\nfn main() {\n\tprintln('elapsed \${label()}')\n}\n")!
 	defer {
 		os.rm(test_source) or {}
 	}
@@ -350,6 +350,28 @@ fn test_simple_string_interpolation_does_not_emit_str_intp_runtime() {
 	assert !compilation.output.contains('StrIntpData')
 }
 
+fn test_skip_unused_os_integer_interpolation_keeps_str_intp_runtime() {
+	os.chdir(vroot) or {}
+	os_function_source := os.join_path(vroot, 'vlib/os/coutput_skip_unused_int_interpolation.v')
+	test_source := os.join_path(os.vtmp_dir(), 'coutput_os_int_interpolation.vv')
+	pexe := os.join_path(os.vtmp_dir(), 'coutput_os_int_interpolation.exe')
+	os.write_file(os_function_source,
+		"module os\n\npub fn coutput_skip_unused_int_interpolation(n int) string {\n\treturn '\${n}'\n}\n")!
+	os.write_file(test_source,
+		'module main\n\nimport os\n\nfn main() {\n\tprintln(os.coutput_skip_unused_int_interpolation(7))\n}\n')!
+	defer {
+		os.rm(os_function_source) or {}
+		os.rm(test_source) or {}
+		os.rm(pexe) or {}
+	}
+	cmd := '${os.quoted_path(vexe)} -skip-unused -o ${os.quoted_path(pexe)} ${os.quoted_path(test_source)}'
+	compilation := os.execute(cmd)
+	ensure_compilation_succeeded(compilation, cmd)
+	res := os.execute(os.quoted_path(pexe))
+	assert res.exit_code == 0
+	assert res.output.trim_space() == '7'
+}
+
 fn test_auto_str_float_array_still_emits_str_intp_runtime() {
 	os.chdir(vroot) or {}
 	test_source := os.join_path(os.vtmp_dir(), 'coutput_float_array_str_intp.vv')

vlib/v/gen/c/str_intp.v

@@ -838,6 +838,19 @@ fn (mut g Gen) string_inter_literal(node ast.StringInterLiteral) {
 
 const simple_string_interpolation_default_precision = 987698
 
+fn (mut g Gen) simple_string_interpolation_needs_str_intp(typ ast.Type) bool {
+	if g.is_builtin_mod {
+		return false
+	}
+	if typ.has_option_or_result() {
+		return false
+	}
+	resolved_typ := g.unwrap_generic(typ).clear_flags()
+	return resolved_typ in [ast.i8_type, ast.i16_type, ast.i32_type, ast.int_type, ast.i64_type,
+		ast.isize_type, ast.u8_type, ast.u16_type, ast.u32_type, ast.u64_type, ast.usize_type,
+		ast.int_literal_type]
+}
+
 fn (mut g Gen) gen_simple_string_inter_literal(node ast.StringInterLiteral, fmts []u8) bool {
 	if g.is_autofree || g.pref.gc_mode == .boehm_leak {
 		// The fast `string_plus_many` lowering can leave nested temporary
@@ -852,6 +865,9 @@ fn (mut g Gen) gen_simple_string_inter_literal(node ast.StringInterLiteral, fmts
 		if i >= node.need_fmts.len || node.need_fmts[i] || i >= fmts.len || fmts[i] == `_` {
 			return false
 		}
+		if g.simple_string_interpolation_needs_str_intp(node.expr_types[i]) {
+			return false
+		}
 		normalized_expr_type := g.table.fully_unaliased_type(g.unwrap_generic(node.expr_types[i]))
 		// Pointer aliases need the full `str_intp` path so nil formatting stays
 		// consistent with plain pointer interpolation.

vlib/v/gen/c/testdata/string_interpolation_simple_optimization.c.must_have

@@ -1,3 +1,3 @@
-return builtin__int_str(n);
-builtin__string_plus_many(3, _MOV((string[3]){prefix, builtin__int_str(n), suffix}))
-builtin__string_plus_many(4, _MOV((string[4]){_S("n="), builtin__int_str(n), _S(":"), suffix}))
+return builtin__str_intp(2, _MOV((StrIntpData[]){{_SLIT0, 0xfe07, {.d_i32 = n}, 0, 0, 0}, {_SLIT0, 0, { .d_c = 0 }, 0, 0, 0}}));
+return builtin__str_intp(4, _MOV((StrIntpData[]){{_SLIT0, 0xfe10, {.d_s = prefix}, 0, 0, 0}, {_SLIT0, 0xfe07, {.d_i32 = n}, 0, 0, 0}, {_SLIT0, 0xfe10, {.d_s = suffix}, 0, 0, 0}, {_SLIT0, 0, { .d_c = 0 }, 0, 0, 0}}));
+return builtin__str_intp(3, _MOV((StrIntpData[]){{_S("n="), 0xfe07, {.d_i32 = n}, 0, 0, 0}, {_S(":"), 0xfe10, {.d_s = suffix}, 0, 0, 0}, {_SLIT0, 0, { .d_c = 0 }, 0, 0, 0}}));

vlib/v/markused/walker.v

@@ -6,6 +6,7 @@ module markused
 // Unused functions can be safely skipped by the backends to save CPU time and space.
 import v.ast
 import v.pref
+import v.util
 
 const simple_string_interpolation_default_precision = 987698
 
@@ -48,6 +49,7 @@ mut:
 	all_structs   map[string]ast.StructDecl
 
 	cur_fn                      string
+	cur_mod                     string
 	cur_fn_concrete_types       []ast.Type
 	level                       int
 	is_builtin_mod              bool
@@ -1387,12 +1389,7 @@ fn (mut w Walker) expr(node_ ast.Expr) {
 			w.mark_by_type(node.typ)
 		}
 		ast.StringInterLiteral {
-			if w.string_inter_literal_needs_runtime(node) {
-				w.uses_interp = true
-				w.uses_interp_isnil = w.uses_interp_isnil || w.string_inter_literal_uses_isnil(node)
-			} else {
-				w.mark_simple_string_inter_literal(node)
-			}
+			w.mark_string_inter_literal(node)
 			w.exprs(node.exprs)
 			for expr in node.fwidth_exprs {
 				if expr !is ast.EmptyExpr {
@@ -1585,9 +1582,11 @@ fn (mut w Walker) fn_decl_with_concrete_types(mut node ast.FnDecl, concrete_type
 	w.is_direct_array_access = node.is_direct_arr || w.pref.no_bounds_checking
 	defer { w.is_direct_array_access = last_is_direct_array_access }
 	last_cur_fn := w.cur_fn
+	last_cur_mod := w.cur_mod
 	last_cur_fn_concrete_types := w.cur_fn_concrete_types.clone()
 	defer {
 		w.cur_fn = last_cur_fn
+		w.cur_mod = last_cur_mod
 		w.cur_fn_concrete_types = last_cur_fn_concrete_types
 	}
 	if w.trace_enabled {
@@ -1657,7 +1656,9 @@ fn (mut w Walker) fn_decl_with_concrete_types(mut node ast.FnDecl, concrete_type
 		}
 	}
 	prev_cur_fn := w.cur_fn
+	prev_cur_mod := w.cur_mod
 	w.cur_fn = fkey
+	w.cur_mod = node.mod
 	w.cur_fn_concrete_types = resolved_concrete_types
 	if node.mod == 'x.json2' && node.name == 'get_decoded_sumtype_workaround'
 		&& w.has_sumtype_generic_context(resolved_concrete_types) {
@@ -1772,6 +1773,7 @@ fn (mut w Walker) fn_decl_with_concrete_types(mut node ast.FnDecl, concrete_type
 	w.stmts(node.stmts)
 	w.defer_stmts(node.defer_stmts)
 	w.cur_fn = prev_cur_fn
+	w.cur_mod = prev_cur_mod
 }
 
 fn (mut w Walker) fn_decl_with_fkey(mut node ast.FnDecl, walk_fkey string) {
@@ -2715,6 +2717,15 @@ fn (w &Walker) infer_expr_type(expr ast.Expr) ast.Type {
 	}
 }
 
+fn (mut w Walker) mark_string_inter_literal(node ast.StringInterLiteral) {
+	if w.string_inter_literal_needs_runtime(node) {
+		w.uses_interp = true
+		w.uses_interp_isnil = w.uses_interp_isnil || w.string_inter_literal_uses_isnil(node)
+	} else {
+		w.mark_simple_string_inter_literal(node)
+	}
+}
+
 fn (mut w Walker) string_inter_literal_needs_runtime(node ast.StringInterLiteral) bool {
 	if w.pref.autofree || w.pref.gc_mode == .boehm_leak {
 		return true
@@ -2736,6 +2747,9 @@ fn (mut w Walker) string_inter_literal_needs_runtime(node ast.StringInterLiteral
 		if typ == 0 || typ == ast.void_type || typ.has_flag(.generic) {
 			return true
 		}
+		if w.simple_string_interpolation_type_needs_runtime(typ) {
+			return true
+		}
 		normalized_expr_type := w.table.fully_unaliased_type(typ)
 		if normalized_expr_type.is_any_kind_of_pointer() || normalized_expr_type.is_int_valptr()
 			|| normalized_expr_type.is_float_valptr() {
@@ -2776,6 +2790,19 @@ fn (mut w Walker) string_inter_literal_needs_runtime(node ast.StringInterLiteral
 	return false
 }
 
+fn (w &Walker) simple_string_interpolation_type_needs_runtime(typ ast.Type) bool {
+	if util.module_is_builtin(w.cur_mod) {
+		return false
+	}
+	if typ.has_option_or_result() {
+		return false
+	}
+	resolved_typ := typ.clear_flags()
+	return resolved_typ in [ast.i8_type, ast.i16_type, ast.i32_type, ast.int_type, ast.i64_type,
+		ast.isize_type, ast.u8_type, ast.u16_type, ast.u32_type, ast.u64_type, ast.usize_type,
+		ast.int_literal_type]
+}
+
 fn (mut w Walker) string_inter_literal_uses_isnil(node ast.StringInterLiteral) bool {
 	for typ in node.expr_types {
 		resolved_typ := w.table.fully_unaliased_type(w.resolve_current_generic_type(typ))
@@ -3549,6 +3576,7 @@ fn (mut w Walker) mark_generic_body_dependencies_in_expr(expr_ ast.Expr) {
 			w.mark_generic_body_dependencies_in_expr(expr.right)
 		}
 		ast.StringInterLiteral {
+			w.mark_string_inter_literal(expr)
 			for sub_expr in expr.exprs {
 				w.mark_generic_body_dependencies_in_expr(sub_expr)
 			}
@@ -3628,7 +3656,7 @@ fn (mut w Walker) mark_resource_dependencies() {
 	if w.uses_interp_isnil || w.auto_str_needs_isnil() {
 		w.fn_by_name('isnil')
 	}
-	if w.auto_str_needs_str_intp() {
+	if w.uses_interp || w.auto_str_needs_str_intp() {
 		w.fn_by_name('str_intp')
 		w.mark_by_sym_name('StrIntpData')
 		w.mark_by_sym_name('StrIntpMem')