Chez Phase 2 (inc T): class native + bare class-token resolution (jolt-13zk)

Bare class names (String, Keyword, File...) evaluate to their JVM
canonical-name string, the same value (class x) returns, so
(= String (class "x")) holds and (defmethod m String ...) keys match a
(class ...) dispatch. New host/chez/host-class.ss ports
eval_resolve.janet's class-canonical-names + core_refs.janet's core-class
(scalar arms; collections/seqs are host-taxonomy-dependent and not class-
compared in the corpus).

The analyzer already resolves these names to clojure.core vars (the seed
ctx interns them via setup-class-ctors), so the back end emits
(var-deref "clojure.core" "String") and a runtime def-var! is all that's
needed -- no analyzer change, Janet path untouched. The class native MUST
land together with token resolution: alone it turns the bare-token corpus
cases (562/564) into divergences (this bit last session).

Parity 2154 -> 2163 (cases 560/562/563/564/2500-2503), 0 new divergences.
New test/chez/_class.janet 19/19.

host/chez/host-class.ss

@@ -0,0 +1,50 @@
+;; host class tokens (jolt-13zk) — a bare class name (String, Keyword, File...)
+;; evaluates to its JVM canonical-name STRING, the same value (class instance)
+;; returns, so (= String (class "x")) holds and a (defmethod m String ...) keys
+;; against a (class …) dispatch (ring.util.request does this). Mirrors
+;; src/jolt/eval_resolve.janet's class-canonical-names + core_refs.janet's
+;; core-class. The analyzer already resolves these names to clojure.core vars (the
+;; seed ctx interns them via setup-class-ctors), so the back end emits
+;; (var-deref "clojure.core" "String") — def-var!'ing the canonical strings here is
+;; all that's needed at runtime. No analyzer change, so the Janet back end is
+;; untouched.
+;;
+;; Loaded after natives-meta.ss (jolt-type) + the printer (jolt-str-render-one).
+
+;; (class x) — Clojure's class of a value. Scalars map to their JVM class name,
+;; matching core-class. Collections/seqs have no JVM class on this host; the seed
+;; leaks the Janet host type ("table"/"struct"/"tuple") there, which we don't
+;; reproduce (Janet is going away) — (str (type x)) is the clean host taxonomy and
+;; is never compared against a class token in the corpus. Records yield their
+;; ns-qualified class name (= (str (type x))). Total — never crashes.
+(define (jolt-class x)
+  (cond
+    ((jolt-nil? x) jolt-nil)
+    ((boolean? x) "java.lang.Boolean")
+    ((number? x) "java.lang.Number")
+    ((string? x) "java.lang.String")
+    ((keyword? x) "clojure.lang.Keyword")
+    ((symbol-t? x) "clojure.lang.Symbol")
+    ((procedure? x) "clojure.lang.IFn")
+    (else (jolt-str-render-one (jolt-type x)))))
+
+(def-var! "clojure.core" "class" jolt-class)
+
+;; bare class-name tokens -> canonical JVM class-name strings.
+(for-each
+  (lambda (pair) (def-var! "clojure.core" (car pair) (cdr pair)))
+  '(("String" . "java.lang.String") ("Number" . "java.lang.Number")
+    ("Boolean" . "java.lang.Boolean") ("Long" . "java.lang.Long")
+    ("Integer" . "java.lang.Integer") ("Double" . "java.lang.Double")
+    ("InputStream" . "java.io.InputStream") ("OutputStream" . "java.io.OutputStream")
+    ("File" . "java.io.File") ("Reader" . "java.io.Reader") ("Writer" . "java.io.Writer")
+    ("ISeq" . "clojure.lang.ISeq") ("Keyword" . "clojure.lang.Keyword")
+    ("Symbol" . "clojure.lang.Symbol") ("MapEntry" . "clojure.lang.MapEntry")
+    ("StringReader" . "java.io.StringReader") ("StringWriter" . "java.io.StringWriter")
+    ("StringBuilder" . "java.lang.StringBuilder")
+    ("StringTokenizer" . "java.util.StringTokenizer")
+    ("Charset" . "java.nio.charset.Charset") ("Base64" . "java.util.Base64")
+    ("Exception" . "java.lang.Exception")
+    ("IllegalArgumentException" . "java.lang.IllegalArgumentException")
+    ("InterruptedException" . "java.lang.InterruptedException")
+    ("Throwable" . "java.lang.Throwable")))

host/chez/jolt-chez.janet

@@ -22,6 +22,7 @@
            "host/chez/atoms.ss" "host/chez/predicates.ss" "host/chez/regex.ss"
            "host/chez/ns.ss" "host/chez/post-prelude.ss" "host/chez/natives-meta.ss"
            "host/chez/natives-str.ss" "host/chez/records.ss"
+           "host/chez/host-class.ss"
            "host/chez/host-static.ss" "host/chez/dot-forms.ss"
            "src/jolt/clojure/string.clj"]
     (array/push parts (slurp f)))

host/chez/rt.ss

@@ -220,6 +220,11 @@
 ;; side-table. After records.ss (jrec) + the collection ctors it copies.
 (load "host/chez/natives-meta.ss")
 
+;; host class tokens (jolt-13zk): bare class names (String/Keyword/File...) ->
+;; canonical JVM class-name strings + (class x). After natives-meta.ss (jolt-type)
+;; and the printer (jolt-str-render-one).
+(load "host/chez/host-class.ss")
+
 ;; dynamic vars (jolt-9ls5): *clojure-version* / *unchecked-math* constants the seed
 ;; binds natively. After collections.ss (jolt-hash-map) + def-var!.
 (load "host/chez/dynamic-vars.ss")

test/chez/_class.janet

@@ -0,0 +1,63 @@
+# jolt-13zk — bare class-name tokens + (class x) on Chez. A class name (String,
+# Keyword, File...) evaluates to its JVM canonical-name STRING — the same value
+# (class instance) returns — so (= String (class "x")) holds and a (defmethod m
+# String ...) keys against a (class ...) dispatch. host-class.ss ports
+# src/jolt/eval_resolve.janet's class-canonical-names + core-class (scalar arms).
+# Oracle = build/jolt. Collection (class ...) is host-taxonomy-dependent (the seed
+# leaks the Janet host type "table"/"struct") and is NOT compared here.
+#
+#   janet test/chez/_class.janet
+(def jolt-bin (or (os/getenv "JOLT_BIN") "bin/jolt-chez"))
+
+(def cases
+  [# --- bare class tokens evaluate to canonical strings ---
+   ["String"            "java.lang.String"]
+   ["Number"            "java.lang.Number"]
+   ["Keyword"           "clojure.lang.Keyword"]
+   ["File"              "java.io.File"]
+   ["Exception"         "java.lang.Exception"]
+   ["MapEntry"          "clojure.lang.MapEntry"]
+   # --- (class x) on scalars matches core-class ---
+   ["(class 1)"         "java.lang.Number"]
+   ["(class 1.5)"       "java.lang.Number"]
+   ["(class \"s\")"     "java.lang.String"]
+   ["(class :k)"        "clojure.lang.Keyword"]
+   ["(class true)"      "java.lang.Boolean"]
+   ["(class false)"     "java.lang.Boolean"]
+   ["(class nil)"       ""]
+   # --- token <-> class equality ---
+   ["(= String (class \"abc\"))"               "true"]
+   ["(= Number (class 7))"                      "true"]
+   ["(= String (class 7))"                      "false"]
+   # --- defmulti dispatch on class ---
+   ["(do (defmulti cm (fn [x] (class x))) (defmethod cm String [x] :str) (cm \"a\"))" ":str"]
+   ["(do (defmulti cn (fn [x] (class x))) (defmethod cn nil [x] :nil) (defmethod cn String [x] :str) (cn nil))" ":nil"]
+   ["(do (defmulti cn (fn [x] (class x))) (defmethod cn nil [x] :nil) (defmethod cn String [x] :str) (cn \"z\"))" ":str"]])
+
+(defn run-capture [bin expr]
+  (def proc (os/spawn [bin "-e" expr] :p {:out :pipe :err :pipe}))
+  (def out (ev/read (proc :out) 0x100000))
+  (def err (ev/read (proc :err) 0x100000))
+  (def code (os/proc-wait proc))
+  (def lines (filter (fn [l] (not (empty? l)))
+                     (string/split "\n" (string/trim (if out (string out) "")))))
+  [code (if (empty? lines) "" (last lines)) (string/trim (if err (string err) ""))])
+
+(var pass 0)
+(def fails @[])
+(each [expr expected] cases
+  (def [ocode oracle _] (run-capture "build/jolt" expr))
+  (def [code got err] (run-capture jolt-bin expr))
+  (cond
+    (not= ocode 0) (array/push fails [expr (string "ORACLE FAILED exit " ocode)])
+    (not= oracle expected) (array/push fails [expr (string "ORACLE MISMATCH want `" expected "` got `" oracle "`")])
+    (not= code 0) (array/push fails [expr (string "exit " code "; err: " err)])
+    (= got expected) (++ pass)
+    (array/push fails [expr (string "want `" expected "`, got `" got "`")])))
+
+(printf "\n_class parity [%s]: %d/%d passed" jolt-bin pass (length cases))
+(when (> (length fails) 0)
+  (printf "%d FAIL(s):" (length fails))
+  (each [e m] fails (printf "  FAIL %s\n    %s" e m)))
+(flush)
+(os/exit (if (empty? fails) 0 1))

test/chez/run-corpus-prelude.janet

@@ -244,8 +244,12 @@
 # validator slots; swap!/reset! validate-then-set-then-notify in seed order;
 # add-watch/remove-watch/set-validator!/get-validator are native and re-asserted
 # in post-prelude.ss over the overlay's ref-put!-on-a-Janet-table versions) 2154.
+# jolt-13zk (bare class tokens String/Keyword/File... -> canonical JVM class-name
+# strings + (class x) scalar arms, host-class.ss; the analyzer already resolves
+# these names to clojure.core vars so it's a runtime def-var! only, no analyzer
+# change) 2163.
 # Strided runs scale down.
-(def base-floor (scan-number (or (os/getenv "JOLT_CHEZ_PRELUDE_FLOOR") "2154")))
+(def base-floor (scan-number (or (os/getenv "JOLT_CHEZ_PRELUDE_FLOOR") "2163")))
 (def floor (if (os/getenv "JOLT_CORPUS_LIMIT") 0 base-floor))
 (when (or (> (length diverged) 0) (< pass floor))
   (printf "REGRESSION: pass %d < floor %d or %d new divergence(s)" pass floor (length diverged)))