nomen-lang 0.8.0 → 0.10.0

package/core/System/ClassBuffer.nm

@@ -12,7 +12,7 @@ pub struct ClassBuffer<T> {
 	// Publicly readable; grown only by ClassBuffer's own methods (`readonly`).
 	readonly cap = 0
 
-	internal func alloc_int = (ref self, int size, out int: out >= size) {
+	internal func alloc_int = (ref self {}, int size, out int: out >= size) {
 		self.cap = size
 		self.data = calloc(size, 8)
 		return self.cap
@@ -25,11 +25,11 @@ pub struct ClassBuffer<T> {
 	// 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 = (ref self, int size, out int: out >= size) {
+	func alloc = (ref self {}, int size, out int: out >= size) {
 		return self.alloc_int(size)
 	}
 
-	internal func grow_int = (ref self, int needed, out int: out >= needed) {
+	internal func grow_int = (ref self {}, int needed, out int: out >= needed) {
 		if self.cap >= needed {
 			return self.cap
 		}
@@ -65,7 +65,7 @@ pub struct ClassBuffer<T> {
 	// handles, so the slot's CONTENT is the instance pointer: return the
 	// stored word, not the slot's address. Library-internal: bounds are the
 	// caller's obligation (the List wrapper constrains them).
-	pub func slot_ptr = (ref self, int i, out ptr T) {
+	internal func slot_ptr = (ref self {}, int i, out ptr T) {
 		```
 		#arch: c
 		// The slot's address: through the alias, reads and writes hit the
@@ -89,7 +89,7 @@ pub struct ClassBuffer<T> {
 	// (Buffer) or a class (ClassBuffer, after the Buffer<T> field is
 	// rewritten). Bodies use 8-byte slots, matching _int.
 
-	func grow = (ref self, int needed, out int: out >= needed) {
+	func grow = (ref self {}, int needed, out int: out >= needed) {
 		if self.cap >= needed {
 			return self.cap
 		}
@@ -118,6 +118,15 @@ pub struct ClassBuffer<T> {
 		```
 	}
 
+	// Labeled delegation point for raw-body callers in other containers
+	// (StableList's chunked storage calls this): `load` is `inline` — spliced
+	// at Nomen call sites, so no label exists for a raw C call or `bl` to
+	// target. Mirror of Buffer.load_from (class slots are pointer words —
+	// the pointer load IS the borrow form).
+	internal func load_from = (self, int i: i >= 0 && i < self.cap, out T) {
+		return self.load(i)
+	}
+
 	// Store the owned class pointer `val` into slot `i`, which MUST be fresh
 	// (calloc'd, or zeroed by mv/move_int). Takes OWNERSHIP of `val`
 	// (`mv`): the slot's #destroy reclaims the instance, so the caller must
@@ -127,7 +136,7 @@ pub struct ClassBuffer<T> {
 	// slot's previous occupant, so a second `store` at an occupied index
 	// leaks that instance. Use replace (or replace_int) to overwrite a live
 	// slot.
-	internal inline func store = (ref self, int i: i >= 0 && i < self.cap, mv T val: val != 0) {
+	internal inline func store = (ref self {}, int i: i >= 0 && i < self.cap, mv T val: val != 0) {
 		```
 		#arch: c
 		((long*)(unsigned long long)self->data)[i] = (long)val;
@@ -141,6 +150,42 @@ pub struct ClassBuffer<T> {
 		```
 	}
 
+	// Initialize this buffer as a VIEW over a foreign slab (INTERNAL — the
+	// chunked-container primitive): `data` becomes `slab` and `cap` becomes
+	// `fill`, and the buffer owns NOTHING — the slab keeps its real owner
+	// (never grown, never freed by the view). Mirror of Buffer.init_view;
+	// class slots are pointer words.
+	internal func init_view = (ref self {}, uint64 slab, int fill: fill >= 0) {
+		self.data = slab
+		self.cap = fill
+	}
+
+	// Clear a view initialized by init_view (see Buffer.clear_view): the
+	// holder's own field destroy then reclaims nothing.
+	internal func clear_view = (ref self {}) {
+		self.data = 0
+		self.cap = 0
+	}
+
+	// Store the owned class pointer `val` into slot `slot` of a foreign slab
+	// at `slab` (fill `fill`) through this buffer as a transient view —
+	// INTERNAL (StableList's directory chunks, class elements): init the
+	// view, run the typed `store` (the ownership-transferring slot store),
+	// then clear the view so the holder's teardown reclaims nothing. The
+	// holder passes a ClassBuffer FIELD, never a local (a local owning buffer
+	// is auto-destroyed at scope exit and would free the borrowed slab).
+	internal func store_in_slab = (
+		ref self {},
+		uint64 slab,
+		int fill: fill >= 0,
+		int slot: slot >= 0,
+		mv T val
+	) {
+		self.init_view(slab, fill)
+		self.store(slot, val)
+		self.clear_view()
+	}
+
 	// Move a class pointer out of a slot: return it and zero the slot so the
 	// buffer no longer references it. Declared `mv out T` so the borrow
 	// checker treats the result as OWNED — the slot is relinquished, so the
@@ -149,7 +194,7 @@ pub struct ClassBuffer<T> {
 	// out of a ClassBuffer slot, or moving a value into a fresh mv
 	// container — load returns a BORROW (the slot is unchanged) and storing
 	// it elsewhere would create shared ownership (double-free at destroy).
-	inline func move = (ref self, int i: i >= 0 && i < self.cap, mv out T) {
+	inline func move = (ref self {}, int i: i >= 0 && i < self.cap, mv out T) {
 		```
 		#arch: c
 		long *slots = (long*)(unsigned long long)self->data;
@@ -180,7 +225,7 @@ pub struct ClassBuffer<T> {
 	// free). Storing the returned instance raw is sound: the slot takes
 	// sole ownership and `f`'s return is not retained elsewhere. NOT
 	// `inline`: the body calls through the fn pointer.
-	func modify = (ref self, int i: i >= 0 && i < self.cap, func(T, out T) f) {
+	func modify = (ref self {}, int i: i >= 0 && i < self.cap, func(T, out T) f) {
 		```
 		#arch: c
 		long *slots = (long*)(unsigned long long)self->data;
@@ -213,7 +258,7 @@ pub struct ClassBuffer<T> {
 		```
 	}
 
-	internal inline func store_int = (ref self, int i: i >= 0 && i < self.cap, int val: val != 0) {
+	internal inline func store_int = (ref self {}, int i: i >= 0 && i < self.cap, int val: val != 0) {
 		```
 		#arch: c
 		((long*)(unsigned long long)self->data)[i] = val;
@@ -227,7 +272,7 @@ pub struct ClassBuffer<T> {
 		```
 	}
 
-	internal inline func move_int = (ref self, int i: i >= 0 && i < self.cap, out int) {
+	internal inline func move_int = (ref self {}, int i: i >= 0 && i < self.cap, out int) {
 		```
 		#arch: c
 		long *slots = (long*)(unsigned long long)self->data;
@@ -247,7 +292,7 @@ pub struct ClassBuffer<T> {
 
 	// Store into a slot, freeing the previous value (it is an owned class
 	// pointer): run its destroy then free it before overwriting.
-	internal func replace_int = (ref self, int i: i >= 0 && i < self.cap, int val: val != 0) {
+	internal func replace_int = (ref self {}, int i: i >= 0 && i < self.cap, int val: val != 0) {
 		```
 		#arch: c
 		long *slots = (long*)(unsigned long long)self->data;
@@ -278,12 +323,46 @@ pub struct ClassBuffer<T> {
 		```
 	}
 
+	// Reclaim slot i's owned class pointer (destroy + free) WITHOUT writing
+	// the slot — the destroy half of replace_int, without the store, zeroing
+	// the handle so a re-destroy is a no-op. The caller (Map.set_slot_ptr's
+	// replace path — the value-side sibling of `values.replace`) overwrites
+	// the slot immediately afterwards. Contract: the slot must be
+	// overwritten before it is read or destroyed again.
+	internal func destroy_at = (ref self {}, int i: i >= 0 && i < self.cap) {
+		```
+		#arch: c
+		long *slots = (long*)(unsigned long long)self->data;
+		if (slots[i]) {
+			T_destroy((void*)slots[i]);
+			free((void*)slots[i]);
+			slots[i] = 0;
+		}
+		```
+		```
+		#arch: aarch64
+		stp x20, x21, [sp, #-16]!
+		ldr x20, [x19, #8]
+		lsl x3, x1, #3
+		add x20, x20, x3
+		ldr x0, [x20]
+		cbz x0, .Lcb_destroy_at_done
+		mov x21, x0
+		bl T_destroy
+		mov x0, x21
+		bl _free
+		str xzr, [x20]
+		.Lcb_destroy_at_done:
+		ldp x20, x21, [sp], #16
+		```
+	}
+
 	// T-typed alias of replace_int: free the outgoing class pointer (destroy +
 	// free) then store the new one. Used by List.set so the uniform API
 	// preserves ownership for class elements.
 	// Overwrite a live slot: destroy + free the displaced instance, then take
 	// OWNERSHIP of `val` (`mv`) — same transfer rule as store.
-	func replace = (ref self, int i: i >= 0 && i < self.cap, mv T val: val != 0) {
+	func replace = (ref self {}, int i: i >= 0 && i < self.cap, mv T val: val != 0) {
 		```
 		#arch: c
 		long *slots = (long*)(unsigned long long)self->data;
@@ -320,7 +399,7 @@ pub struct ClassBuffer<T> {
 	// used by Map/Set.remove's backward-shift so shifting entries neither
 	// duplicates nor orphans owned instances.
 	func shift = (
-		ref self,
+		ref self {},
 		int dst: dst >= 0 && dst < self.cap,
 		int src: src >= 0 && src < self.cap
 	) {
@@ -363,6 +442,59 @@ pub struct ClassBuffer<T> {
 		```
 	}
 
+	// Bulk transfer for backward-shift deletion — the ClassBuffer
+	// counterpart of Buffer.move_range (same contract: every slot in
+	// [dst, dst + count) must be DEAD — zeroed by a move-out or otherwise
+	// unowned — because the block move overwrites without reclaiming; the
+	// deletion algorithms zero and relocate in lockstep). Slots are 8-byte
+	// instance pointers, so the block is one memmove + one memset of the
+	// source slots the destination never covers — List.remove_at_or_panic's
+	// whole-tail shift instead of per-element `shift` calls.
+	internal inline func move_range = (
+		ref self {},
+		int dst: dst >= 0,
+		int src: src >= dst,
+		int count: count >= 0 && src + count <= self.cap
+	) {
+		```
+		#arch: c
+		if (count > 0) {
+			long *slots = (long*)(unsigned long long)self->data;
+			memmove((void*)&slots[dst], (void*)&slots[src],
+				(unsigned long long)count * sizeof(long));
+			memset((void*)&slots[dst + count], 0,
+				(unsigned long long)(src - dst) * sizeof(long));
+		}
+		```
+		```
+		#arch: aarch64
+		// x19 = self, x1 = dst, x2 = src, x3 = count. x0-x18 die across the
+		// bl calls, so the block math parks on the stack around _memmove.
+		cbz x3, .Lcb_move_range_T_end
+		ldr x4, [x19, #8]
+		lsl x5, x1, #3
+		add x6, x4, x5
+		lsl x5, x2, #3
+		add x7, x4, x5
+		lsl x9, x3, #3
+		sub x10, x2, x1
+		lsl x10, x10, #3
+		stp x6, x9, [sp, #-16]!
+		str x10, [sp, #-16]!
+		mov x0, x6
+		mov x1, x7
+		mov x2, x9
+		bl _memmove
+		ldr x10, [sp], #16
+		ldp x6, x9, [sp], #16
+		add x0, x6, x9
+		mov x1, #0
+		mov x2, x10
+		bl _memset
+		.Lcb_move_range_T_end:
+		```
+	}
+
 	// A non-mv (ptr, len) slice [start, end) over this buffer's class
 	// pointers, returned as a `view T` (T is a class, so each element is an
 	// 8-byte pointer). Borrows from self — invalidated on reassignment. Mirrors

package/core/System/Controls/Alert.nm

@@ -12,13 +12,13 @@
  * UIAlertController needs a presenting view controller (TODO stubs; see
  * GUI_PLAN Tier 1 #19).
  **/
-pub mv struct Alert : Control {
+pub mv struct Alert: Control {
 	var uint64 handle = 0
 
 	// The `#handle` hook synthesizes `NameHandle` — a copyable, non-owning
 	// twin (same public bare-self methods, no destroy) so closures can
 	// capture this control without moving it. See GUI.md, "Handles".
-	#handle = () {}
+	#handle = () { }
 
 	pub func #init = (self) {
 		```
@@ -281,7 +281,7 @@ pub mv struct Alert : Control {
 	// An alert is a modal, not an in-window view: it measures to nothing and
 	// the layout engine never frames it. The conformance exists so an Alert
 	// can sit in a Control-typed slot without special-casing.
-	pub func set_frame = (ref self, int x, int y, int width, int height) {
+	pub func set_frame = (ref self {}, int x, int y, int width, int height) {
 		// No-op: modals are positioned by the window server.
 	}
 

package/core/System/Controls/App.nm

@@ -51,11 +51,11 @@
 pub trait App {
 	// Called once before the window is shown, after the app is in its
 	// final storage. Register layout roots here.
-	func start = (ref self, ref Window win) {
+	func start = (ref self, ref Window win {}) {
 	}
 
 	// Called every frame until the window closes.
-	func frame = (ref self, ref Window win, FrameEvents ev) {
+	func frame = (ref self, ref Window win {}, FrameEvents ev) {
 	}
 
 	// The per-frame event pump: drains every registered control event —
@@ -67,7 +67,7 @@ pub trait App {
 	// in this one slot — the App contract never grows with the event
 	// catalog. Conformers without registrations inherit this empty default
 	// (trait defaults have precedent: `Enumerable.length`).
-	func handle_events = (ref self, ref Window win) {
+	func handle_events = (ref self, ref Window win {}) {
 	}
 
 	// The up-call protocol (docs/HANDLERS.md Stage 3): a composite the app
@@ -76,7 +76,7 @@ pub trait App {
 	// synthesized override, whose arms dispatch the id to the app's handler.
 	// The borrow flows down per call; nothing outlives it. Default-empty,
 	// like `handle_events`.
-	func run_handler = (ref self, int id, ref Window win) {
+	func run_handler = (ref self, int id, ref Window win {}) {
 	}
 
 	// Close interception (the unsaved-changes pattern): run consults this
@@ -86,7 +86,7 @@ pub trait App {
 	// close request consults again. Programmatic `win.close()` is FORCED
 	// and bypasses this — handlers closing their own window never trip the
 	// interception. Default: allow.
-	func close_requested = (ref self, ref Window win, out bool) {
+	func close_requested = (ref self, ref Window win {}, out bool) {
 		return true
 	}
 }
@@ -102,7 +102,7 @@ pub trait App {
 pub mv struct FrameEvents {
 	// 0 = no mouse-down this frame, 1 = left, 2 = right (edge-triggered:
 	// only the frame that pumped the event reports it).
-	pub var int click = 0
+	pub var click = 0
 	pub var int click_x = -1
 	pub var int click_y = -1
 	// The full mouse record for this frame (0 = no mouse-down): the 1-based
@@ -112,14 +112,14 @@ pub mv struct FrameEvents {
 	// 0x40000, Shift = 0x20000). The same values the `win.mouse_button()` /
 	// `mouse_click_count()` / `mouse_modifiers()` getters report to
 	// `on_mouse_down` handlers. `click` remains the left/right compat view.
-	pub var int mouse_button = 0
-	pub var int mouse_click_count = 0
-	pub var int mouse_modifiers = 0
+	pub var mouse_button = 0
+	pub var mouse_click_count = 0
+	pub var mouse_modifiers = 0
 	// This frame's accumulated scroll-wheel deltas (dy positive scrolling
 	// up/away, dx positive right; trackpad frames sum every small event).
 	// `Scrollable.on_scroll` is the registered-handler form.
-	pub var int scroll_dx = 0
-	pub var int scroll_dy = 0
+	pub var scroll_dx = 0
+	pub var scroll_dy = 0
 	// The keyboard record for this frame (-1 = no key this frame): the
 	// hardware keycode of the last key-down (Space = 49, Return = 36,
 	// arrows = 123–126, letters a…z = 0–25), the modifiers at key-down,
@@ -127,8 +127,8 @@ pub mv struct FrameEvents {
 	// `on_key_down` / `on_key_up` are the registered-handler forms; text
 	// ENTRY flows through `on_input` (the field editor), not here.
 	pub var int key_code = -1
-	pub var int key_modifiers = 0
-	pub var bool key_repeat = false
+	pub var key_modifiers = 0
+	pub var key_repeat = false
 	pub var int key_up_code = -1
 	// The pointer-MOVE record for this frame (-1 = no movement): the
 	// current pointer position. `on_mouse_move` is the registered-handler
@@ -137,11 +137,11 @@ pub mv struct FrameEvents {
 	pub var int mouse_y = -1
 	// Milliseconds since the previous frame (0 on the first) — the
 	// animation clock. `win.dt()` reports the same value.
-	pub var int dt = 0
+	pub var dt = 0
 	// True when the window's content rect changed since the last frame —
 	// the framework has already re-laid-out the registered roots; re-layout
 	// App-owned panes (tab pages, split panes) here.
-	pub var bool resized = false
-	pub var int width = 0
-	pub var int height = 0
+	pub var resized = false
+	pub var width = 0
+	pub var height = 0
 }

package/core/System/Controls/Button.nm

@@ -12,7 +12,7 @@ pub mv struct Button: Control {
 	// The `#handle` hook synthesizes `NameHandle` — a copyable, non-owning
 	// twin (same public bare-self methods, no destroy) so closures can
 	// capture this control without moving it. See GUI.md, "Handles".
-	#handle = () {}
+	#handle = () { }
 
 	pub func #init = (self, Window window, string title) {
 		```
@@ -99,7 +99,7 @@ pub mv struct Button: Control {
 		```
 	}
 
-	pub func set_frame = (ref self, int x, int y, int width, int height) {
+	pub func set_frame = (ref self {}, int x, int y, int width, int height) {
 		```
 		#arch: c
 		#platform: macos

package/core/System/Controls/CheckBox.nm

@@ -6,13 +6,13 @@
  * `#destroy` releases what the handle names. The constructor's `self` is
  * the inline instance (the `.` accessor); methods keep the pointer form.
  **/
-pub mv struct CheckBox : Control {
+pub mv struct CheckBox: Control {
 	var uint64 handle = 0
 
 	// The `#handle` hook synthesizes `NameHandle` — a copyable, non-owning
 	// twin (same public bare-self methods, no destroy) so closures can
 	// capture this control without moving it. See GUI.md, "Handles".
-	#handle = () {}
+	#handle = () { }
 
 	pub func #init = (self, Window window) {
 		```
@@ -85,7 +85,7 @@ pub mv struct CheckBox : Control {
 		```
 	}
 
-	pub func set_frame = (ref self, int x, int y, int width, int height) {
+	pub func set_frame = (ref self {}, int x, int y, int width, int height) {
 		```
 		#arch: c
 		#platform: macos

package/core/System/Controls/ColorPicker.nm

@@ -18,7 +18,7 @@ pub struct Rgb {
  * Components travel as 0-255 ints; the platform stores 0-1 doubles, so the
  * round trip is exact to ±1 (the getters round).
  **/
-pub mv struct ColorPicker : Control {
+pub mv struct ColorPicker: Control {
 	var uint64 handle = 0
 
 	pub func #init = (self, Window window) {
@@ -80,7 +80,7 @@ pub mv struct ColorPicker : Control {
 		```
 	}
 
-	pub func set_frame = (ref self, int x, int y, int width, int height) {
+	pub func set_frame = (ref self {}, int x, int y, int width, int height) {
 		```
 		#arch: c
 		#platform: macos

package/core/System/Controls/ComboBox.nm

@@ -12,7 +12,7 @@
  * macOS-only (NSComboBox has no iOS counterpart — see GUI_PLAN Tier 2; the
  * iOS blocks are TODO stubs).
  **/
-pub mv struct ComboBox : Control {
+pub mv struct ComboBox: Control {
 	var uint64 handle = 0
 
 	pub func #init = (self, Window window) {
@@ -63,7 +63,7 @@ pub mv struct ComboBox : Control {
 		```
 	}
 
-	pub func set_frame = (ref self, int x, int y, int width, int height) {
+	pub func set_frame = (ref self {}, int x, int y, int width, int height) {
 		```
 		#arch: c
 		#platform: macos