nice

Author: medvednikov

vlib/builtin/rune.v

@@ -37,7 +37,7 @@ pub fn (c rune) repeat(count int) string {
 }
 
 // bytes converts a rune to an array of bytes.
-@[manualfree]
+@[manualfree; markused]
 pub fn (c rune) bytes() []u8 {
 	mut res := []u8{cap: 5}
 	mut buf := &u8(res.data)

vlib/strconv/atof.c.v

@@ -429,13 +429,14 @@ fn converter(mut pn PrepNumber) u64 {
 	return result
 }
 
-@[params]
+@[markused; params]
 pub struct AtoF64Param {
 pub:
 	allow_extra_chars bool // allow extra characters after number
 }
 
 // atof64 parses the string `s`, and if possible, converts it into a f64 number
+@[markused]
 pub fn atof64(s string, param AtoF64Param) !f64 {
 	if s.len == 0 {
 		return error('expected a number found an empty string')

vlib/strconv/atoi.v

@@ -147,6 +147,7 @@ pub fn common_parse_uint2(s string, _base int, _bit_size int) (u64, int) {
 }
 
 // parse_uint is like parse_int but for unsigned numbers.
+@[markused]
 pub fn parse_uint(s string, _base int, _bit_size int) !u64 {
 	return common_parse_uint(s, _base, _bit_size, true, true)
 }
@@ -286,31 +287,35 @@ fn atoi_common(s string, type_min i64, type_max i64) !i64 {
 
 // atoi is equivalent to parse_int(s, 10, 0), converted to type int.
 // It follows V scanner as much as observed.
+@[markused]
 pub fn atoi(s string) !int {
 	return int(atoi_common(s, i64_min_int32, i64_max_int32)!)
 }
 
 // atoi8 is equivalent to atoi(s), converted to type i8.
 // returns an i8 [-128 .. 127] or an error.
+@[markused]
 pub fn atoi8(s string) !i8 {
 	return i8(atoi_common(s, min_i8, max_i8)!)
 }
 
 // atoi16 is equivalent to atoi(s), converted to type i16.
 // returns an i16 [-32678 .. 32767] or an error.
+@[markused]
 pub fn atoi16(s string) !i16 {
 	return i16(atoi_common(s, min_i16, max_i16)!)
 }
 
 // atoi32 is equivalent to atoi(s), converted to type i32.
 // returns an i32 [-2147483648 .. 2147483647] or an error.
+@[markused]
 pub fn atoi32(s string) !i32 {
 	return i32(atoi_common(s, min_i32, max_i32)!)
 }
 
 // atoi64 converts radix 10 string to i64 type.
 // returns an i64 [-9223372036854775808 .. 9223372036854775807] or an error.
-@[direct_array_access]
+@[direct_array_access; markused]
 pub fn atoi64(s string) !i64 {
 	mut sign, mut start_idx := atoi_common_check(s)!
 	mut x := i64(0)

vlib/strconv/atou.v

@@ -67,29 +67,34 @@ fn atou_common(s string, type_max u64) !u64 {
 
 // atou8 is equivalent to parse_uint(s, 10, 0), converted to type u8.
 // It returns u8 in range [0..255] or an Error.
+@[markused]
 pub fn atou8(s string) !u8 {
 	return u8(atou_common(s, max_u8)!)
 }
 
 // atou16 is equivalent to parse_uint(s, 10, 0), converted to type u16.
 // It returns u16 in range [0..65535] or an Error.
+@[markused]
 pub fn atou16(s string) !u16 {
 	return u16(atou_common(s, max_u16)!)
 }
 
 // atou is equivalent to parse_uint(s, 10, 0), converted to type u32.
+@[markused]
 pub fn atou(s string) !u32 {
 	return u32(atou_common(s, max_u32)!)
 }
 
 // atou32 is identical to atou. Here to provide a symmetrical API with atoi/atoi32
 // It returns u32 in range [0..4294967295] or an Error.
+@[markused]
 pub fn atou32(s string) !u32 {
 	return u32(atou_common(s, max_u32)!)
 }
 
 // atou64 is equivalent to parse_uint(s, 10, 0), converted to type u64.
 // It returns u64 in range [0..18446744073709551615] or an Error.
+@[markused]
 pub fn atou64(s string) !u64 {
 	return u64(atou_common(s, max_u64)!)
 }

vlib/time/time.v

@@ -35,6 +35,7 @@ pub const days_before = [
 ]!
 
 // Time contains various time units for a point in time.
+@[markused]
 pub struct Time {
 	unix i64
 pub:

vlib/v/markused/walker.v

@@ -36,17 +36,18 @@ mut:
 	all_decltypes map[string]ast.TypeDecl
 	all_structs   map[string]ast.StructDecl
 
-	cur_fn                    string
-	cur_fn_concrete_types     []ast.Type
-	level                     int
-	is_builtin_mod            bool
-	is_direct_array_access    bool
-	inside_in_op              bool
-	inside_comptime           int
-	inside_comptime_if        int
-	used_fn_generic_types     map[string][][]ast.Type
-	walked_fn_generic_types   map[string][][]ast.Type
-	keep_all_fn_generic_types map[string]bool
+	cur_fn                     string
+	cur_fn_concrete_types      []ast.Type
+	level                      int
+	is_builtin_mod             bool
+	is_direct_array_access     bool
+	inside_in_op               bool
+	inside_comptime            int
+	inside_comptime_if         int
+	used_fn_generic_types      map[string][][]ast.Type
+	walked_fn_generic_types    map[string][][]ast.Type
+	keep_all_fn_generic_types  map[string]bool
+	json2_encode_field_helpers map[string]bool
 
 	// dependencies finding flags
 	uses_atomic                bool // has atomic
@@ -269,6 +270,11 @@ fn (mut w Walker) mark_json2_optional_field_helpers(concrete_typ ast.Type) {
 }
 
 fn (mut w Walker) mark_json2_encode_field_helpers(receiver_typ ast.Type, concrete_typ ast.Type) {
+	helper_key := '${int(receiver_typ)}:${int(concrete_typ)}'
+	if w.json2_encode_field_helpers[helper_key] {
+		return
+	}
+	w.json2_encode_field_helpers[helper_key] = true
 	concrete_sym := w.table.final_sym(w.table.unaliased_type(concrete_typ))
 	if concrete_sym.kind != .struct || concrete_sym.info !is ast.Struct {
 		return
@@ -1483,6 +1489,10 @@ fn (mut w Walker) fn_decl_with_concrete_types(mut node ast.FnDecl, concrete_type
 		return
 	}
 	w.mark_fn_as_used(fkey)
+	if node.mod == 'x.json2' {
+		w.mark_by_sym_name('EnumData')
+		w.mark_by_sym_name('time.Time')
+	}
 	last_is_direct_array_access := w.is_direct_array_access
 	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 }
@@ -1576,7 +1586,8 @@ fn (mut w Walker) fn_decl_with_concrete_types(mut node ast.FnDecl, concrete_type
 						continue
 					}
 					concrete_typ := w.table.unaliased_type(concrete_type_list[0])
-					if w.table.final_sym(concrete_typ).kind == .struct {
+					concrete_sym := w.table.final_sym(concrete_typ)
+					if concrete_sym.kind == .struct && concrete_sym.name != 'time.Time' {
 						w.fn_decl_with_concrete_types(mut check_struct_type_valid_fn,
 							concrete_type_list)
 					}
@@ -1597,7 +1608,7 @@ fn (mut w Walker) fn_decl_with_concrete_types(mut node ast.FnDecl, concrete_type
 				}
 			}
 		}
-		if concrete_sym.kind == .struct {
+		if concrete_sym.kind == .struct && concrete_sym.name != 'time.Time' {
 			if mut decode_struct_key_fn := w.all_fns['x.json2.decode_struct_key'] {
 				w.fn_decl_with_concrete_types(mut decode_struct_key_fn, resolved_concrete_types)
 			}
@@ -1611,6 +1622,10 @@ fn (mut w Walker) fn_decl_with_concrete_types(mut node ast.FnDecl, concrete_type
 	if node.mod == 'x.json2' && node.name == 'decode_struct_key' && resolved_concrete_types.len == 1 {
 		w.mark_json2_optional_field_helpers(resolved_concrete_types[0])
 	}
+	if node.mod == 'x.json2' && node.name == 'decode_enum' {
+		w.uses_ct_values = true
+		w.mark_by_sym_name('EnumData')
+	}
 	if node.mod == 'x.json2' && node.name == 'encode_value' && node.is_method
 		&& resolved_concrete_types.len == 1 {
 		concrete_typ := w.table.unaliased_type(resolved_concrete_types[0])
@@ -1622,7 +1637,7 @@ fn (mut w Walker) fn_decl_with_concrete_types(mut node ast.FnDecl, concrete_type
 				}
 			}
 		}
-		if concrete_sym.kind in [.array, .array_fixed] {
+		if concrete_sym.kind == .array {
 			encode_array_fkey, _ := w.resolve_method_fkey_for_type(node.receiver.typ,
 				'encode_array')
 			if encode_array_fkey != '' {
@@ -2030,7 +2045,8 @@ pub fn (mut w Walker) call_expr(mut node ast.CallExpr) {
 				w.mark_by_type(concrete_type)
 			}
 			generic_call_inside_generic_caller := w.fn_generic_names(stmt).len > 0
-				&& node.raw_concrete_types.len == 0 && caller_generic_names.len > 0
+				&& call_concrete_types.len == 0 && node.raw_concrete_types.len == 0
+				&& caller_generic_names.len > 0
 			keep_all_generic_types := (stmt.generic_names.len > 0 && call_concrete_types.len == 0)
 				|| generic_call_inside_generic_caller
 			if keep_all_generic_types {

vlib/x/json2/attr_utils.v

@@ -20,6 +20,7 @@ fn json_attr_value(attr string) ?string {
 	return unquote_attr_value(attr[5..])
 }
 
+@[markused]
 fn json_attr_value_range(attr string) ?(int, int) {
 	if !attr.starts_with('json:') {
 		return none

vlib/x/json2/decode.v

@@ -1,6 +1,7 @@
 module json2
 
 import strconv
+import time
 
 const null_in_string = 'null'
 
@@ -36,6 +37,7 @@ struct DecoderFieldInfo {
 	is_raw       bool
 }
 
+@[markused]
 struct StructFieldInfo {
 	json_name_ptr voidptr
 	json_name_len int
@@ -375,15 +377,15 @@ fn (mut decoder Decoder) cached_struct_field_infos[T]() []StructFieldInfo {
 	return *field_infos
 }
 
-@[inline]
+@[inline; markused]
 fn struct_field_is_decoded(decoded_mask u64, decoded_fields []bool, field_idx int) bool {
 	if field_idx < 64 {
 		return (decoded_mask & (u64(1) << u64(field_idx))) != 0
 	}
 	return decoded_fields[field_idx]
 }
 
-@[inline]
+@[inline; markused]
 fn mark_struct_field_decoded(decoded_mask u64, mut decoded_fields []bool, field_idx int) u64 {
 	if field_idx < 64 {
 		return decoded_mask | (u64(1) << u64(field_idx))
@@ -402,7 +404,7 @@ fn (decoder &Decoder) json_key_matches(key_info ValueInfo, key_name string) bool
 	}
 }
 
-@[inline]
+@[inline; markused]
 fn (decoder &Decoder) is_empty_value(value_info ValueInfo) bool {
 	match value_info.value_kind {
 		.null {
@@ -430,6 +432,7 @@ fn (decoder &Decoder) is_empty_value(value_info ValueInfo) bool {
 	return false
 }
 
+@[markused]
 fn (mut decoder Decoder) skip_current_value() {
 	if decoder.current_node == unsafe { nil } {
 		return
@@ -673,6 +676,23 @@ fn (mut decoder Decoder) decode_value[T](mut val T) ! {
 		return
 	} $else $if T.unaliased_typ is string {
 		decoder.decode_string(mut val)!
+	} $else $if T.unaliased_typ is time.Time {
+		value_info := decoder.current_node.value
+		mut decoded_time := time.Time{}
+		if value_info.value_kind == .string {
+			decoded_time.from_json_string(decoder.json[value_info.position + 1..
+				value_info.position + value_info.length - 1]) or {
+				decoder.decode_error('${typeof(val).name}: ${err.msg()}')!
+			}
+		} else if value_info.value_kind == .number {
+			decoded_time.from_json_number(decoder.json[value_info.position..value_info.position +
+				value_info.length]) or {
+				decoder.decode_error('${typeof(val).name}: ${err.msg()}')!
+			}
+		} else {
+			decoder.decode_error('Expected string or number, but got ${value_info.value_kind}')!
+		}
+		val = T(decoded_time)
 	} $else $if T.unaliased_typ is $sumtype {
 		decoder.decode_sumtype(mut val)!
 		return
@@ -1173,6 +1193,7 @@ fn (mut decoder Decoder) decode_enum[T](mut val T) ! {
 
 const max_integer_number_digits = 20
 
+@[markused]
 fn has_exponent_number_syntax(str string) bool {
 	for c in str {
 		if c == `e` || c == `E` {
@@ -1182,6 +1203,7 @@ fn has_exponent_number_syntax(str string) bool {
 	return false
 }
 
+@[markused]
 fn scientific_number_to_integer_string(str string) !string {
 	if !has_exponent_number_syntax(str) {
 		// Handle plain decimal numbers with zero fractional part (e.g., "-123.0")
@@ -1326,8 +1348,10 @@ fn parse_integer_number[T](str string) !T {
 		return T(strconv.atou32(int_str)!)
 	} $else $if T.unaliased_typ is u64 {
 		return T(strconv.atou64(int_str)!)
+	} $else $if T is int {
+		return int(strconv.atoi64(int_str)!)
 	} $else $if T.unaliased_typ is int {
-		return T(strconv.atoi(int_str)!)
+		return T(int(strconv.atoi64(int_str)!))
 	} $else $if T.unaliased_typ is isize {
 		return T(isize(strconv.atoi64(int_str)!))
 	} $else $if T.unaliased_typ is usize {
@@ -1337,6 +1361,12 @@ fn parse_integer_number[T](str string) !T {
 	}
 }
 
+@[markused]
+fn parse_int_number(str string) !int {
+	int_str := scientific_number_to_integer_string(str)!
+	return int(strconv.atoi64(int_str)!)
+}
+
 fn parse_float_number[T](str string) !T {
 	$if js {
 		$if T.unaliased_typ is f32 {
@@ -1372,7 +1402,7 @@ fn (mut decoder Decoder) decode_number[T](val &T) ! {
 		u16 { *val = parse_integer_number[T](str)! }
 		u32 { *val = parse_integer_number[T](str)! }
 		u64 { *val = parse_integer_number[T](str)! }
-		int { *val = parse_integer_number[T](str)! }
+		int { *val = parse_int_number(str)! }
 		isize { *val = parse_integer_number[T](str)! }
 		usize { *val = parse_integer_number[T](str)! }
 		f32 { *val = parse_float_number[T](str)! }
@@ -1406,6 +1436,8 @@ fn (mut decoder Decoder) decode_number_from_string[T]() !T {
 		return parse_integer_number[T](str)!
 	} $else $if T.unaliased_typ is u64 {
 		return parse_integer_number[T](str)!
+	} $else $if T is int {
+		return parse_int_number(str)!
 	} $else $if T.unaliased_typ is int {
 		return parse_integer_number[T](str)!
 	} $else $if T.unaliased_typ is isize {