markused: reduce hello world csize by 49%, do more cleanups and improvements (#24971)

felipensp · web-flow · commit 396dc77a2020 · 2025-07-29T09:00:57.000+03:00
diff --git a/cmd/tools/vast/vast.v b/cmd/tools/vast/vast.v
@@ -1468,6 +1468,7 @@ fn (t Tree) index_expr(node ast.IndexExpr) &Node {
 	obj.add_terse('is_setter', t.bool_node(node.is_setter))
 	obj.add_terse('is_direct', t.bool_node(node.is_direct))
 	obj.add_terse('or_expr', t.or_expr(node.or_expr))
+	obj.add_terse('typ', t.type_node(node.typ))
 	obj.add('pos', t.pos(node.pos))
 	return obj
 }
diff --git a/vlib/builtin/string.v b/vlib/builtin/string.v
@@ -134,7 +134,7 @@ pub fn tos2(s &u8) string {
 // It will panic, when the pointer `s` is 0.
 // It is the same as `tos2`, but for &char pointers, avoiding callsite casts.
 // See also `tos_clone`.
-@[markused; unsafe]
+@[unsafe]
 pub fn tos3(s &char) string {
 	if s == 0 {
 		panic('tos3: nil string')
@@ -151,7 +151,7 @@ pub fn tos3(s &char) string {
 // It returns '', when given a 0 pointer `s`, it does NOT panic.
 // It is the same as `tos5`, but for &u8 pointers, avoiding callsite casts.
 // See also `tos_clone`.
-@[markused; unsafe]
+@[unsafe]
 pub fn tos4(s &u8) string {
 	if s == 0 {
 		return ''
@@ -168,7 +168,7 @@ pub fn tos4(s &u8) string {
 // It returns '', when given a 0 pointer `s`, it does NOT panic.
 // It is the same as `tos4`, but for &char pointers, avoiding callsite casts.
 // See also `tos_clone`.
-@[markused; unsafe]
+@[unsafe]
 pub fn tos5(s &char) string {
 	if s == 0 {
 		return ''
diff --git a/vlib/v/ast/ast.v b/vlib/v/ast/ast.v
@@ -1207,6 +1207,7 @@ pub mut:
 	is_option bool // IfGuard
 	is_direct bool // Set if the underlying memory can be safely accessed
 	is_gated  bool // #[] gated array
+	typ       Type
 }
 
 @[minify]
diff --git a/vlib/v/ast/table.v b/vlib/v/ast/table.v
@@ -14,7 +14,6 @@ pub mut:
 	index          bool            // string[0]
 	range_index    bool            // string[0..1]
 	cast_ptr       bool            // &u8(...)
-	asserts        bool            // assert expr
 	anon_fn        bool            // fn () { }
 	auto_str       bool            // auto str fns
 	auto_str_ptr   bool            // auto str fns for ptr type
@@ -25,10 +24,8 @@ pub mut:
 	arr_pop        bool            // arr.pop()
 	arr_delete     bool            // arr.delete()
 	arr_reverse    bool            // arr.reverse()
-	arr_init       bool            // [1, 2, 3]
 	arr_map        bool            // []map[key]value
 	type_name      bool            // var.type_name()
-	map_update     bool            // {...foo}
 	print_options  bool            // print option type
 	print_types    map[int]bool    // print() idx types
 	used_fns       map[string]bool // filled in by markused
@@ -39,11 +36,8 @@ pub mut:
 	used_maps      int             // how many times maps were used, filled in by markused
 	used_none      int             // how many times `none` was used, filled in by markused
 	// json             bool            // json is imported
-	debugger       bool            // debugger is used
 	comptime_calls map[string]bool // resolved name to call on comptime
-	comptime_syms  map[int]bool    // resolved syms (generic)
-	comptime_for   bool            // uses $for
-	memory_align   bool            // @[aligned] for struct
+	comptime_syms  map[Type]bool   // resolved syms (generic)
 }
 
 @[unsafe]
diff --git a/vlib/v/checker/checker.v b/vlib/v/checker/checker.v
@@ -2385,9 +2385,7 @@ fn (mut c Checker) stmt(mut node ast.Stmt) {
 			}
 		}
 		ast.NodeError {}
-		ast.DebuggerStmt {
-			c.table.used_features.debugger = true
-		}
+		ast.DebuggerStmt {}
 		ast.AsmStmt {
 			c.asm_stmt(mut node)
 		}
@@ -2398,9 +2396,6 @@ fn (mut c Checker) stmt(mut node ast.Stmt) {
 }
 
 fn (mut c Checker) assert_stmt(mut node ast.AssertStmt) {
-	if node.is_used {
-		c.table.used_features.asserts = true
-	}
 	cur_exp_typ := c.expected_type
 	c.expected_type = ast.bool_type
 	assert_type := c.check_expr_option_or_result_call(node.expr, c.expr(mut node.expr))
@@ -5140,6 +5135,7 @@ fn (mut c Checker) index_expr(mut node ast.IndexExpr) ast.Type {
 	}
 	c.stmts_ending_with_expression(mut node.or_expr.stmts, c.expected_or_type)
 	c.check_expr_option_or_result_call(node, typ)
+	node.typ = typ
 	return typ
 }
 
diff --git a/vlib/v/checker/comptime.v b/vlib/v/checker/comptime.v
@@ -277,7 +277,6 @@ fn (mut c Checker) comptime_for(mut node ast.ComptimeFor) {
 				prev_inside_x_matches_type := c.inside_x_matches_type
 				c.push_new_comptime_info()
 				c.comptime.inside_comptime_for = true
-				c.table.used_features.comptime_for = true
 				if c.field_data_type == 0 {
 					c.field_data_type = c.table.find_type('FieldData')
 				}
@@ -322,7 +321,6 @@ fn (mut c Checker) comptime_for(mut node ast.ComptimeFor) {
 			c.type_resolver.update_ct_type('${node.val_var}.typ', node.typ)
 			c.stmts(mut node.stmts)
 			c.pop_comptime_info()
-			c.table.used_features.comptime_for = true
 		} else {
 			c.error('iterating over .values is supported only for enums, and ${sym.name} is not an enum',
 				node.typ_pos)
@@ -340,7 +338,6 @@ fn (mut c Checker) comptime_for(mut node ast.ComptimeFor) {
 			c.stmts(mut node.stmts)
 			c.pop_comptime_info()
 		}
-		c.table.used_features.comptime_for = true
 	} else if node.kind == .params {
 		if !(sym.kind == .function || sym.name == 'FunctionData') {
 			c.error('iterating over `.params` is supported only for functions, and `${sym.name}` is not a function',
diff --git a/vlib/v/checker/containers.v b/vlib/v/checker/containers.v
@@ -8,14 +8,14 @@ import v.token
 fn (mut c Checker) array_init(mut node ast.ArrayInit) ast.Type {
 	mut elem_type := ast.void_type
 	unwrap_elem_type := c.unwrap_generic(node.elem_type)
+	if node.typ.has_flag(.generic) {
+		c.table.used_features.comptime_syms[c.unwrap_generic(node.typ)] = true
+	}
 	if c.pref.warn_about_allocs {
 		c.warn_alloc('array initialization', node.pos)
 	}
 	// `x := []string{}` (the type was set in the parser)
 	if node.typ != ast.void_type {
-		if !c.is_builtin_mod && c.mod !in ['builtin', 'strings', 'strconv', 'math.bits'] {
-			c.table.used_features.arr_init = true
-		}
 		if node.elem_type != 0 {
 			elem_sym := c.table.sym(node.elem_type)
 			c.check_any_type(node.elem_type, elem_sym, node.pos)
@@ -159,9 +159,6 @@ fn (mut c Checker) array_init(mut node ast.ArrayInit) ast.Type {
 	}
 	// `[1,2,3]`
 	if node.exprs.len > 0 && node.elem_type == ast.void_type {
-		if !c.is_builtin_mod && c.mod !in ['builtin', 'strings', 'strconv', 'math.bits'] {
-			c.table.used_features.arr_init = true
-		}
 		mut expected_value_type := ast.void_type
 		mut expecting_interface_array := false
 		mut expecting_sumtype_array := false
@@ -502,6 +499,9 @@ fn (mut c Checker) map_init(mut node ast.MapInit) ast.Type {
 	// `x := map[string]string` - set in parser
 	if node.typ != 0 {
 		info := c.table.sym(node.typ).map_info()
+		if node.typ.has_flag(.generic) {
+			c.table.used_features.comptime_syms[c.unwrap_generic(node.typ)] = true
+		}
 		if info.value_type != 0 {
 			if info.value_type.has_flag(.result) {
 				c.error('cannot use Result type as map value type', node.pos)
@@ -541,7 +541,6 @@ fn (mut c Checker) map_init(mut node ast.MapInit) ast.Type {
 	}
 
 	if (node.keys.len > 0 && node.vals.len > 0) || node.has_update_expr {
-		c.table.used_features.map_update = true
 		mut map_type := ast.void_type
 		use_expected_type := c.expected_type != ast.void_type && !c.inside_const
 			&& c.table.sym(c.expected_type).kind == .map && !(c.inside_fn_arg
diff --git a/vlib/v/checker/fn.v b/vlib/v/checker/fn.v
@@ -342,9 +342,15 @@ fn (mut c Checker) fn_decl(mut node ast.FnDecl) {
 			if c.pref.skip_unused {
 				if param.typ.has_flag(.generic) {
 					c.table.used_features.comptime_syms[c.unwrap_generic(param.typ)] = true
+					c.table.used_features.comptime_syms[param.typ] = true
 				}
 				if node.return_type.has_flag(.generic) {
 					c.table.used_features.comptime_syms[c.unwrap_generic(node.return_type)] = true
+					c.table.used_features.comptime_syms[node.return_type] = true
+				}
+				if node.receiver.typ.has_flag(.generic) {
+					c.table.used_features.comptime_syms[node.receiver.typ] = true
+					c.table.used_features.comptime_syms[c.unwrap_generic(node.receiver.typ)] = true
 				}
 			}
 			if param.name == node.mod && param.name != 'main' {
@@ -1895,6 +1901,7 @@ fn (mut c Checker) fn_call(mut node ast.CallExpr, mut continue_check &bool) ast.
 			c.register_trace_call(node, func)
 			if func.return_type.has_flag(.generic) {
 				c.table.used_features.comptime_syms[typ.clear_option_and_result()] = true
+				c.table.used_features.comptime_syms[func.return_type] = true
 			}
 			return typ
 		}
@@ -2028,6 +2035,10 @@ fn (mut c Checker) method_call(mut node ast.CallExpr, mut continue_check &bool)
 	node.return_type = left_type
 	node.receiver_type = left_type
 
+	if is_generic {
+		c.table.used_features.comptime_syms[c.unwrap_generic(left_type)] = true
+	}
+
 	if c.table.cur_fn != unsafe { nil } && c.table.cur_fn.generic_names.len > 0 {
 		c.table.unwrap_generic_type(left_type, c.table.cur_fn.generic_names, c.table.cur_concrete_types)
 	}
diff --git a/vlib/v/checker/struct.v b/vlib/v/checker/struct.v
@@ -68,10 +68,6 @@ fn (mut c Checker) struct_decl(mut node ast.StructDecl) {
 			if node.language != .c && attr.name == 'typedef' {
 				c.error('`typedef` attribute can only be used with C structs', node.pos)
 			}
-			aligned := if attr.arg == '' { 0 } else { attr.arg.int() }
-			if aligned > 1 {
-				c.table.used_features.memory_align = true
-			}
 		}
 
 		// Evaluate the size of the unresolved fixed array
@@ -533,6 +529,7 @@ fn (mut c Checker) struct_init(mut node ast.StructInit, is_field_zero_struct_ini
 			true)
 		if c.pref.skip_unused && node.typ.has_flag(.generic) {
 			c.table.used_features.comptime_syms[c.unwrap_generic(node.typ)] = true
+			c.table.used_features.comptime_syms[node.typ] = true
 		}
 	}
 	if !is_field_zero_struct_init {
@@ -865,8 +862,6 @@ or use an explicit `unsafe{ a[..] }`, if you do not want a copy of the slice.',
 				mut info := first_sym.info as ast.Struct
 				c.check_uninitialized_struct_fields_and_embeds(node, first_sym, mut info, mut
 					inited_fields)
-			} else if first_sym.kind == .array {
-				c.table.used_features.arr_init = true
 			}
 		}
 		.none {
diff --git a/vlib/v/checker/used_features.v b/vlib/v/checker/used_features.v
@@ -175,7 +175,6 @@ fn (mut c Checker) markused_infixexpr(check bool) {
 		return
 	}
 	c.table.used_features.index = true
-	c.table.used_features.arr_init = true
 }
 
 fn (mut c Checker) markused_array_method(check bool, method_name string) {
@@ -184,7 +183,6 @@ fn (mut c Checker) markused_array_method(check bool, method_name string) {
 	}
 	match method_name {
 		'' { // array init
-			c.table.used_features.arr_init = true
 		}
 		'first' {
 			c.table.used_features.arr_first = true
diff --git a/vlib/v/gen/c/cgen.v b/vlib/v/gen/c/cgen.v
@@ -1702,6 +1702,9 @@ pub fn (mut g Gen) write_typedef_types() {
 	type_symbols := g.table.type_symbols.filter(!it.is_builtin
 		&& it.kind in [.array, .array_fixed, .chan, .map])
 	for sym in type_symbols {
+		if g.pref.skip_unused && sym.idx !in g.table.used_features.used_syms {
+			continue
+		}
 		match sym.kind {
 			.array {
 				info := sym.info as ast.Array
@@ -1752,9 +1755,6 @@ pub fn (mut g Gen) write_typedef_types() {
 					chan_inf := sym.chan_info()
 					chan_elem_type := chan_inf.elem_type
 					esym := g.table.sym(chan_elem_type)
-					if g.pref.skip_unused && esym.idx !in g.table.used_features.used_syms {
-						continue
-					}
 					g.type_definitions.writeln('typedef chan ${sym.cname};')
 					is_fixed_arr := esym.kind == .array_fixed
 					if !chan_elem_type.has_flag(.generic) {
@@ -1776,9 +1776,6 @@ static inline void __${sym.cname}_pushval(${sym.cname} ch, ${push_arg} val) {
 				}
 			}
 			.map {
-				if g.pref.skip_unused && g.table.used_features.used_maps == 0 {
-					continue
-				}
 				g.type_definitions.writeln('typedef map ${sym.cname};')
 			}
 			else {
@@ -2614,7 +2611,8 @@ fn (mut g Gen) stmt(node ast.Stmt) {
 		ast.InterfaceDecl {
 			// definitions are sorted and added in write_types
 			ts := g.table.sym(node.typ)
-			if !(ts.info as ast.Interface).is_generic {
+			if !(ts.info as ast.Interface).is_generic
+				&& (!g.pref.skip_unused || ts.idx in g.table.used_features.used_syms) {
 				for method in node.methods {
 					if method.return_type.has_flag(.option) {
 						// Register an option if it's not registered yet
@@ -6711,7 +6709,8 @@ fn (mut g Gen) write_types(symbols []&ast.TypeSymbol) {
 		}
 		match sym.info {
 			ast.Struct {
-				if !struct_names[name] {
+				if !struct_names[name]
+					&& (!g.pref.skip_unused || sym.idx in g.table.used_features.used_syms) {
 					// generate field option types for fixed array of option struct before struct declaration
 					opt_fields := sym.info.fields.filter(g.table.final_sym(it.typ).kind == .array_fixed)
 					for opt_field in opt_fields {
@@ -6733,15 +6732,13 @@ fn (mut g Gen) write_types(symbols []&ast.TypeSymbol) {
 							}
 						}
 					}
-					if g.pref.skip_unused && sym.idx !in g.table.used_features.used_syms {
-						continue
-					}
 					g.struct_decl(sym.info, name, false, false)
 					struct_names[name] = true
 				}
 			}
 			ast.Thread {
-				if !g.pref.is_bare && !g.pref.no_builtin {
+				if !g.pref.is_bare && !g.pref.no_builtin
+					&& (!g.pref.skip_unused || sym.idx in g.table.used_features.used_syms) {
 					if g.pref.os == .windows {
 						if name == '__v_thread' {
 							g.thread_definitions.writeln('typedef HANDLE ${name};')
@@ -6814,7 +6811,8 @@ fn (mut g Gen) write_types(symbols []&ast.TypeSymbol) {
 			ast.ArrayFixed {
 				elem_sym := g.table.sym(sym.info.elem_type)
 				if !elem_sym.is_builtin() && !sym.info.elem_type.has_flag(.generic)
-					&& !sym.info.is_fn_ret {
+					&& (!g.pref.skip_unused || (!sym.info.is_fn_ret
+					&& sym.idx in g.table.used_features.used_syms)) {
 					// .array_fixed {
 					styp := sym.cname
 					// array_fixed_char_300 => char x[300]
@@ -6848,10 +6846,6 @@ fn (mut g Gen) write_types(symbols []&ast.TypeSymbol) {
 								}
 								g.type_definitions.writeln('typedef ${fixed_elem_name} ${styp} [${len}];')
 							} else if !(elem_sym.info is ast.ArrayFixed && elem_sym.info.is_fn_ret) {
-								if g.pref.skip_unused
-									&& elem_sym.idx !in g.table.used_features.used_syms {
-									continue
-								}
 								g.type_definitions.writeln('typedef ${fixed_elem_name} ${styp} [${len}];')
 							}
 						}
diff --git a/vlib/v/gen/c/testdata/alias_c_parent_type_decl.vv b/vlib/v/gen/c/testdata/alias_c_parent_type_decl.vv
@@ -1,3 +1,4 @@
 pub struct C.atype {}
 
+@[markused]
 type BType = &C.atype
diff --git a/vlib/v/gen/c/testdata/iface_method_order.vv b/vlib/v/gen/c/testdata/iface_method_order.vv
@@ -10,6 +10,7 @@ fn (b Bar) b() {}
 
 fn (b Bar) a() {}
 
+@[markused]
 struct Baz implements Foo {
 }
 
diff --git a/vlib/v/markused/markused.v b/vlib/v/markused/markused.v
diff --git a/vlib/v/markused/walker.v b/vlib/v/markused/walker.v
diff --git a/vlib/v/type_resolver/comptime_resolver.v b/vlib/v/type_resolver/comptime_resolver.v

Original file line number	Diff line number	Diff line change
`@@ -1468,6 +1468,7 @@ fn (t Tree) index_expr(node ast.IndexExpr) &Node {`
`1468`	`1468`	`obj.add_terse('is_setter', t.bool_node(node.is_setter))`
`1469`	`1469`	`obj.add_terse('is_direct', t.bool_node(node.is_direct))`
`1470`	`1470`	`obj.add_terse('or_expr', t.or_expr(node.or_expr))`
	`1471`	`+ obj.add_terse('typ', t.type_node(node.typ))`
`1471`	`1472`	`obj.add('pos', t.pos(node.pos))`
`1472`	`1473`	`return obj`
`1473`	`1474`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1207,6 +1207,7 @@ pub mut:`
`1207`	`1207`	`is_option bool // IfGuard`
`1208`	`1208`	`is_direct bool // Set if the underlying memory can be safely accessed`
`1209`	`1209`	`is_gated bool // #[] gated array`
	`1210`	`+ typ Type`
`1210`	`1211`	`}`
`1211`	`1212`
`1212`	`1213`	`@[minify]`
Original file line number	Diff line number	Diff line change
`@@ -2385,9 +2385,7 @@ fn (mut c Checker) stmt(mut node ast.Stmt) {`
`2385`	`2385`	`}`
`2386`	`2386`	`}`
`2387`	`2387`	`ast.NodeError {}`
`2388`		`- ast.DebuggerStmt {`
`2389`		`- c.table.used_features.debugger = true`
`2390`		`- }`
	`2388`	`+ ast.DebuggerStmt {}`
`2391`	`2389`	`ast.AsmStmt {`
`2392`	`2390`	`c.asm_stmt(mut node)`
`2393`	`2391`	`}`
`@@ -2398,9 +2396,6 @@ fn (mut c Checker) stmt(mut node ast.Stmt) {`
`2398`	`2396`	`}`
`2399`	`2397`
`2400`	`2398`	`fn (mut c Checker) assert_stmt(mut node ast.AssertStmt) {`
`2401`		`- if node.is_used {`
`2402`		`- c.table.used_features.asserts = true`
`2403`		`- }`
`2404`	`2399`	`cur_exp_typ := c.expected_type`
`2405`	`2400`	`c.expected_type = ast.bool_type`
`2406`	`2401`	`assert_type := c.check_expr_option_or_result_call(node.expr, c.expr(mut node.expr))`
`@@ -5140,6 +5135,7 @@ fn (mut c Checker) index_expr(mut node ast.IndexExpr) ast.Type {`
`5140`	`5135`	`}`
`5141`	`5136`	`c.stmts_ending_with_expression(mut node.or_expr.stmts, c.expected_or_type)`
`5142`	`5137`	`c.check_expr_option_or_result_call(node, typ)`
	`5138`	`+ node.typ = typ`
`5143`	`5139`	`return typ`
`5144`	`5140`	`}`
`5145`	`5141`
Original file line number	Diff line number	Diff line change
`@@ -342,9 +342,15 @@ fn (mut c Checker) fn_decl(mut node ast.FnDecl) {`
`342`	`342`	`if c.pref.skip_unused {`
`343`	`343`	`if param.typ.has_flag(.generic) {`
`344`	`344`	`c.table.used_features.comptime_syms[c.unwrap_generic(param.typ)] = true`
	`345`	`+ c.table.used_features.comptime_syms[param.typ] = true`
`345`	`346`	`}`
`346`	`347`	`if node.return_type.has_flag(.generic) {`
`347`	`348`	`c.table.used_features.comptime_syms[c.unwrap_generic(node.return_type)] = true`
	`349`	`+ c.table.used_features.comptime_syms[node.return_type] = true`
	`350`	`+ }`
	`351`	`+ if node.receiver.typ.has_flag(.generic) {`
	`352`	`+ c.table.used_features.comptime_syms[node.receiver.typ] = true`
	`353`	`+ c.table.used_features.comptime_syms[c.unwrap_generic(node.receiver.typ)] = true`
`348`	`354`	`}`
`349`	`355`	`}`
`350`	`356`	`if param.name == node.mod && param.name != 'main' {`
`@@ -1895,6 +1901,7 @@ fn (mut c Checker) fn_call(mut node ast.CallExpr, mut continue_check &bool) ast.`
`1895`	`1901`	`c.register_trace_call(node, func)`
`1896`	`1902`	`if func.return_type.has_flag(.generic) {`
`1897`	`1903`	`c.table.used_features.comptime_syms[typ.clear_option_and_result()] = true`
	`1904`	`+ c.table.used_features.comptime_syms[func.return_type] = true`
`1898`	`1905`	`}`
`1899`	`1906`	`return typ`
`1900`	`1907`	`}`
`@@ -2028,6 +2035,10 @@ fn (mut c Checker) method_call(mut node ast.CallExpr, mut continue_check &bool)`
`2028`	`2035`	`node.return_type = left_type`
`2029`	`2036`	`node.receiver_type = left_type`
`2030`	`2037`
	`2038`	`+ if is_generic {`
	`2039`	`+ c.table.used_features.comptime_syms[c.unwrap_generic(left_type)] = true`
	`2040`	`+ }`
	`2041`	`+`
`2031`	`2042`	`if c.table.cur_fn != unsafe { nil } && c.table.cur_fn.generic_names.len > 0 {`
`2032`	`2043`	`c.table.unwrap_generic_type(left_type, c.table.cur_fn.generic_names, c.table.cur_concrete_types)`
`2033`	`2044`	`}`
Original file line number	Diff line number	Diff line change
`@@ -68,10 +68,6 @@ fn (mut c Checker) struct_decl(mut node ast.StructDecl) {`
`68`	`68`	`if node.language != .c && attr.name == 'typedef' {`
`69`	`69`	c.error('`typedef` attribute can only be used with C structs', node.pos)
`70`	`70`	`}`
`71`		`- aligned := if attr.arg == '' { 0 } else { attr.arg.int() }`
`72`		`- if aligned > 1 {`
`73`		`- c.table.used_features.memory_align = true`
`74`		`- }`
`75`	`71`	`}`
`76`	`72`
`77`	`73`	`// Evaluate the size of the unresolved fixed array`
`@@ -533,6 +529,7 @@ fn (mut c Checker) struct_init(mut node ast.StructInit, is_field_zero_struct_ini`
`533`	`529`	`true)`
`534`	`530`	`if c.pref.skip_unused && node.typ.has_flag(.generic) {`
`535`	`531`	`c.table.used_features.comptime_syms[c.unwrap_generic(node.typ)] = true`
	`532`	`+ c.table.used_features.comptime_syms[node.typ] = true`
`536`	`533`	`}`
`537`	`534`	`}`
`538`	`535`	`if !is_field_zero_struct_init {`
@@ -865,8 +862,6 @@ or use an explicit `unsafe{ a[..] }`, if you do not want a copy of the slice.',
`865`	`862`	`mut info := first_sym.info as ast.Struct`
`866`	`863`	`c.check_uninitialized_struct_fields_and_embeds(node, first_sym, mut info, mut`
`867`	`864`	`inited_fields)`
`868`		`- } else if first_sym.kind == .array {`
`869`		`- c.table.used_features.arr_init = true`
`870`	`865`	`}`
`871`	`866`	`}`
`872`	`867`	`.none {`
Original file line number	Diff line number	Diff line change
`@@ -175,7 +175,6 @@ fn (mut c Checker) markused_infixexpr(check bool) {`
`175`	`175`	`return`
`176`	`176`	`}`
`177`	`177`	`c.table.used_features.index = true`
`178`		`- c.table.used_features.arr_init = true`
`179`	`178`	`}`
`180`	`179`
`181`	`180`	`fn (mut c Checker) markused_array_method(check bool, method_name string) {`
`@@ -184,7 +183,6 @@ fn (mut c Checker) markused_array_method(check bool, method_name string) {`
`184`	`183`	`}`
`185`	`184`	`match method_name {`
`186`	`185`	`'' { // array init`
`187`		`- c.table.used_features.arr_init = true`
`188`	`186`	`}`
`189`	`187`	`'first' {`
`190`	`188`	`c.table.used_features.arr_first = true`