From 05706864b7cdbd8fabf09dd8cb4d55e1e9174acf Mon Sep 17 00:00:00 2001
From: Damian Tarnawski <gthetarnav@gmail.com>
Date: Sat, 23 Aug 2025 12:55:07 +0200
Subject: [PATCH 1/7] Support using allocator resize in `_reserve_soa` (fixes
 #5615)

---
 base/runtime/core_builtin_soa.odin        | 60 ++++++++++++++++++++---
 tests/core/runtime/test_core_runtime.odin | 26 ++++++++++
 2 files changed, 79 insertions(+), 7 deletions(-)

diff --git a/base/runtime/core_builtin_soa.odin b/base/runtime/core_builtin_soa.odin
index ff27a4559..5baeb9e24 100644
--- a/base/runtime/core_builtin_soa.odin
+++ b/base/runtime/core_builtin_soa.odin
@@ -249,17 +249,63 @@ _reserve_soa :: proc(array: ^$T/#soa[dynamic]$E, capacity: int, zero_memory: boo
 
 	old_data := (^rawptr)(array)^
 
-	new_bytes := array.allocator.procedure(
-		array.allocator.data, .Alloc if zero_memory else .Alloc_Non_Zeroed, new_size, max_align,
-		nil, old_size, loc,
-	) or_return
+	new_bytes, resize_err := array.allocator.procedure(
+		array.allocator.data, .Resize if zero_memory else .Resize_Non_Zeroed, new_size, max_align,
+		old_data, old_size, loc,
+	)
 	new_data := raw_data(new_bytes)
 
-
-	footer.cap = capacity
-
 	old_offset := 0
 	new_offset := 0
+
+	if resize_err == .None {
+
+		footer.cap = capacity
+
+		// Adjust layout
+		// before: |x x y y z z|
+		// now:    |x x y y z z _ _ _|
+		// after:  |x x _ y y _ z z _|
+
+		for i in 0..<field_count {
+			type := si.types[i].variant.(Type_Info_Multi_Pointer).elem
+
+			old_offset = align_forward_int(old_offset, max_align)
+			new_offset = align_forward_int(new_offset, max_align)
+
+			new_data_elem := rawptr(uintptr(new_data) + uintptr(new_offset))
+			old_data_elem := rawptr(uintptr(new_data) + uintptr(old_offset))
+
+			mem_copy(new_data_elem, old_data_elem, type.size * old_cap)
+
+			(^rawptr)(uintptr(array) + i*size_of(rawptr))^ = new_data_elem
+
+			mem_zero(old_data_elem, int(uintptr(new_data_elem) - uintptr(old_data_elem)))
+
+			old_offset += type.size * old_cap
+			new_offset += type.size * capacity
+		}
+
+		return nil
+	}
+
+	if resize_err != .Mode_Not_Implemented {
+		return resize_err
+	}
+
+	new_bytes = array.allocator.procedure(
+		array.allocator.data, .Alloc if zero_memory else .Alloc_Non_Zeroed, new_size, max_align,
+		nil, old_size, loc,
+	) or_return
+	new_data = raw_data(new_bytes)
+
+	footer.cap = capacity
+
+	// Adjust layout
+	// before: |x x y y z z|
+	// now:    |x x y y z z| ... |_ _ _ _ _ _ _ _ _|
+	// after:                    |x x _ y y _ z z _|
+
 	for i in 0..<field_count {
 		type := si.types[i].variant.(Type_Info_Multi_Pointer).elem
 
diff --git a/tests/core/runtime/test_core_runtime.odin b/tests/core/runtime/test_core_runtime.odin
index 65312a523..d74edd3f8 100644
--- a/tests/core/runtime/test_core_runtime.odin
+++ b/tests/core/runtime/test_core_runtime.odin
@@ -179,6 +179,32 @@ test_map_get :: proc(t: ^testing.T) {
 	}
 }
 
+@(test)
+test_soa_array_allocator_resize :: proc(t: ^testing.T) {
+	arena: runtime.Arena
+	context.allocator = runtime.arena_allocator(&arena)
+	defer runtime.arena_destroy(&arena)
+
+	array, err := make(#soa[dynamic][2]int, 2, 3)
+	array[0] = [2]int{1, 2}
+	array[1] = [2]int{3, 4}
+
+	testing.expect_value(t, err, nil)
+	testing.expect_value(t, len(array), 2)
+	testing.expect_value(t, cap(array), 3)
+
+	err = resize(&array, 4)
+
+	testing.expect_value(t, err, nil)
+	testing.expect_value(t, len(array), 4)
+	testing.expect_value(t, cap(array), 4)
+
+	testing.expect_value(t, array[0], [2]int{1, 2})
+	testing.expect_value(t, array[1], [2]int{3, 4})
+	testing.expect_value(t, array[2], [2]int{0, 0})
+	testing.expect_value(t, array[3], [2]int{0, 0})
+}
+
 @(test)
 test_memory_equal :: proc(t: ^testing.T) {
 	data: [256]u8

From 9d651348b5c6772db26af79dd2ff077c3af670f2 Mon Sep 17 00:00:00 2001
From: Damian Tarnawski <gthetarnav@gmail.com>
Date: Sat, 23 Aug 2025 13:10:19 +0200
Subject: [PATCH 2/7] Only zero memory when requested

---
 base/runtime/core_builtin_soa.odin | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/base/runtime/core_builtin_soa.odin b/base/runtime/core_builtin_soa.odin
index 5baeb9e24..7548f6735 100644
--- a/base/runtime/core_builtin_soa.odin
+++ b/base/runtime/core_builtin_soa.odin
@@ -262,10 +262,9 @@ _reserve_soa :: proc(array: ^$T/#soa[dynamic]$E, capacity: int, zero_memory: boo
 
 		footer.cap = capacity
 
-		// Adjust layout
-		// before: |x x y y z z|
-		// now:    |x x y y z z _ _ _|
-		// after:  |x x _ y y _ z z _|
+		// Correct data memory
+		// from: |x x y y z z _ _ _|
+		// to:   |x x _ y y _ z z _|
 
 		for i in 0..<field_count {
 			type := si.types[i].variant.(Type_Info_Multi_Pointer).elem
@@ -280,7 +279,9 @@ _reserve_soa :: proc(array: ^$T/#soa[dynamic]$E, capacity: int, zero_memory: boo
 
 			(^rawptr)(uintptr(array) + i*size_of(rawptr))^ = new_data_elem
 
-			mem_zero(old_data_elem, int(uintptr(new_data_elem) - uintptr(old_data_elem)))
+			if zero_memory {
+				mem_zero(old_data_elem, int(uintptr(new_data_elem) - uintptr(old_data_elem)))
+			}
 
 			old_offset += type.size * old_cap
 			new_offset += type.size * capacity
@@ -301,10 +302,9 @@ _reserve_soa :: proc(array: ^$T/#soa[dynamic]$E, capacity: int, zero_memory: boo
 
 	footer.cap = capacity
 
-	// Adjust layout
-	// before: |x x y y z z|
-	// now:    |x x y y z z| ... |_ _ _ _ _ _ _ _ _|
-	// after:                    |x x _ y y _ z z _|
+	// Correct data memory
+	// from: |x x y y z z| ... |_ _ _ _ _ _ _ _ _|
+	// to:                     |x x _ y y _ z z _|
 
 	for i in 0..<field_count {
 		type := si.types[i].variant.(Type_Info_Multi_Pointer).elem

From 2a6dfd2545b78b91ddb690f30068742212862f81 Mon Sep 17 00:00:00 2001
From: Damian Tarnawski <gthetarnav@gmail.com>
Date: Sat, 23 Aug 2025 16:55:12 +0200
Subject: [PATCH 3/7] Avoid overlap issues when correcting memory after resize
 in _reserve_soa

---
 base/runtime/core_builtin_soa.odin        | 19 ++++++--
 tests/core/runtime/test_core_runtime.odin | 58 +++++++++++++++++------
 2 files changed, 58 insertions(+), 19 deletions(-)

diff --git a/base/runtime/core_builtin_soa.odin b/base/runtime/core_builtin_soa.odin
index 7548f6735..46c767751 100644
--- a/base/runtime/core_builtin_soa.odin
+++ b/base/runtime/core_builtin_soa.odin
@@ -266,6 +266,12 @@ _reserve_soa :: proc(array: ^$T/#soa[dynamic]$E, capacity: int, zero_memory: boo
 		// from: |x x y y z z _ _ _|
 		// to:   |x x _ y y _ z z _|
 
+		// move old data to the end of the new allocation to avoid overlap
+		old_start := uintptr(new_data) + uintptr(new_size - old_size)
+		mem_copy(rawptr(old_start), old_data, old_size)
+
+		// now:  |_ _ _ x x y y z z|
+
 		for i in 0..<field_count {
 			type := si.types[i].variant.(Type_Info_Multi_Pointer).elem
 
@@ -273,18 +279,21 @@ _reserve_soa :: proc(array: ^$T/#soa[dynamic]$E, capacity: int, zero_memory: boo
 			new_offset = align_forward_int(new_offset, max_align)
 
 			new_data_elem := rawptr(uintptr(new_data) + uintptr(new_offset))
-			old_data_elem := rawptr(uintptr(new_data) + uintptr(old_offset))
+			old_data_elem := rawptr(old_start + uintptr(old_offset))
 
-			mem_copy(new_data_elem, old_data_elem, type.size * old_cap)
+			old_size_elem := type.size * old_cap
+			new_size_elem := type.size * capacity
+
+			mem_copy(new_data_elem, old_data_elem, old_size_elem)
 
 			(^rawptr)(uintptr(array) + i*size_of(rawptr))^ = new_data_elem
 
 			if zero_memory {
-				mem_zero(old_data_elem, int(uintptr(new_data_elem) - uintptr(old_data_elem)))
+				mem_zero(rawptr(uintptr(new_data_elem) + uintptr(old_size_elem)), new_size_elem - old_size_elem)
 			}
 
-			old_offset += type.size * old_cap
-			new_offset += type.size * capacity
+			old_offset += old_size_elem
+			new_offset += new_size_elem
 		}
 
 		return nil
diff --git a/tests/core/runtime/test_core_runtime.odin b/tests/core/runtime/test_core_runtime.odin
index d74edd3f8..1bc100348 100644
--- a/tests/core/runtime/test_core_runtime.odin
+++ b/tests/core/runtime/test_core_runtime.odin
@@ -181,28 +181,58 @@ test_map_get :: proc(t: ^testing.T) {
 
 @(test)
 test_soa_array_allocator_resize :: proc(t: ^testing.T) {
+
 	arena: runtime.Arena
 	context.allocator = runtime.arena_allocator(&arena)
 	defer runtime.arena_destroy(&arena)
 
-	array, err := make(#soa[dynamic][2]int, 2, 3)
-	array[0] = [2]int{1, 2}
-	array[1] = [2]int{3, 4}
+	{
+		// |1 3 _ 2 4 _|
+		// |1 3 _ _ 2 4 _ _|
 
-	testing.expect_value(t, err, nil)
-	testing.expect_value(t, len(array), 2)
-	testing.expect_value(t, cap(array), 3)
+		array, err := make(#soa[dynamic][2]int, 2, 3)
+		array[0] = [2]int{1, 2}
+		array[1] = [2]int{3, 4}
 
-	err = resize(&array, 4)
+		testing.expect_value(t, err, nil)
+		testing.expect_value(t, len(array), 2)
+		testing.expect_value(t, cap(array), 3)
 
-	testing.expect_value(t, err, nil)
-	testing.expect_value(t, len(array), 4)
-	testing.expect_value(t, cap(array), 4)
+		err = resize(&array, 4)
 
-	testing.expect_value(t, array[0], [2]int{1, 2})
-	testing.expect_value(t, array[1], [2]int{3, 4})
-	testing.expect_value(t, array[2], [2]int{0, 0})
-	testing.expect_value(t, array[3], [2]int{0, 0})
+		testing.expect_value(t, err, nil)
+		testing.expect_value(t, len(array), 4)
+		testing.expect_value(t, cap(array), 4)
+
+		testing.expect_value(t, array[0], [2]int{1, 2})
+		testing.expect_value(t, array[1], [2]int{3, 4})
+		testing.expect_value(t, array[2], [2]int{0, 0})
+		testing.expect_value(t, array[3], [2]int{0, 0})
+	}
+
+	{
+		// |1 4 2 5 3 6|
+		// |1 4 _ _ 2 5 _ _ 3 6 _ _|
+
+		array, err := make(#soa[dynamic][3]int, 2, 2)
+		array[0] = [3]int{1, 2, 3}
+		array[1] = [3]int{4, 5, 6}
+
+		testing.expect_value(t, err, nil)
+		testing.expect_value(t, len(array), 2)
+		testing.expect_value(t, cap(array), 2)
+
+		err = resize(&array, 4)
+
+		testing.expect_value(t, err, nil)
+		testing.expect_value(t, len(array), 4)
+		testing.expect_value(t, cap(array), 4)
+
+		testing.expect_value(t, array[0], [3]int{1, 2, 3})
+		testing.expect_value(t, array[1], [3]int{4, 5, 6})
+		testing.expect_value(t, array[2], [3]int{0, 0, 0})
+		testing.expect_value(t, array[3], [3]int{0, 0, 0})
+	}
 }
 
 @(test)

From ac4a89e7651f3942c02af89d530e4fdc048e1dd5 Mon Sep 17 00:00:00 2001
From: Damian Tarnawski <gthetarnav@gmail.com>
Date: Sat, 23 Aug 2025 17:07:57 +0200
Subject: [PATCH 4/7] Always use .Resize_Non_Zeroed in _reserve_soa

---
 base/runtime/core_builtin_soa.odin | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/base/runtime/core_builtin_soa.odin b/base/runtime/core_builtin_soa.odin
index 46c767751..33cb760ed 100644
--- a/base/runtime/core_builtin_soa.odin
+++ b/base/runtime/core_builtin_soa.odin
@@ -250,7 +250,7 @@ _reserve_soa :: proc(array: ^$T/#soa[dynamic]$E, capacity: int, zero_memory: boo
 	old_data := (^rawptr)(array)^
 
 	new_bytes, resize_err := array.allocator.procedure(
-		array.allocator.data, .Resize if zero_memory else .Resize_Non_Zeroed, new_size, max_align,
+		array.allocator.data, .Resize_Non_Zeroed, new_size, max_align,
 		old_data, old_size, loc,
 	)
 	new_data := raw_data(new_bytes)

From 66f4c9342098e5d5c0cf10b5aea7b57c5e0dd1d3 Mon Sep 17 00:00:00 2001
From: Damian Tarnawski <gthetarnav@gmail.com>
Date: Sun, 24 Aug 2025 15:04:19 +0200
Subject: [PATCH 5/7] Handle nil old data case

---
 base/runtime/core_builtin_soa.odin | 89 ++++++++++++++++--------------
 1 file changed, 48 insertions(+), 41 deletions(-)

diff --git a/base/runtime/core_builtin_soa.odin b/base/runtime/core_builtin_soa.odin
index 33cb760ed..d436b9a3a 100644
--- a/base/runtime/core_builtin_soa.odin
+++ b/base/runtime/core_builtin_soa.odin
@@ -249,68 +249,73 @@ _reserve_soa :: proc(array: ^$T/#soa[dynamic]$E, capacity: int, zero_memory: boo
 
 	old_data := (^rawptr)(array)^
 
-	new_bytes, resize_err := array.allocator.procedure(
-		array.allocator.data, .Resize_Non_Zeroed, new_size, max_align,
-		old_data, old_size, loc,
-	)
-	new_data := raw_data(new_bytes)
+	if old_data != nil {
+		new_bytes, resize_err := array.allocator.procedure(
+			array.allocator.data, .Resize_Non_Zeroed, new_size, max_align,
+			old_data, old_size, loc,
+		)
+		new_data := raw_data(new_bytes)
 
-	old_offset := 0
-	new_offset := 0
+		if resize_err == .None {
 
-	if resize_err == .None {
+			footer.cap = capacity
 
-		footer.cap = capacity
+			old_offset := 0
+			new_offset := 0
 
-		// Correct data memory
-		// from: |x x y y z z _ _ _|
-		// to:   |x x _ y y _ z z _|
+			// Correct data memory
+			// from: |x x y y z z _ _ _|
+			// to:   |x x _ y y _ z z _|
 
-		// move old data to the end of the new allocation to avoid overlap
-		old_start := uintptr(new_data) + uintptr(new_size - old_size)
-		mem_copy(rawptr(old_start), old_data, old_size)
+			// move old data to the end of the new allocation to avoid overlap
+			old_start := uintptr(new_data) + uintptr(new_size - old_size)
+			mem_copy(rawptr(old_start), new_data, old_size)
 
-		// now:  |_ _ _ x x y y z z|
+			// now:  |_ _ _ x x y y z z|
 
-		for i in 0..<field_count {
-			type := si.types[i].variant.(Type_Info_Multi_Pointer).elem
+			for i in 0..<field_count {
+				type := si.types[i].variant.(Type_Info_Multi_Pointer).elem
 
-			old_offset = align_forward_int(old_offset, max_align)
-			new_offset = align_forward_int(new_offset, max_align)
+				old_offset = align_forward_int(old_offset, max_align)
+				new_offset = align_forward_int(new_offset, max_align)
 
-			new_data_elem := rawptr(uintptr(new_data) + uintptr(new_offset))
-			old_data_elem := rawptr(old_start + uintptr(old_offset))
+				new_data_elem := rawptr(uintptr(new_data) + uintptr(new_offset))
+				old_data_elem := rawptr(old_start + uintptr(old_offset))
 
-			old_size_elem := type.size * old_cap
-			new_size_elem := type.size * capacity
+				old_size_elem := type.size * old_cap
+				new_size_elem := type.size * capacity
 
-			mem_copy(new_data_elem, old_data_elem, old_size_elem)
+				mem_copy(new_data_elem, old_data_elem, old_size_elem)
 
-			(^rawptr)(uintptr(array) + i*size_of(rawptr))^ = new_data_elem
+				(^rawptr)(uintptr(array) + i*size_of(rawptr))^ = new_data_elem
 
-			if zero_memory {
-				mem_zero(rawptr(uintptr(new_data_elem) + uintptr(old_size_elem)), new_size_elem - old_size_elem)
+				if zero_memory {
+					mem_zero(rawptr(uintptr(new_data_elem) + uintptr(old_size_elem)), new_size_elem - old_size_elem)
+				}
+
+				old_offset += old_size_elem
+				new_offset += new_size_elem
 			}
 
-			old_offset += old_size_elem
-			new_offset += new_size_elem
+			return nil
 		}
 
-		return nil
+		if resize_err != .Mode_Not_Implemented {
+			return resize_err
+		}
 	}
 
-	if resize_err != .Mode_Not_Implemented {
-		return resize_err
-	}
-
-	new_bytes = array.allocator.procedure(
+	new_bytes := array.allocator.procedure(
 		array.allocator.data, .Alloc if zero_memory else .Alloc_Non_Zeroed, new_size, max_align,
 		nil, old_size, loc,
 	) or_return
-	new_data = raw_data(new_bytes)
+	new_data := raw_data(new_bytes)
 
 	footer.cap = capacity
 
+	old_offset := 0
+	new_offset := 0
+
 	// Correct data memory
 	// from: |x x y y z z| ... |_ _ _ _ _ _ _ _ _|
 	// to:                     |x x _ y y _ z z _|
@@ -332,10 +337,12 @@ _reserve_soa :: proc(array: ^$T/#soa[dynamic]$E, capacity: int, zero_memory: boo
 		new_offset += type.size * capacity
 	}
 
-	array.allocator.procedure(
-		array.allocator.data, .Free, 0, max_align,
-		old_data, old_size, loc,
-	) or_return
+	if old_data != nil {
+		array.allocator.procedure(
+			array.allocator.data, .Free, 0, max_align,
+			old_data, old_size, loc,
+		) or_return
+	}
 
 	return nil
 }

From 8a894c6ce6cbedc187563a07a2bb689d9f8cdf56 Mon Sep 17 00:00:00 2001
From: Damian Tarnawski <gthetarnav@gmail.com>
Date: Sun, 24 Aug 2025 15:09:08 +0200
Subject: [PATCH 6/7] More soa tests

---
 tests/core/runtime/test_core_runtime.odin | 95 ++++++++++++++---------
 1 file changed, 59 insertions(+), 36 deletions(-)

diff --git a/tests/core/runtime/test_core_runtime.odin b/tests/core/runtime/test_core_runtime.odin
index 1bc100348..3ed252026 100644
--- a/tests/core/runtime/test_core_runtime.odin
+++ b/tests/core/runtime/test_core_runtime.odin
@@ -179,6 +179,22 @@ test_map_get :: proc(t: ^testing.T) {
 	}
 }
 
+@(test)
+test_soa_make_len :: proc(t: ^testing.T) {
+
+	array, err := make(#soa[dynamic][2]int, 2)
+	defer delete(array)
+	array[0] = [2]int{1, 2}
+	array[1] = [2]int{3, 4}
+
+	testing.expect_value(t, err, nil)
+	testing.expect_value(t, len(array), 2)
+	testing.expect_value(t, cap(array), 2)
+
+	testing.expect_value(t, array[0], [2]int{1, 2})
+	testing.expect_value(t, array[1], [2]int{3, 4})
+}
+
 @(test)
 test_soa_array_allocator_resize :: proc(t: ^testing.T) {
 
@@ -186,53 +202,60 @@ test_soa_array_allocator_resize :: proc(t: ^testing.T) {
 	context.allocator = runtime.arena_allocator(&arena)
 	defer runtime.arena_destroy(&arena)
 
-	{
-		// |1 3 _ 2 4 _|
-		// |1 3 _ _ 2 4 _ _|
+	// |1 3 _ 2 4 _|
+	// |1 3 _ _ 2 4 _ _|
 
-		array, err := make(#soa[dynamic][2]int, 2, 3)
-		array[0] = [2]int{1, 2}
-		array[1] = [2]int{3, 4}
+	array, err := make(#soa[dynamic][2]int, 2, 3)
+	defer delete(array)
+	array[0] = [2]int{1, 2}
+	array[1] = [2]int{3, 4}
 
-		testing.expect_value(t, err, nil)
-		testing.expect_value(t, len(array), 2)
-		testing.expect_value(t, cap(array), 3)
+	testing.expect_value(t, err, nil)
+	testing.expect_value(t, len(array), 2)
+	testing.expect_value(t, cap(array), 3)
 
-		err = resize(&array, 4)
+	err = resize(&array, 4)
 
-		testing.expect_value(t, err, nil)
-		testing.expect_value(t, len(array), 4)
-		testing.expect_value(t, cap(array), 4)
+	testing.expect_value(t, err, nil)
+	testing.expect_value(t, len(array), 4)
+	testing.expect_value(t, cap(array), 4)
 
-		testing.expect_value(t, array[0], [2]int{1, 2})
-		testing.expect_value(t, array[1], [2]int{3, 4})
-		testing.expect_value(t, array[2], [2]int{0, 0})
-		testing.expect_value(t, array[3], [2]int{0, 0})
-	}
+	testing.expect_value(t, array[0], [2]int{1, 2})
+	testing.expect_value(t, array[1], [2]int{3, 4})
+	testing.expect_value(t, array[2], [2]int{0, 0})
+	testing.expect_value(t, array[3], [2]int{0, 0})
+}
 
-	{
-		// |1 4 2 5 3 6|
-		// |1 4 _ _ 2 5 _ _ 3 6 _ _|
 
-		array, err := make(#soa[dynamic][3]int, 2, 2)
-		array[0] = [3]int{1, 2, 3}
-		array[1] = [3]int{4, 5, 6}
+@(test)
+test_soa_array_allocator_resize_overlapping :: proc(t: ^testing.T) {
 
-		testing.expect_value(t, err, nil)
-		testing.expect_value(t, len(array), 2)
-		testing.expect_value(t, cap(array), 2)
+	arena: runtime.Arena
+	context.allocator = runtime.arena_allocator(&arena)
+	defer runtime.arena_destroy(&arena)
 
-		err = resize(&array, 4)
+	// |1 4 2 5 3 6|
+	// |1 4 _ _ 2 5 _ _ 3 6 _ _|
 
-		testing.expect_value(t, err, nil)
-		testing.expect_value(t, len(array), 4)
-		testing.expect_value(t, cap(array), 4)
+	array, err := make(#soa[dynamic][3]int, 2, 2)
+	defer delete(array)
+	array[0] = [3]int{1, 2, 3}
+	array[1] = [3]int{4, 5, 6}
 
-		testing.expect_value(t, array[0], [3]int{1, 2, 3})
-		testing.expect_value(t, array[1], [3]int{4, 5, 6})
-		testing.expect_value(t, array[2], [3]int{0, 0, 0})
-		testing.expect_value(t, array[3], [3]int{0, 0, 0})
-	}
+	testing.expect_value(t, err, nil)
+	testing.expect_value(t, len(array), 2)
+	testing.expect_value(t, cap(array), 2)
+
+	err = resize(&array, 4)
+
+	testing.expect_value(t, err, nil)
+	testing.expect_value(t, len(array), 4)
+	testing.expect_value(t, cap(array), 4)
+
+	testing.expect_value(t, array[0], [3]int{1, 2, 3})
+	testing.expect_value(t, array[1], [3]int{4, 5, 6})
+	testing.expect_value(t, array[2], [3]int{0, 0, 0})
+	testing.expect_value(t, array[3], [3]int{0, 0, 0})
 }
 
 @(test)

From 95cfad67b776c4d839aa494fa88832a67c0c28cc Mon Sep 17 00:00:00 2001
From: Damian Tarnawski <gthetarnav@gmail.com>
Date: Sun, 24 Aug 2025 15:17:13 +0200
Subject: [PATCH 7/7] =?UTF-8?q?Cleanup=20soa=20resize=20logic=E2=80=94redu?=
 =?UTF-8?q?ce=20nesting?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 base/runtime/core_builtin_soa.odin | 64 +++++++++++++++---------------
 1 file changed, 32 insertions(+), 32 deletions(-)

diff --git a/base/runtime/core_builtin_soa.odin b/base/runtime/core_builtin_soa.odin
index d436b9a3a..9d042267a 100644
--- a/base/runtime/core_builtin_soa.odin
+++ b/base/runtime/core_builtin_soa.odin
@@ -249,60 +249,60 @@ _reserve_soa :: proc(array: ^$T/#soa[dynamic]$E, capacity: int, zero_memory: boo
 
 	old_data := (^rawptr)(array)^
 
-	if old_data != nil {
+	resize: if old_data != nil {
+
 		new_bytes, resize_err := array.allocator.procedure(
 			array.allocator.data, .Resize_Non_Zeroed, new_size, max_align,
 			old_data, old_size, loc,
 		)
 		new_data := raw_data(new_bytes)
 
-		if resize_err == .None {
+		#partial switch resize_err {
+		case .Mode_Not_Implemented: break resize
+		case .None: // continue resizing
+		case: return resize_err
+		}
 
-			footer.cap = capacity
+		footer.cap = capacity
 
-			old_offset := 0
-			new_offset := 0
+		old_offset := 0
+		new_offset := 0
 
-			// Correct data memory
-			// from: |x x y y z z _ _ _|
-			// to:   |x x _ y y _ z z _|
+		// Correct data memory
+		// from: |x x y y z z _ _ _|
+		// to:   |x x _ y y _ z z _|
 
-			// move old data to the end of the new allocation to avoid overlap
-			old_start := uintptr(new_data) + uintptr(new_size - old_size)
-			mem_copy(rawptr(old_start), new_data, old_size)
+		// move old data to the end of the new allocation to avoid overlap
+		old_data = rawptr(uintptr(new_data) + uintptr(new_size - old_size))
+		mem_copy(old_data, new_data, old_size)
 
-			// now:  |_ _ _ x x y y z z|
+		// now:  |_ _ _ x x y y z z|
 
-			for i in 0..<field_count {
-				type := si.types[i].variant.(Type_Info_Multi_Pointer).elem
+		for i in 0..<field_count {
+			type := si.types[i].variant.(Type_Info_Multi_Pointer).elem
 
-				old_offset = align_forward_int(old_offset, max_align)
-				new_offset = align_forward_int(new_offset, max_align)
+			old_offset = align_forward_int(old_offset, max_align)
+			new_offset = align_forward_int(new_offset, max_align)
 
-				new_data_elem := rawptr(uintptr(new_data) + uintptr(new_offset))
-				old_data_elem := rawptr(old_start + uintptr(old_offset))
+			new_data_elem := rawptr(uintptr(new_data) + uintptr(new_offset))
+			old_data_elem := rawptr(uintptr(old_data) + uintptr(old_offset))
 
-				old_size_elem := type.size * old_cap
-				new_size_elem := type.size * capacity
+			old_size_elem := type.size * old_cap
+			new_size_elem := type.size * capacity
 
-				mem_copy(new_data_elem, old_data_elem, old_size_elem)
+			mem_copy(new_data_elem, old_data_elem, old_size_elem)
 
-				(^rawptr)(uintptr(array) + i*size_of(rawptr))^ = new_data_elem
+			(^rawptr)(uintptr(array) + i*size_of(rawptr))^ = new_data_elem
 
-				if zero_memory {
-					mem_zero(rawptr(uintptr(new_data_elem) + uintptr(old_size_elem)), new_size_elem - old_size_elem)
-				}
-
-				old_offset += old_size_elem
-				new_offset += new_size_elem
+			if zero_memory {
+				mem_zero(rawptr(uintptr(new_data_elem) + uintptr(old_size_elem)), new_size_elem - old_size_elem)
 			}
 
-			return nil
+			old_offset += old_size_elem
+			new_offset += new_size_elem
 		}
 
-		if resize_err != .Mode_Not_Implemented {
-			return resize_err
-		}
+		return nil
 	}
 
 	new_bytes := array.allocator.procedure(