From 3319684a38615bb530b1741892f53200674612dd Mon Sep 17 00:00:00 2001 From: Yogthos Date: Fri, 19 Jun 2026 08:41:45 -0400 Subject: [PATCH] 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 | 50 ++++++++++++++++++++++++ host/chez/jolt-chez.janet | 1 + host/chez/rt.ss | 5 +++ test/chez/_class.janet | 63 ++++++++++++++++++++++++++++++ test/chez/run-corpus-prelude.janet | 6 ++- 5 files changed, 124 insertions(+), 1 deletion(-) create mode 100644 host/chez/host-class.ss create mode 100644 test/chez/_class.janet diff --git a/host/chez/host-class.ss b/host/chez/host-class.ss new file mode 100644 index 0000000..fa7794f --- /dev/null +++ b/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"))) diff --git a/host/chez/jolt-chez.janet b/host/chez/jolt-chez.janet index 424c211..9be9f1b 100644 --- a/host/chez/jolt-chez.janet +++ b/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))) diff --git a/host/chez/rt.ss b/host/chez/rt.ss index 0d5600b..0d32861 100644 --- a/host/chez/rt.ss +++ b/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") diff --git a/test/chez/_class.janet b/test/chez/_class.janet new file mode 100644 index 0000000..8f047ed --- /dev/null +++ b/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)) diff --git a/test/chez/run-corpus-prelude.janet b/test/chez/run-corpus-prelude.janet index 8fb30be..d67d1d8 100644 --- a/test/chez/run-corpus-prelude.janet +++ b/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)))