markused: clean up features tracking from checker - remove 1 all_fns loop (#24999)

felipensp · web-flow · commit 844b7007a7db · 2025-07-31T08:18:40.000+03:00
diff --git a/vlib/v/ast/table.v b/vlib/v/ast/table.v
@@ -10,13 +10,12 @@ import v.util
 @[heap; minify]
 pub struct UsedFeatures {
 pub mut:
-	dump           bool            // dump()
-	index          bool            // string[0]
+	dump           bool            // filled in by markused
 	range_index    bool            // string[0..1]
-	cast_ptr       bool            // &u8(...)
 	anon_fn        bool            // fn () { }
 	auto_str       bool            // auto str fns
 	auto_str_ptr   bool            // auto str fns for ptr type
+	auto_str_arr   bool            // auto str fns for array
 	arr_prepend    bool            // arr.prepend()
 	arr_insert     bool            // arr.insert()
 	arr_first      bool            // arr.first()
diff --git a/vlib/v/checker/checker.v b/vlib/v/checker/checker.v
@@ -3069,7 +3069,6 @@ pub fn (mut c Checker) expr(mut node ast.Expr) ast.Type {
 			return c.concat_expr(mut node)
 		}
 		ast.DumpExpr {
-			c.table.used_features.dump = true
 			c.expected_type = ast.string_type
 			node.expr_type = c.expr(mut node.expr)
 			c.markused_dumpexpr(mut node)
@@ -5014,7 +5013,6 @@ fn (mut c Checker) index_expr(mut node ast.IndexExpr) ast.Type {
 		if node.index is ast.RangeExpr {
 			c.table.used_features.range_index = true
 		}
-		c.table.used_features.index = true
 	}
 	is_aggregate_arr := typ_sym.kind == .aggregate
 		&& (typ_sym.info as ast.Aggregate).types.filter(c.table.type_kind(it) !in [.array, .array_fixed, .string, .map]).len == 0
diff --git a/vlib/v/checker/fn.v b/vlib/v/checker/fn.v
@@ -1441,7 +1441,7 @@ fn (mut c Checker) fn_call(mut node ast.CallExpr, mut continue_check &bool) ast.
 	if args_len > 0 && fn_name in print_everything_fns {
 		node.args[0].ct_expr = c.comptime.is_comptime(node.args[0].expr)
 		c.builtin_args(mut node, fn_name, func)
-		c.markused_fn_call(mut node)
+		c.markused_print_call(mut node)
 		return func.return_type
 	}
 	// `return error(err)` -> `return err`
diff --git a/vlib/v/checker/infix.v b/vlib/v/checker/infix.v
@@ -60,7 +60,6 @@ fn (mut c Checker) infix_expr(mut node ast.InfixExpr) ast.Type {
 		if left_type.has_flag(.option) {
 			c.error('cannot push to Option array that was not unwrapped first', node.left.pos())
 		}
-		c.markused_infixexpr(!c.is_builtin_mod && c.mod != 'strings')
 		if mut node.right is ast.IfExpr {
 			if node.right.is_expr && node.right.branches.len > 0 {
 				mut last_stmt := node.right.branches[0].stmts.last()
diff --git a/vlib/v/checker/used_features.v b/vlib/v/checker/used_features.v
@@ -36,6 +36,9 @@ fn (mut c Checker) markused_dumpexpr(mut node ast.DumpExpr) {
 		if node.expr_type.is_ptr() {
 			c.table.used_features.auto_str_ptr = true
 		}
+		if !c.table.used_features.auto_str_arr {
+			c.table.used_features.auto_str_arr = c.table.final_sym(unwrapped_type).kind == .array
+		}
 	} else {
 		c.table.used_features.print_types[node.expr_type.idx()] = true
 	}
@@ -58,9 +61,6 @@ fn (mut c Checker) markused_castexpr(mut node ast.CastExpr, to_type ast.Type, mu
 			c.table.used_features.used_maps++
 		}
 	}
-	if c.mod !in ['strings', 'math.bits'] && to_type.is_ptr() {
-		c.table.used_features.cast_ptr = true
-	}
 }
 
 fn (mut c Checker) markused_comptimecall(mut node ast.ComptimeCall) {
@@ -91,7 +91,6 @@ fn (mut c Checker) markused_comptimecall(mut node ast.ComptimeCall) {
 }
 
 fn (mut c Checker) markused_comptimefor(mut node ast.ComptimeFor, unwrapped_expr_type ast.Type) {
-	c.table.used_features.dump = true
 	if c.table.used_features.used_maps == 0 {
 		final_sym := c.table.final_sym(unwrapped_expr_type)
 		if final_sym.info is ast.Map {
@@ -108,34 +107,45 @@ fn (mut c Checker) markused_call_expr(left_type ast.Type, mut node ast.CallExpr)
 	if left_type != 0 && left_type.is_ptr() && !c.table.used_features.auto_str_ptr
 		&& node.name == 'str' {
 		c.table.used_features.auto_str_ptr = true
+		if !c.table.used_features.auto_str_arr {
+			c.table.used_features.auto_str_arr = c.table.final_sym(left_type).kind == .array
+		}
 	}
 }
 
-fn (mut c Checker) markused_fn_call(mut node ast.CallExpr) {
+fn (mut c Checker) markused_print_call(mut node ast.CallExpr) {
 	if !c.is_builtin_mod && c.mod != 'math.bits' && node.args[0].expr !is ast.StringLiteral {
+		arg_typ := c.unwrap_generic(node.args[0].typ)
 		if (node.args[0].expr is ast.CallExpr && node.args[0].expr.is_method
 			&& node.args[0].expr.name == 'str')
-			|| !c.table.sym(c.unwrap_generic(node.args[0].typ)).has_method('str') {
+			|| !c.table.sym(arg_typ).has_method('str') {
 			c.table.used_features.auto_str = true
 		} else {
-			if node.args[0].typ.has_option_or_result() {
+			if arg_typ.has_option_or_result() {
 				c.table.used_features.print_options = true
 			}
-			c.table.used_features.print_types[node.args[0].typ.idx()] = true
+			c.table.used_features.print_types[arg_typ.idx()] = true
 			if !c.table.used_features.auto_str_ptr && node.args[0].expr is ast.Ident {
 				var_obj := node.args[0].expr.obj
 				if var_obj is ast.Var {
-					if var_obj.orig_type != 0
-						&& c.table.final_sym(var_obj.orig_type).kind == .interface {
-						c.table.used_features.auto_str_ptr = true
+					if var_obj.orig_type != 0 {
+						fsym := c.table.final_sym(var_obj.orig_type)
+						if fsym.kind == .interface {
+							c.table.used_features.auto_str_ptr = true
+						} else if fsym.kind == .array {
+							c.table.used_features.auto_str_arr = true
+						}
 						return
 					}
 				}
 			}
 		}
-		if node.args[0].typ.is_ptr() {
+		if arg_typ.is_ptr() {
 			c.table.used_features.auto_str_ptr = true
 		}
+		if !c.table.used_features.auto_str_arr {
+			c.table.used_features.auto_str_arr = c.table.final_sym(arg_typ).kind == .array
+		}
 	}
 }
 
@@ -165,18 +175,14 @@ fn (mut c Checker) markused_string_inter_lit(mut node ast.StringInterLiteral, ft
 	if ftyp.is_ptr() {
 		c.table.used_features.auto_str_ptr = true
 	}
+	if !c.table.used_features.auto_str_arr {
+		c.table.used_features.auto_str_arr = c.table.final_sym(ftyp).kind == .array
+	}
 	if ftyp.has_option_or_result() {
 		c.table.used_features.print_options = true
 	}
 }
 
-fn (mut c Checker) markused_infixexpr(check bool) {
-	if !check {
-		return
-	}
-	c.table.used_features.index = true
-}
-
 fn (mut c Checker) markused_array_method(check bool, method_name string) {
 	if !check {
 		return
diff --git a/vlib/v/gen/c/dumpexpr.v b/vlib/v/gen/c/dumpexpr.v
@@ -107,6 +107,10 @@ fn (mut g Gen) dump_expr_definitions() {
 		}
 		_, str_method_expects_ptr, _ := dump_sym.str_method_info()
 		typ := ast.idx_to_type(dump_type)
+		if g.pref.skip_unused
+			&& (!g.table.used_features.dump || typ.idx() !in g.table.used_features.used_syms) {
+			continue
+		}
 		is_ptr := typ.is_ptr()
 		deref, _ := deref_kind(str_method_expects_ptr, is_ptr, typ)
 		to_string_fn_name := g.get_str_fn(typ.clear_flags(.shared_f, .result))
diff --git a/vlib/v/markused/markused.v b/vlib/v/markused/markused.v
@@ -85,21 +85,6 @@ pub fn mark_used(mut table ast.Table, mut pref_ pref.Preferences, ast_files []&a
 			core_fns << '__new_array_with_array_default_noscan'
 			core_fns << 'new_array_from_c_array'
 		}
-		if table.used_features.index || pref_.is_shared {
-			include_panic_deps = true
-			core_fns << string_idx_str + '.at_with_check'
-			core_fns << string_idx_str + '.clone'
-			core_fns << string_idx_str + '.clone_static'
-			core_fns << string_idx_str + '.at'
-			core_fns << array_idx_str + '.set'
-			core_fns << array_idx_str + '.get_with_check' // used for `x := a[i] or {}`
-			core_fns << ref_array_idx_str + '.set'
-			core_fns << map_idx_str + '.get'
-			core_fns << map_idx_str + '.set'
-			core_fns << '__new_array_noscan'
-			core_fns << ref_array_idx_str + '.push_noscan'
-			core_fns << ref_array_idx_str + '.push_many_noscan'
-		}
 		if table.used_features.range_index || pref_.is_shared {
 			core_fns << string_idx_str + '.substr_with_check'
 			core_fns << string_idx_str + '.substr_ni'
@@ -109,10 +94,6 @@ pub fn mark_used(mut table ast.Table, mut pref_ pref.Preferences, ast_files []&a
 			core_fns << array_idx_str + '.clone_static_to_depth'
 			core_fns << array_idx_str + '.clone_to_depth'
 		}
-		if table.used_features.auto_str || table.used_features.dump {
-			core_fns << string_idx_str + '.repeat'
-			core_fns << 'tos3'
-		}
 		if table.used_features.arr_prepend {
 			core_fns << ref_array_idx_str + '.prepend_many'
 		}
@@ -121,6 +102,7 @@ pub fn mark_used(mut table ast.Table, mut pref_ pref.Preferences, ast_files []&a
 		}
 		if table.used_features.arr_pop {
 			core_fns << ref_array_idx_str + '.pop'
+			core_fns << ref_array_idx_str + '.pop_noscan'
 		}
 		if table.used_features.arr_first {
 			core_fns << array_idx_str + '.first'
@@ -130,15 +112,7 @@ pub fn mark_used(mut table ast.Table, mut pref_ pref.Preferences, ast_files []&a
 		}
 		if table.used_features.arr_insert {
 			core_fns << ref_array_idx_str + '.insert_many'
-		}
-		if table.used_features.dump {
-			include_panic_deps = true
-			builderptr_idx := int(table.find_type('strings.Builder').ref()).str()
-			core_fns << [
-				builderptr_idx + '.str',
-				builderptr_idx + '.free',
-				builderptr_idx + '.write_rune',
-			]
+			core_fns << ref_array_idx_str + '.insert_noscan'
 		}
 		if table.used_features.print_options {
 			include_panic_deps = true
@@ -285,26 +259,6 @@ pub fn mark_used(mut table ast.Table, mut pref_ pref.Preferences, ast_files []&a
 	handle_vweb(mut table, mut all_fn_root_names, 'vweb.Result', 'vweb.filter', 'vweb.Context')
 	handle_vweb(mut table, mut all_fn_root_names, 'x.vweb.Result', 'x.vweb.filter', 'x.vweb.Context')
 
-	// handle ORM drivers:
-	orm_connection_implementations := table.iface_types['orm.Connection'] or { []ast.Type{} }
-	if orm_connection_implementations.len > 0 {
-		for k, _ in all_fns {
-			if k.starts_with('orm.') {
-				all_fn_root_names << k
-			}
-		}
-		for orm_type in orm_connection_implementations {
-			typ := int(orm_type).str()
-			all_fn_root_names << typ + '.select'
-			all_fn_root_names << typ + '.insert'
-			all_fn_root_names << typ + '.update'
-			all_fn_root_names << typ + '.delete'
-			all_fn_root_names << typ + '.create'
-			all_fn_root_names << typ + '.drop'
-			all_fn_root_names << typ + '.last_id'
-		}
-	}
-
 	if 'debug_used_features' in pref_.compile_defines {
 		eprintln('> debug_used_features: ${table.used_features}')
 	}
diff --git a/vlib/v/markused/walker.v b/vlib/v/markused/walker.v

Original file line number	Diff line number	Diff line change
`@@ -3069,7 +3069,6 @@ pub fn (mut c Checker) expr(mut node ast.Expr) ast.Type {`
`3069`	`3069`	`return c.concat_expr(mut node)`
`3070`	`3070`	`}`
`3071`	`3071`	`ast.DumpExpr {`
`3072`		`- c.table.used_features.dump = true`
`3073`	`3072`	`c.expected_type = ast.string_type`
`3074`	`3073`	`node.expr_type = c.expr(mut node.expr)`
`3075`	`3074`	`c.markused_dumpexpr(mut node)`
`@@ -5014,7 +5013,6 @@ fn (mut c Checker) index_expr(mut node ast.IndexExpr) ast.Type {`
`5014`	`5013`	`if node.index is ast.RangeExpr {`
`5015`	`5014`	`c.table.used_features.range_index = true`
`5016`	`5015`	`}`
`5017`		`- c.table.used_features.index = true`
`5018`	`5016`	`}`
`5019`	`5017`	`is_aggregate_arr := typ_sym.kind == .aggregate`
`5020`	`5018`	`&& (typ_sym.info as ast.Aggregate).types.filter(c.table.type_kind(it) !in [.array, .array_fixed, .string, .map]).len == 0`
Original file line number	Diff line number	Diff line change
`@@ -1441,7 +1441,7 @@ fn (mut c Checker) fn_call(mut node ast.CallExpr, mut continue_check &bool) ast.`
`1441`	`1441`	`if args_len > 0 && fn_name in print_everything_fns {`
`1442`	`1442`	`node.args[0].ct_expr = c.comptime.is_comptime(node.args[0].expr)`
`1443`	`1443`	`c.builtin_args(mut node, fn_name, func)`
`1444`		`- c.markused_fn_call(mut node)`
	`1444`	`+ c.markused_print_call(mut node)`
`1445`	`1445`	`return func.return_type`
`1446`	`1446`	`}`
`1447`	`1447`	// `return error(err)` -> `return err`
Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,6 @@ fn (mut c Checker) infix_expr(mut node ast.InfixExpr) ast.Type {`
`60`	`60`	`if left_type.has_flag(.option) {`
`61`	`61`	`c.error('cannot push to Option array that was not unwrapped first', node.left.pos())`
`62`	`62`	`}`
`63`		`- c.markused_infixexpr(!c.is_builtin_mod && c.mod != 'strings')`
`64`	`63`	`if mut node.right is ast.IfExpr {`
`65`	`64`	`if node.right.is_expr && node.right.branches.len > 0 {`
`66`	`65`	`mut last_stmt := node.right.branches[0].stmts.last()`
Original file line number	Diff line number	Diff line change
`@@ -36,6 +36,9 @@ fn (mut c Checker) markused_dumpexpr(mut node ast.DumpExpr) {`
`36`	`36`	`if node.expr_type.is_ptr() {`
`37`	`37`	`c.table.used_features.auto_str_ptr = true`
`38`	`38`	`}`
	`39`	`+ if !c.table.used_features.auto_str_arr {`
	`40`	`+ c.table.used_features.auto_str_arr = c.table.final_sym(unwrapped_type).kind == .array`
	`41`	`+ }`
`39`	`42`	`} else {`
`40`	`43`	`c.table.used_features.print_types[node.expr_type.idx()] = true`
`41`	`44`	`}`
`@@ -58,9 +61,6 @@ fn (mut c Checker) markused_castexpr(mut node ast.CastExpr, to_type ast.Type, mu`
`58`	`61`	`c.table.used_features.used_maps++`
`59`	`62`	`}`
`60`	`63`	`}`
`61`		`- if c.mod !in ['strings', 'math.bits'] && to_type.is_ptr() {`
`62`		`- c.table.used_features.cast_ptr = true`
`63`		`- }`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`fn (mut c Checker) markused_comptimecall(mut node ast.ComptimeCall) {`
`@@ -91,7 +91,6 @@ fn (mut c Checker) markused_comptimecall(mut node ast.ComptimeCall) {`
`91`	`91`	`}`
`92`	`92`
`93`	`93`	`fn (mut c Checker) markused_comptimefor(mut node ast.ComptimeFor, unwrapped_expr_type ast.Type) {`
`94`		`- c.table.used_features.dump = true`
`95`	`94`	`if c.table.used_features.used_maps == 0 {`
`96`	`95`	`final_sym := c.table.final_sym(unwrapped_expr_type)`
`97`	`96`	`if final_sym.info is ast.Map {`
`@@ -108,34 +107,45 @@ fn (mut c Checker) markused_call_expr(left_type ast.Type, mut node ast.CallExpr)`
`108`	`107`	`if left_type != 0 && left_type.is_ptr() && !c.table.used_features.auto_str_ptr`
`109`	`108`	`&& node.name == 'str' {`
`110`	`109`	`c.table.used_features.auto_str_ptr = true`
	`110`	`+ if !c.table.used_features.auto_str_arr {`
	`111`	`+ c.table.used_features.auto_str_arr = c.table.final_sym(left_type).kind == .array`
	`112`	`+ }`
`111`	`113`	`}`
`112`	`114`	`}`
`113`	`115`
`114`		`-fn (mut c Checker) markused_fn_call(mut node ast.CallExpr) {`
	`116`	`+fn (mut c Checker) markused_print_call(mut node ast.CallExpr) {`
`115`	`117`	`if !c.is_builtin_mod && c.mod != 'math.bits' && node.args[0].expr !is ast.StringLiteral {`
	`118`	`+ arg_typ := c.unwrap_generic(node.args[0].typ)`
`116`	`119`	`if (node.args[0].expr is ast.CallExpr && node.args[0].expr.is_method`
`117`	`120`	`&& node.args[0].expr.name == 'str')`
`118`		`- \|\| !c.table.sym(c.unwrap_generic(node.args[0].typ)).has_method('str') {`
	`121`	`+ \|\| !c.table.sym(arg_typ).has_method('str') {`
`119`	`122`	`c.table.used_features.auto_str = true`
`120`	`123`	`} else {`
`121`		`- if node.args[0].typ.has_option_or_result() {`
	`124`	`+ if arg_typ.has_option_or_result() {`
`122`	`125`	`c.table.used_features.print_options = true`
`123`	`126`	`}`
`124`		`- c.table.used_features.print_types[node.args[0].typ.idx()] = true`
	`127`	`+ c.table.used_features.print_types[arg_typ.idx()] = true`
`125`	`128`	`if !c.table.used_features.auto_str_ptr && node.args[0].expr is ast.Ident {`
`126`	`129`	`var_obj := node.args[0].expr.obj`
`127`	`130`	`if var_obj is ast.Var {`
`128`		`- if var_obj.orig_type != 0`
`129`		`- && c.table.final_sym(var_obj.orig_type).kind == .interface {`
`130`		`- c.table.used_features.auto_str_ptr = true`
	`131`	`+ if var_obj.orig_type != 0 {`
	`132`	`+ fsym := c.table.final_sym(var_obj.orig_type)`
	`133`	`+ if fsym.kind == .interface {`
	`134`	`+ c.table.used_features.auto_str_ptr = true`
	`135`	`+ } else if fsym.kind == .array {`
	`136`	`+ c.table.used_features.auto_str_arr = true`
	`137`	`+ }`
`131`	`138`	`return`
`132`	`139`	`}`
`133`	`140`	`}`
`134`	`141`	`}`
`135`	`142`	`}`
`136`		`- if node.args[0].typ.is_ptr() {`
	`143`	`+ if arg_typ.is_ptr() {`
`137`	`144`	`c.table.used_features.auto_str_ptr = true`
`138`	`145`	`}`
	`146`	`+ if !c.table.used_features.auto_str_arr {`
	`147`	`+ c.table.used_features.auto_str_arr = c.table.final_sym(arg_typ).kind == .array`
	`148`	`+ }`
`139`	`149`	`}`
`140`	`150`	`}`
`141`	`151`
`@@ -165,18 +175,14 @@ fn (mut c Checker) markused_string_inter_lit(mut node ast.StringInterLiteral, ft`
`165`	`175`	`if ftyp.is_ptr() {`
`166`	`176`	`c.table.used_features.auto_str_ptr = true`
`167`	`177`	`}`
	`178`	`+ if !c.table.used_features.auto_str_arr {`
	`179`	`+ c.table.used_features.auto_str_arr = c.table.final_sym(ftyp).kind == .array`
	`180`	`+ }`
`168`	`181`	`if ftyp.has_option_or_result() {`
`169`	`182`	`c.table.used_features.print_options = true`
`170`	`183`	`}`
`171`	`184`	`}`
`172`	`185`
`173`		`-fn (mut c Checker) markused_infixexpr(check bool) {`
`174`		`- if !check {`
`175`		`- return`
`176`		`- }`
`177`		`- c.table.used_features.index = true`
`178`		`-}`
`179`		`-`
`180`	`186`	`fn (mut c Checker) markused_array_method(check bool, method_name string) {`
`181`	`187`	`if !check {`
`182`	`188`	`return`