nomen-lang 0.2.3 → 0.4.0

package/core/System/Buffer.nm

@@ -1,94 +1,54 @@
 // 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>.
+//
+// Public API is the size-aware family (`alloc`/`grow`/`load`/`replace`/
+// `move`/`modify`/`shift`/`slice` plus the readonly `cap`). `replace` is the
+// public write — it reclaims the displaced element, so it is correct on both
+// fresh and occupied slots. `store` (which assumes a fresh slot and leaks on
+// overwrite), `zero`, the fixed-width `*_u32`/`*_int`/`*_float` primitives,
+// and the raw `data` pointer are `internal` and reserved for the System
+// containers.
+
 /**
  * A flat, low-level buffer of value slots of type T — the backing store for arrays and collections
  **/
 pub struct Buffer<T> {
-	var uint64 data = 0
-	var cap = 0
+	internal var uint64 data = 0
+	// Publicly readable capacity (`i < self.cap` guards every accessor), but
+	// only Buffer's own methods may grow it — `readonly`.
+	readonly cap = 0
 
-	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]
-		```
+	// 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.
+	internal func alloc_u32 = (ref self, int size, out int: out >= size) {
+		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]
-		```
+	internal func grow_u32 = (ref self, int needed, out int: out >= needed) {
+		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
-		```
+	internal func zero_u32 = (ref self, int len) {
+		memset(self.data, 0, len * 4)
 	}
 
-	inline func load = (self, int i: i >= 0 && i < self.cap, out uint32) {
+	internal inline func load_u32 = (self, int i: i >= 0 && i < self.cap, out uint32) {
 		```
 		#arch: c
 		return ((unsigned int*)(unsigned long long)self->data)[i];
@@ -103,7 +63,7 @@ pub struct Buffer<T> {
 		```
 	}
 
-	inline func store = (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;
@@ -117,7 +77,7 @@ pub struct Buffer<T> {
 		```
 	}
 
-	inline func store_or = (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;
@@ -133,73 +93,28 @@ 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]
-		```
+	internal func alloc_int = (ref self, int size, out int: out >= size) {
+		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]
-		```
+	internal func grow_int = (ref self, int needed, out int: out >= needed) {
+		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) {
+	internal inline func load_int = (self, int i: i >= 0 && i < self.cap, out int) {
 		```
 		#arch: c
 		return ((long*)(unsigned long long)self->data)[i];
@@ -213,7 +128,7 @@ pub struct Buffer<T> {
 		```
 	}
 
-	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;
@@ -231,7 +146,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.
-	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;
@@ -252,7 +167,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.
-	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;
@@ -266,18 +181,8 @@ 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
-		```
+	internal inline func zero_int = (ref self, int len) {
+		memset(self.data, 0, len * 8)
 	}
 
 	// T_SIZE-aware primitives for value-struct elements. Slab is sized in
@@ -285,82 +190,32 @@ pub struct Buffer<T> {
 	// correctly. Classes route to ClassBuffer<T> (per-element destroy), so 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]
-		```
+	func alloc = (ref self, int size, out int: out >= size) {
+		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]
-		```
+	func grow = (ref self, int needed, out int: out >= needed) {
+		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
 	// call sites — the load/store pair behind every container `.at`/`set` is
 	// the hottest path in data-heavy code, and the naked-inline path keeps it
 	// to a handful of instructions with no call overhead.
-	inline func load_T = (self, int i: i >= 0 && i < self.cap, out T) {
+	inline func load = (self, int i: i >= 0 && i < self.cap, out T) {
 		```
 		#arch: c
 		return ((T*)(unsigned long long)self->data)[i];
@@ -403,7 +258,15 @@ pub struct Buffer<T> {
 		```
 	}
 
-	inline func store_T = (ref self, int i: i >= 0 && i < self.cap, T val) {
+	// Store `val` into slot `i`, which MUST be fresh (calloc'd, or zeroed by
+	// move). 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` at an occupied index
+	// leaks it. To overwrite a live slot use replace (frees the displaced
+	// 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) {
 		```
 		#arch: c
 		((T*)(unsigned long long)self->data)[i] = val;
@@ -449,7 +312,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_T = (ref self, int i: i >= 0 && i < self.cap, move out T) {
+	inline func move = (ref self, int i: i >= 0 && i < self.cap, move out T) {
 		```
 		#arch: c
 		T* _slots = (T*)(unsigned long long)self->data;
@@ -505,14 +368,101 @@ pub struct Buffer<T> {
 		```
 	}
 
+	// Apply `f` to slot `i` in place: the safe way to do a load→modify→store
+	// round-trip on a live slot. `f` receives the current value as a borrow
+	// (by value) and returns the replacement; the primitive itself handles
+	// ownership — the displaced value is freed, and a returned field that
+	// aliases the slot's own copy (the round-trip case) is kept, not freed or
+	// re-copied. Unlike store this never leaks on overwrite, and unlike
+	// replace it is safe to derive the new value from the old one. The
+	// returned struct's owning fields must be fresh, null, or identical to
+	// the corresponding input fields (no cross-field aliasing). For owning
+	// elements (string / structs with string fields) the build phase replaces
+	// this body with a specialized one (see owning_buffer_specialize.ts);
+	// 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) {
+		```
+		#arch: c
+		((T*)(unsigned long long)self->data)[i] = f(((T*)(unsigned long long)self->data)[i]);
+		```
+		```
+		#arch: aarch64
+		// x19 = self, x1 = i, x2 = f. Scalar elements round-trip through x0
+		// (width-matched); larger trivially-copyable structs pass the slot
+		// address and an sret pointer (x8) — the fn writes the replacement
+		// straight into the slot from a stack-stage copy of the old value.
+		stp x20, x21, [sp, #-16]!
+		stp x22, x23, [sp, #-16]!
+		mov x22, x2
+		ldr x9, [x19, #8]
+		mov x3, #T_SIZE
+		madd x20, x1, x3, xzr
+		add x20, x20, x9
+		cmp x3, #8
+		b.gt .Lbuffer_modify_T_big
+		cmp x3, #1
+		b.eq .Lbuffer_modify_T_ld1
+		cmp x3, #2
+		b.eq .Lbuffer_modify_T_ld2
+		cmp x3, #4
+		b.eq .Lbuffer_modify_T_ld4
+		ldr x0, [x20]
+		b .Lbuffer_modify_T_call
+		.Lbuffer_modify_T_ld1:
+		ldrb w0, [x20]
+		b .Lbuffer_modify_T_call
+		.Lbuffer_modify_T_ld2:
+		ldrh w0, [x20]
+		b .Lbuffer_modify_T_call
+		.Lbuffer_modify_T_ld4:
+		ldr w0, [x20]
+		.Lbuffer_modify_T_call:
+		blr x22
+		cmp x3, #1
+		b.eq .Lbuffer_modify_T_st1
+		cmp x3, #2
+		b.eq .Lbuffer_modify_T_st2
+		cmp x3, #4
+		b.eq .Lbuffer_modify_T_st4
+		str x0, [x20]
+		b .Lbuffer_modify_T_end
+		.Lbuffer_modify_T_st1:
+		strb w0, [x20]
+		b .Lbuffer_modify_T_end
+		.Lbuffer_modify_T_st2:
+		strh w0, [x20]
+		b .Lbuffer_modify_T_end
+		.Lbuffer_modify_T_st4:
+		str w0, [x20]
+		b .Lbuffer_modify_T_end
+		.Lbuffer_modify_T_big:
+		add x23, x3, #15
+		bic x23, x23, #15
+		sub sp, sp, x23
+		mov x0, sp
+		mov x1, x20
+		mov x2, x3
+		bl _memcpy
+		mov x0, sp
+		mov x8, x20
+		blr x22
+		add sp, sp, x23
+		.Lbuffer_modify_T_end:
+		ldp x22, x23, [sp], #16
+		ldp x20, x21, [sp], #16
+		```
+	}
+
 	// Store into a T_SIZE-sized slot, overwriting the previous value. For
 	// trivially-destructible value structs this is a plain overwrite. For
 	// owning value structs (with string fields), the build phase replaces this
 	// body with a specialised version that calls T_destroy on the old slot
 	// value, then deep-copies (strdup per string field). See
-	// owning_buffer_specialize.ts (both backends). ClassBuffer.replace_T
+	// owning_buffer_specialize.ts (both backends). ClassBuffer.replace
 	// destroys+frees class slots soundly.
-	inline func replace_T = (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;
@@ -556,14 +506,14 @@ pub struct Buffer<T> {
 	// Move slot src into slot dst: overwrite dst with src's bytes and zero
 	// src, so exactly ONE slot owns the value afterwards. The
 	// ownership-transferring primitive behind backward-shift deletion
-	// (Map/Set.remove) — unlike store_T, which gives the slot its own deep
+	// (Map/Set.remove) — unlike store, which gives the slot its own deep
 	// copy and leaves the source slot intact, a shift transfers the source's
 	// heap pointers wholesale. For owning elements (string / value structs
 	// with string fields) the build replaces this body with a specialized
 	// version that also reclaims dst's previous value first (see
 	// owning_buffer_specialize.ts); this raw form is correct for
 	// trivially-destructible elements only.
-	inline func shift_T = (ref self, int dst: dst >= 0 && dst < self.cap, int src: src >= 0 && src < self.cap) {
+	inline func shift = (ref self, int dst: dst >= 0 && dst < self.cap, int src: src >= 0 && src < self.cap) {
 		```
 		#arch: c
 		T* _slots = (T*)(unsigned long long)self->data;
@@ -630,7 +580,7 @@ pub struct Buffer<T> {
 	// self's scope and is invalidated if self is reassigned. This is the single
 	// primitive every other slice (Array<T>, List<T>, user containers) builds
 	// on — higher layers just `return self.items.slice(start, end)`.
-	func slice = (self, int start: start >= 0, int end: end >= start, out view T) {
+	func slice = (self, int start: start >= 0, int end: end >= start && end <= self.cap, out view T) {
 		```
 		#arch: c
 		nomen_view _r;
@@ -649,22 +599,12 @@ 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
-		```
+	// Internal: zeroes slots without reclaiming owning elements.
+	internal inline func zero = (ref self, int len) {
+		memset(self.data, 0, len * T_SIZE)
 	}
 
-	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;
@@ -680,25 +620,13 @@ 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]
-		```
+	internal func alloc_float = (ref self, int size, out int: out >= size) {
+		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) {
+	internal inline func load_float = (self, int i: i >= 0 && i < self.cap, out float) {
 		```
 		#arch: c
 		return ((double*)(unsigned long long)self->data)[i];
@@ -712,7 +640,7 @@ pub struct Buffer<T> {
 		```
 	}
 
-	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;
@@ -727,20 +655,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
 	}
 }