nomen-lang 0.9.0 → 0.10.0

package/core/System/Buffer.nm

@@ -23,13 +23,13 @@ pub struct Buffer<T> {
 	// 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.
-	internal func alloc_u32 = (ref self, int size, out int: out >= size) {
+	internal func alloc_u32 = (ref self {}, int size, out int: out >= size) {
 		self.cap = size
 		self.data = calloc(size, 4)
 		return self.cap
 	}
 
-	internal func grow_u32 = (ref self, int needed, out int: out >= needed) {
+	internal func grow_u32 = (ref self {}, int needed, out int: out >= needed) {
 		if self.cap >= needed {
 			return self.cap
 		}
@@ -44,7 +44,7 @@ pub struct Buffer<T> {
 		return self.cap
 	}
 
-	internal func zero_u32 = (ref self, int len) {
+	internal func zero_u32 = (ref self {}, int len) {
 		memset(self.data, 0, len * 4)
 	}
 
@@ -63,7 +63,7 @@ pub struct Buffer<T> {
 		```
 	}
 
-	internal inline func store_u32 = (ref self, int i: i >= 0 && i < self.cap, uint32 val) {
+	internal inline func store_u32 = (ref self {}, int i: i >= 0 && i < self.cap, uint32 val) {
 		```
 		#arch: c
 		((unsigned int*)(unsigned long long)self->data)[i] = val;
@@ -77,7 +77,7 @@ pub struct Buffer<T> {
 		```
 	}
 
-	internal inline func store_or_u32 = (ref self, int i: i >= 0 && i < self.cap, uint32 val) {
+	internal inline func store_or_u32 = (ref self {}, int i: i >= 0 && i < self.cap, uint32 val) {
 		```
 		#arch: c
 		((unsigned int*)(unsigned long long)self->data)[i] |= val;
@@ -109,7 +109,7 @@ pub struct Buffer<T> {
 		```
 	}
 
-	internal inline func store_u8 = (ref self, int i: i >= 0 && i < self.cap, uint8 val) {
+	internal inline func store_u8 = (ref self {}, int i: i >= 0 && i < self.cap, uint8 val) {
 		```
 		#arch: c
 		((unsigned char*)(unsigned long long)self->data)[i] = val;
@@ -122,12 +122,12 @@ pub struct Buffer<T> {
 		```
 	}
 
-	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
 	}
-	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
 		}
@@ -156,7 +156,7 @@ pub struct Buffer<T> {
 		```
 	}
 
-	internal inline func store_int = (ref self, int i: i >= 0 && i < self.cap, int val) {
+	internal inline func store_int = (ref self {}, int i: i >= 0 && i < self.cap, int val) {
 		```
 		#arch: c
 		((long*)(unsigned long long)self->data)[i] = val;
@@ -249,7 +249,7 @@ pub struct Buffer<T> {
 	// relay — the same stack view the raw bodies build by hand, in typed
 	// Nomen. The holder must clear the view afterwards (see clear_view):
 	// an owning Buffer FIELD is destroyed by its holder's teardown.
-	internal func init_view = (ref self, uint64 slab, int fill: fill >= 0) {
+	internal func init_view = (ref self {}, uint64 slab, int fill: fill >= 0) {
 		self.data = slab
 		self.cap = fill
 	}
@@ -257,7 +257,7 @@ pub struct Buffer<T> {
 	// Clear a view initialized by init_view: `data`/`cap` back to zero, so
 	// the holder's own field destroy reclaims nothing (the slab's real owner
 	// still owns it).
-	internal func clear_view = (ref self) {
+	internal func clear_view = (ref self {}) {
 		self.data = 0
 		self.cap = 0
 	}
@@ -270,7 +270,7 @@ pub struct Buffer<T> {
 	// local — a local owning Buffer would be auto-destroyed at scope exit
 	// and free the slab it only borrows.
 	internal func store_in_slab = (
-		ref self,
+		ref self {},
 		uint64 slab,
 		int fill: fill >= 0,
 		int slot: slot >= 0,
@@ -278,10 +278,12 @@ pub struct Buffer<T> {
 	) {
 		self.init_view(slab, fill)
 		// `val` arrives owned from the container's `mv T` push parameter: a
-		// value-struct element moves into the chunk slot (store_take — the
-		// caller's storage zeroes, no deep copy); strings keep the
-		// deep-copying store (their pair arrives by value).
-		if T_IS_VALUE_STRUCT {
+		// value-struct element that OWNS resources moves into the chunk slot
+		// (store_take — the caller's storage zeroes, no deep copy). A
+		// non-owning value struct is a legal bare argument, so it keeps the
+		// copying store (taking it would zero the caller's copy); strings
+		// keep the deep-copying store too (their pair arrives by value).
+		if T_TAKES_OWNERSHIP {
 			self.store_take(slot, val)
 		} else {
 			self.store(slot, val)
@@ -293,7 +295,7 @@ pub struct Buffer<T> {
 	// the ownership-extracting primitive (used by e.g. List.pop) — unlike
 	// load_int (a borrow read), it relinquishes the slot so the buffer no
 	// longer owns the value.
-	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;
@@ -314,7 +316,7 @@ pub struct Buffer<T> {
 	// Store into a slot, freeing the previous value when the buffer holds
 	// owned class pointers (has_class_refs). For non-class buffers this is a
 	// plain store, so it is safe to use anywhere store_int would be.
-	internal inline func replace_int = (ref self, int i: i >= 0 && i < self.cap, int val) {
+	internal inline func replace_int = (ref self {}, int i: i >= 0 && i < self.cap, int val) {
 		```
 		#arch: c
 		((long*)(unsigned long long)self->data)[i] = val;
@@ -328,7 +330,7 @@ pub struct Buffer<T> {
 		```
 	}
 
-	internal inline func zero_int = (ref self, int len) {
+	internal inline func zero_int = (ref self {}, int len) {
 		memset(self.data, 0, len * 8)
 	}
 
@@ -338,7 +340,7 @@ pub struct Buffer<T> {
 	// structs of any width work correctly. Classes route to ClassBuffer<T> (per-element destroy), so T
 	// reaching here is always a value type (primitive or struct).
 
-	func alloc = (ref self, int size, out int: out >= size) {
+	func alloc = (ref self {}, int size, out int: out >= size) {
 		// Reclaim the old slab before the fresh calloc (the raw body runs
 		// for scalar / trivially-destructible elements — plain bytes, so a
 		// straight free is sound; mv element types take the specialized
@@ -352,7 +354,7 @@ pub struct Buffer<T> {
 		return self.cap
 	}
 
-	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
 		}
@@ -430,7 +432,7 @@ pub struct Buffer<T> {
 	// value) — this is the primitive every container's `set` uses.
 	// Internal: assumes a FRESH slot (see the contract comment). The public
 	// write is `replace`, which is correct on fresh and occupied slots alike.
-	internal inline func store = (ref self, int i: i >= 0 && i < self.cap, T val) {
+	internal inline func store = (ref self {}, int i: i >= 0 && i < self.cap, T val) {
 		```
 		#arch: c
 		((T*)(unsigned long long)self->data)[i] = val;
@@ -490,7 +492,7 @@ pub struct Buffer<T> {
 	// parameter is a pointer to the caller's storage — a `string`'s fat pair
 	// arrives by value, so take-store would zero the callee's copy and leave
 	// the caller's buffer shared).
-	internal inline func store_take = (ref self, int i: i >= 0 && i < self.cap, T val) {
+	internal inline func store_take = (ref self {}, int i: i >= 0 && i < self.cap, T val) {
 		```
 		#arch: c
 		{
@@ -572,7 +574,7 @@ pub struct Buffer<T> {
 	// the result is treated as OWNED by the borrow checker — the slot is
 	// relinquished, so the caller is the sole remaining owner. The value
 	// counterpart of ClassBuffer.move_int — used by List.pop for any value T.
-	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
 		T* _slots = (T*)(unsigned long long)self->data;
@@ -652,7 +654,7 @@ pub struct Buffer<T> {
 	// this raw form is correct for trivially-copyable elements only. NOT
 	// `inline`: the body calls through the fn pointer, so splicing the raw
 	// block into a caller would bypass the per-element specializations.
-	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
 		((T*)(unsigned long long)self->data)[i] = ((T (*)(void *, T))f->code)(f->env, ((T*)(unsigned long long)self->data)[i]);
@@ -739,7 +741,7 @@ pub struct Buffer<T> {
 	// value, then deep-copies (strdup per string field). See
 	// owning_buffer_specialize.ts (both backends). ClassBuffer.replace
 	// destroys+frees class slots soundly.
-	inline func replace = (ref self, int i: i >= 0 && i < self.cap, T val) {
+	inline func replace = (ref self {}, int i: i >= 0 && i < self.cap, T val) {
 		```
 		#arch: c
 		((T*)(unsigned long long)self->data)[i] = val;
@@ -795,7 +797,7 @@ pub struct Buffer<T> {
 	// cannot accept the `mv` keyword, so a borrow being transferred
 	// (e.g. a loaded element) must go through here rather than be bound to
 	// a freed local.
-	pub func set = (ref self, int i: i >= 0 && i < self.cap, mv T value) {
+	pub func set = (ref self {}, int i: i >= 0 && i < self.cap, mv T value) {
 		self.replace(i, value)
 	}
 
@@ -810,7 +812,7 @@ pub struct Buffer<T> {
 	// overwritten before it is read or destroyed again — Map.set_slot_ptr
 	// (the probe-then-construct primitive) and the in-place `set` splice
 	// are the callers, and both overwrite immediately.
-	internal func destroy_at = (ref self, int i: i >= 0 && i < self.cap) {
+	internal func destroy_at = (ref self {}, int i: i >= 0 && i < self.cap) {
 		```
 		#arch: c
 		T* _slots = (T*)(unsigned long long)self->data;
@@ -854,7 +856,7 @@ pub struct Buffer<T> {
 	// borrow-invalidation rules. Library-internal: the caller (the `List`
 	// wrapper, or trusted internals) bounds-checks; the body is raw-only so
 	// the missing-return net does not apply to the raw return.
-	internal func slot_ptr = (ref self, int i, out ptr T) {
+	internal func slot_ptr = (ref self {}, int i, out ptr T) {
 		```
 		#arch: c
 		return (T*)(unsigned long long)self->data + i;
@@ -880,7 +882,7 @@ pub struct Buffer<T> {
 	// owning_buffer_specialize.ts); this raw form is correct for
 	// trivially-destructible elements only.
 	inline func shift = (
-		ref self,
+		ref self {},
 		int dst: dst >= 0 && dst < self.cap,
 		int src: src >= 0 && src < self.cap
 	) {
@@ -969,7 +971,7 @@ pub struct Buffer<T> {
 	// carries mv elements' heap pointers with them — correct for every
 	// element kind, raw for both backends (never names T).
 	internal inline func move_range = (
-		ref self,
+		ref self {},
 		int dst: dst >= 0,
 		int src: src >= dst,
 		int count: count >= 0 && src + count <= self.cap
@@ -1045,7 +1047,7 @@ pub struct Buffer<T> {
 	}
 
 	// Internal: zeroes slots without reclaiming mv elements.
-	internal inline func zero = (ref self, int len) {
+	internal inline func zero = (ref self {}, int len) {
 		memset(self.data, 0, len * T_SIZE)
 	}
 
@@ -1076,7 +1078,7 @@ pub struct Buffer<T> {
 		return dst
 	}
 
-	internal inline func store_or_int = (ref self, int i: i >= 0 && i < self.cap, int val) {
+	internal inline func store_or_int = (ref self {}, int i: i >= 0 && i < self.cap, int val) {
 		```
 		#arch: c
 		((long*)(unsigned long long)self->data)[i] |= val;
@@ -1092,7 +1094,7 @@ pub struct Buffer<T> {
 		```
 	}
 
-	internal func alloc_float = (ref self, int size, out int: out >= size) {
+	internal func alloc_float = (ref self {}, int size, out int: out >= size) {
 		self.cap = size
 		self.data = calloc(size, 8)
 		return self.cap
@@ -1112,7 +1114,7 @@ pub struct Buffer<T> {
 		```
 	}
 
-	internal inline func store_float = (ref self, int i: i >= 0 && i < self.cap, float val) {
+	internal inline func store_float = (ref self {}, int i: i >= 0 && i < self.cap, float val) {
 		```
 		#arch: c
 		((double*)(unsigned long long)self->data)[i] = val;

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).
-	internal 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
 		}
@@ -136,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;
@@ -155,14 +155,14 @@ pub struct ClassBuffer<T> {
 	// `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) {
+	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) {
+	internal func clear_view = (ref self {}) {
 		self.data = 0
 		self.cap = 0
 	}
@@ -175,7 +175,7 @@ pub struct ClassBuffer<T> {
 	// 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,
+		ref self {},
 		uint64 slab,
 		int fill: fill >= 0,
 		int slot: slot >= 0,
@@ -194,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;
@@ -225,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;
@@ -258,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;
@@ -272,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;
@@ -292,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;
@@ -329,7 +329,7 @@ pub struct ClassBuffer<T> {
 	// 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) {
+	internal func destroy_at = (ref self {}, int i: i >= 0 && i < self.cap) {
 		```
 		#arch: c
 		long *slots = (long*)(unsigned long long)self->data;
@@ -362,7 +362,7 @@ pub struct ClassBuffer<T> {
 	// 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;
@@ -399,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
 	) {
@@ -451,7 +451,7 @@ pub struct ClassBuffer<T> {
 	// 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,
+		ref self {},
 		int dst: dst >= 0,
 		int src: src >= dst,
 		int count: count >= 0 && src + count <= self.cap

package/core/System/Controls/Alert.nm

@@ -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
 	}
 }

package/core/System/Controls/Button.nm

@@ -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

@@ -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

@@ -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

@@ -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