nomen-lang 0.2.3 → 0.3.0

package/core/System/Buffer.nm

@@ -1,6 +1,7 @@
 // Buffer<T>: a flat buffer of value slots of type T. The value counterpart to
 // ClassBuffer<T>: no per-element freeing, store_int unconstrained. When T is a
 // class, the monomorphizer rewrites a Buffer<T> field to ClassBuffer<T>.
+
 /**
  * A flat, low-level buffer of value slots of type T — the backing store for arrays and collections
  **/
@@ -8,84 +9,33 @@ pub struct Buffer<T> {
 	var uint64 data = 0
 	var cap = 0
 
+	// Allocation / sizing primitives are `unsafe` Nomen single-sourced for
+	// both backends. They run once per container op (never per element), so
+	// the aarch64 inline-method ABI cost that keeps the per-limb load/store
+	// primitives raw (see BigInt.nm) doesn't apply here.
 	func alloc = (ref self, int size, out int: out >= size) {
-		```
-		#arch: c
-		self->cap = size;
-		self->data = (unsigned long long)(unsigned int*)calloc(size, sizeof(unsigned int));
-		return self->cap;
-		```
-		```
-		#arch: aarch64
-		str x1, [x19, #16]
-		mov x0, x1
-		mov x1, #4
-		bl _calloc
-		str x0, [x19, #8]
-		ldr x0, [x19, #16]
-		```
+		self.cap = size
+		self.data = calloc(size, 4)
+		return self.cap
 	}
 
 	func grow = (ref self, int needed, out int: out >= needed) {
-		```
-		#arch: c
-		if (self->cap >= needed) return self->cap;
-		int new_cap = self->cap;
-		if (new_cap == 0) new_cap = 8;
-		while (new_cap < needed) new_cap *= 2;
-		self->data = (unsigned long long)(unsigned int*)realloc((unsigned int*)(unsigned long long)self->data, new_cap * sizeof(unsigned int));
-		memset((unsigned int*)(unsigned long long)self->data + self->cap, 0, (new_cap - self->cap) * sizeof(unsigned int));
-		self->cap = new_cap;
-		return self->cap;
-		```
-		```
-		#arch: aarch64
-		ldr x2, [x19, #16]
-		cmp x2, x1
-		b.ge .Lbuffer_grow_end
-		mov x3, #8
-		cmp x2, #0
-		csel x3, x3, x2, eq
-		cmp x3, x1
-		b.ge .Lbuffer_grow_got
-		.Lbuffer_grow_loop:
-		lsl x3, x3, #1
-		cmp x3, x1
-		b.lt .Lbuffer_grow_loop
-		.Lbuffer_grow_got:
-		sub sp, sp, #16
-		str x2, [sp, #0]
-		str x3, [sp, #8]
-		ldr x0, [x19, #8]
-		lsl x1, x3, #2
-		bl _realloc
-		str x0, [x19, #8]
-		ldr x2, [sp, #0]
-		ldr x3, [sp, #8]
-		add sp, sp, #16
-		str x3, [x19, #16]
-		add x0, x0, x2, lsl #2
-		mov x1, #0
-		sub x2, x3, x2
-		lsl x2, x2, #2
-		bl _memset
-		.Lbuffer_grow_end:
-		ldr x0, [x19, #16]
-		```
+		if self.cap >= needed {
+			return self.cap
+		}
+		var int new_cap = self.cap
+		if new_cap == 0 {
+			new_cap = 8
+		}
+		while new_cap < needed; new_cap *= 2 {}
+		self.data = realloc(self.data, new_cap * 4)
+		memset(self.data + self.cap * 4, 0, (new_cap - self.cap) * 4)
+		self.cap = new_cap
+		return self.cap
 	}
 
 	func zero = (ref self, int len) {
-		```
-		#arch: c
-		memset((unsigned int*)(unsigned long long)self->data, 0, len * sizeof(unsigned int));
-		```
-		```
-		#arch: aarch64
-		ldr x0, [x19, #8]
-		lsl x2, x1, #2
-		mov x1, #0
-		bl _memset
-		```
+		memset(self.data, 0, len * 4)
 	}
 
 	inline func load = (self, int i: i >= 0 && i < self.cap, out uint32) {
@@ -134,69 +84,24 @@ pub struct Buffer<T> {
 	}
 
 	func alloc_int = (ref self, int size, out int: out >= size) {
-		```
-		#arch: c
-		self->cap = size;
-		self->data = (unsigned long long)(long*)calloc(size, sizeof(long));
-		return self->cap;
-		```
-		```
-		#arch: aarch64
-		str x1, [x19, #16]
-		mov x0, x1
-		mov x1, #8
-		bl _calloc
-		str x0, [x19, #8]
-		ldr x0, [x19, #16]
-		```
+		self.cap = size
+		self.data = calloc(size, 8)
+		return self.cap
 	}
 
 	func grow_int = (ref self, int needed, out int: out >= needed) {
-		```
-		#arch: c
-		if (self->cap >= needed) return self->cap;
-		int new_cap = self->cap;
-		if (new_cap == 0) new_cap = 4;
-		while (new_cap < needed) new_cap *= 2;
-		self->data = (unsigned long long)(long*)realloc((long*)(unsigned long long)self->data, new_cap * sizeof(long));
-		memset((long*)(unsigned long long)self->data + self->cap, 0, (new_cap - self->cap) * sizeof(long));
-		self->cap = new_cap;
-		return self->cap;
-		```
-		```
-		#arch: aarch64
-		ldr x2, [x19, #16]
-		cmp x2, x1
-		b.ge .Lbuffer_grow_int_end
-		mov x3, #4
-		cmp x2, #0
-		csel x3, x3, x2, eq
-		cmp x3, x1
-		b.ge .Lbuffer_grow_int_got
-		.Lbuffer_grow_int_loop:
-		lsl x3, x3, #1
-		cmp x3, x1
-		b.lt .Lbuffer_grow_int_loop
-		.Lbuffer_grow_int_got:
-		sub sp, sp, #16
-		str x2, [sp, #0]
-		str x3, [sp, #8]
-		ldr x0, [x19, #8]
-		lsl x1, x3, #3
-		bl _realloc
-		str x0, [x19, #8]
-		ldr x2, [sp, #0]
-		ldr x3, [sp, #8]
-		add sp, sp, #16
-		str x3, [x19, #16]
-		add x0, x0, x2, lsl #3
-		mov x1, #0
-		sub x2, x3, x2
-		lsl x2, x2, #3
-		bl _memset
-		.Lbuffer_grow_int_end:
-		ldr x0, [x19, #16]
-		```
+		if self.cap >= needed {
+			return self.cap
+		}
+		var int new_cap = self.cap
+		if new_cap == 0 {
+			new_cap = 4
+		}
+		while new_cap < needed; new_cap *= 2 {}
+		self.data = realloc(self.data, new_cap * 8)
+		memset(self.data + self.cap * 8, 0, (new_cap - self.cap) * 8)
+		self.cap = new_cap
+		return self.cap
 	}
 
 	inline func load_int = (self, int i: i >= 0 && i < self.cap, out int) {
@@ -267,17 +172,7 @@ pub struct Buffer<T> {
 	}
 
 	inline func zero_int = (ref self, int len) {
-		```
-		#arch: c
-		memset((long*)(unsigned long long)self->data, 0, len * sizeof(long));
-		```
-		```
-		#arch: aarch64
-		ldr x0, [x19, #8]
-		lsl x2, x1, #3
-		mov x1, #0
-		bl _memset
-		```
+		memset(self.data, 0, len * 8)
 	}
 
 	// T_SIZE-aware primitives for value-struct elements. Slab is sized in
@@ -286,74 +181,24 @@ pub struct Buffer<T> {
 	// reaching here is always a value type (primitive or struct).
 
 	func alloc_T = (ref self, int size, out int: out >= size) {
-		```
-		#arch: c
-		self->cap = size;
-		self->data = (unsigned long long)(T*)calloc(size, T_SIZE);
-		return self->cap;
-		```
-		```
-		#arch: aarch64
-		str x1, [x19, #16]
-		mov x0, x1
-		mov x1, #T_SIZE
-		bl _calloc
-		str x0, [x19, #8]
-		ldr x0, [x19, #16]
-		```
+		self.cap = size
+		self.data = calloc(size, T_SIZE)
+		return self.cap
 	}
 
 	func grow_T = (ref self, int needed, out int: out >= needed) {
-		```
-		#arch: c
-		if (self->cap >= needed) return self->cap;
-		int new_cap = self->cap;
-		if (new_cap == 0) new_cap = 4;
-		while (new_cap < needed) new_cap *= 2;
-		self->data = (unsigned long long)(T*)realloc((T*)(unsigned long long)self->data, new_cap * T_SIZE);
-		memset((char*)(unsigned long long)self->data + self->cap * T_SIZE, 0, (new_cap - self->cap) * T_SIZE);
-		self->cap = new_cap;
-		return self->cap;
-		```
-		```
-		#arch: aarch64
-		ldr x2, [x19, #16]
-		cmp x2, x1
-		b.ge .Lbuffer_grow_T_end
-		mov x3, #4
-		cmp x2, #0
-		csel x3, x3, x2, eq
-		cmp x3, x1
-		b.ge .Lbuffer_grow_T_got
-		.Lbuffer_grow_T_loop:
-		lsl x3, x3, #1
-		cmp x3, x1
-		b.lt .Lbuffer_grow_T_loop
-		.Lbuffer_grow_T_got:
-		sub sp, sp, #32
-		str x2, [sp, #0]
-		str x3, [sp, #8]
-		mov x4, #T_SIZE
-		str x4, [sp, #16]
-		ldr x0, [x19, #8]
-		madd x1, x3, x4, xzr
-		bl _realloc
-		str x0, [x19, #8]
-		ldr x2, [sp, #0]
-		ldr x3, [sp, #8]
-		ldr x4, [sp, #16]
-		add sp, sp, #32
-		str x3, [x19, #16]
-		ldr x0, [x19, #8]
-		mul x5, x2, x4
-		add x0, x0, x5
-		sub x2, x3, x2
-		mul x2, x2, x4
-		mov x1, #0
-		bl _memset
-		.Lbuffer_grow_T_end:
-		ldr x0, [x19, #16]
-		```
+		if self.cap >= needed {
+			return self.cap
+		}
+		var int new_cap = self.cap
+		if new_cap == 0 {
+			new_cap = 4
+		}
+		while new_cap < needed; new_cap *= 2 {}
+		self.data = realloc(self.data, new_cap * T_SIZE)
+		memset(self.data + self.cap * T_SIZE, 0, (new_cap - self.cap) * T_SIZE)
+		self.cap = new_cap
+		return self.cap
 	}
 
 	// `inline` splices the (width-folded at monomorphization) raw body at
@@ -403,6 +248,12 @@ pub struct Buffer<T> {
 		```
 	}
 
+	// Store `val` into slot `i`, which MUST be fresh (calloc'd, or zeroed by
+	// move_T). For an owning T (string, or a struct with string fields) the
+	// specialised body deep-copies the incoming value but does NOT free the
+	// slot's previous occupant — a second `store_T` at an occupied index
+	// leaks it. To overwrite a live slot use replace_T (frees the displaced
+	// value) — this is the primitive every container's `set` uses.
 	inline func store_T = (ref self, int i: i >= 0 && i < self.cap, T val) {
 		```
 		#arch: c
@@ -650,18 +501,7 @@ pub struct Buffer<T> {
 	}
 
 	inline func zero_T = (ref self, int len) {
-		```
-		#arch: c
-		memset((T*)(unsigned long long)self->data, 0, len * T_SIZE);
-		```
-		```
-		#arch: aarch64
-		ldr x0, [x19, #8]
-		mov x2, #T_SIZE
-		mul x2, x1, x2
-		mov x1, #0
-		bl _memset
-		```
+		memset(self.data, 0, len * T_SIZE)
 	}
 
 	inline func store_or_int = (ref self, int i: i >= 0 && i < self.cap, int val) {
@@ -681,21 +521,9 @@ pub struct Buffer<T> {
 	}
 
 	func alloc_float = (ref self, int size, out int: out >= size) {
-		```
-		#arch: c
-		self->cap = size;
-		self->data = (unsigned long long)(double*)calloc(size, sizeof(double));
-		return self->cap;
-		```
-		```
-		#arch: aarch64
-		str x1, [x19, #16]
-		mov x0, x1
-		mov x1, #8
-		bl _calloc
-		str x0, [x19, #8]
-		ldr x0, [x19, #16]
-		```
+		self.cap = size
+		self.data = calloc(size, 8)
+		return self.cap
 	}
 
 	inline func load_float = (self, int i: i >= 0 && i < self.cap, out float) {
@@ -727,20 +555,10 @@ pub struct Buffer<T> {
 	}
 
 	func #destroy = () {
-		```
-		#arch: c
-		if (self->data) free((unsigned int*)(unsigned long long)self->data);
-		self->data = 0;
-		self->cap = 0;
-		```
-		```
-		#arch: aarch64
-		ldr x0, [x19, #8]
-		cbz x0, .Lbuffer_destroy_end
-		bl _free
-		.Lbuffer_destroy_end:
-		str xzr, [x19, #8]
-		str xzr, [x19, #16]
-		```
+		if self.data != 0 {
+			free(self.data)
+		}
+		self.data = 0
+		self.cap = 0
 	}
 }

package/core/System/ClassBuffer.nm

@@ -12,69 +12,35 @@ pub struct ClassBuffer<T> {
 	var cap = 0
 
 	func alloc_int = (ref self, int size, out int: out >= size) {
-		```
-		#arch: c
-		self->cap = size;
-		self->data = (unsigned long long)(long*)calloc(size, sizeof(long));
-		return self->cap;
-		```
-		```
-		#arch: aarch64
-		str x1, [x19, #16]
-		mov x0, x1
-		mov x1, #8
-		bl _calloc
-		str x0, [x19, #8]
-		ldr x0, [x19, #16]
-		```
+		self.cap = size
+		self.data = calloc(size, 8)
+		return self.cap
+	}
+
+	// Semantic parity with Buffer<T>.alloc_T: generic code (e.g. Map#init's
+	// `self.values.alloc_T(N)`) forwards to either Buffer — where alloc_T is
+	// T_SIZE-aware (string slots are 16 bytes) — or this ClassBuffer, whose
+	// slots are always one pointer wide. The compiler routes value-struct
+	// element types to Buffer and class/trait elements to ClassBuffer
+	// (monomorphize's field rewrite), so a call arriving HERE is always
+	// pointer-sized: delegate to alloc_int.
+	func alloc_T = (ref self, int size, out int: out >= size) {
+		return self.alloc_int(size)
 	}
 
 	func grow_int = (ref self, int needed, out int: out >= needed) {
-		```
-		#arch: c
-		if (self->cap >= needed) return self->cap;
-		int new_cap = self->cap;
-		if (new_cap == 0) new_cap = 4;
-		while (new_cap < needed) new_cap *= 2;
-		self->data = (unsigned long long)(long*)realloc((long*)(unsigned long long)self->data, new_cap * sizeof(long));
-		memset((long*)(unsigned long long)self->data + self->cap, 0, (new_cap - self->cap) * sizeof(long));
-		self->cap = new_cap;
-		return self->cap;
-		```
-		```
-		#arch: aarch64
-		ldr x2, [x19, #16]
-		cmp x2, x1
-		b.ge .Lcb_grow_end
-		mov x3, #4
-		cmp x2, #0
-		csel x3, x3, x2, eq
-		cmp x3, x1
-		b.ge .Lcb_grow_got
-		.Lcb_grow_loop:
-		lsl x3, x3, #1
-		cmp x3, x1
-		b.lt .Lcb_grow_loop
-		.Lcb_grow_got:
-		sub sp, sp, #16
-		str x2, [sp, #0]
-		str x3, [sp, #8]
-		ldr x0, [x19, #8]
-		lsl x1, x3, #3
-		bl _realloc
-		str x0, [x19, #8]
-		ldr x2, [sp, #0]
-		ldr x3, [sp, #8]
-		add sp, sp, #16
-		str x3, [x19, #16]
-		add x0, x0, x2, lsl #3
-		mov x1, #0
-		sub x2, x3, x2
-		lsl x2, x2, #3
-		bl _memset
-		.Lcb_grow_end:
-		ldr x0, [x19, #16]
-		```
+		if self.cap >= needed {
+			return self.cap
+		}
+		var int new_cap = self.cap
+		if new_cap == 0 {
+			new_cap = 4
+		}
+		while new_cap < needed; new_cap *= 2 {}
+		self.data = realloc(self.data, new_cap * 8)
+		memset(self.data + self.cap * 8, 0, (new_cap - self.cap) * 8)
+		self.cap = new_cap
+		return self.cap
 	}
 
 	inline func load_int = (self, int i: i >= 0 && i < self.cap, out int) {
@@ -99,51 +65,18 @@ pub struct ClassBuffer<T> {
 	// slots, matching _int.
 
 	func grow_T = (ref self, int needed, out int: out >= needed) {
-		```
-		#arch: c
-		if (self->cap >= needed) return self->cap;
-		int new_cap = self->cap;
-		if (new_cap == 0) new_cap = 4;
-		while (new_cap < needed) new_cap *= 2;
-		self->data = (unsigned long long)(long*)realloc((long*)(unsigned long long)self->data, new_cap * sizeof(long));
-		memset((long*)(unsigned long long)self->data + self->cap, 0, (new_cap - self->cap) * sizeof(long));
-		self->cap = new_cap;
-		return self->cap;
-		```
-		```
-		#arch: aarch64
-		ldr x2, [x19, #16]
-		cmp x2, x1
-		b.ge .Lcb_grow_T_end
-		mov x3, #4
-		cmp x2, #0
-		csel x3, x3, x2, eq
-		cmp x3, x1
-		b.ge .Lcb_grow_T_got
-		.Lcb_grow_T_loop:
-		lsl x3, x3, #1
-		cmp x3, x1
-		b.lt .Lcb_grow_T_loop
-		.Lcb_grow_T_got:
-		sub sp, sp, #16
-		str x2, [sp, #0]
-		str x3, [sp, #8]
-		ldr x0, [x19, #8]
-		lsl x1, x3, #3
-		bl _realloc
-		str x0, [x19, #8]
-		ldr x2, [sp, #0]
-		ldr x3, [sp, #8]
-		add sp, sp, #16
-		str x3, [x19, #16]
-		add x0, x0, x2, lsl #3
-		mov x1, #0
-		sub x2, x3, x2
-		lsl x2, x2, #3
-		bl _memset
-		.Lcb_grow_T_end:
-		ldr x0, [x19, #16]
-		```
+		if self.cap >= needed {
+			return self.cap
+		}
+		var int new_cap = self.cap
+		if new_cap == 0 {
+			new_cap = 4
+		}
+		while new_cap < needed; new_cap *= 2 {}
+		self.data = realloc(self.data, new_cap * 8)
+		memset(self.data + self.cap * 8, 0, (new_cap - self.cap) * 8)
+		self.cap = new_cap
+		return self.cap
 	}
 
 	inline func load_T = (self, int i: i >= 0 && i < self.cap, out T) {
@@ -160,6 +93,11 @@ pub struct ClassBuffer<T> {
 		```
 	}
 
+	// Store the owned class pointer `val` into slot `i`, which MUST be fresh
+	// (calloc'd, or zeroed by move_T/move_int). This is a plain pointer
+	// store — it does NOT destroy/free the slot's previous occupant, so a
+	// second `store_T` at an occupied index leaks that instance. Use
+	// replace_T (or replace_int) to overwrite a live slot.
 	inline func store_T = (ref self, int i: i >= 0 && i < self.cap, T val: val != 0) {
 		```
 		#arch: c

package/core/System/Controls/LayoutParams.nm

@@ -41,7 +41,7 @@ pub struct LayoutParams {
 }
 
 // Sensible defaults so most children just work
-const LayoutParams DEFAULT_PARAMS = LayoutParams() + [
+const LayoutParams DEFAULT_PARAMS = [ .. LayoutParams(),
 	width = .auto,
 	height = .auto,
 	grow = 0,

package/core/System/Map.nm

@@ -27,6 +27,9 @@ pub struct Map<TK: Hashable + Equatable, TV> {
 	pub func set = (ref self, move TK key, move TV value) {
 		var int cap = self.keys.cap
 		if cap == 0 {
+			// alloc_T: for Buffer<TK> it is T_SIZE-aware (string keys are
+			// 16-byte slots); for ClassBuffer<TV> it delegates to alloc_int
+			// (one pointer per slot). Both have it for generic parity.
 			cap = self.keys.alloc_T(8)
 			self.values.alloc_T(8)
 			self.used.alloc(8)