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 {
+   mem.lazy_set_allocator(kv);
-      init(kv, context.allocator);
+   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;

vm/interp.jai

@@ -36,19 +36,9 @@ Interp_Value :: struct {
    }
 }
 
-init :: (i: *Interp, allocator: Allocator) {
-   value_nil = make_interp_value(i, .nil);
-
-   value_true   = make_interp_value(i, .bool);
-   value_true.b = true;
-
-   value_false   = make_interp_value(i, .bool);
-   value_false.b = false;
-
-   i.global = make_scope(null,, allocator = allocator);
-}
-
 interp_program :: (i: *Interp) {
+   try_lazy_init(i);
+
    for i.toplevel {
       interp_statement(i, it, i.global);
    }
@@ -309,7 +299,6 @@ find_symbol :: (scope: *Interp_Scope, symbol: string, all_the_way_up := true) ->
 make_scope :: (parent: *Interp_Scope) -> *Interp_Scope {
    scope := mem.request_memory(Interp_Scope);
    scope.parent = parent;
-   kv.init(*scope.bindings, context.allocator);
    return scope;
 }
 
@@ -318,3 +307,15 @@ make_interp_value :: (i: *Interp, kind: Interp_Value.Kind) -> *Interp_Value {
    value.kind = kind;
    return value;
 }
+
+try_lazy_init :: (i: *Interp) {
+   value_nil = make_interp_value(i, .nil);
+
+   value_true   = make_interp_value(i, .bool);
+   value_true.b = true;
+
+   value_false   = make_interp_value(i, .bool);
+   value_false.b = false;
+
+   i.global = make_scope(null);
+}

vm/module.jai

@@ -18,8 +18,6 @@ strings :: #import "String"; // @future
 
 #run {
    parser: Parser;
-   init(*parser, context.allocator);
-
    ok := parse_string(*parser, #string END
       fn add(l, r) do return l + r end
       fn sub(l, r) do return l - r end
@@ -87,7 +85,6 @@ strings :: #import "String"; // @future
 
    interp: Interp;
    interp.toplevel = parser.toplevel;
-   init(*interp, context.allocator);
 
    interp_program(*interp);
 }

vm/parser.jai

@@ -208,6 +208,14 @@ Node_Type :: struct {
       array;
       procedure;
    }
+
+   init :: (n: *Node_Type, allocator: Allocator) {
+      if n.type_kind == {
+         case .procedure;
+            mem.lazy_set_allocator(*n.procedure_arguments, allocator);
+            mem.lazy_set_allocator(*n.procedure_returns, allocator);
+      }
+   }
 }
 
 Node_Procedure :: struct {
@@ -225,6 +233,11 @@ Node_Procedure :: struct {
    Flag :: enum_flags {
       must_inline;
    }
+
+   init :: (n: *Node_Procedure, allocator: Allocator) {
+      mem.lazy_set_allocator(*n.arguments, allocator);
+      mem.lazy_set_allocator(*n.returns, allocator);
+   }
 }
 
 Parameter :: struct {
@@ -254,6 +267,11 @@ Node_Procedure_Call :: struct {
    call_expr:       *Node;
    named_arguments: kv.Kv(*Node, *Node);
    all_arguments:   [..]*Node;
+
+   init :: (n: *Node_Procedure_Call, allocator: Allocator) {
+      mem.lazy_set_allocator(*n.all_arguments, allocator);
+      mem.lazy_set_allocator(*n.named_arguments, allocator);
+   }
 }
 
 Node_Block :: struct {
@@ -261,6 +279,10 @@ Node_Block :: struct {
    n.kind = .block;
 
    body: [..]*Node;
+
+   init :: (n: *Node_Block, allocator: Allocator) {
+      mem.lazy_set_allocator(*n.body, allocator);
+   }
 }
 
 Node_Return :: struct {
@@ -268,6 +290,10 @@ Node_Return :: struct {
    n.kind = .return_;
 
    values: [..]*Node;
+
+   init :: (n: *Node_Return, allocator: Allocator) {
+      mem.lazy_set_allocator(*n.values, allocator);
+   }
 }
 
 Parser :: struct {
@@ -280,12 +306,9 @@ Parser :: struct {
    offset:   int;
 }
 
-init :: (p: *Parser, allocator: Allocator) {
-   p.allocator       = allocator;
-   p.toplevel.allocator = allocator;
-}
-
 parse_string :: (p: *Parser, source: string) -> bool {
+   try_lazy_init(p);
+
    p.source = source;
    p.offset = 0;
 
@@ -753,17 +776,8 @@ parse_expression_base :: (p: *Parser) -> *Node {
 make_node :: (p: *Parser, $T: Type) -> *T {
    node := mem.request_memory(T,, allocator = p.allocator);
 
-   #if T == { // nodes that require initialization
+   #if #exists(T.init) {
-      case Node_Block;
+      T.init(node, p.allocator);
-         array.init(*node.body, p.allocator);
-      case Node_Return;
-         array.init(*node.values, p.allocator);
-      case Node_Procedure_Call;
-         array.init(*node.all_arguments, p.allocator);
-         kv.init(*node.named_arguments, p.allocator);
-      case Node_Procedure;
-         array.init(*node.arguments, p.allocator);
-         array.init(*node.returns, p.allocator);
    }
 
    return node;
@@ -772,13 +786,7 @@ make_node :: (p: *Parser, $T: Type) -> *T {
 make_node :: (p: *Parser, $type_kind: Node_Type.Type_Kind) -> *Node_Type {
    type := mem.request_memory(Node_Type,, allocator = p.allocator);
    type.type_kind = type_kind;
-
+   Node_Type.init(type, p.allocator);
-   #if type_kind == {
-      case .procedure;
-         array.init(*type.procedure_arguments, p.allocator);
-         array.init(*type.procedure_returns, p.allocator);
-   }
-
    return type;
 }
 
@@ -948,3 +956,7 @@ expect_token :: (p: *Parser, kinds: ..Token.Kind) -> Token, bool {
    return t, false;
 }
 
+try_lazy_init :: (p: *Parser) {
+   mem.lazy_set_allocator(p);
+   mem.lazy_set_allocator(*p.toplevel);
+}