From 918e2798db859d3d54a963a07ad8d05be5418f57 Mon Sep 17 00:00:00 2001 From: Yogthos Date: Sat, 6 Jun 2026 02:49:53 -0400 Subject: [PATCH] compiler: resolve Janet-env fallback symbols; validate full suite under compile MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit analyze-form now mirrors resolve-sym's full resolution order: jolt var (current ns / clojure.core), then the runtime/Janet env, then a pending forward-ref cell. Previously a name that resolves only via the Janet-env fallback (int?, type, …) interned an empty var and miscompiled; now it emits the runtime binding directly, matching the interpreter. suite-worker honors JOLT_COMPILE=1 to run the whole clojure-test-suite through the compile path. Under compilation it now passes 3932 / errors 124 — at parity with the interpreter baseline (3913 / 125) across 4600+ assertions, confirming the hybrid compile path doesn't diverge from the interpreter. --- src/jolt/compiler.janet | 29 +++++++++++++++++------------ test/integration/suite-worker.janet | 13 +++++++++---- 2 files changed, 26 insertions(+), 16 deletions(-) diff --git a/src/jolt/compiler.janet b/src/jolt/compiler.janet index 11ee5d5..e51a9e6 100644 --- a/src/jolt/compiler.janet +++ b/src/jolt/compiler.janet @@ -338,21 +338,26 @@ {:op :local :name name} (if (and (not (special-form? name)) (get core-renames name)) {:op :core-symbol :name name :janet-name (get core-renames name)} - # A global reference: resolve the Jolt var cell now and compile a - # deref through it, so redefinition is visible to compiled callers - # (Janet early-binds plain symbols). Resolution mirrors the - # interpreter's resolve-var — current ns (which also holds refers), - # then clojure.core — so unqualified core fns resolve to their real - # var rather than a fresh empty one. Only a genuinely-undefined name - # interns a pending cell in the current ns (forward refs; the getter - # derefs at call time, so a later def fills it in). No ctx -> plain - # symbol. + # A global reference. Resolution mirrors the interpreter's resolve-sym + # so compiled and interpreted code agree: + # 1. a jolt var in the current ns (which also holds refers) or + # clojure.core -> deref through the cell, so redefinition is + # visible to compiled callers (Janet early-binds plain symbols); + # 2. otherwise a binding in the runtime/Janet env (resolve-sym's own + # fallback — this is how int?, type, etc. resolve) -> emit it + # directly; + # 3. otherwise a forward reference -> intern a pending cell whose + # getter derefs at call time, once a later def fills it in. + # No ctx -> plain symbol. (if ctx (let [cur-ns (ctx-find-ns ctx (ctx-current-ns ctx)) cell (or (ns-find cur-ns name) - (ns-find (ctx-find-ns ctx "clojure.core") name) - (ns-intern cur-ns name))] - {:op :var :name name :var cell}) + (ns-find (ctx-find-ns ctx "clojure.core") name))] + (cond + cell {:op :var :name name :var cell} + (get jolt-runtime-env (symbol name)) + {:op :core-symbol :name name :janet-name name} + {:op :var :name name :var (ns-intern cur-ns name)})) {:op :symbol :name name}))))) (array? form) diff --git a/test/integration/suite-worker.janet b/test/integration/suite-worker.janet index bfa0b5b..c7ba60b 100644 --- a/test/integration/suite-worker.janet +++ b/test/integration/suite-worker.janet @@ -19,8 +19,13 @@ (def path (get (dyn :args) 1)) (when path - (def ctx (init)) - (each f (parse-forms (slurp "test/support/clojure_test.clj")) (eval-form ctx @{} f)) + # JOLT_COMPILE=1 runs the suite through the compile path (hybrid: hot forms + # compile, unsupported forms fall back to the interpreter) so the whole battery + # validates compile-mode correctness against the same baseline. + (def compile? (= "1" (os/getenv "JOLT_COMPILE"))) + (def ctx (init (if compile? {:compile? true} {}))) + (defn run-form [f] (if compile? (eval-one ctx f) (eval-form ctx @{} f))) + (each f (parse-forms (slurp "test/support/clojure_test.clj")) (run-form f)) # Pre-load the suite's own clojure.core-test.number-range helper ns if present # (35 files require it for r/max-int, r/max-double, … — its :default branches are @@ -29,10 +34,10 @@ (let [dir (string/slice path 0 (- (length path) (length (last (string/split "/" path))))) nr (string dir "number_range.cljc")] (when (os/stat nr) - (each f (parse-forms (slurp nr)) (protect (eval-form ctx @{} f))))) + (each f (parse-forms (slurp nr)) (protect (run-form f))))) (eval-string ctx "(clojure.test/reset-report!)") - (each form (parse-forms (slurp path)) (protect (eval-form ctx @{} form))) + (each form (parse-forms (slurp path)) (protect (run-form form))) (protect (eval-string ctx "(clojure.test/run-registered)")) (def p (eval-string ctx "(clojure.test/n-pass)")) (def f (eval-string ctx "(clojure.test/n-fail)"))