core: set! mutates topmost dynamic binding instead of being a no-op

set! was defined as a no-op macro on the theory that it was just a
JVM compiler directive. But Clojure's set! does double duty: on the
JVM it mutates fields (irrelevant to mino), and on dynamic vars it
mutates the thread-local binding frame inside an enclosing binding.
The latter shape is portable Clojure code that mino was silently
ignoring -- counters built on (binding [*c* 0] (set! *c* (inc *c*)))
stayed at 0.

Added prim_set_dyn_binding (set-dyn-binding!) which walks ctx->dyn_
stack, finds the topmost binding for the named symbol, mutates its
val, and returns the new value. Throws "Can't change/establish root
binding" when no binding frame is active for the name, matching JVM
Clojure's runtime contract. set! macro now expands to a
set-dyn-binding! call with a quoted target symbol.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: leifericf

CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## v0.255.23 — Fix: `set!` mutates dynamic-var bindings (was no-op)
+
+`set!` used to be a no-op macro: `(set! *x* 5)` returned `nil` and
+left `*x*` unchanged, even inside a `(binding [*x* 0] ...)` form.
+The comment called it "a JVM compiler directive, not applicable to
+mino", which is half-true (`set!` does double duty in JVM Clojure:
+field mutation on the JVM side, *and* thread-local dynamic-var
+binding mutation). The dynamic-var shape is portable code that
+mino was silently ignoring.
+
+Now: `(set! *x* expr)` calls the new `set-dyn-binding!` C primitive
+which walks `ctx->dyn_stack`, finds the topmost binding for the
+symbol, mutates its `val`, and returns the new value. With no
+active binding frame for the named var, throws
+`Can't change/establish root binding of: *name* with set!` —
+matches JVM Clojure's runtime contract.
+
+The JVM-only field-mutation shape `(set! (.-field obj) val)` is not
+supported; mino has no JVM fields. Pre-existing Clojure code that
+relied on the old no-op behavior to silently swallow
+`(set! *warn-on-reflection* true)` now needs to wrap such calls in
+`try/catch` (or just delete them, since they had no effect anyway).
+Per `[[alpha-no-backwards-compat]]`, this contract change is acceptable.
+
+Regression in `tests/compat_test.clj`
+(`set-bang-mutates-dynamic-binding`).
+
 ## v0.255.22 — Fix: Regex engine now parses `{n}` / `{n,m}` / `{n,}` quantifiers
 
 The vendored regex engine recognized `*`, `+`, `?` quantifiers but

src/core.clj

@@ -1004,8 +1004,18 @@
     `(let [~@pairs] ~@body)))
 
 (defmacro set!
-  "No-op. JVM compiler directive, not applicable to mino."
-  [& _] nil)
+  "Mutates a thread-local dynamic-var binding to the given value.
+   The target must be a dynamic var with an enclosing (binding ...)
+   form on the call stack; without one, throws \"Can't
+   change/establish root binding\". Matches Clojure JVM's contract
+   for set! on Vars. Returns the new value.
+
+   The JVM-only field-mutation shape (set! (.-field obj) val) is not
+   supported -- mino has no JVM fields."
+  [target value]
+  (when-not (symbol? target)
+    (throw "set!: first argument must be a symbol naming a dynamic var"))
+  (list 'set-dyn-binding! (list 'quote target) value))
 
 (defmacro comment "Ignores body, returns nil." [& body] nil)
 

src/mino.h

@@ -28,7 +28,7 @@
  */
 #define MINO_VERSION_MAJOR 0
 #define MINO_VERSION_MINOR 255
-#define MINO_VERSION_PATCH 22
+#define MINO_VERSION_PATCH 23
 
 /*
  * Human-readable version string of the *linked* runtime, e.g. "0.48.0".

src/prim/stateful.c

@@ -625,6 +625,50 @@ mino_val_t *prim_get_thread_bindings(mino_state_t *S, mino_val_t *args,
     return mino_snapshot_thread_bindings(S);
 }
 
+/* (set-dyn-binding! 'name value) -- mutate the topmost active dynamic
+ * binding for `name` to `value`. Returns the new value. Throws when
+ * there is no active binding frame for the name (matches Clojure's
+ * contract: set! on a dynamic var without an enclosing binding form
+ * raises "Can't change/establish root binding"). Used by the
+ * (set! *var* expr) macro to back the JVM-Clojure dynamic-var mutation
+ * shape. */
+mino_val_t *prim_set_dyn_binding(mino_state_t *S, mino_val_t *args,
+                                 mino_env_t *env)
+{
+    mino_val_t    *name_sym;
+    mino_val_t    *new_val;
+    const char    *name;
+    dyn_frame_t   *f;
+    dyn_binding_t *b;
+    (void)env;
+    if (!mino_is_cons(args) || !mino_is_cons(args->as.cons.cdr)
+        || mino_is_cons(args->as.cons.cdr->as.cons.cdr)) {
+        return prim_throw_classified(S, "eval/arity", "MAR001",
+            "set-dyn-binding! requires two arguments: name value");
+    }
+    name_sym = args->as.cons.car;
+    new_val  = args->as.cons.cdr->as.cons.car;
+    if (name_sym == NULL || mino_type_of(name_sym) != MINO_SYMBOL) {
+        return prim_throw_classified(S, "eval/type", "MTY001",
+            "set-dyn-binding!: first argument must be a symbol");
+    }
+    name = name_sym->as.s.data;
+    for (f = mino_current_ctx(S)->dyn_stack; f != NULL; f = f->prev) {
+        for (b = f->bindings; b != NULL; b = b->next) {
+            if (strcmp(b->name, name) == 0) {
+                b->val = new_val;
+                return new_val;
+            }
+        }
+    }
+    {
+        char msg[256];
+        snprintf(msg, sizeof(msg),
+            "Can't change/establish root binding of: %s with set!", name);
+        return prim_throw_classified(S, "eval/contract", "MCT001", msg);
+    }
+}
+
 /* (with-bindings* bindings-map fn) -- pushes a fresh dynamic-binding
  * frame from the map's entries (symbol-or-string keys), invokes fn
  * with no arguments, pops the frame, and returns the result. Used by
@@ -994,6 +1038,8 @@ const mino_prim_def k_prims_stateful[] = {
      "Returns a map of symbol->value for the active dynamic bindings, or nil if no binding frames are active."},
     {"with-bindings*", prim_with_bindings_star,
      "(with-bindings* bindings-map fn) — pushes the bindings as a dynamic frame and invokes fn with no args."},
+    {"set-dyn-binding!", prim_set_dyn_binding,
+     "(set-dyn-binding! 'name value) — mutate the topmost active dynamic binding for `name`. Returns the value. Throws when no binding frame is active for `name`. Backs (set! *var* expr)."},
     {"set-fail-alloc-at!", prim_set_fail_alloc_at,
      "Make the n-th GC allocation fail (simulated OOM). Pass 0 to disable."},
     {"mino-thread-limit", prim_mino_thread_limit,

tests/compat_test.clj

@@ -266,11 +266,33 @@
   (testing "second defonce does not overwrite"
     (is (= 42 compat-defonce-val))))
 
-;; --- set! no-op ---
-
-(deftest set-bang-noop
-  (testing "set! is a no-op that returns nil"
-    (is (nil? (set! *warn-on-reflection* true)))))
+;; --- set! on dynamic vars ---
+;;
+;; mino used to make set! a no-op so JVM-Clojure code that pokes
+;; *warn-on-reflection* etc. would load without erroring. That hid
+;; the legitimate set!-on-bound-dynamic-var contract: real Clojure
+;; mutates the thread-local binding frame, and code that needs to
+;; bump a counter or stash a value inside binding relies on it.
+;; Now set! mutates the topmost dyn frame when one exists, and
+;; throws "Can't change/establish root binding" when no binding
+;; frame is active -- matching JVM Clojure's runtime contract.
+
+(deftest set-bang-mutates-dynamic-binding
+  (testing "set! mutates the topmost binding frame"
+    (def ^:dynamic *set-bang-test* 0)
+    (binding [*set-bang-test* 0]
+      (is (= 1 (set! *set-bang-test* 1)))
+      (is (= 1 *set-bang-test*))
+      (set! *set-bang-test* 99)
+      (is (= 99 *set-bang-test*))))
+  (testing "set! on dynamic var without binding form throws"
+    (def ^:dynamic *set-bang-unbound* 0)
+    (is (thrown? (set! *set-bang-unbound* 5))))
+  (testing "set!-style increment inside binding"
+    (def ^:dynamic *counter* 0)
+    (binding [*counter* 0]
+      (dotimes [_ 5] (set! *counter* (inc *counter*)))
+      (is (= 5 *counter*)))))
 
 ;; --- random-uuid ---