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

Author: felipensp

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
 }

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 ''

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]

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]

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
 }
 

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',

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

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)
 	}

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 {

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