remove explicit init procs

array/dynamic_array.jai

@@ -1,26 +1,30 @@
 // @todo(judah): replace array_add
 
-init :: inline (arr: *[..]$T, allocator: Allocator) {
-   arr.allocator = allocator;
-}
-
 append :: inline (arr: *[..]$T, value: T) -> *T {
+   mem.lazy_set_allocator(arr);
+
    ptr := basic.array_add(arr,, allocator = arr.allocator);
    ptr.* = value;
    return ptr;
 }
 
 append :: inline (arr: *[..]$T, values: ..T) -> *T {
+   mem.lazy_set_allocator(arr);
+
    count := arr.count;
    basic.array_add(arr, ..values,, allocator = arr.allocator);
    return *arr.data[count];
 }
 
 append :: inline (arr: *[..]$T) -> *T {
+   mem.lazy_set_allocator(arr);
+
    return basic.array_add(arr,, allocator = arr.allocator);
 }
 
 resize :: inline (arr: *[..]$T, new_count: int) {
+   mem.lazy_set_allocator(arr);
+
    if new_count <= arr.allocated return;
    basic.array_reserve(arr, new_count,, allocator = arr.allocator);
 }

array/stable_array.jai

@@ -10,11 +10,6 @@ Stable_Array :: struct(T: Type, items_per_chunk := 32) {
    Chunk :: Static_Array(items_per_chunk, T);
 }
 
-init :: (a: *Stable_Array, allocator: Allocator) {
-   a.allocator        = allocator;
-   a.chunks.allocator = allocator;
-}
-
 append :: (a: *Stable_Array) -> *a.T {
    chunk := find_or_create_chunk(a, 1);
    a.count += 1;
@@ -119,19 +114,14 @@ find_or_create_chunk :: (a: *Stable_Array, amount: int) -> *a.Chunk {
 }
 
 create_chunk :: (a: *Stable_Array) -> *a.Chunk {
-   inline try_lazy_init(a);
+   mem.lazy_set_allocator(a);
+   mem.lazy_set_allocator(*a.chunks);
 
    chunk := mem.request_memory(a.Chunk,, allocator = a.allocator);
    append(*a.chunks, chunk);
    return chunk;
 }
 
-try_lazy_init :: (a: *Stable_Array) {
-   if a.allocator.proc == null {
-      init(a, context.allocator);
-   }
-}
-
 
 // ----------------------------------------------------------
 // TESTS

bytes/buffer.jai

@@ -6,6 +6,8 @@ Buffer :: struct {
 }
 
 append :: inline (buf: *Buffer, ptr: *void, count: int) {
+   inline meta.lazy_set_allocator(buf);
+
    free_space := ensure_buffer_has_room(buf, count);
    memcpy(free_space, ptr, count);
    buf.count += count;
@@ -26,6 +28,7 @@ reset :: inline (buf: *Buffer) {
 #scope_file;
 
 array :: #import "jc/array";
+meta  :: #import "jc/meta";
 
 ensure_buffer_has_room :: (buf: *Buffer, count: int) -> *u8 {
    ptr := buf.data.data + buf.count;

kv/module.jai

@@ -18,12 +18,6 @@ Kv :: struct(Key: Type, Value: Type) {
    number_of_items_to_allocate_initially :: 16; // @note(judah): must be a power of two
 }
 
-init :: (kv: *Kv, allocator: Allocator) {
-   kv.allocator            = allocator;
-   kv.slots.allocator      = allocator;
-   kv.free_slots.allocator = allocator;
-}
-
 get :: (kv: *Kv, key: kv.Key) -> kv.Value, bool {
    slot, ok := find_slot(kv, get_hash(kv, key));
    if !ok {
@@ -124,9 +118,9 @@ mark_slot_for_reuse :: (kv: *Kv, index: int) {
 }
 
 try_lazy_init :: inline (kv: *Kv) {
-   if kv.allocator.proc == null {
-      init(kv, context.allocator);
-   }
+   mem.lazy_set_allocator(kv);
+   mem.lazy_set_allocator(*kv.slots);
+   mem.lazy_set_allocator(*kv.free_slots);
 }
 
 mem   :: #import "jc/memory";

memory/module.jai

@@ -147,6 +147,31 @@ release_memory :: inline (str: string) {
    release_memory(str.data.(*void));
 }
 
+// @todo(judah): why can't we use $T/struct{ allocator: Allocator }?
+lazy_set_allocator :: (thing: *$T, allocator := context.allocator) #modify {
+   info := T.(*Type_Info_Struct);
+
+   ok := false;
+   if info.type == .STRUCT ok = true;
+
+   if ok for info.members if it.name == "allocator" && it.type == Allocator.(*Type_Info) {
+      ok = true;
+      break;
+   }
+
+   return ok, "can only set allocator on struct with allocator field or dynamic array";
+} #expand {
+   if thing.allocator.proc == null {
+      thing.allocator = allocator;
+   }
+}
+
+lazy_set_allocator :: (array: *[..]$T, allocator := context.allocator) #expand {
+   if array.allocator.proc == null {
+      array.allocator = allocator;
+   }
+}
+
 #load "allocators.jai";
 
 #scope_file;