nomen-lang 0.6.7 → 0.6.9

package/NOMEN_AGENTS.md

@@ -219,9 +219,9 @@ Special function names: `#init` (constructor), `#destroy` (auto-raii destructor)
 
 ```nomen
 if cond { ... }
-switch x {
-	0 { ... }
-	1 { ... }
+switch {
+	case x == 0 { ... }
+	case x == 1 { ... }
 	else { ... }
 }
 for i of 0 .. 10 { ... }       // exclusive range
@@ -280,6 +280,15 @@ const typed = Array<int>(1, 2, 3)
 for n of nums { Console.write("\{n}\n") }
 ```
 
+### Compile-time embedding
+
+```nomen
+const corpus = #embed_file("bench/full-markdown.md")   // string literal of the
+                                                        // file's contents; path
+                                                        // resolves from the
+                                                        // package root
+```
+
 ## Reference
 
 - Full language spec: [SPEC.md](https://github.com/andrewjk/nomen/blob/main/SPEC.md)

package/audit_runtime.c

@@ -0,0 +1,50 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// Atomic: worker threads from the pool malloc/free concurrently, and a
+// plain `long` would lose updates under that contention (showing up as
+// spurious LEAK/negative-count failures in tests that use spawns).
+static volatile long nomen_malloc_count = 0;
+
+void *nomen_malloc_wrap(unsigned long size) {
+	void *ptr = malloc(size);
+	__atomic_add_fetch(&nomen_malloc_count, 1, __ATOMIC_SEQ_CST);
+	return ptr;
+}
+
+void *nomen_calloc_wrap(unsigned long count, unsigned long size) {
+	void *ptr = calloc(count, size);
+	__atomic_add_fetch(&nomen_malloc_count, 1, __ATOMIC_SEQ_CST);
+	return ptr;
+}
+
+void *nomen_realloc_wrap(void *old_ptr, unsigned long size) {
+	if (!old_ptr) {
+		__atomic_add_fetch(&nomen_malloc_count, 1, __ATOMIC_SEQ_CST);
+	}
+	void *ptr = realloc(old_ptr, size);
+	return ptr;
+}
+
+void nomen_free_wrap(void *ptr) {
+	if (ptr) {
+		free(ptr);
+		__atomic_sub_fetch(&nomen_malloc_count, 1, __ATOMIC_SEQ_CST);
+	}
+}
+
+void *nomen_strdup_wrap(const char *s) {
+	unsigned long len = strlen(s) + 1;
+	void *ptr = malloc(len);
+	if (ptr) memcpy(ptr, s, len);
+	__atomic_add_fetch(&nomen_malloc_count, 1, __ATOMIC_SEQ_CST);
+	return ptr;
+}
+
+void nomen_audit_check(void) {
+	long count = __atomic_load_n(&nomen_malloc_count, __ATOMIC_SEQ_CST);
+	if (count != 0) {
+		printf("LEAK: %ld allocation(s)\n", count);
+	}
+}

package/core/System/Buffer.nm

@@ -510,6 +510,17 @@ pub struct Buffer<T> {
 		```
 	}
 
+	// Move-taking write, mirroring `List.set`: the caller's value is
+	// consumed and an independent copy is installed in the slot (replace
+	// deep-copies owning elements). The owning entry point a caller uses
+	// when it wants to hand over a value — `replace`'s by-value parameter
+	// cannot accept the `move` 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, move T value) {
+		self.replace(i, value)
+	}
+
 	// 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
@@ -620,6 +631,33 @@ pub struct Buffer<T> {
 		memset(self.data, 0, len * T_SIZE)
 	}
 
+	// An independent copy: fresh slab, per-element deep copies. Each slot
+	// round-trips load→replace through a local, so owning element types get
+	// the same treatment a List<T>.copy slot does (the load materializes an
+	// owned copy, replace gives the destination its own). Class elements
+	// never reach this body (a `Buffer<T>` with T a class monomorphizes to
+	// `ClassBuffer<T>`, which has no copy).
+	pub func copy = (self, out Buffer<T>: out.cap == self.cap) {
+		var dst = Buffer<T>()
+		if self.cap > 0 {
+			dst.alloc(self.cap)
+			var i = 0
+			while i < self.cap {
+				// Bind the loaded element and hand it to `set` (move): for a
+				// string element load returns a BORROW of the source slot, and
+				// the move transfers it into the write without a scope-exit
+				// reclaim (which would free the source's buffer); for an owning
+				// struct element load returns an owned copy that transfers the
+				// same way. Mirrors List.copy's `var T v = self.at(i)` +
+				// `dst.push(v)`.
+				var T v = self.load(i)
+				dst.set(i, v)
+				i += 1
+			}
+		}
+		return dst
+	}
+
 	internal inline func store_or_int = (ref self, int i: i >= 0 && i < self.cap, int val) {
 		```
 		#arch: c

package/core/System/StringBuilder.nm

@@ -241,7 +241,10 @@ pub struct StringBuilder {
 	}
 
 	// Finalize: null-terminate, return the byte buffer as a string, and
-	// release ownership (sets `data` to 0 so the destructor won't free it).
+	// release ownership (sets `data` to 0 so the destructor won't free it,
+	// and resets `len`/`cap` so the builder is a valid empty builder again —
+	// a stale `cap` would let a later append skip the grow and memcpy to a
+	// null buffer). Reuse after `to_string` yields a fresh builder.
 	// Explicitly `pub`: struct members default to pub, but this is the
 	// builder's primary read-back — the contract should not depend on the
 	// default.
@@ -260,6 +263,8 @@ pub struct StringBuilder {
 		((unsigned char*)(unsigned long long)self->data)[idx] = 0;
 		unsigned long long result = self->data;
 		self->data = 0;
+		self->len = 0;
+		self->cap = 0;
 		return (nomen_string){ (char*)result, (long)idx };
 		```
 		```
@@ -290,6 +295,10 @@ pub struct StringBuilder {
 		strb wzr, [x0, x1]        // data[len] = 0
 		// transfer ownership: clear self->data. x0 retains the old ptr.
 		str xzr, [x19, #8]
+		// reset the stale bookkeeping so reuse yields a valid empty builder
+		// (a stale cap would skip the append's grow against the null buffer)
+		str xzr, [x19, #16]
+		str xzr, [x19, #24]
 		// Fat-string ABI: (x0 = data, x1 = len) is already the return pair.
 		```
 	}