nomen-lang 0.8.0 → 0.10.0

package/core/System/Task.nm

@@ -23,8 +23,6 @@
  * Conforms to `Awaitable`: `.wait()` may park the current execution context.
  **/
 pub mv struct Task<T> : Awaitable {
-	pub var uint64 handle = 0
-	pub var done = false
 	pub var uint64 result_slot = 0
 	pub var uint64 cancel_flag = 0
 	pub var uint64 future = 0
@@ -46,8 +44,6 @@ pub mv struct Task<T> : Awaitable {
 	// names. Struct receivers travel by address regardless (the raw body
 	// reads `self->future`), so the ABI is unchanged; the bare spelling is
 	// what lets the read-only `Awaitable` dispatch form typecheck.
-	// The legacy `pthread_join` fallback is gone — `handle` has been
-	// permanently zero since the pool migration.
 	pub func wait = (self) {
 		```
 		#arch: c
@@ -58,7 +54,7 @@ pub mv struct Task<T> : Awaitable {
 		```
 		#arch: aarch64
 		// if (self->future) __nomen_future_wait(self->future)
-		ldr x0, [x19, #40]
+		ldr x0, [x19, #24]
 		cbz x0, .Lwait_done
 		bl ___nomen_future_wait
 		.Lwait_done:
@@ -71,18 +67,22 @@ pub mv struct Task<T> : Awaitable {
 	// trampoline writes the function's return value there before exiting.
 	// The result is MOVED OUT: the slot is zeroed as the value leaves, and
 	// `mv out T` marks the caller as the owner. Call it once; a second call
-	// returns the zero value. For tasks with no return value (void
-	// functions), returns the zero value.
-	pub func result = (ref self, mv out T) {
+	// returns the zero value. An empty handle (never launched, machinery
+	// already destroyed) owns no slot — it also returns the zero value
+	// rather than reading through a null pointer. For tasks with no return
+	// value (void functions), returns the zero value.
+	pub func result = (ref self {}, mv out T) {
 		```
 		#arch: c
 		if (self->future) {
 			__nomen_future_wait((struct nomen_future *)self->future);
-		} else if (self->handle && !self->done) {
-			void *ret;
-			pthread_join((pthread_t)self->handle, &ret);
-			self->handle = 0;
-			self->done = 1;
+		}
+		// An empty or already-consumed handle owns no result cell — return
+		// the zero value instead of reading through a null slot.
+		if (!self->result_slot) {
+			T _z;
+			memset(&_z, 0, sizeof(T));
+			return _z;
 		}
 		T _r = *(T *)self->result_slot;
 		memset((void *)self->result_slot, 0, sizeof(T));
@@ -91,72 +91,64 @@ pub mv struct Task<T> : Awaitable {
 		```
 		#arch: aarch64
 		// Wait for completion (same as wait method)
-		ldr x0, [x19, #40]
-		cbz x0, .Lresult_handle
-		bl ___nomen_future_wait
-		b .Lresult_read
-		.Lresult_handle:
-		ldr x0, [x19, #8]
+		ldr x0, [x19, #24]
 		cbz x0, .Lresult_read
-		ldrb w1, [x19, #16]
-		cbnz w1, .Lresult_read
-		sub sp, sp, #16
-		mov x1, sp
-		bl _pthread_join
-		add sp, sp, #16
-		str xzr, [x19, #8]
-		mov w0, #1
-		strb w0, [x19, #16]
+		bl ___nomen_future_wait
 		.Lresult_read:
+		// An empty or already-consumed handle owns no result cell: return
+		// the zero T instead of reading through a null slot.
+		ldr x8, [x19, #8]
+		cbz x8, .Lresult_zero
 		// The result cell is always 16 bytes (see the spawn build phase):
 		// load the full pair — a fat string returns (ptr, len) in x0/x1, a
 		// scalar returns its word in x0 — then zero the cell (the value is
 		// moved out; a second call observes the zero).
-		ldr x8, [x19, #24]
 		ldr x0, [x8]
 		ldr x1, [x8, #8]
 		stp xzr, xzr, [x8]
+		b .Lresult_end
+		.Lresult_zero:
+		mov x0, #0
+		mov x1, #0
+		.Lresult_end:
 		```
 	}
 
 	// Block until the task finishes, then return its result as a uint64.
 	// Convenience for the common case; same as result() for uint64 tasks.
-	pub func result_uint64 = (ref self, out uint64) {
+	// Like result(), it zeroes the cell as the value leaves (one end state
+	// for a consumed handle), and an empty handle returns zero.
+	pub func result_uint64 = (ref self {}, out uint64) {
 		```
 		#arch: c
 		if (self->future) {
 			__nomen_future_wait((struct nomen_future *)self->future);
-		} else if (self->handle && !self->done) {
-			void *ret;
-			pthread_join((pthread_t)self->handle, &ret);
-			self->handle = 0;
-			self->done = 1;
 		}
-		return *(unsigned long long *)self->result_slot;
+		if (!self->result_slot) {
+			return 0;
+		}
+		unsigned long long _r = *(unsigned long long *)self->result_slot;
+		*(unsigned long long *)self->result_slot = 0;
+		return _r;
 		```
 		```
 		#arch: aarch64
 		// Wait for completion
-		ldr x0, [x19, #40]
-		cbz x0, .Lru64_handle
-		bl ___nomen_future_wait
-		b .Lru64_read
-		.Lru64_handle:
-		ldr x0, [x19, #8]
+		ldr x0, [x19, #24]
 		cbz x0, .Lru64_read
-		ldrb w1, [x19, #16]
-		cbnz w1, .Lru64_read
-		sub sp, sp, #16
-		mov x1, sp
-		bl _pthread_join
-		add sp, sp, #16
-		str xzr, [x19, #8]
-		mov w0, #1
-		strb w0, [x19, #16]
+		bl ___nomen_future_wait
 		.Lru64_read:
-		// return *(unsigned long long *)self->result_slot
-		ldr x0, [x19, #24]
-		ldr x0, [x0]
+		// An empty or already-consumed handle owns no result cell: return
+		// zero instead of reading through a null slot. Otherwise zero the
+		// cell as the value leaves (matching result()'s end state).
+		ldr x8, [x19, #8]
+		cbz x8, .Lru64_zero
+		ldr x0, [x8]
+		str xzr, [x8]
+		b .Lru64_end
+		.Lru64_zero:
+		mov x0, #0
+		.Lru64_end:
 		```
 	}
 
@@ -165,7 +157,7 @@ pub mv struct Task<T> : Awaitable {
 	// handle whose machinery was already consumed). The missing peek
 	// between wait (blocking) and cancel (cooperative): event loops use it
 	// to notice a finished task without parking the UI thread.
-	pub func is_done = (ref self, out bool) {
+	pub func is_done = (ref self {}, out bool) {
 		```
 		#arch: c
 		return __nomen_future_is_done((struct nomen_future *)self->future);
@@ -173,14 +165,14 @@ pub mv struct Task<T> : Awaitable {
 		```
 		#arch: aarch64
 		// x0 = self->future; result in x0.
-		ldr x0, [x19, #40]
+		ldr x0, [x19, #24]
 		bl ___nomen_future_is_done
 		```
 	}
 
 	// Request that the task stop. Cooperative — the task observes this via
 	// `Task.current_cancelled()` at its own checkpoints. No preemption.
-	pub func cancel = (ref self) {
+	pub func cancel = (ref self {}) {
 		```
 		#arch: c
 		// Sets the flag and wakes any fiber parked on this task's future, so
@@ -195,12 +187,12 @@ pub mv struct Task<T> : Awaitable {
 		#arch: aarch64
 		// if (self->future) __nomen_future_cancel(self->future);
 		// else if (self->cancel_flag) *(self->cancel_flag) = 1
-		ldr x0, [x19, #40]
+		ldr x0, [x19, #24]
 		cbz x0, .Lcancel_flag_path
 		bl ___nomen_future_cancel
 		b .Lcancel_done
 		.Lcancel_flag_path:
-		ldr x0, [x19, #32]
+		ldr x0, [x19, #16]
 		cbz x0, .Lcancel_done
 		mov x1, #1
 		str x1, [x0]
@@ -393,12 +385,12 @@ pub mv struct Task<T> : Awaitable {
 		```
 		#arch: aarch64
 		// if (self->future) { free an unconsumed string result; release; zero fields }
-		ldr x0, [x19, #40]
+		ldr x0, [x19, #24]
 		cbz x0, .Ldestroy_done
 		// An unconsumed string result: the cell still holds (ptr, len) —
 		// result() zeroes it when it moves the value out. The T_FAT dispatch
 		// folds to a constant branch after monomorphization.
-		ldr x8, [x19, #24]
+		ldr x8, [x19, #8]
 		mov x0, #T_FAT
 		cmp x0, #0
 		b.eq .Ldestroy_nofree
@@ -411,11 +403,11 @@ pub mv struct Task<T> : Awaitable {
 		stp xzr, xzr, [x8]
 		bl _free
 		.Ldestroy_nofree:
-		ldr x0, [x19, #40]
+		ldr x0, [x19, #24]
 		bl ___nomen_future_release
-		str xzr, [x19, #40]
 		str xzr, [x19, #24]
-		str xzr, [x19, #32]
+		str xzr, [x19, #8]
+		str xzr, [x19, #16]
 		.Ldestroy_done:
 		```
 	}

package/core/System/Test.nm

@@ -96,7 +96,7 @@ pub mv struct Tester {
 
 	// (harness) Start timing `name` and clear the per-test state. Called by
 	// the `main` that `nomen test` generates — not by test code.
-	pub func begin_test = (ref self, string name) {
+	pub func begin_test = (ref self { current }, string name) {
 		self.has_failed = false
 		self.passed = 0
 		self.failed = 0
@@ -106,7 +106,7 @@ pub mv struct Tester {
 	}
 
 	// (harness) Close the current test and emit its `done` record.
-	pub func end_test = (ref self) {
+	pub func end_test = (ref self {}) {
 		const uint64 elapsed = Time.now_ns() - self.started
 		Console.write_line(
 			"\\nomen|done|" + self.current + "|\{self.passed}|\{self.failed}|\{elapsed}",
@@ -124,7 +124,7 @@ pub mv struct Tester {
 	 *
 	 *	t.expect(result == 2, "add(1, 1) should be 2")
 	 **/
-	pub func expect = (ref self, bool condition, string message) {
+	pub func expect = (ref self {}, bool condition, string message) {
 		if self.has_failed {
 			return
 		}
@@ -143,7 +143,7 @@ pub mv struct Tester {
 	 *		t.fail("expected to find the key")
 	 *	}
 	 **/
-	pub func fail = (ref self, string message) {
+	pub func fail = (ref self {}, string message) {
 		if self.has_failed {
 			return
 		}
@@ -154,43 +154,43 @@ pub mv struct Tester {
 	//
 	// Nomen has no generic methods, so there is one overload per nullable
 	// type the compiler can compare against `null`.
-	pub func assert = (ref self, int? value, string message) {
+	pub func assert = (ref self {}, int? value, string message) {
 		self.expect(value != null, message)
 	}
 
-	pub func assert = (ref self, uint? value, string message) {
+	pub func assert = (ref self {}, uint? value, string message) {
 		self.expect(value != null, message)
 	}
 
-	pub func assert = (ref self, int64? value, string message) {
+	pub func assert = (ref self {}, int64? value, string message) {
 		self.expect(value != null, message)
 	}
 
-	pub func assert = (ref self, uint64? value, string message) {
+	pub func assert = (ref self {}, uint64? value, string message) {
 		self.expect(value != null, message)
 	}
 
-	pub func assert = (ref self, int8? value, string message) {
+	pub func assert = (ref self {}, int8? value, string message) {
 		self.expect(value != null, message)
 	}
 
-	pub func assert = (ref self, uint8? value, string message) {
+	pub func assert = (ref self {}, uint8? value, string message) {
 		self.expect(value != null, message)
 	}
 
-	pub func assert = (ref self, float? value, string message) {
+	pub func assert = (ref self {}, float? value, string message) {
 		self.expect(value != null, message)
 	}
 
-	pub func assert = (ref self, bool? value, string message) {
+	pub func assert = (ref self {}, bool? value, string message) {
 		self.expect(value != null, message)
 	}
 
-	pub func assert = (ref self, char? value, string message) {
+	pub func assert = (ref self {}, char? value, string message) {
 		self.expect(value != null, message)
 	}
 
-	pub func assert = (ref self, string? value, string message) {
+	pub func assert = (ref self {}, string? value, string message) {
 		self.expect(value != null, message)
 	}
 
@@ -212,7 +212,7 @@ pub mv struct Tester {
 	 * (default 1000, override with `bench_n`) and computes min / median /
 	 * mean / max / stddev over the per-iteration durations.
 	 **/
-	pub func bench = (ref self, string label, func() body) {
+	pub func bench = (ref self { bench_label }, string label, func() body) {
 		if self.has_failed {
 			return
 		}
@@ -226,7 +226,7 @@ pub mv struct Tester {
 	 * for slow functions (where the default 1000 would dominate the suite) or
 	 * for reproducible sample counts.
 	 **/
-	pub func bench_n = (ref self, string label, func() body, int samples) {
+	pub func bench_n = (ref self { bench_label }, string label, func() body, int samples) {
 		if self.has_failed {
 			return
 		}
@@ -244,7 +244,7 @@ pub mv struct Tester {
 	 * this is a no-op.
 	 **/
 	pub func record_bench = (
-		ref self,
+		ref self {},
 		string label,
 		int n,
 		int min,
@@ -263,7 +263,7 @@ pub mv struct Tester {
 		)
 	}
 
-	func record_failure = (ref self, string message) {
+	func record_failure = (ref self {}, string message) {
 		self.failed += 1
 		self.total_failed += 1
 		self.has_failed = true

package/core/System/Text/CharIndex.nm

@@ -51,16 +51,16 @@ pub mv struct CharIndex {
 					chars = chars + 1
 				}
 			} else {
-					if open_at >= 0 {
-						self.runs.push(CharRun(open_at, open_start, open_width, open_count))
-					}
-					open_at = pos
-					open_start = chars
-					open_width = w
-					open_count = 1
-					pos = pos + w
-					chars = chars + 1
+				if open_at >= 0 {
+					self.runs.push(CharRun(open_at, open_start, open_width, open_count))
 				}
+				open_at = pos
+				open_start = chars
+				open_width = w
+				open_count = 1
+				pos = pos + w
+				chars = chars + 1
+			}
 		}
 		if open_at >= 0 {
 			self.runs.push(CharRun(open_at, open_start, open_width, open_count))

package/core/System/Text/Chars.nm

@@ -21,7 +21,7 @@ pub struct Chars {
 
 	// The code point at the cursor, advancing past it. Malformed sequences
 	// yield U+FFFD. Panics when exhausted — check has_next first.
-	pub func next = (ref self, out int) {
+	pub func next = (ref self {}, out int) {
 		if self.byte_pos >= self.source.length {
 			panic("Chars exhausted; check has_next first")
 		}

package/core/System/Text/Json.nm

@@ -5,7 +5,7 @@
 // Integer (de)serialization is handled by int.to_string() and int.parse()
 // (see int.nm), so this struct only deals with JSON strings.
 //
-// `parse` / `stringify` use a JsonTree pool (flat Buffer-backed slot array)
+// `parse` / `stringify` use a JsonTree pool (a flat StableList of nodes)
 // instead of per-node heap allocation, avoiding O(nodes) malloc/free per
 // parse cycle. The caller creates a JsonTree once and resets it per document.
 
@@ -41,8 +41,8 @@ pub struct Json {
 					sb.append_string("\x5cr")
 				}
 			} else {
-					sb.append_char(c)
-				}
+				sb.append_char(c)
+			}
 		}
 		sb.append_char('"')
 		return sb.to_string()
@@ -90,8 +90,8 @@ pub struct Json {
 							sb.append_string("\x5c")
 						}
 					} else {
-							sb.append_char(e)
-						}
+						sb.append_char(e)
+					}
 				}
 			} else {
 				sb.append_char(c)
@@ -102,7 +102,7 @@ pub struct Json {
 
 	// Parse a JSON document into tree. The caller provides a JsonTree pool
 	// which is reset and filled. Returns the index of the root node.
-	pub func parse = (string s, ref JsonTree tree, out int) {
+	pub func parse = (string s, ref JsonTree tree { nodes }, out int) {
 		tree.reset()
 		var pos = Buffer<int>()
 		pos.alloc_int(1)
@@ -112,14 +112,14 @@ pub struct Json {
 	}
 
 	// Serialize a node in the tree back to a JSON string.
-	pub func stringify = (ref JsonTree tree, int root, out string) {
+	pub func stringify = (ref JsonTree tree { nodes }, int root, out string) {
 		var sb = StringBuilder()
 		json_ser_value(ref tree, root, ref sb)
 		return sb.to_string()
 	}
 }
 
-func json_skip_ws = (string s, ref Buffer<int> pos, int len) {
+func json_skip_ws = (string s, ref Buffer<int> pos {}, int len) {
 	while pos.load_int(0) < len {
 		var int i = pos.load_int(0)
 		var int code = s.at(i) as int
@@ -131,54 +131,69 @@ func json_skip_ws = (string s, ref Buffer<int> pos, int len) {
 	}
 }
 
-func json_parse_string = (string s, ref Buffer<int> pos, int len, ref JsonTree tree, out int) {
+func json_parse_string = (string s, ref Buffer<int> pos {}, int len, ref JsonTree tree { nodes }, out int) {
 	var int i = pos.load_int(0)
 	i += 1
 	var sb = StringBuilder()
-	while i < len; i += 1 {
-		var char c = s.at(i)
-		var int code = c as int
-		if code == 34 {
+	while i < len {
+		// Scan-to-next-escape fast path: copy the run of plain bytes in ONE
+		// bulk append instead of a per-byte append_char (each of which pays
+		// the builder's capacity check and length bump).
+		var int run_start = i
+		var int code = 0
+		while i < len {
+			code = s.at(i) as int
+			if code == 34 || code == 92 {
+				break
+			}
 			i += 1
+		}
+		if i > run_start {
+			sb.append_string_view(s.slice(run_start, i))
+		}
+		if i >= len {
 			break
 		}
-		if code == 92 {
+		if code == 34 {
 			i += 1
-			if i < len {
-				var char e = s.at(i)
-				var int ec = e as int
-				switch {
-					case ec == 110 {
-						sb.append_string("\n")
-					}
-					case ec == 116 {
-						sb.append_string("\t")
-					}
-					case ec == 114 {
-						sb.append_string("\r")
-					}
-					case ec == 34 {
-						sb.append_char('"')
-					}
-					case ec == 92 {
-						sb.append_string("\x5c")
-					}
-				} else {
-						sb.append_char(e)
-					}
+			break
+		}
+		// code == 92 — escape sequence: consume the backslash, append the
+		// decoded byte (an unknown escape appends the byte verbatim).
+		i += 1
+		if i < len {
+			var char e = s.at(i)
+			var int ec = e as int
+			switch {
+				case ec == 110 {
+					sb.append_string("\n")
+				}
+				case ec == 116 {
+					sb.append_string("\t")
+				}
+				case ec == 114 {
+					sb.append_string("\r")
+				}
+				case ec == 34 {
+					sb.append_char('"')
+				}
+				case ec == 92 {
+					sb.append_string("\x5c")
+				}
+			} else {
+				sb.append_char(e)
 			}
-		} else {
-			sb.append_char(c)
+			i += 1
 		}
 	}
 	pos.store_int(0, i)
 	var int n = tree.alloc_node()
 	tree.set_kind(n, 3)
-	tree.set_text(n, sb.to_string())
+	tree.take_text(n, ref sb)
 	return n
 }
 
-func json_parse_number = (string s, ref Buffer<int> pos, int len, ref JsonTree tree, out int) {
+func json_parse_number = (string s, ref Buffer<int> pos {}, int len, ref JsonTree tree { nodes }, out int) {
 	var int i = pos.load_int(0)
 	var int start = i
 	while i < len {
@@ -191,17 +206,16 @@ func json_parse_number = (string s, ref Buffer<int> pos, int len, ref JsonTree t
 	}
 	pos.store_int(0, i)
 	var sb = StringBuilder()
-	var int j = start
-	while j < i; j += 1 {
-		sb.append_char(s.at(j))
-	}
+	// One bulk append for the whole run of number bytes (the scan above
+	// already found its end) — no per-byte append_char.
+	sb.append_string_view(s.slice(start, i))
 	var int n = tree.alloc_node()
 	tree.set_kind(n, 2)
-	tree.set_text(n, sb.to_string())
+	tree.take_text(n, ref sb)
 	return n
 }
 
-func json_parse_literal = (string s, ref Buffer<int> pos, int len, ref JsonTree tree, out int) {
+func json_parse_literal = (string s, ref Buffer<int> pos {}, int len, ref JsonTree tree { nodes }, out int) {
 	var int i = pos.load_int(0)
 	var int code = s.at(i) as int
 	var int n = tree.alloc_node()
@@ -216,14 +230,14 @@ func json_parse_literal = (string s, ref Buffer<int> pos, int len, ref JsonTree
 			adv = 5
 		}
 	} else {
-			tree.set_kind(n, 0)
-			adv = 4
-		}
+		tree.set_kind(n, 0)
+		adv = 4
+	}
 	pos.store_int(0, i + adv)
 	return n
 }
 
-func json_parse_value = (string s, ref Buffer<int> pos, int len, ref JsonTree tree, out int) {
+func json_parse_value = (string s, ref Buffer<int> pos {}, int len, ref JsonTree tree { nodes }, out int) {
 	json_skip_ws(s, ref pos, len)
 	var int i = pos.load_int(0)
 	if i >= len {
@@ -253,7 +267,7 @@ func json_parse_value = (string s, ref Buffer<int> pos, int len, ref JsonTree tr
 	return json_parse_number(s, ref pos, len, ref tree)
 }
 
-func json_parse_elements = (string s, ref Buffer<int> pos, int len, ref JsonTree tree, out int) {
+func json_parse_elements = (string s, ref Buffer<int> pos {}, int len, ref JsonTree tree { nodes }, out int) {
 	json_skip_ws(s, ref pos, len)
 	var int i = pos.load_int(0)
 	if i >= len {
@@ -275,7 +289,7 @@ func json_parse_elements = (string s, ref Buffer<int> pos, int len, ref JsonTree
 	return elem
 }
 
-func json_parse_pairs = (string s, ref Buffer<int> pos, int len, ref JsonTree tree, out int) {
+func json_parse_pairs = (string s, ref Buffer<int> pos {}, int len, ref JsonTree tree { nodes }, out int) {
 	json_skip_ws(s, ref pos, len)
 	var int i = pos.load_int(0)
 	if i >= len {
@@ -307,7 +321,7 @@ func json_parse_pairs = (string s, ref Buffer<int> pos, int len, ref JsonTree tr
 	return key
 }
 
-func json_ser_list = (ref JsonTree tree, int first, ref StringBuilder sb) {
+func json_ser_list = (ref JsonTree tree { nodes }, int first, ref StringBuilder sb {}) {
 	json_ser_value(ref tree, first, ref sb)
 	var int next = tree.get_next(first)
 	if next >= 0 {
@@ -316,9 +330,9 @@ func json_ser_list = (ref JsonTree tree, int first, ref StringBuilder sb) {
 	}
 }
 
-func json_ser_pairs = (ref JsonTree tree, int first, ref StringBuilder sb) {
+func json_ser_pairs = (ref JsonTree tree { nodes }, int first, ref StringBuilder sb {}) {
 	sb.append_char('"')
-	sb.append_string(tree.get_text(first))
+	sb.append_string_view(tree.get_text_view(first))
 	sb.append_string("\":")
 	var int v = tree.get_val(first)
 	if v < 0 {
@@ -333,7 +347,7 @@ func json_ser_pairs = (ref JsonTree tree, int first, ref StringBuilder sb) {
 	}
 }
 
-func json_ser_value = (ref JsonTree tree, int n, ref StringBuilder sb) {
+func json_ser_value = (ref JsonTree tree { nodes }, int n, ref StringBuilder sb {}) {
 	var int k = tree.get_kind(n)
 	if k == 0 {
 		sb.append_string("null")
@@ -348,12 +362,12 @@ func json_ser_value = (ref JsonTree tree, int n, ref StringBuilder sb) {
 		return
 	}
 	if k == 2 {
-		sb.append_string(tree.get_text(n))
+		sb.append_string_view(tree.get_text_view(n))
 		return
 	}
 	if k == 3 {
 		sb.append_char('"')
-		sb.append_string(tree.get_text(n))
+		sb.append_string_view(tree.get_text_view(n))
 		sb.append_char('"')
 		return
 	}