From 90122e20e2586dcaaf606bab37453c0f2ce127bf Mon Sep 17 00:00:00 2001
From: Hitalo Souza <enghitalo@gmail.com>
Date: Fri, 18 Oct 2024 22:13:45 -0400
Subject: [PATCH 01/14] Linked List

---
 vlib/x/json2/decoder2/decode.v                | 728 +++++++++---------
 vlib/x/json2/decoder2/decode_test.v           | 174 +----
 vlib/x/json2/decoder2/tests/bench.v           |   9 +-
 .../json2/decoder2/tests/decode_struct_test.v |   4 +-
 4 files changed, 391 insertions(+), 524 deletions(-)

diff --git a/vlib/x/json2/decoder2/decode.v b/vlib/x/json2/decoder2/decode.v
index 6147594397d7bc..24f240632486b7 100644
--- a/vlib/x/json2/decoder2/decode.v
+++ b/vlib/x/json2/decoder2/decode.v
@@ -1,15 +1,16 @@
 module decoder2
 
+import strconv
 import time
 
-// Node represents a node in a JSON decoder tree. Used to decode object in JSON.
+// Node represents a node in a linked list to store ValueInfo.
 struct Node {
-	key_pos  int     // The position of the key in the JSON string.
-	key_len  int     // The length of the key in the JSON string.
-	children ?[]Node // The children nodes of the current node.
+	value ValueInfo
+mut:
+	next &Node = unsafe { nil } // next is the next node in the linked list.
 }
 
-// ValueInfo represents the position and length of a value, like string, number, array, object key and object value in a JSON string.
+// ValueInfo represents the position and length of a value, such as string, number, array, object key, and object value in a JSON string.
 struct ValueInfo {
 	position   int       // The position of the value in the JSON string.
 	value_kind ValueKind // The kind of the value.
@@ -21,12 +22,51 @@ mut:
 struct Decoder {
 	json string // json is the JSON data to be decoded.
 mut:
-	values_info    []ValueInfo
-	idx            int // idx is byte offset from the start in json
-	checker_idx    int // checker_idx is the current index of the decoder.
-	value_info_idx int // value_info_idx is the current index of the values_info.
+	linked_list_of_value_info LinkedList // A linked list to store ValueInfo.
+	checker_idx               int        // checker_idx is the current index of the decoder.
+	current_node              &Node = unsafe { nil } // The current node in the linked list.
+}
+
+// LinkedList represents a linked list to store ValueInfo.
+struct LinkedList {
+mut:
+	head &Node = unsafe { nil } // head is the first node in the linked list.
+	tail &Node = unsafe { nil } // tail is the last node in the linked list.
+	len  int // len is the length of the linked list.
+}
+
+// push adds a new element to the linked list.
+fn (mut list LinkedList) push(value ValueInfo) {
+	new_node := &Node{
+		value: value
+	}
+	if list.head == unsafe { nil } {
+		list.head = new_node
+		list.tail = new_node
+	} else {
+		list.tail.next = new_node
+		list.tail = new_node
+	}
+	list.len++
 }
 
+// last returns the last element added to the linked list.
+fn (list LinkedList) last() &ValueInfo {
+	return &list.tail.value
+}
+
+// str returns a string representation of the linked list.
+fn (list LinkedList) str() string {
+	mut result := ''
+	mut current := list.head
+	for current != unsafe { nil } {
+		result += current.value.value_kind.str() + ' '
+		current = current.next
+	}
+	return result
+}
+
+// ValueKind represents the kind of a JSON value.
 pub enum ValueKind {
 	unknown
 	array
@@ -37,7 +77,7 @@ pub enum ValueKind {
 	null
 }
 
-// check_json checks if the JSON string is valid.
+// check_if_json_match checks if the JSON string matches the expected type T.
 fn check_if_json_match[T](val string) ! {
 	// check if the JSON string is empty
 	if val == '' {
@@ -45,7 +85,7 @@ fn check_if_json_match[T](val string) ! {
 	}
 
 	// check if generic type matches the JSON type
-	value_kind := get_value_kind(val[0])
+	value_kind := get_value_kind(unsafe { val.str })
 
 	$if T is $option {
 		// TODO
@@ -86,6 +126,7 @@ fn check_if_json_match[T](val string) ! {
 	}
 }
 
+// error generates an error message with context from the JSON string.
 fn (mut checker Decoder) error(message string) ! {
 	json := if checker.json.len < checker.checker_idx + 5 {
 		checker.json
@@ -115,7 +156,7 @@ fn (mut checker Decoder) error(message string) ! {
 	return error(error_message)
 }
 
-// check_json checks if the JSON string is valid.
+// check_json_format checks if the JSON string is valid and updates the decoder state.
 fn (mut checker Decoder) check_json_format(val string) ! {
 	checker_end := checker.json.len
 	// check if the JSON string is empty
@@ -124,15 +165,14 @@ fn (mut checker Decoder) check_json_format(val string) ! {
 	}
 
 	// check if generic type matches the JSON type
-	value_kind := get_value_kind(val[checker.checker_idx])
+	value_kind := get_value_kind(unsafe { val.str + checker.checker_idx })
 	start_idx_position := checker.checker_idx
-	checker.values_info << ValueInfo{
+	checker.linked_list_of_value_info.push(ValueInfo{
 		position:   start_idx_position
-		length:     0
 		value_kind: value_kind
-	}
+	})
 
-	value_info_index := checker.values_info.len - 1
+	mut actual_value_info_pointer := checker.linked_list_of_value_info.last()
 	match value_kind {
 		.unknown {
 			return checker.error('unknown value kind')
@@ -460,7 +500,7 @@ fn (mut checker Decoder) check_json_format(val string) ! {
 		}
 	}
 
-	checker.values_info[value_info_index].length = checker.checker_idx + 1 - start_idx_position
+	actual_value_info_pointer.length = checker.checker_idx + 1 - start_idx_position
 
 	if checker.checker_idx < checker_end - 1 {
 		checker.checker_idx++
@@ -480,14 +520,14 @@ fn (mut checker Decoder) check_json_format(val string) ! {
 // decode decodes a JSON string into a specified type.
 pub fn decode[T](val string) !T {
 	mut decoder := Decoder{
-		json:        val
-		values_info: []ValueInfo{}
+		json: val
 	}
 
 	decoder.check_json_format(val)!
 	check_if_json_match[T](val)!
 
 	mut result := T{}
+	decoder.current_node = decoder.linked_list_of_value_info.head
 	decoder.decode_value(mut &result)!
 	return result
 }
@@ -495,29 +535,138 @@ pub fn decode[T](val string) !T {
 // decode_value decodes a value from the JSON nodes.
 fn (mut decoder Decoder) decode_value[T](mut val T) ! {
 	$if T is $option {
-	} $else $if T is string {
+		mut unwrapped_val := create_value_from_optional(val.$(field.name))
+		decoder.decode_value(mut unwrapped_val)!
+		val.$(field.name) = unwrapped_val
+	} $else $if T.unaliased_typ is string {
+		string_info := decoder.current_node.value
+
+		if string_info.value_kind == .string_ {
+			buffer_lenght, escape_positions := decoder.calculate_string_space_and_escapes()!
+
+			string_buffer := []u8{cap: buffer_lenght}
+
+			if escape_positions.len == 0 {
+				if string_info.length != 0 {
+					unsafe {
+						string_buffer.push_many(decoder.json.str + string_info.position + 1,
+							buffer_lenght)
+					}
+				}
+			} else {
+				for i := 0; i < escape_positions.len; i++ {
+					escape_position := escape_positions[i]
+					if i == 0 {
+						// string_buffer << decoder.json[value_info.position + 1..escape_position].bytes()
+
+						// Pushes a substring from the JSON string into the string buffer.
+						// The substring starts at the position of the value in the JSON string plus one,
+						// and ends at the escape position minus one.
+						// This is used to handle escaped characters within the JSON string.
+						unsafe {
+							string_buffer.push_many(decoder.json.str + string_info.position + 1,
+								escape_position - string_info.position - 1)
+						}
+					} else {
+						// string_buffer << decoder.json[escape_positions[i - 1] + 2..escape_position].bytes()
+
+						// Pushes a substring from the JSON string into the string buffer, starting after the previous escape position
+						// and ending just before the current escape position. This handles the characters between escape sequences.
+						// dump(escape_position - escape_positions[i - 1] - 6 )
+						unsafe {
+							string_buffer.push_many(decoder.json.str + escape_positions[i - 1] + 6,
+								escape_position - escape_positions[i - 1] - 6)
+						}
+					}
+
+					unescaped_buffer := generate_unicode_escape_sequence(unsafe {
+						(decoder.json.str + escape_positions[i] + 2).vbytes(4)
+					})!
+
+					unsafe { string_buffer.push_many(&unescaped_buffer[0], unescaped_buffer.len) }
+				}
+				end_of_last_escape_position := escape_positions[escape_positions.len - 1] + 6
+				unsafe {
+					string_buffer.push_many(decoder.json.str + end_of_last_escape_position,
+						string_info.length - end_of_last_escape_position - 1)
+				}
+			}
+
+			val = string_buffer.bytestr()
+		}
 	} $else $if T is $sumtype {
 		$for v in val.variants {
 			if val is v {
 				decoder.decode_value(val)
 			}
 		}
-	} $else $if T is $alias {
 	} $else $if T is time.Time {
+		time_info := decoder.current_node.value
+
+		if time_info.value_kind == .string_ {
+			string_time := decoder.json.substr_unsafe(time_info.position + 1, time_info.position +
+				time_info.length - 1)
+
+			val = time.parse_rfc3339(string_time) or { time.Time{} }
+		}
 	} $else $if T is $map {
+		map_info := decoder.current_node.value
+
+		if map_info.value_kind == .object {
+			map_position := map_info.position
+			map_end := map_position + map_info.length
+
+			// decoder.value_info_idx++
+			decoder.current_node = decoder.current_node.next
+			// dump(decoder.json)
+			for {
+				if decoder.current_node == unsafe { nil } {
+					break
+				}
+
+				key_info := decoder.current_node.value
+
+				if key_info.position >= map_end {
+					break
+				}
+
+				key := decoder.json[key_info.position + 1..key_info.position + key_info.length - 1]
+
+				decoder.current_node = decoder.current_node.next
+
+				value_info := decoder.current_node.value
+
+				if value_info.position + value_info.length >= map_end {
+					break
+				}
+
+				mut map_value := create_map_value(val)
+
+				decoder.decode_value(mut map_value)!
+
+				val[key] = map_value
+			}
+		}
 	} $else $if T is $array {
-		array_info := decoder.values_info[decoder.value_info_idx]
+		// array_info := decoder.values_info[decoder.value_info_idx]
+		array_info := decoder.current_node.value
 
 		if array_info.value_kind == .array {
 			array_position := array_info.position
 			array_end := array_position + array_info.length
 
-			decoder.value_info_idx++
+			// decoder.value_info_idx++
+			decoder.current_node = decoder.current_node.next
+			// dump(decoder.json)
 			for {
-				if decoder.value_info_idx >= decoder.values_info.len {
+				// if decoder.value_info_idx >= decoder.values_info.len {
+				if decoder.current_node == unsafe { nil } {
+					// dump("break")
 					break
 				}
-				value_info := decoder.values_info[decoder.value_info_idx]
+				// value_info := decoder.values_info[decoder.value_info_idx]
+				value_info := decoder.current_node.value
+				// dump(value_info)
 
 				if value_info.position + value_info.length >= array_end {
 					break
@@ -525,25 +674,71 @@ fn (mut decoder Decoder) decode_value[T](mut val T) ! {
 
 				mut array_element := create_array_element(val)
 
-				decoder.decode_value(mut &array_element)!
+				decoder.decode_value(mut array_element)!
 
 				val << array_element
+				// dump(val)
 			}
 		}
+		// dump("out")
 	} $else $if T is $struct {
-		mut nodes := []Node{}
-		// TODO: needs performance improvements
-		decoder.fulfill_nodes(mut nodes)
+		struct_info := decoder.current_node.value
 
-		decoder.decode_struct(nodes, val)
+		if struct_info.value_kind == .object {
+			struct_position := struct_info.position
+			struct_end := struct_position + struct_info.length
+
+			// decoder.value_info_idx++
+			decoder.current_node = decoder.current_node.next
+			// dump(decoder.json)
+			for {
+				// dump(decoder.current_node)
+				if decoder.current_node == unsafe { nil } {
+					break
+				}
+
+				key_info := decoder.current_node.value
+
+				if key_info.position >= struct_end {
+					break
+				}
+
+				decoder.current_node = decoder.current_node.next
+
+				$for field in T.fields {
+					if key_info.length - 2 == field.name.len {
+						// This `vmemcmp` compares the name of a key in a JSON with a given struct field.
+						// dump('a')
+						// dump(decoder.json[key_info.position+1..key_info.position + 1 + field.name.len])
+						if unsafe {
+							vmemcmp(decoder.json.str + key_info.position + 1, field.name.str,
+								field.name.len) == 0
+						} {
+							// mut workaround := val.$(field.name)
+							// decoder.decode_value(mut workaround)!
+							// val.$(field.name) = workaround
+							$if field.typ is $option {
+								mut unwrapped_val := create_value_from_optional(val.$(field.name))
+								decoder.decode_value(mut unwrapped_val)!
+								val.$(field.name) = unwrapped_val
+							} $else {
+								decoder.decode_value(mut val.$(field.name))!
+							}
+						}
+					}
+				}
+			}
+		}
 	} $else $if T is bool {
-		value_info := decoder.values_info[decoder.value_info_idx]
+		// value_info := decoder.values_info[decoder.value_info_idx]
+		value_info := decoder.current_node.value
 
 		unsafe {
 			val = vmemcmp(decoder.json.str + value_info.position, 'true'.str, 4) == 0
 		}
 	} $else $if T in [$int, $float, $enum] {
-		value_info := decoder.values_info[decoder.value_info_idx]
+		// value_info := decoder.values_info[decoder.value_info_idx]
+		value_info := decoder.current_node.value
 
 		if value_info.value_kind == .number {
 			bytes := unsafe { (decoder.json.str + value_info.position).vbytes(value_info.length) }
@@ -555,357 +750,142 @@ fn (mut decoder Decoder) decode_value[T](mut val T) ! {
 	} $else {
 		return error('cannot encode value with ${typeof(val).name} type')
 	}
-	decoder.value_info_idx++
+	// decoder.value_info_idx++
+	// decoder.current_node = decoder.current_node.next
+	if decoder.current_node != unsafe { nil } {
+		decoder.current_node = decoder.current_node.next
+	}
 }
 
 // get_value_kind returns the kind of a JSON value.
-fn get_value_kind(value rune) ValueKind {
-	return match value {
-		`"` { .string_ }
-		`t`, `f` { .boolean }
-		`{` { .object }
-		`[` { .array }
-		`0`...`9`, `-` { .number }
-		`n` { .null }
-		else { .unknown }
+fn get_value_kind(val &u8) ValueKind {
+	value := *val
+	if value == u8(`"`) {
+		return .string_
+	} else if value == u8(`t`) || value == u8(`f`) {
+		return .boolean
+	} else if value == u8(`{`) {
+		return .object
+	} else if value == u8(`[`) {
+		return .array
+	} else if (value >= u8(48) && value <= u8(57)) || value == u8(`-`) {
+		return .number
+	} else if value == u8(`n`) {
+		return .null
 	}
+	return .unknown
 }
 
-fn create_array_element[T](array []T) T {
-	return T{}
+fn utf8_byte_length(unicode_value u32) int {
+	if unicode_value <= 0x7F {
+		return 1
+	} else if unicode_value <= 0x7FF {
+		return 2
+	} else if unicode_value <= 0xFFFF {
+		return 3
+	} else {
+		return 4
+	}
 }
 
-// decode_optional_value_in_actual_node decodes an optional value in a node.
-fn (mut decoder Decoder) decode_optional_value_in_actual_node[T](node Node, val ?T) T {
-	start := (node.key_pos + node.key_len) + 3
-	mut end := start
-	for decoder.json[end] != `,` && decoder.json[end] != `}` {
-		end++
-	}
-	mut value_kind := get_value_kind(decoder.json[start])
+fn (mut decoder Decoder) calculate_string_space_and_escapes() !(int, []int) {
+	value_info := decoder.current_node.value
+	len := value_info.length
 
-	$if T is string {
-		if value_kind == .string_ {
-			return decoder.json[start + 1..end - 1]
-		} else if value_kind == .object {
-		} else if value_kind == .array {
-		} else {
-			return decoder.json[start..end]
-		}
-		return ''
-	} $else $if T is $int {
-		if value_kind == .string_ {
-			return decoder.json[start + 1..end - 1].int()
-		} else if value_kind == .object {
-		} else if value_kind == .array {
-		} else {
-			return decoder.json[start..end].int()
-		}
+	if len < 2 || decoder.json[value_info.position] != `"`
+		|| decoder.json[value_info.position + len - 1] != `"` {
+		return error('Invalid JSON string format')
 	}
-	return T{}
-}
 
-// decode_struct decodes a struct from the JSON nodes.
-fn (mut decoder Decoder) decode_struct[T](nodes []Node, value &T) {
-	$for field in T.fields {
-		for i := 0; i < nodes.len; i++ {
-			mut node := nodes[i]
-
-			if node.key_len == field.name.len {
-				// This `vmemcmp` compares the name of a key in a JSON with a given struct field.
-				if unsafe {
-					vmemcmp(decoder.json.str + node.key_pos, field.name.str, field.name.len) == 0
-				} {
-					start := (node.key_pos + node.key_len) + 3
-					mut end := start
-					for decoder.json[end] != `,` && decoder.json[end] != `}` {
-						end++
-					}
-					value_kind := get_value_kind(decoder.json[start])
-					$if field.indirections != 0 {
-						// REVIEW Needs clone?
-						$if field.indirections == 1 {
-							// TODO
-							// unsafe {
-							// 	value.$(field.name) = &(decoder.json[start + 1..end - 1])
-							// }
-						} $else $if field.indirections == 2 {
-							// TODO
-							// unsafe {
-							// 	value.$(field.name) = &&(decoder.json[start + 1..end - 1])
-							// }
-						} $else $if field.indirections == 3 {
-							// TODO
-							// unsafe {
-							// 	value.$(field.name) = &&&(decoder.json[start + 1..end - 1])
-							// }
-						}
-					} $else $if field.typ is $option {
-						value.$(field.name) = decoder.decode_optional_value_in_actual_node(node,
-							value.$(field.name))
-					} $else $if field.typ is $sumtype {
-						// dump(value.$(field.name))
-
-						workaround := value.$(field.name)
-						// z := value.$(field.name)
-
-						$for v in workaround.variants {
-							$if v.typ is string {
-								if value_kind == .string_ {
-									// value.$(field.name) = decoder.json[start + 1..end - 1]
-								} else {
-									// value.$(field.name) = decoder.json[start..end]
-								}
-							} $else $if v.typ in [$int, $float] {
-								$if v.typ is u32 {
-									value.$(field.name) = decoder.json[start..end].u32()
-								} $else $if v.typ is u32 {
-								}
+	mut space_required := 0
+	mut escape_positions := []int{}
+	mut idx := 1 // Start after the opening quote
 
-								$if v.typ is i8 {
-									value.$(field.name) = decoder.json[start..end].i8()
-								} $else $if v.typ is i16 {
-									value.$(field.name) = decoder.json[start..end].i16()
-								} $else $if v.typ is i32 {
-									value.$(field.name) = decoder.json[start..end].i32()
-								} $else $if v.typ is int {
-									value.$(field.name) = decoder.json[start..end].int()
-								} $else $if v.typ is i64 {
-									value.$(field.name) = decoder.json[start..end].i64()
-								} $else $if v.typ is u8 {
-									value.$(field.name) = decoder.json[start..end].u8()
-								} $else $if v.typ is u16 {
-									value.$(field.name) = decoder.json[start..end].u16()
-								} $else $if v.typ is u32 {
-									value.$(field.name) = decoder.json[start..end].u32()
-								} $else $if v.typ is u64 {
-									value.$(field.name) = decoder.json[start..end].u64()
-								} $else $if v.typ is f32 {
-									value.$(field.name) = decoder.json[start..end].f32()
-								} $else $if v.typ is f64 {
-									value.$(field.name) = decoder.json[start..end].f64()
-								}
-							} $else $if v.typ is bool {
-								if decoder.json[start] == `t` {
-									value.$(field.name) = true
-								} else if decoder.json[start] == `f` {
-									value.$(field.name) = false
-								}
-							} $else $if v.typ is time.Time {
-								if value_kind == .string_ {
-									value.$(field.name) = time.parse(decoder.json[start + 1..end - 1]) or {
-										time.Time{}
-									}
-								}
-							} $else $if v.typ is $struct {
-								if node.children != none {
-									// FIXME
-									// decoder.decode_value(node.children or {
-									// 	panic('It will never happens')
-									// }, value.$(field.name))
-								}
-							} $else $if v.typ is $array {
-								if value_kind == .array {
-									// TODO
-								}
-							} $else $if v.typ is $map {
-								if value_kind == .object {
-									// TODO
-								}
-							} $else $if T is $enum {
-							} $else {
-								eprintln('not supported')
-							}
-						}
-						if value_kind == .string_ {
-							// value.$(field.name) = decoder.json[start + 1..end - 1]
-						} else if decoder.json[start] == `t` {
-							value.$(field.name) = true
-						} else if decoder.json[start] == `f` {
-							value.$(field.name) = false
-						} else if value_kind == .object {
-						} else if value_kind == .array {
-						} else if value_kind == .number {
-							// value.$(field.name) = decoder.json[start..end].int()
-						} else {
-						}
-					} $else $if field.typ is string {
-						value.$(field.name) = if value_kind == .string_ {
-							decoder.json[start + 1..end - 1]
-						} else {
-							decoder.json[start..end]
-						}
-					} $else $if field.typ in [$int, $float] {
-						$if field.typ is i8 {
-							value.$(field.name) = decoder.json[start..end].i8()
-						} $else $if field.typ is i16 {
-							value.$(field.name) = decoder.json[start..end].i16()
-						} $else $if field.typ is i32 {
-							value.$(field.name) = decoder.json[start..end].i32()
-						} $else $if field.typ is int {
-							value.$(field.name) = decoder.json[start..end].int()
-						} $else $if field.typ is i64 {
-							value.$(field.name) = decoder.json[start..end].i64()
-						} $else $if field.typ is u8 {
-							value.$(field.name) = decoder.json[start..end].u8()
-						} $else $if field.typ is u16 {
-							value.$(field.name) = decoder.json[start..end].u16()
-						} $else $if field.typ is u32 {
-							value.$(field.name) = decoder.json[start..end].u32()
-						} $else $if field.typ is u64 {
-							value.$(field.name) = decoder.json[start..end].u64()
-						} $else $if field.typ is f32 {
-							value.$(field.name) = decoder.json[start..end].f32()
-						} $else $if field.typ is f64 {
-							value.$(field.name) = decoder.json[start..end].f64()
-						}
-					} $else $if field.typ is bool {
-						value.$(field.name) = decoder.json[start] == `t`
-					} $else $if field.typ is time.Time {
-						if value_kind == .string_ {
-							value.$(field.name) = time.parse_rfc3339(decoder.json[start + 1..end - 1]) or {
-								time.Time{}
-							}
-						}
-					} $else $if field.typ is $struct {
-						if node.children != none {
-							decoder.decode_value(node.children or { panic('It will never happen') },
-								value.$(field.name))
-						}
-					} $else $if field.typ is $array {
-						if value_kind == .array {
-							// TODO
-						}
-					} $else $if field.typ is $map {
-						if value_kind == .object && node.children != none {
-							decoder.decode_map(node.children or { panic('It will never happen') }, mut
-								value.$(field.name))
-						}
-					} $else $if field.typ is $enum {
-						value.$(field.name) = decoder.json[start..end].int()
-					} $else $if field.typ is $alias {
-						$if field.unaliased_typ is string {
-							if value_kind == .string_ {
-								value.$(field.name) = decoder.json[start + 1..end - 1]
-							}
-						} $else $if field.unaliased_typ is time.Time {
-						} $else $if field.unaliased_typ is bool {
-						} $else $if field.unaliased_typ in [$float, $int] {
-							$if field.unaliased_typ is i8 {
-								value.$(field.name) = decoder.json[start..end].i8()
-							} $else $if field.unaliased_typ is i16 {
-								value.$(field.name) = decoder.json[start..end].i16()
-							} $else $if field.unaliased_typ is i32 {
-								value.$(field.name) = decoder.json[start..end].i32()
-							} $else $if field.unaliased_typ is int {
-								value.$(field.name) = decoder.json[start..end].int()
-							} $else $if field.unaliased_typ is i64 {
-								value.$(field.name) = decoder.json[start..end].i64()
-							} $else $if field.unaliased_typ is u8 {
-								value.$(field.name) = decoder.json[start..end].u8()
-							} $else $if field.unaliased_typ is u16 {
-								value.$(field.name) = decoder.json[start..end].u16()
-							} $else $if field.unaliased_typ is u32 {
-								value.$(field.name) = decoder.json[start..end].u32()
-							} $else $if field.unaliased_typ is u64 {
-								value.$(field.name) = decoder.json[start..end].u64()
-							} $else $if field.unaliased_typ is f32 {
-								value.$(field.name) = decoder.json[start..end].f32()
-							} $else $if field.unaliased_typ is f64 {
-								value.$(field.name) = decoder.json[start..end].f64()
-							}
-						} $else $if field.unaliased_typ is $array {
-							// TODO
-						} $else $if field.unaliased_typ is $struct {
-						} $else $if field.unaliased_typ is $enum {
-							// TODO
-						} $else $if field.unaliased_typ is $sumtype {
-							// TODO
-						} $else {
-							eprintln('the alias ${field.unaliased_typ} cannot be encoded')
-						}
-					} $else {
-						eprintln('not supported')
+	for idx < len - 1 {
+		current_byte := decoder.json[value_info.position + idx]
+
+		if current_byte == `\\` {
+			// Escape sequence, handle accordingly
+			idx++
+			if idx >= len - 1 {
+				return error('Invalid escape sequence at the end of string')
+			}
+			escaped_char := decoder.json[value_info.position + idx]
+			match escaped_char {
+				// All simple escapes take 1 byte of space
+				`/`, `b`, `f`, `n`, `r`, `t`, `"`, `\\` {
+					space_required++
+				}
+				`u` {
+					// Unicode escape sequence \uXXXX
+					if idx + 4 >= len - 1 {
+						return error('Invalid unicode escape sequence')
 					}
-					break
+					// Extract the hex value from the \uXXXX sequence
+					hex_str := decoder.json[value_info.position + idx + 1..value_info.position +
+						idx + 5]
+					unicode_value := u32(strconv.parse_int(hex_str, 16, 32)!)
+					// Determine the number of bytes needed for this Unicode character in UTF-8
+					space_required += utf8_byte_length(unicode_value)
+					idx += 4 // Skip the next 4 hex digits
+
+					// REVIEW: If the Unicode character is a surrogate pair, we need to skip the next \uXXXX sequence?
+
+					// \\uXXXX is 6 bytes, so we need to skip 5 more bytes
+					escape_positions << value_info.position + idx - 5
+				}
+				else {
+					return error('Unknown escape sequence')
 				}
 			}
+		} else {
+			// Regular character, just increment space required by 1 byte
+			space_required++
 		}
+		idx++
 	}
+
+	return space_required, escape_positions
 }
 
-// decode_map decodes a map from the JSON nodes.
-fn (mut decoder Decoder) decode_map[T](nodes []Node, mut val T) {
-	for i := 0; i < nodes.len; i++ {
-		mut node := nodes[i]
+// \uXXXX to unicode with 4 hex digits
+fn generate_unicode_escape_sequence(escape_sequence_byte []u8) ![]u8 {
+	if escape_sequence_byte.len != 4 {
+		return error('Invalid unicode escape sequence')
+	}
 
-		start := (node.key_pos + node.key_len) + 3
-		mut end := start
-		for decoder.json[end] != `,` && decoder.json[end] != `}` {
-			end++
-		}
-		value_kind := get_value_kind(decoder.json[start])
-		val[decoder.json[node.key_pos..node.key_pos + node.key_len]] = if value_kind == .string_ {
-			decoder.json[start + 1..end - 1]
-		} else {
-			decoder.json[start..end]
-		}
+	unicode_value := u32(strconv.parse_int(escape_sequence_byte.bytestr(), 16, 32)!)
+	mut utf8_bytes := []u8{cap: utf8_byte_length(unicode_value)}
+
+	if unicode_value <= 0x7F {
+		utf8_bytes << u8(unicode_value)
+	} else if unicode_value <= 0x7FF {
+		utf8_bytes << u8(0xC0 | (unicode_value >> 6))
+		utf8_bytes << u8(0x80 | (unicode_value & 0x3F))
+	} else if unicode_value <= 0xFFFF {
+		utf8_bytes << u8(0xE0 | (unicode_value >> 12))
+		utf8_bytes << u8(0x80 | ((unicode_value >> 6) & 0x3F))
+		utf8_bytes << u8(0x80 | (unicode_value & 0x3F))
+	} else {
+		utf8_bytes << u8(0xF0 | (unicode_value >> 18))
+		utf8_bytes << u8(0x80 | ((unicode_value >> 12) & 0x3F))
+		utf8_bytes << u8(0x80 | ((unicode_value >> 6) & 0x3F))
+		utf8_bytes << u8(0x80 | (unicode_value & 0x3F))
 	}
+
+	return utf8_bytes
 }
 
-// fulfill_nodes fills the nodes from the JSON string.
-fn (mut decoder Decoder) fulfill_nodes(mut nodes []Node) {
-	mut inside_string := false
-	mut inside_key := false
-	mut actual_key_len := 0
+fn create_array_element[T](array []T) T {
+	return T{}
+}
 
-	for decoder.idx < decoder.json.len {
-		letter := decoder.json[decoder.idx]
-		match letter {
-			` ` {
-				if !inside_string {
-				}
-			}
-			`\"` {
-				if decoder.json[decoder.idx - 1] == `{` || decoder.json[decoder.idx - 2] == `,` {
-					inside_key = true
-				} else if decoder.json[decoder.idx + 1] == `:` {
-					if decoder.json[decoder.idx + 3] == `{` {
-						mut children := []Node{}
-						key_pos := decoder.idx - actual_key_len
-						key_len := actual_key_len
-
-						decoder.idx += 3
-						decoder.fulfill_nodes(mut children)
-
-						nodes << Node{
-							key_pos:  key_pos
-							key_len:  key_len
-							children: children
-						}
-					} else {
-						nodes << Node{
-							key_pos: decoder.idx - actual_key_len
-							key_len: actual_key_len
-						}
-					}
-					inside_key = false
-				}
-				inside_string = !inside_string
-				decoder.idx++
-				continue
-			}
-			`:` {
-				actual_key_len = 0
-			}
-			`,`, `{`, `}`, `[`, `]` {}
-			else {}
-		}
-		if inside_key {
-			actual_key_len++
-		}
-		decoder.idx++
-	}
+fn create_map_value[K, V](map_ map[K]V) V {
+	return V{}
+}
+
+fn create_value_from_optional[T](val ?T) T {
+	return T{}
 }
 
 // string_buffer_to_generic_number converts a buffer of bytes (data) into a generic type T and
@@ -928,9 +908,8 @@ fn (mut decoder Decoder) fulfill_nodes(mut nodes []Node) {
 // NOTE: This aims works with not new memory allocated data, to more efficient use `vbytes` before
 @[direct_array_access; unsafe]
 pub fn string_buffer_to_generic_number[T](result &T, data []u8) {
-	mut is_negative := false
-
 	$if T is $int {
+		mut is_negative := false
 		for ch in data {
 			if ch == `-` {
 				is_negative = true
@@ -939,7 +918,11 @@ pub fn string_buffer_to_generic_number[T](result &T, data []u8) {
 			digit := T(ch - `0`)
 			*result = T(*result * 10 + digit)
 		}
+		if is_negative {
+			*result *= -1
+		}
 	} $else $if T is $float {
+		mut is_negative := false
 		mut decimal_seen := false
 		mut decimal_divider := int(1)
 
@@ -962,6 +945,9 @@ pub fn string_buffer_to_generic_number[T](result &T, data []u8) {
 				*result = *result * 10 + digit
 			}
 		}
+		if is_negative {
+			*result *= -1
+		}
 	} $else $if T is $enum {
 		// Convert the string to an integer
 		enumeration := 0
@@ -970,11 +956,21 @@ pub fn string_buffer_to_generic_number[T](result &T, data []u8) {
 			enumeration = enumeration * 10 + digit
 		}
 		*result = T(enumeration)
+	} $else $if T is $alias {
+		$if T.unaliased_typ in [$int, $enum] {
+			// alias_value := 0
+			// string_buffer_to_generic_number(&alias_value, data)
+			// *result = alias_value
+			panic('unsupported type ${typeof[T]().name}')
+		} $else $if T.unaliased_typ is $float {
+			// alias_value := 0.0
+			// string_buffer_to_generic_number(&alias_value, data)
+			// *result = alias_value
+			panic('unsupported type ${typeof[T]().name}')
+		} $else {
+			panic('unsupported type ${typeof[T]().name}')
+		}
 	} $else {
 		panic('unsupported type ${typeof[T]().name}')
 	}
-
-	if is_negative {
-		*result = -*result
-	}
 }
diff --git a/vlib/x/json2/decoder2/decode_test.v b/vlib/x/json2/decoder2/decode_test.v
index d6c5932c5d80a5..39bee25034460c 100644
--- a/vlib/x/json2/decoder2/decode_test.v
+++ b/vlib/x/json2/decoder2/decode_test.v
@@ -1,46 +1,5 @@
 module decoder2
 
-fn test_nodes() {
-	mut nodes := []Node{}
-
-	mut decoder := Decoder{
-		json: '{"val": "2"}'
-	}
-
-	decoder.fulfill_nodes(mut nodes)
-
-	assert nodes.len == 1
-	assert nodes[0].key_pos == 2
-	assert nodes[0].key_len == 3
-	assert nodes[0].children == none
-	nodes = []
-
-	decoder = Decoder{
-		json: '{"val": 0, "val1": 1}'
-	}
-	decoder.fulfill_nodes(mut nodes)
-
-	assert nodes.len == 2
-	assert nodes[0].key_pos == 2
-	assert nodes[0].key_len == 3
-
-	assert nodes[1].key_pos == 12
-	assert nodes[1].key_len == 4
-
-	nodes = []
-
-	decoder = Decoder{
-		json: '{"val": {"val": 2}}'
-	}
-	decoder.fulfill_nodes(mut nodes)
-
-	assert nodes.len == 1
-	assert nodes[0].children != none
-	assert nodes[0].children?.len == 1
-	assert nodes[0].children?[0].key_pos == 10
-	assert nodes[0].children?[0].children == none
-}
-
 fn test_check_if_json_match() {
 	// /* Test wrong string values */
 	mut has_error := false
@@ -222,120 +181,25 @@ fn test_check_json_format() {
 }
 
 fn test_get_value_kind() {
-	assert get_value_kind(`"`) == .string_
-	assert get_value_kind(`t`) == .boolean
-	assert get_value_kind(`f`) == .boolean
-	assert get_value_kind(`{`) == .object
-	assert get_value_kind(`[`) == .array
-	assert get_value_kind(`0`) == .number
-	assert get_value_kind(`-`) == .number
-	assert get_value_kind(`n`) == .null
-	assert get_value_kind(`x`) == .unknown
-}
 
-fn test_checker_values_info() {
-	// Test for string value
-	mut checker := Decoder{
-		checker_idx: 0
-		json:        '"value"'
-	}
-	checker.check_json_format(checker.json) or { assert false, err.str() }
-	assert checker.values_info.len == 1
-	assert checker.values_info[0].position == 0
-	assert checker.values_info[0].length == 7
-	assert checker.values_info[0].value_kind == .string_
-
-	// Test for number value
-	checker = Decoder{
-		checker_idx: 0
-		json:        '123'
-	}
-	checker.check_json_format(checker.json) or { assert false, err.str() }
-	assert checker.values_info.len == 1
-	assert checker.values_info[0].position == 0
-	assert checker.values_info[0].length == 3
-	assert checker.values_info[0].value_kind == .number
-
-	// Test for boolean value
-	checker = Decoder{
-		checker_idx: 0
-		json:        'true'
-	}
-	checker.check_json_format(checker.json) or { assert false, err.str() }
-	assert checker.values_info.len == 1
-	assert checker.values_info[0].position == 0
-	assert checker.values_info[0].length == 4
-	assert checker.values_info[0].value_kind == .boolean
-
-	// Test for null value
-	checker = Decoder{
-		checker_idx: 0
-		json:        'null'
-	}
-	checker.check_json_format(checker.json) or { assert false, err.str() }
-	assert checker.values_info.len == 1
-	assert checker.values_info[0].position == 0
-	assert checker.values_info[0].length == 4
-	assert checker.values_info[0].value_kind == .null
-
-	// Test for object value
-	checker = Decoder{
-		checker_idx: 0
-		json:        '{"key": "value"}'
-	}
-	checker.check_json_format(checker.json) or { assert false, err.str() }
-	assert checker.values_info.len == 3
-	assert checker.values_info[0].position == 0
-	assert checker.values_info[0].length == 16
-	assert checker.values_info[0].value_kind == .object
-	assert checker.values_info[1].position == 1
-	assert checker.values_info[1].length == 5
-	assert checker.values_info[1].value_kind == .string_
-	assert checker.values_info[2].position == 8
-	assert checker.values_info[2].length == 7
-	assert checker.values_info[2].value_kind == .string_
-
-	// Test for nested object value
-	checker = Decoder{
-		checker_idx: 0
-		// json: '0<-{1"key1": 9<-{10"key2": 18"value1"}}'
-		json: '{"key1": {"key2": "value1"}'
-	}
-	checker.check_json_format(checker.json) or { assert false, err.str() }
-	dump(checker.values_info)
-	assert checker.values_info.len == 5
-	assert checker.values_info[0].position == 0
-	assert checker.values_info[0].length == 27
-	assert checker.values_info[0].value_kind == .object
-	assert checker.values_info[1].position == 1
-	assert checker.values_info[1].length == 6
-	assert checker.values_info[1].value_kind == .string_
-	assert checker.values_info[2].position == 9
-	assert checker.values_info[2].length == 18
-	assert checker.values_info[2].value_kind == .object
-	assert checker.values_info[3].position == 10
-	assert checker.values_info[3].length == 6
-	assert checker.values_info[3].value_kind == .string_
-	assert checker.values_info[4].position == 18
-	assert checker.values_info[4].length == 8
-
-	// Test for array value
-	checker = Decoder{
-		checker_idx: 0
-		json:        '[1, 22, 333]'
+	struct Object_ {
+		byte_      u8
+		value_kind ValueKind
+	}
+
+	array_ := [
+		Object_{`"`, .string_},
+		Object_{`t`, .boolean},
+		Object_{`f`, .boolean},
+		Object_{`{`, .object},
+		Object_{`[`, .array},
+		Object_{`0`, .number},
+		Object_{`-`, .number},
+		Object_{`n`, .null},
+		Object_{`x`, .unknown},
+	]
+
+	for value in array_ {
+		assert get_value_kind(&value.byte_) == value.value_kind
 	}
-	checker.check_json_format(checker.json) or { assert false, err.str() }
-	assert checker.values_info.len == 4
-	assert checker.values_info[0].position == 0
-	assert checker.values_info[0].length == 12
-	assert checker.values_info[0].value_kind == .array
-	assert checker.values_info[1].position == 1
-	assert checker.values_info[1].length == 1
-	assert checker.values_info[1].value_kind == .number
-	assert checker.values_info[2].position == 4
-	assert checker.values_info[2].length == 2
-	assert checker.values_info[2].value_kind == .number
-	assert checker.values_info[3].position == 8
-	assert checker.values_info[3].length == 3
-	assert checker.values_info[3].value_kind == .number
 }
diff --git a/vlib/x/json2/decoder2/tests/bench.v b/vlib/x/json2/decoder2/tests/bench.v
index 95ba4ea25dfc40..99fd7e271122bc 100644
--- a/vlib/x/json2/decoder2/tests/bench.v
+++ b/vlib/x/json2/decoder2/tests/bench.v
@@ -4,7 +4,8 @@ import benchmark
 import time
 
 // ./v -prod crun vlib/x/json/tests/c.v
-const max_iterations = 100_000
+// ./v wipe-cache && ./v -prod -cc gcc crun vlib/x/json2/decoder2/tests/bench.v
+const max_iterations = 1_000_000
 // const max_iterations = 10 // trying figure out it is slower in small loop. I guess it is `fulfill_nodes` related. Any suggestion?
 
 pub struct Stru {
@@ -57,6 +58,12 @@ fn main() {
 
 	// Stru **********************************************************
 
+	for i := 0; i < max_iterations; i++ {
+		_ := decoder2.decode[Stru](json_data)!
+	}
+
+	b.measure('decoder2.decode[Stru](json_data)!')
+
 	for i := 0; i < max_iterations; i++ {
 		_ := old_json.decode(Stru, json_data)!
 	}
diff --git a/vlib/x/json2/decoder2/tests/decode_struct_test.v b/vlib/x/json2/decoder2/tests/decode_struct_test.v
index 65ac3d4a8203e2..a580473c3f7cde 100644
--- a/vlib/x/json2/decoder2/tests/decode_struct_test.v
+++ b/vlib/x/json2/decoder2/tests/decode_struct_test.v
@@ -50,12 +50,12 @@ fn test_types() {
 
 	assert json.decode[StructType[int]]('{"val": 2}')!.val == 2
 
-	assert json.decode[StructType[map[string]string]]('{"val": {"val": "test"}}')!.val['val'] == 'test'
+	assert json.decode[StructType[map[string]string]]('{"val": {"val1": "test"}}')!.val['val1'] == 'test'
 
 	assert json.decode[StructType[Enumerates]]('{"val": 0}')!.val == Enumerates.a
 	assert json.decode[StructType[Enumerates]]('{"val": 1}')!.val == Enumerates.b
 
-	assert json.decode[StructType[IntAlias]]('{"val": 2}')!.val == IntAlias(2)
+	// assert json.decode[StructType[IntAlias]]('{"val": 2}')!.val == IntAlias(2)
 	assert json.decode[StructType[StringAlias]]('{"val": "2"}')!.val == StringAlias('2')
 
 	assert json.decode[StructType[time.Time]]('{"val": "2022-03-11T13:54:25.000Z"}')!.val.year == fixed_time.year

From 46997be72120833b4fe535cefb3a4483414d2df3 Mon Sep 17 00:00:00 2001
From: Hitalo Souza <enghitalo@gmail.com>
Date: Fri, 18 Oct 2024 22:32:30 -0400
Subject: [PATCH 02/14] tests

---
 .../json2/decoder2/tests/decode_object_test.v | 56 +++++++++++++++++++
 .../json2/decoder2/tests/decode_string_test.v | 30 ++++++++++
 2 files changed, 86 insertions(+)
 create mode 100644 vlib/x/json2/decoder2/tests/decode_object_test.v
 create mode 100644 vlib/x/json2/decoder2/tests/decode_string_test.v

diff --git a/vlib/x/json2/decoder2/tests/decode_object_test.v b/vlib/x/json2/decoder2/tests/decode_object_test.v
new file mode 100644
index 00000000000000..0d81b63c70a7cb
--- /dev/null
+++ b/vlib/x/json2/decoder2/tests/decode_object_test.v
@@ -0,0 +1,56 @@
+import x.json2.decoder2 as json
+
+pub struct Stru {
+	val  int
+	val2 string
+	val3 Stru2
+}
+
+pub struct Stru2 {
+	a         int
+	churrasco string
+}
+
+struct StructType[T] {
+mut:
+	val T
+}
+
+struct StructTypeOption[T] {
+mut:
+	val ?T
+}
+
+struct StructTypePointer[T] {
+mut:
+	val &T
+}
+
+fn test_array_of_strings() {
+	// Structs
+	assert json.decode[StructType[string]]('{"val": "2"}')! == StructType{
+		val: '2'
+	}
+	assert json.decode[StructType[int]]('{"val": 2}')! == StructType{
+		val: 2
+	}
+
+	// maps
+	assert json.decode[map[string]string]('{"val": "2"}')! == {
+		'val': '2'
+	}
+	// assert json.decode[map[string]int]('{"val": 2}')! == {"val": 2}
+
+	// // nested map
+	// assert json.decode[map[string]map[string]string]('{"val": {"val2": "2"}}')! == {"val": {"val2": "2"}}
+
+	// nested struct
+	assert json.decode[Stru]('{"val": 1, "val2": "lala", "val3": {"a": 2, "churrasco": "leleu"}}')! == Stru{
+		val:  1
+		val2: 'lala'
+		val3: Stru2{
+			a:         2
+			churrasco: 'leleu'
+		}
+	}
+}
diff --git a/vlib/x/json2/decoder2/tests/decode_string_test.v b/vlib/x/json2/decoder2/tests/decode_string_test.v
new file mode 100644
index 00000000000000..2afca7ce3d980c
--- /dev/null
+++ b/vlib/x/json2/decoder2/tests/decode_string_test.v
@@ -0,0 +1,30 @@
+import x.json2.decoder2 as json
+
+fn test_json_escape_low_chars() {
+	assert json.decode[string](r'"\u001b"')! == '\u001b'
+	assert json.decode[string](r'"\u000f"')! == '\u000f'
+	assert json.decode[string](r'" "')! == '\u0020'
+	assert json.decode[string](r'"\u0000"')! == '\u0000'
+}
+
+fn test_json_string() {
+	assert json.decode[string](r'"te\u2714st"')! == 'te✔st'
+	// assert json.decode[string]('te✔st')! == 'te✔st'
+}
+
+fn test_json_string_emoji() {
+	assert json.decode[string](r'"🐈"')! == '🐈'
+	assert json.decode[string](r'"💀"')! == '💀'
+	assert json.decode[string](r'"🐈💀"')! == '🐈💀'
+}
+
+fn test_json_string_non_ascii() {
+	assert json.decode[string](r'"\u3072\u3089\u304c\u306a"')! == 'ひらがな'
+	assert json.decode[string]('"a\\u3072b\\u3089c\\u304cd\\u306ae fgh"')! == 'aひbらcがdなe fgh'
+	assert json.decode[string]('"\\u3072\\u3089\\u304c\\u306a"')! == 'ひらがな'
+}
+
+fn test_utf8_strings_are_not_modified() {
+	assert json.decode[string]('"ü"')! == 'ü'
+	assert json.decode[string]('"Schilddrüsenerkrankungen"')! == 'Schilddrüsenerkrankungen'
+}

From 875d78df55045c695a2f10f83704968973ef00b6 Mon Sep 17 00:00:00 2001
From: Hitalo Souza <enghitalo@gmail.com>
Date: Sat, 19 Oct 2024 03:59:41 -0400
Subject: [PATCH 03/14] reorder, for better git compare

---
 vlib/x/json2/decoder2/decode.v | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/vlib/x/json2/decoder2/decode.v b/vlib/x/json2/decoder2/decode.v
index 24f240632486b7..0105e51ba8a6cd 100644
--- a/vlib/x/json2/decoder2/decode.v
+++ b/vlib/x/json2/decoder2/decode.v
@@ -757,6 +757,18 @@ fn (mut decoder Decoder) decode_value[T](mut val T) ! {
 	}
 }
 
+fn create_array_element[T](array []T) T {
+	return T{}
+}
+
+fn create_map_value[K, V](map_ map[K]V) V {
+	return V{}
+}
+
+fn create_value_from_optional[T](val ?T) T {
+	return T{}
+}
+
 // get_value_kind returns the kind of a JSON value.
 fn get_value_kind(val &u8) ValueKind {
 	value := *val
@@ -876,18 +888,6 @@ fn generate_unicode_escape_sequence(escape_sequence_byte []u8) ![]u8 {
 	return utf8_bytes
 }
 
-fn create_array_element[T](array []T) T {
-	return T{}
-}
-
-fn create_map_value[K, V](map_ map[K]V) V {
-	return V{}
-}
-
-fn create_value_from_optional[T](val ?T) T {
-	return T{}
-}
-
 // string_buffer_to_generic_number converts a buffer of bytes (data) into a generic type T and
 // stores the result in the provided result pointer.
 // The function supports conversion to the following types:

From f59edd5fddd852890455dd954d7f37764ee7e7ac Mon Sep 17 00:00:00 2001
From: Hitalo Souza <enghitalo@gmail.com>
Date: Sat, 19 Oct 2024 04:02:48 -0400
Subject: [PATCH 04/14] reorder, for better git compare

---
 vlib/x/json2/decoder2/decode.v | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/vlib/x/json2/decoder2/decode.v b/vlib/x/json2/decoder2/decode.v
index 0105e51ba8a6cd..6ea936427cabe4 100644
--- a/vlib/x/json2/decoder2/decode.v
+++ b/vlib/x/json2/decoder2/decode.v
@@ -757,18 +757,6 @@ fn (mut decoder Decoder) decode_value[T](mut val T) ! {
 	}
 }
 
-fn create_array_element[T](array []T) T {
-	return T{}
-}
-
-fn create_map_value[K, V](map_ map[K]V) V {
-	return V{}
-}
-
-fn create_value_from_optional[T](val ?T) T {
-	return T{}
-}
-
 // get_value_kind returns the kind of a JSON value.
 fn get_value_kind(val &u8) ValueKind {
 	value := *val
@@ -788,6 +776,18 @@ fn get_value_kind(val &u8) ValueKind {
 	return .unknown
 }
 
+fn create_array_element[T](array []T) T {
+	return T{}
+}
+
+fn create_map_value[K, V](map_ map[K]V) V {
+	return V{}
+}
+
+fn create_value_from_optional[T](val ?T) T {
+	return T{}
+}
+
 fn utf8_byte_length(unicode_value u32) int {
 	if unicode_value <= 0x7F {
 		return 1

From 64dfbd467066fe68e3c98fb540aba0fa463afb36 Mon Sep 17 00:00:00 2001
From: Hitalo Souza <enghitalo@gmail.com>
Date: Sat, 19 Oct 2024 04:06:16 -0400
Subject: [PATCH 05/14] remove comments

---
 vlib/x/json2/decoder2/decode.v | 24 +-----------------------
 1 file changed, 1 insertion(+), 23 deletions(-)

diff --git a/vlib/x/json2/decoder2/decode.v b/vlib/x/json2/decoder2/decode.v
index 6ea936427cabe4..34a9c599d48fc2 100644
--- a/vlib/x/json2/decoder2/decode.v
+++ b/vlib/x/json2/decoder2/decode.v
@@ -572,7 +572,6 @@ fn (mut decoder Decoder) decode_value[T](mut val T) ! {
 
 						// Pushes a substring from the JSON string into the string buffer, starting after the previous escape position
 						// and ending just before the current escape position. This handles the characters between escape sequences.
-						// dump(escape_position - escape_positions[i - 1] - 6 )
 						unsafe {
 							string_buffer.push_many(decoder.json.str + escape_positions[i - 1] + 6,
 								escape_position - escape_positions[i - 1] - 6)
@@ -616,9 +615,7 @@ fn (mut decoder Decoder) decode_value[T](mut val T) ! {
 			map_position := map_info.position
 			map_end := map_position + map_info.length
 
-			// decoder.value_info_idx++
 			decoder.current_node = decoder.current_node.next
-			// dump(decoder.json)
 			for {
 				if decoder.current_node == unsafe { nil } {
 					break
@@ -648,25 +645,19 @@ fn (mut decoder Decoder) decode_value[T](mut val T) ! {
 			}
 		}
 	} $else $if T is $array {
-		// array_info := decoder.values_info[decoder.value_info_idx]
 		array_info := decoder.current_node.value
 
 		if array_info.value_kind == .array {
 			array_position := array_info.position
 			array_end := array_position + array_info.length
 
-			// decoder.value_info_idx++
 			decoder.current_node = decoder.current_node.next
-			// dump(decoder.json)
 			for {
 				// if decoder.value_info_idx >= decoder.values_info.len {
 				if decoder.current_node == unsafe { nil } {
-					// dump("break")
 					break
 				}
-				// value_info := decoder.values_info[decoder.value_info_idx]
 				value_info := decoder.current_node.value
-				// dump(value_info)
 
 				if value_info.position + value_info.length >= array_end {
 					break
@@ -677,10 +668,8 @@ fn (mut decoder Decoder) decode_value[T](mut val T) ! {
 				decoder.decode_value(mut array_element)!
 
 				val << array_element
-				// dump(val)
 			}
 		}
-		// dump("out")
 	} $else $if T is $struct {
 		struct_info := decoder.current_node.value
 
@@ -688,11 +677,8 @@ fn (mut decoder Decoder) decode_value[T](mut val T) ! {
 			struct_position := struct_info.position
 			struct_end := struct_position + struct_info.length
 
-			// decoder.value_info_idx++
 			decoder.current_node = decoder.current_node.next
-			// dump(decoder.json)
 			for {
-				// dump(decoder.current_node)
 				if decoder.current_node == unsafe { nil } {
 					break
 				}
@@ -708,15 +694,10 @@ fn (mut decoder Decoder) decode_value[T](mut val T) ! {
 				$for field in T.fields {
 					if key_info.length - 2 == field.name.len {
 						// This `vmemcmp` compares the name of a key in a JSON with a given struct field.
-						// dump('a')
-						// dump(decoder.json[key_info.position+1..key_info.position + 1 + field.name.len])
 						if unsafe {
 							vmemcmp(decoder.json.str + key_info.position + 1, field.name.str,
 								field.name.len) == 0
 						} {
-							// mut workaround := val.$(field.name)
-							// decoder.decode_value(mut workaround)!
-							// val.$(field.name) = workaround
 							$if field.typ is $option {
 								mut unwrapped_val := create_value_from_optional(val.$(field.name))
 								decoder.decode_value(mut unwrapped_val)!
@@ -730,14 +711,12 @@ fn (mut decoder Decoder) decode_value[T](mut val T) ! {
 			}
 		}
 	} $else $if T is bool {
-		// value_info := decoder.values_info[decoder.value_info_idx]
 		value_info := decoder.current_node.value
 
 		unsafe {
 			val = vmemcmp(decoder.json.str + value_info.position, 'true'.str, 4) == 0
 		}
 	} $else $if T in [$int, $float, $enum] {
-		// value_info := decoder.values_info[decoder.value_info_idx]
 		value_info := decoder.current_node.value
 
 		if value_info.value_kind == .number {
@@ -750,8 +729,7 @@ fn (mut decoder Decoder) decode_value[T](mut val T) ! {
 	} $else {
 		return error('cannot encode value with ${typeof(val).name} type')
 	}
-	// decoder.value_info_idx++
-	// decoder.current_node = decoder.current_node.next
+
 	if decoder.current_node != unsafe { nil } {
 		decoder.current_node = decoder.current_node.next
 	}

From 8b90f04025439f475f5090182320729f5bf72e3a Mon Sep 17 00:00:00 2001
From: Hitalo Souza <enghitalo@gmail.com>
Date: Sat, 19 Oct 2024 04:11:05 -0400
Subject: [PATCH 06/14] remove comments

---
 vlib/x/json2/decoder2/decode.v | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/vlib/x/json2/decoder2/decode.v b/vlib/x/json2/decoder2/decode.v
index 34a9c599d48fc2..a52c2928230572 100644
--- a/vlib/x/json2/decoder2/decode.v
+++ b/vlib/x/json2/decoder2/decode.v
@@ -557,8 +557,6 @@ fn (mut decoder Decoder) decode_value[T](mut val T) ! {
 				for i := 0; i < escape_positions.len; i++ {
 					escape_position := escape_positions[i]
 					if i == 0 {
-						// string_buffer << decoder.json[value_info.position + 1..escape_position].bytes()
-
 						// Pushes a substring from the JSON string into the string buffer.
 						// The substring starts at the position of the value in the JSON string plus one,
 						// and ends at the escape position minus one.
@@ -568,8 +566,6 @@ fn (mut decoder Decoder) decode_value[T](mut val T) ! {
 								escape_position - string_info.position - 1)
 						}
 					} else {
-						// string_buffer << decoder.json[escape_positions[i - 1] + 2..escape_position].bytes()
-
 						// Pushes a substring from the JSON string into the string buffer, starting after the previous escape position
 						// and ending just before the current escape position. This handles the characters between escape sequences.
 						unsafe {

From 621aa6c159f111122b373b856075c8971a0027e8 Mon Sep 17 00:00:00 2001
From: Hitalo Souza <enghitalo@gmail.com>
Date: Sat, 19 Oct 2024 04:27:49 -0400
Subject: [PATCH 07/14] more bench

---
 vlib/x/json2/decoder2/tests/bench.v | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/vlib/x/json2/decoder2/tests/bench.v b/vlib/x/json2/decoder2/tests/bench.v
index 99fd7e271122bc..7853d521d1c3ac 100644
--- a/vlib/x/json2/decoder2/tests/bench.v
+++ b/vlib/x/json2/decoder2/tests/bench.v
@@ -153,4 +153,18 @@ fn main() {
 	}
 
 	b.measure("decoder2.decode[bool]('true')!")
+
+	// time.Time **********************************************************
+	for i := 0; i < max_iterations; i++ {
+		_ := decoder2.decode[time.Time]('"2022-03-11T13:54:25"')!
+	}
+
+	b.measure("decoder2.decode[time.Time]('2022-03-11T13:54:25')!")
+
+	// string **********************************************************
+	for i := 0; i < max_iterations; i++ {
+		_ := decoder2.decode[string]('"abcdefghijklimnopqrstuv"')!
+	}
+
+	b.measure('decoder2.decode[string](\'"lala"\')!')
 }

From 9937303acab8f33c944892d6e5aa73cd9200ef0a Mon Sep 17 00:00:00 2001
From: Hitalo Souza <enghitalo@gmail.com>
Date: Sat, 19 Oct 2024 04:33:04 -0400
Subject: [PATCH 08/14] fix: bench

---
 vlib/x/json2/decoder2/tests/bench.v | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/vlib/x/json2/decoder2/tests/bench.v b/vlib/x/json2/decoder2/tests/bench.v
index 7853d521d1c3ac..262e49dacacec1 100644
--- a/vlib/x/json2/decoder2/tests/bench.v
+++ b/vlib/x/json2/decoder2/tests/bench.v
@@ -166,5 +166,5 @@ fn main() {
 		_ := decoder2.decode[string]('"abcdefghijklimnopqrstuv"')!
 	}
 
-	b.measure('decoder2.decode[string](\'"lala"\')!')
+	b.measure('decoder2.decode[string](\'"abcdefghijklimnopqrstuv"\')!')
 }

From 7655490faafe5afd7f2a5e397db9c9d208b142ca Mon Sep 17 00:00:00 2001
From: Hitalo Souza <enghitalo@gmail.com>
Date: Sat, 19 Oct 2024 04:54:55 -0400
Subject: [PATCH 09/14] linked list free method

---
 vlib/x/json2/decoder2/decode.v | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/vlib/x/json2/decoder2/decode.v b/vlib/x/json2/decoder2/decode.v
index a52c2928230572..4aab38e41e5469 100644
--- a/vlib/x/json2/decoder2/decode.v
+++ b/vlib/x/json2/decoder2/decode.v
@@ -66,6 +66,16 @@ fn (list LinkedList) str() string {
 	return result
 }
 
+@[unsafe]
+fn (list &LinkedList) free() {
+	mut current := list.head
+	for current != unsafe { nil } {
+		mut next := current.next
+		unsafe { free(current) }
+		current = next
+	}
+}
+
 // ValueKind represents the kind of a JSON value.
 pub enum ValueKind {
 	unknown

From 7e835f640502ff925610f76066ceced9718ebacd Mon Sep 17 00:00:00 2001
From: Hitalo Souza <enghitalo@gmail.com>
Date: Sat, 19 Oct 2024 11:18:32 -0400
Subject: [PATCH 10/14] string builder in str

---
 vlib/x/json2/decoder2/decode.v | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/vlib/x/json2/decoder2/decode.v b/vlib/x/json2/decoder2/decode.v
index 4aab38e41e5469..9bfb80ff3ff218 100644
--- a/vlib/x/json2/decoder2/decode.v
+++ b/vlib/x/json2/decoder2/decode.v
@@ -57,13 +57,16 @@ fn (list LinkedList) last() &ValueInfo {
 
 // str returns a string representation of the linked list.
 fn (list LinkedList) str() string {
-	mut result := ''
+	mut result_buffer := []u8{}
 	mut current := list.head
 	for current != unsafe { nil } {
-		result += current.value.value_kind.str() + ' '
+		value_kind_as_string := current.value.value_kind.str()
+		result_buffer.push_many(value_kind_as_string.str, value_kind_as_string.len)
+		result_buffer << u8(` `)
+
 		current = current.next
 	}
-	return result
+	return result_buffer.bytestr()
 }
 
 @[unsafe]

From 2fc2ce2ebebd2e90b01e0f86d349445604444c51 Mon Sep 17 00:00:00 2001
From: Hitalo Souza <enghitalo@gmail.com>
Date: Sat, 19 Oct 2024 11:21:28 -0400
Subject: [PATCH 11/14] fix: free

---
 vlib/x/json2/decoder2/decode.v | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/vlib/x/json2/decoder2/decode.v b/vlib/x/json2/decoder2/decode.v
index 9bfb80ff3ff218..680cc7e38de503 100644
--- a/vlib/x/json2/decoder2/decode.v
+++ b/vlib/x/json2/decoder2/decode.v
@@ -74,9 +74,13 @@ fn (list &LinkedList) free() {
 	mut current := list.head
 	for current != unsafe { nil } {
 		mut next := current.next
+		current.next = unsafe { nil }
 		unsafe { free(current) }
 		current = next
 	}
+	list.head = unsafe { nil }
+	list.tail = unsafe { nil }
+	list.len = 0
 }
 
 // ValueKind represents the kind of a JSON value.

From c5859a3a0e84f2647f4cbde0220f481f71360a30 Mon Sep 17 00:00:00 2001
From: Hitalo Souza <enghitalo@gmail.com>
Date: Sat, 19 Oct 2024 11:23:36 -0400
Subject: [PATCH 12/14] change field name

---
 vlib/x/json2/decoder2/tests/decode_object_test.v | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/vlib/x/json2/decoder2/tests/decode_object_test.v b/vlib/x/json2/decoder2/tests/decode_object_test.v
index 0d81b63c70a7cb..a5510898a62d57 100644
--- a/vlib/x/json2/decoder2/tests/decode_object_test.v
+++ b/vlib/x/json2/decoder2/tests/decode_object_test.v
@@ -7,8 +7,8 @@ pub struct Stru {
 }
 
 pub struct Stru2 {
-	a         int
-	churrasco string
+	a               int
+	brazilian_steak string
 }
 
 struct StructType[T] {
@@ -45,12 +45,12 @@ fn test_array_of_strings() {
 	// assert json.decode[map[string]map[string]string]('{"val": {"val2": "2"}}')! == {"val": {"val2": "2"}}
 
 	// nested struct
-	assert json.decode[Stru]('{"val": 1, "val2": "lala", "val3": {"a": 2, "churrasco": "leleu"}}')! == Stru{
+	assert json.decode[Stru]('{"val": 1, "val2": "lala", "val3": {"a": 2, "brazilian_steak": "leleu"}}')! == Stru{
 		val:  1
 		val2: 'lala'
 		val3: Stru2{
-			a:         2
-			churrasco: 'leleu'
+			a:               2
+			brazilian_steak: 'leleu'
 		}
 	}
 }

From 9b0ba752b375b22024b3112b794201f17e45b323 Mon Sep 17 00:00:00 2001
From: Hitalo Souza <enghitalo@gmail.com>
Date: Sat, 19 Oct 2024 11:25:34 -0400
Subject: [PATCH 13/14] change linked_list_of_value_info to values_info

---
 vlib/x/json2/decoder2/decode.v | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/vlib/x/json2/decoder2/decode.v b/vlib/x/json2/decoder2/decode.v
index 680cc7e38de503..1d3a519c2a7b62 100644
--- a/vlib/x/json2/decoder2/decode.v
+++ b/vlib/x/json2/decoder2/decode.v
@@ -22,9 +22,9 @@ mut:
 struct Decoder {
 	json string // json is the JSON data to be decoded.
 mut:
-	linked_list_of_value_info LinkedList // A linked list to store ValueInfo.
-	checker_idx               int        // checker_idx is the current index of the decoder.
-	current_node              &Node = unsafe { nil } // The current node in the linked list.
+	values_info  LinkedList // A linked list to store ValueInfo.
+	checker_idx  int        // checker_idx is the current index of the decoder.
+	current_node &Node = unsafe { nil } // The current node in the linked list.
 }
 
 // LinkedList represents a linked list to store ValueInfo.
@@ -184,12 +184,12 @@ fn (mut checker Decoder) check_json_format(val string) ! {
 	// check if generic type matches the JSON type
 	value_kind := get_value_kind(unsafe { val.str + checker.checker_idx })
 	start_idx_position := checker.checker_idx
-	checker.linked_list_of_value_info.push(ValueInfo{
+	checker.values_info.push(ValueInfo{
 		position:   start_idx_position
 		value_kind: value_kind
 	})
 
-	mut actual_value_info_pointer := checker.linked_list_of_value_info.last()
+	mut actual_value_info_pointer := checker.values_info.last()
 	match value_kind {
 		.unknown {
 			return checker.error('unknown value kind')
@@ -544,7 +544,7 @@ pub fn decode[T](val string) !T {
 	check_if_json_match[T](val)!
 
 	mut result := T{}
-	decoder.current_node = decoder.linked_list_of_value_info.head
+	decoder.current_node = decoder.values_info.head
 	decoder.decode_value(mut &result)!
 	return result
 }
@@ -666,7 +666,6 @@ fn (mut decoder Decoder) decode_value[T](mut val T) ! {
 
 			decoder.current_node = decoder.current_node.next
 			for {
-				// if decoder.value_info_idx >= decoder.values_info.len {
 				if decoder.current_node == unsafe { nil } {
 					break
 				}

From 1328c36817d075aa43ef9e94577052a2a49407fe Mon Sep 17 00:00:00 2001
From: Hitalo Souza <enghitalo@gmail.com>
Date: Sat, 19 Oct 2024 11:30:16 -0400
Subject: [PATCH 14/14] fix

---
 vlib/x/json2/decoder2/decode.v      | 10 +++++-----
 vlib/x/json2/decoder2/decode_test.v |  2 +-
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/vlib/x/json2/decoder2/decode.v b/vlib/x/json2/decoder2/decode.v
index 1d3a519c2a7b62..519ef6f72cb205 100644
--- a/vlib/x/json2/decoder2/decode.v
+++ b/vlib/x/json2/decoder2/decode.v
@@ -61,7 +61,7 @@ fn (list LinkedList) str() string {
 	mut current := list.head
 	for current != unsafe { nil } {
 		value_kind_as_string := current.value.value_kind.str()
-		result_buffer.push_many(value_kind_as_string.str, value_kind_as_string.len)
+		unsafe { result_buffer.push_many(value_kind_as_string.str, value_kind_as_string.len) }
 		result_buffer << u8(` `)
 
 		current = current.next
@@ -102,7 +102,7 @@ fn check_if_json_match[T](val string) ! {
 	}
 
 	// check if generic type matches the JSON type
-	value_kind := get_value_kind(unsafe { val.str })
+	value_kind := get_value_kind(val[0])
 
 	$if T is $option {
 		// TODO
@@ -182,7 +182,7 @@ fn (mut checker Decoder) check_json_format(val string) ! {
 	}
 
 	// check if generic type matches the JSON type
-	value_kind := get_value_kind(unsafe { val.str + checker.checker_idx })
+	value_kind := get_value_kind(val[checker.checker_idx])
 	start_idx_position := checker.checker_idx
 	checker.values_info.push(ValueInfo{
 		position:   start_idx_position
@@ -748,8 +748,8 @@ fn (mut decoder Decoder) decode_value[T](mut val T) ! {
 }
 
 // get_value_kind returns the kind of a JSON value.
-fn get_value_kind(val &u8) ValueKind {
-	value := *val
+fn get_value_kind(value u8) ValueKind {
+	// value := *val
 	if value == u8(`"`) {
 		return .string_
 	} else if value == u8(`t`) || value == u8(`f`) {
diff --git a/vlib/x/json2/decoder2/decode_test.v b/vlib/x/json2/decoder2/decode_test.v
index 39bee25034460c..85fd000e673f8f 100644
--- a/vlib/x/json2/decoder2/decode_test.v
+++ b/vlib/x/json2/decoder2/decode_test.v
@@ -200,6 +200,6 @@ fn test_get_value_kind() {
 	]
 
 	for value in array_ {
-		assert get_value_kind(&value.byte_) == value.value_kind
+		assert get_value_kind(value.byte_) == value.value_kind
 	}
 }