errors: unresolved symbols error with Clojure's message (jolt-2o7.3)

A typo'd symbol used to auto-intern an unbound var and die later as
'Cannot call nil as a function' with no hint which symbol. Now:

    $ jolt -e '(undefined-fn 1)'
    Error: Unable to resolve symbol: undefined-fn in this context

The analyzer's :unresolved fallthrough now punts to the interpreter
(whose resolver raises the message above when the form runs) instead of
emitting a var-ref that interned the var. A punt rather than a hard
throw because runtime-interning forms (defmulti's setup) legitimately
reference the var they're about to create from a nested do.

Pulling that thread surfaced three real bugs the leniency was masking:

- h-resolve-global resolved unqualified symbols against ctx-current-ns,
  which during analysis is jolt.analyzer — so user-ns vars NEVER
  resolved through it; the lenient arm happened to emit the right ns.
  Now resolves against the compile ns like the qualified branch.
- Top-level (do ...) wasn't split: Clojure compiles and EVALS each
  child in sequence so earlier children's runtime effects (defmulti's
  intern) are visible while later children compile. eval-toplevel now
  splits.
- The stdlib itself had forward references the auto-intern hid:
  10-seq's transducers used vreset!/vswap! from 20-coll (moved to
  10-seq); in 20-coll qualified-ident?/realized?/list*/underive
  referenced defs declared later in the file (reordered); sorted? and
  partition-all are genuinely later-tier and got (declare ...).

Test rows updated where they encoded the old leniency: ir-passes'
dead-branch row (unresolved in a dead branch is an error, as in
Clojure), compile-mode's ctx-isolation row (other ctx now errors
instead of reading nil), cli rows assert the new message. Gate green,
conformance 335/335 x3, suite 4718 steady, bench within noise.

jolt-core/clojure/core/10-seq.clj

@@ -8,6 +8,14 @@
 ;; self-hosted compiler (jolt-core/jolt/*.clj). Compiler-facing structural fns go
 ;; in the kernel tier (00-kernel) instead — see its header.
 
+;; Volatiles (moved up from 20-coll: this tier's transducers use them, and the
+;; analyzer now ERRORS on unresolved forward references — jolt-2o7.3). The
+;; constructor (volatile!) stays native; these are pure over ref-put!/get.
+(defn vreset! [vol newval]
+  (jolt.host/ref-put! vol :val newval) newval)
+(defn vswap! [vol f & args]
+  (vreset! vol (apply f (get vol :val) args)))
+
 (defn ffirst [coll] (first (first coll)))
 (defn nfirst [coll] (next (first coll)))
 (defn fnext  [coll] (first (next coll)))

jolt-core/clojure/core/20-coll.clj

@@ -7,6 +7,8 @@
 ;; internal Janet callers, not used by the self-hosted compiler.
 
 ;; Tiny leaves first — fns below in this tier (and 25-sorted) use them.
+(defn some? [x] (not (nil? x)))
+
 (defn identity [x] x)
 
 (defn constantly [x] (fn [& args] x))
@@ -130,6 +132,11 @@
 
 (defn split-with [pred coll] [(take-while pred coll) (drop-while pred coll)])
 
+(defn qualified-keyword? [x] (and (keyword? x) (some? (namespace x))))
+(defn simple-keyword? [x] (and (keyword? x) (nil? (namespace x))))
+(defn qualified-symbol? [x] (and (symbol? x) (some? (namespace x))))
+(defn simple-symbol? [x] (and (symbol? x) (nil? (namespace x))))
+
 (defn ident? [x] (or (keyword? x) (symbol? x)))
 
 (defn qualified-ident? [x] (or (qualified-symbol? x) (qualified-keyword? x)))
@@ -234,10 +241,8 @@
 (defn thread-bound? [& vars]
   (every? (fn [v] (__thread-bound? v)) vars))
 
-;; file-seq: the tree of paths under root (root included), directories walked
-;; via the host dir primitives. Paths (strings), not File objects.
-(defn file-seq [root]
-  (tree-seq __dir? __list-dir root))
+(defn key [e] (if (map-entry? e) (nth e 0) (throw (ex-info "key requires a map entry" {}))))
+(defn val [e] (if (map-entry? e) (nth e 1) (throw (ex-info "val requires a map entry" {}))))
 
 ;; --- Ad-hoc hierarchies (stage 3) — Clojure's canonical pure-map port. -----
 ;; A hierarchy is {:parents {tag #{parents}} :ancestors {tag #{all}} 
@@ -322,6 +327,10 @@
 (defn counted? [x]
   (or (vector? x) (map? x) (set? x) (list? x) (string? x)))
 (defn indexed? [x] (vector? x))
+;; sorted? is defined by the next tier (25-sorted) — declared here so this
+;; tier compiles (forward references are analysis errors now, jolt-2o7.3).
+(declare sorted?)
+
 (defn reversible? [x] (or (vector? x) (sorted? x)))
 (defn seqable? [x]
   (or (nil? x) (coll? x) (string? x)))
@@ -331,10 +340,8 @@
 (defn float? [x] (double? x))
 (defn infinite? [x] (and (number? x) (or (= x ##Inf) (= x ##-Inf))))
 
-(defn qualified-keyword? [x] (and (keyword? x) (some? (namespace x))))
-(defn simple-keyword? [x] (and (keyword? x) (nil? (namespace x))))
-(defn qualified-symbol? [x] (and (symbol? x) (some? (namespace x))))
-(defn simple-symbol? [x] (and (symbol? x) (nil? (namespace x))))
+;; qualified-/simple- keyword?/symbol? moved above qualified-ident? (forward
+;; references are analysis errors now — jolt-2o7.3).
 
 ;; find: the map entry [k v] when k is present (nil values included), nil
 ;; otherwise. contains? gives vectors-by-index for free, matching Clojure.
@@ -342,6 +349,19 @@
   (when (contains? m k) [k (get m k)]))
 
 ;; realized?: defined on the pending types only (delay/lazy-seq/future read
+;; Tagged-value predicates. The constructors (atom/volatile!/...) stay in Janet,
+;; but every tagged value carries its kind under :jolt/type (records under
+;; :jolt/deftype), reachable via get — which is nil on non-tables — so the
+;; predicates are pure over get and move out of the seed.
+(defn atom? [x]               (= (get x :jolt/type) :jolt/atom))
+(defn volatile? [x]           (= (get x :jolt/type) :jolt/volatile))
+(defn reader-conditional? [x] (= (get x :jolt/type) :jolt/reader-conditional))
+(defn tagged-literal? [x]     (= (get x :jolt/type) :jolt/tagged-literal))
+(defn record? [x]             (some? (get x :jolt/deftype)))
+(defn uuid? [x]               (= (get x :jolt/type) :jolt/uuid))
+(defn inst? [x]               (= (get x :jolt/type) :jolt/inst))
+(defn char? [x]               (= (get x :jolt/type) :jolt/char))
+
 ;; their realization slot; promises/atoms always-realized), error otherwise.
 (defn realized? [x]
   (cond
@@ -379,6 +399,14 @@
   ([coll] (dorun coll) coll)
   ([n coll] (dorun n coll) coll))
 
+;; spread: (spread [1 2 [3 4]]) => (1 2 3 4) — list*'s variadic helper
+;; (private in Clojure).
+(defn- spread [arglist]
+  (cond
+    (nil? arglist) nil
+    (nil? (next arglist)) (seq (first arglist))
+    :else (cons (first arglist) (spread (next arglist)))))
+
 ;; list*: cons the leading args onto the final seq argument.
 (defn list*
   ([args] (seq args))
@@ -388,14 +416,6 @@
   ([a b c d & more]
    (cons a (cons b (cons c (cons d (spread more)))))))
 
-;; spread: (spread [1 2 [3 4]]) => (1 2 3 4) — list*'s variadic helper
-;; (private in Clojure; defined after use is fine, vars resolve at call time).
-(defn- spread [arglist]
-  (cond
-    (nil? arglist) nil
-    (nil? (next arglist)) (seq (first arglist))
-    :else (cons (first arglist) (spread (next arglist)))))
-
 ;; print-str family: print/println/prn into a captured *out*.
 (defn print-str [& xs] (__with-out-str (fn* [] (apply print xs))))
 (defn println-str [& xs] (__with-out-str (fn* [] (apply println xs))))
@@ -495,6 +515,12 @@
                          (mapcat walk (children node))))))]
     (walk root)))
 
+;; file-seq: the tree of paths under root (root included), directories walked
+;; via the host dir primitives. Paths (strings), not File objects. (Lives below
+;; tree-seq: forward references are analysis errors now — jolt-2o7.3.)
+(defn file-seq [root]
+  (tree-seq __dir? __list-dir root))
+
 ;; Canonical flatten via tree-seq: the leaves (non-sequential nodes) in order.
 ;; Flattens lists too (sequential?), matching Clojure/CLJS.
 (defn flatten [coll]
@@ -603,19 +629,6 @@
 (defn ex-cause [e]
   (let [e (ex-unwrap e)] (if (ex-info-val? e) (get e :cause) nil)))
 
-;; Tagged-value predicates. The constructors (atom/volatile!/...) stay in Janet,
-;; but every tagged value carries its kind under :jolt/type (records under
-;; :jolt/deftype), reachable via get — which is nil on non-tables — so the
-;; predicates are pure over get and move out of the seed.
-(defn atom? [x]               (= (get x :jolt/type) :jolt/atom))
-(defn volatile? [x]           (= (get x :jolt/type) :jolt/volatile))
-(defn reader-conditional? [x] (= (get x :jolt/type) :jolt/reader-conditional))
-(defn tagged-literal? [x]     (= (get x :jolt/type) :jolt/tagged-literal))
-(defn record? [x]             (some? (get x :jolt/deftype)))
-(defn uuid? [x]               (= (get x :jolt/type) :jolt/uuid))
-(defn inst? [x]               (= (get x :jolt/type) :jolt/inst))
-(defn char? [x]               (= (get x :jolt/type) :jolt/char))
-
 ;; inst-ms: epoch milliseconds of an instant; throws on a non-inst (Clojure
 ;; protocol behavior).
 (defn inst-ms [x]
@@ -635,6 +648,10 @@
   ([n step coll] (map vec (partition n step coll)))
   ([n step pad coll] (map vec (partition n step pad coll))))
 
+;; partition-all is a lazy-tier fn (40-lazy) — declared so partitionv-all
+;; compiles; bound by the time anything calls it.
+(declare partition-all)
+
 (defn partitionv-all
   ([n coll] (map vec (partition-all n coll)))
   ([n step coll] (map vec (partition-all n step coll))))
@@ -684,12 +701,7 @@
 (defn set-validator! [a f]
   (jolt.host/ref-put! a :validator f) nil)
 
-;; Volatiles. The constructor (volatile!) stays native — it builds the mutable box —
-;; but vreset! sets the box's slot through ref-put! and vswap! is pure over it + get.
-(defn vreset! [vol newval]
-  (jolt.host/ref-put! vol :val newval) newval)
-(defn vswap! [vol f & args]
-  (vreset! vol (apply f (get vol :val) args)))
+;; vreset!/vswap! live in the seq tier (10-seq.clj): its transducers use them.
 
 ;; Future status predicates — pure reads of the future's :cached/:cancelled slots.
 ;; future? stays native (deref/future-cancel/realized? call it); future-call and
@@ -761,8 +773,7 @@
 
 ;; Strict, as in Clojure: an entry is what (seq m) yields (a host tuple), NOT
 ;; a plain vector — (key [1 2]) throws.
-(defn key [e] (if (map-entry? e) (nth e 0) (throw (ex-info "key requires a map entry" {}))))
-(defn val [e] (if (map-entry? e) (nth e 1) (throw (ex-info "val requires a map entry" {}))))
+;; key/val moved above the hierarchies section (underive uses them).
 
 ;; find was previously missing from jolt entirely. Presence (contains?), not
 ;; value, decides — so (find {:a nil} :a) is [:a nil]. Works on vectors by
@@ -772,7 +783,7 @@
 (defn find [m k]
   (when (contains? m k) (first {k (get m k)})))
 
-(defn some? [x] (not (nil? x)))
+;; some? lives in the top leaf block now (forward refs are errors).
 (defn true? [x] (= true x))
 (defn false? [x] (= false x))
 

jolt-core/jolt/analyzer.clj

@@ -199,7 +199,17 @@
               (case (:kind r)
                 :var (var-ref (:ns r) (:name r))
                 :host (host-ref (:name r))
-                (var-ref (compile-ns ctx) nm))))))
+                ;; :unresolved — previously emitted a var-ref that auto-interned
+                ;; an UNBOUND var, so a typo'd symbol died later as 'Cannot call
+                ;; nil as a function' with no hint which symbol (jolt-2o7.3).
+                ;; Punt to the interpreter: its resolver raises Clojure's
+                ;; 'Unable to resolve symbol' when the form actually runs (at
+                ;; eval for top-level forms, at call for fn bodies). A punt
+                ;; rather than a hard throw because runtime-interning forms
+                ;; (defmulti's setup call) legitimately reference the var they
+                ;; are about to create when nested in a non-top-level do. Real
+                ;; forward references want (declare ...), as in Clojure.
+                (uncompilable (str "Unable to resolve symbol: " nm " in this context")))))))
 
 (defn- analyze-list [ctx form env]
   (let [items (vec (form-elements form))]