nomen-lang 0.0.7 → 0.0.8

package/core/System/Test.nm

@@ -0,0 +1,241 @@
+// The runtime half of `nomen test`.
+//
+// `Tester` is handed to every `pub func <name> = (ref Tester t)` in a
+// `*.test.nm` file by a `main` that the CLI generates. It records assertion
+// results and benchmark statistics, and streams them to stdout as
+// machine-readable records that the CLI parses back and renders.
+//
+// Record grammar — one record per line. Every record begins with the literal
+// prefix "\nomen|" (backslash + "nomen|") so the CLI can recognise it, and its
+// fields are separated by "|":
+//
+//	\nomen|start|<test>
+//	\nomen|fail|<test>|<message>
+//	\nomen|done|<test>|<passed>|<failed>|<ns>
+//	\nomen|bench|<label>|<n>|<min>|<median>|<max>|<mean>|<stddev>
+//
+// A leading backslash was chosen over a control character because the C and
+// aarch64 backends both mis-parse a "\x1f" escape that is immediately followed
+// by an ASCII letter. "|" can still appear inside a <message>, but the CLI
+// only splits fields up to the fixed arity of each record kind, so the
+// message is taken verbatim from the remainder. Anything a test prints that
+// does not start with "\nomen|" is forwarded verbatim and shown beneath the
+// file when it fails.
+//
+// Escaping note: Nomen string escapes pass through to the target language
+// (the C compiler / assembler), which then interpret them. So to emit a
+// LITERAL backslash at runtime the source must write a doubled "\\": a single
+// "\" would have "\n" read as a newline. The record strings below therefore
+// use "\\nomen|", which the backend emits as "\\nomen|" and the C/assembler
+// collapses to the runtime "\nomen|".
+//
+// See TESTING.md for the full design.
+
+/**
+ * Records assertions and benchmarks for one test file.
+ *
+ * A test function receives the tester by mutable reference:
+ *
+ *	import System/Test
+ *
+ *	pub func test_add = (ref Tester t) {
+ *		t.expect(add(1, 1) == 2, "1 + 1 should be 2")
+ *	}
+ *
+ * Once an assertion in a test fails the remaining assertions in that test are
+ * skipped, so a single root cause reports as a single failure. Check
+ * `t.has_failed` to bail out of expensive follow-up work yourself.
+ **/
+pub class Tester {
+	// Has the *current* test recorded a failure? Reset by `begin_test`.
+	pub var bool has_failed = false
+
+	// Assertion tallies for the current test.
+	var int passed = 0
+	var int failed = 0
+
+	// Tallies for the whole file, so `done` records stay per-test while the
+	// process still knows whether anything failed overall.
+	var int total_failed = 0
+
+	var string current = ""
+	var uint64 started = 0
+
+	// Benchmark capture state. `bench`/`bench_n` record the label and sample
+	// count here; the `nomen test` harness reads them after running the test
+	// function and drives the actual timing loop (Nomen can't store or call a
+	// function pointer, so the harness measures `bench_fn` itself). `bench_fn`
+	// is reconstructed by the harness from the call site, not stored here.
+	var bool bench_pending = false
+	var string bench_label = ""
+	var int bench_samples = 1000
+
+	// (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) {
+		self.has_failed = false
+		self.passed = 0
+		self.failed = 0
+		self.current = name
+		Console.write_line("\\nomen|start|" + name)
+		self.started = Time.now_ns()
+	}
+
+	// (harness) Close the current test and emit its `done` record.
+	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}",
+		)
+	}
+
+	// (harness) Did anything in this file fail?
+	pub func any_failed = (self, out bool) {
+		return self.total_failed > 0
+	}
+
+	/**
+	 * Record a passing or failing assertion. Does nothing once the current
+	 * test has already failed.
+	 *
+	 *	t.expect(result == 2, "add(1, 1) should be 2")
+	 **/
+	pub func expect = (ref self, bool condition, string message) {
+		if self.has_failed {
+			return
+		}
+		if condition {
+			self.passed += 1
+			return
+		}
+		self.record_failure(message)
+	}
+
+	/**
+	 * Record an unconditional failure. Useful for branches that should be
+	 * unreachable.
+	 *
+	 *	if !found {
+	 *		t.fail("expected to find the key")
+	 *	}
+	 **/
+	pub func fail = (ref self, string message) {
+		if self.has_failed {
+			return
+		}
+		self.record_failure(message)
+	}
+
+	// Assert that a nullable value holds a value.
+	//
+	// Nomen has no generic methods, so there is one overload per nullable
+	// type the compiler can compare against `null`. Nullable *struct* values
+	// (`Point?`) are not supported by the backend yet — use
+	// `t.expect(p != null, "...")` once that gap closes.
+	pub func assert = (ref self, int? value, string message) {
+		self.expect(value != null, message)
+	}
+
+	pub func assert = (ref self, uint? value, string message) {
+		self.expect(value != null, message)
+	}
+
+	pub func assert = (ref self, int64? value, string message) {
+		self.expect(value != null, message)
+	}
+
+	pub func assert = (ref self, uint64? value, string message) {
+		self.expect(value != null, message)
+	}
+
+	pub func assert = (ref self, int8? value, string message) {
+		self.expect(value != null, message)
+	}
+
+	pub func assert = (ref self, uint8? value, string message) {
+		self.expect(value != null, message)
+	}
+
+	pub func assert = (ref self, float? value, string message) {
+		self.expect(value != null, message)
+	}
+
+	pub func assert = (ref self, bool? value, string message) {
+		self.expect(value != null, message)
+	}
+
+	pub func assert = (ref self, char? value, string message) {
+		self.expect(value != null, message)
+	}
+
+	pub func assert = (ref self, string? value, string message) {
+		self.expect(value != null, message)
+	}
+
+	/**
+	 * Register a benchmark. The timing itself is run by the `nomen test`
+	 * harness — Nomen cannot call a function pointer from a parameter (the C
+	 * backend has no way to emit it), so `bench` only *captures* the function
+	 * and the harness measures it and reports the result via `record_bench`.
+	 *
+	 *	func add_once = () {
+	 *		const _ = add(1, 1)
+	 *	}
+	 *
+	 *	pub func bench_add = (ref Tester t) {
+	 *		t.bench("add", add_once)
+	 *	}
+	 *
+	 * The harness warms up, then runs the function `t.bench_samples` times
+	 * (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) {
+		if self.has_failed {
+			return
+		}
+		self.bench_pending = true
+		self.bench_label = label
+		self.bench_samples = 1000
+	}
+
+	/**
+	 * Like `bench`, but the harness runs exactly `samples` iterations. Use it
+	 * 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) {
+		if self.has_failed {
+			return
+		}
+		self.bench_pending = true
+		self.bench_label = label
+		self.bench_samples = samples
+	}
+
+	/**
+	 * Emit a benchmark record. Called by the `nomen test` harness after it
+	 * has measured `bench_fn` itself — durations are nanoseconds and the
+	 * harness passes the summary statistics it computed.
+	 *
+	 * If a test has already recorded a failure, benchmarks are skipped and
+	 * this is a no-op.
+	 **/
+	pub func record_bench = (ref self, string label, int n, int min, int median, int max, float mean, float stddev) {
+		if self.has_failed {
+			return
+		}
+		Console.write_line(
+			"\\nomen|bench|" +
+				label +
+				"|\{n}|\{min}|\{median}|\{max}|\{mean}|\{stddev}",
+		)
+	}
+
+	func record_failure = (ref self, string message) {
+		self.failed += 1
+		self.total_failed += 1
+		self.has_failed = true
+		Console.write_line("\\nomen|fail|" + self.current + "|" + message)
+	}
+}

package/core/System/Text/Json.nm

@@ -0,0 +1,377 @@
+// JSON serialize / deserialize for Nomen string values, written in pure Nomen.
+//
+// `serialize` quotes and escapes a string into a JSON string literal;
+// `deserialize` parses a JSON string literal back into the raw value.
+// 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)
+// 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.
+
+/**
+ * JSON serialization helpers — `serialize`/`deserialize` strings, `parse`/`stringify` via a JsonTree
+ **/
+pub struct Json {
+	// Serialize a string to a JSON string literal, escaping the special
+	// characters ", \, newline, tab and carriage return.
+	pub func serialize = (string value, out string) {
+		var sb = StringBuilder()
+		sb.append_char('"')
+		var i = 0
+		var int len = value.length
+		while i < len; i += 1 {
+			var char c = value.at(i)
+			var int code = c as int
+			switch {
+				case code == 34 {
+					sb.append_string("\x5c\"")
+				}
+				case code == 92 {
+					sb.append_string("\x5c\x5c")
+				}
+				case code == 10 {
+					sb.append_string("\x5cn")
+				}
+				case code == 9 {
+					sb.append_string("\x5ct")
+				}
+				case code == 13 {
+					sb.append_string("\x5cr")
+				}
+				else {
+					sb.append_char(c)
+				}
+			}
+		}
+		sb.append_char('"')
+		return sb.to_string()
+	}
+
+	// Deserialize a JSON string literal to the raw, unescaped value.
+	pub func deserialize = (string json, out string) {
+		var sb = StringBuilder()
+		var int len = json.length
+		var i = 0
+		// skip up to the opening quote
+		while i < len; i += 1 {
+			if (json.at(i) as int) == 34 {
+				i += 1
+				break
+			}
+		}
+		// read until the unescaped closing quote, unescaping as we go
+		while i < len; i += 1 {
+			var char c = json.at(i)
+			var int code = c as int
+			if code == 34 {
+				break
+			}
+			if code == 92 {
+				i += 1
+				if i < len {
+					var char e = json.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)
+			}
+		}
+		return sb.to_string()
+	}
+
+	// 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) {
+		tree.reset()
+		var pos = Buffer<int>()
+		pos.alloc_int(1)
+		pos.store_int(0, 0)
+		var int len = s.length
+		return json_parse_value(s, ref pos, len, ref tree)
+	}
+
+	// Serialize a node in the tree back to a JSON string.
+	pub func stringify = (ref JsonTree tree, 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) {
+	while pos.load_int(0) < len {
+		var int i = pos.load_int(0)
+		var int code = s.at(i) as int
+		if code == 32 || code == 9 || code == 10 || code == 13 {
+			pos.store_int(0, i + 1)
+		} else {
+			return
+		}
+	}
+}
+
+func json_parse_string = (string s, ref Buffer<int> pos, int len, ref JsonTree tree, 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 {
+			i += 1
+			break
+		}
+		if code == 92 {
+			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)
+		}
+	}
+	pos.store_int(0, i)
+	var int n = tree.alloc_node()
+	tree.set_kind(n, 3)
+	tree.set_text(n, sb.to_string())
+	return n
+}
+
+func json_parse_number = (string s, ref Buffer<int> pos, int len, ref JsonTree tree, out int) {
+	var int i = pos.load_int(0)
+	var int start = i
+	while i < len {
+		var int code = s.at(i) as int
+		if code == 45 || code == 43 || code == 46 || code == 101 || code == 69 || (code >= 48 && code <= 57) {
+			i += 1
+		} else {
+			break
+		}
+	}
+	pos.store_int(0, i)
+	var sb = StringBuilder()
+	var int j = start
+	while j < i; j += 1 {
+		sb.append_char(s.at(j))
+	}
+	var int n = tree.alloc_node()
+	tree.set_kind(n, 2)
+	tree.set_text(n, sb.to_string())
+	return n
+}
+
+func json_parse_literal = (string s, ref Buffer<int> pos, int len, ref JsonTree tree, out int) {
+	var int i = pos.load_int(0)
+	var int code = s.at(i) as int
+	var int n = tree.alloc_node()
+	var adv = 4
+	switch {
+		case code == 116 {
+			tree.set_kind(n, 1)
+			adv = 4
+		}
+		case code == 102 {
+			tree.set_kind(n, 6)
+			adv = 5
+		}
+		else {
+			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) {
+	json_skip_ws(s, ref pos, len)
+	var int i = pos.load_int(0)
+	if i >= len {
+		return tree.alloc_node()
+	}
+	var int code = s.at(i) as int
+	if code == 123 {
+		pos.store_int(0, i + 1)
+		var int n = tree.alloc_node()
+		tree.set_kind(n, 5)
+		tree.set_child(n, json_parse_pairs(s, ref pos, len, ref tree))
+		return n
+	}
+	if code == 91 {
+		pos.store_int(0, i + 1)
+		var int n = tree.alloc_node()
+		tree.set_kind(n, 4)
+		tree.set_child(n, json_parse_elements(s, ref pos, len, ref tree))
+		return n
+	}
+	if code == 34 {
+		return json_parse_string(s, ref pos, len, ref tree)
+	}
+	if code == 116 || code == 102 || code == 110 {
+		return json_parse_literal(s, ref pos, len, ref tree)
+	}
+	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) {
+	json_skip_ws(s, ref pos, len)
+	var int i = pos.load_int(0)
+	if i >= len {
+		return -1
+	}
+	if (s.at(i) as int) == 93 {
+		pos.store_int(0, i + 1)
+		return -1
+	}
+	var int elem = json_parse_value(s, ref pos, len, ref tree)
+	json_skip_ws(s, ref pos, len)
+	var int i2 = pos.load_int(0)
+	if i2 < len {
+		if (s.at(i2) as int) == 44 {
+			pos.store_int(0, i2 + 1)
+		}
+	}
+	tree.set_next(elem, json_parse_elements(s, ref pos, len, ref tree))
+	return elem
+}
+
+func json_parse_pairs = (string s, ref Buffer<int> pos, int len, ref JsonTree tree, out int) {
+	json_skip_ws(s, ref pos, len)
+	var int i = pos.load_int(0)
+	if i >= len {
+		return -1
+	}
+	if (s.at(i) as int) == 125 {
+		pos.store_int(0, i + 1)
+		return -1
+	}
+	json_skip_ws(s, ref pos, len)
+	var int key = json_parse_string(s, ref pos, len, ref tree)
+	json_skip_ws(s, ref pos, len)
+	var int i2 = pos.load_int(0)
+	if i2 < len {
+		if (s.at(i2) as int) == 58 {
+			pos.store_int(0, i2 + 1)
+		}
+	}
+	var int v = json_parse_value(s, ref pos, len, ref tree)
+	tree.set_val(key, v)
+	json_skip_ws(s, ref pos, len)
+	var int i3 = pos.load_int(0)
+	if i3 < len {
+		if (s.at(i3) as int) == 44 {
+			pos.store_int(0, i3 + 1)
+		}
+	}
+	tree.set_next(key, json_parse_pairs(s, ref pos, len, ref tree))
+	return key
+}
+
+func json_ser_list = (ref JsonTree tree, int first, ref StringBuilder sb) {
+	json_ser_value(ref tree, first, ref sb)
+	var int next = tree.get_next(first)
+	if next >= 0 {
+		sb.append_char(',')
+		json_ser_list(ref tree, next, ref sb)
+	}
+}
+
+func json_ser_pairs = (ref JsonTree tree, int first, ref StringBuilder sb) {
+	sb.append_char('"')
+	sb.append_string(tree.get_text(first))
+	sb.append_string("\":")
+	var int v = tree.get_val(first)
+	if v < 0 {
+		sb.append_string("null")
+	} else {
+		json_ser_value(ref tree, v, ref sb)
+	}
+	var int next = tree.get_next(first)
+	if next >= 0 {
+		sb.append_char(',')
+		json_ser_pairs(ref tree, next, ref sb)
+	}
+}
+
+func json_ser_value = (ref JsonTree tree, int n, ref StringBuilder sb) {
+	var int k = tree.get_kind(n)
+	if k == 0 {
+		sb.append_string("null")
+		return
+	}
+	if k == 1 {
+		sb.append_string("true")
+		return
+	}
+	if k == 6 {
+		sb.append_string("false")
+		return
+	}
+	if k == 2 {
+		sb.append_string(tree.get_text(n))
+		return
+	}
+	if k == 3 {
+		sb.append_char('"')
+		sb.append_string(tree.get_text(n))
+		sb.append_char('"')
+		return
+	}
+	if k == 4 {
+		sb.append_char('[')
+		var int child = tree.get_child(n)
+		if child >= 0 {
+			json_ser_list(ref tree, child, ref sb)
+		}
+		sb.append_char(']')
+		return
+	}
+	sb.append_char('{')
+	var int child = tree.get_child(n)
+	if child >= 0 {
+		json_ser_pairs(ref tree, child, ref sb)
+	}
+	sb.append_char('}')
+}