cljd AOT test: round-trip the suite through the native binary

borkdude · borkdude · commit e560e69acaa4 · 2026-07-06T11:47:29.000+02:00
Rework the AOT test to mirror SCI_TEST_ENV=native on the JVM. aot_main is now a
generic form+ctx eval CLI (the cljd sci.impl.main). tu/eval* gets a cljd native
branch that shells out to the AOT binary and parses stdout, so each eval
round-trips through the native build. Interop tests carry override fns that
cannot serialize, so they use sci/eval-string in-process, as on the JVM. The
binary also runs --selftest for the fn-override AOT path that cannot round-trip.
Verified: bugging the binary fails 169 round-tripped assertions.
diff --git a/doc/ai/0008-cljd-port.md b/doc/ai/0008-cljd-port.md
@@ -64,12 +64,17 @@ map written for the JVM works on cljd if it carries `:class`.
 
 This survives tree-shaking: an override body that calls a real Dart method
 (`(fn [s] (.toUpperCase s))`) compiles to a direct call site, so AOT keeps the
-method. Guarded by script/test/cljd-native (CI test-cljd job): it
-`dart compile exe`s test/sci/aot_main.cljd and runs the native binary, which
-asserts the override returns "HELLO FROM SCI" and an unlisted member is denied.
-This is the AOT analogue of script/test/native (GraalVM); the JIT `dart test`
-suite cannot catch a tree-shaken reflective path. This is why overrides are the
-right interop model for Dart, which has no runtime reflection.
+method. Guarded by script/test/cljd-native (CI test-cljd job), the AOT analogue
+of script/test/native (GraalVM). test/sci/aot_main.cljd is a generic form+ctx
+eval CLI (the cljd sci.impl.main); the script `dart compile exe`s it and:
+- runs `--selftest`, asserting an override survives tree-shaking and an unlisted
+  member is denied (the fn-override path, which cannot round-trip);
+- runs the suite with SCI_TEST_ENV=native so tu/eval* shells out to the binary,
+  round-tripping each eval through the native build (like ./sci on the JVM). A
+  ctx carrying override fns cannot serialize, so those tests use sci/eval-string
+  (in-process), matching the JVM. The JIT `dart test` suite cannot catch a
+  tree-shaken reflective path; this can. This is why overrides are the right
+  interop model for Dart, which has no runtime reflection.
 
 Non-record deftype works on cljd: the cljs arm
 of analyze-deftype* became :default (SciType path, platform-neutral).
diff --git a/script/test/cljd-native b/script/test/cljd-native
@@ -2,11 +2,13 @@
 
 set -eo pipefail
 
-# AOT test for ClojureDart: dart compile exe a non-interactive sci-interop
-# program and run the native binary. Verifies the reflection-free interop model
-# survives Dart AOT tree-shaking, which the JIT `dart test` suite cannot catch.
-# Analogous to script/test/native (GraalVM). Run after script/test/cljd, which
-# scaffolds the cljd project (pubspec.yaml, deps).
+# AOT test for ClojureDart: round-trip the test suite through a native binary,
+# the cljd analogue of SCI_TEST_ENV=native on the JVM (which shells out ./sci).
+# sci.aot-main is a generic form+ctx eval CLI; script AOT-compiles it and runs
+# the suite with SCI_TEST_ENV=native so tu/eval* shells out to it. Tests whose
+# ctx carries override fns cannot serialize (same limit as the JVM) and use
+# sci/eval-string directly, running in-process. Run after script/test/cljd,
+# which scaffolds the cljd project.
 
 if [ ! -f pubspec.yaml ]; then
   echo 'No pubspec.yaml. Run script/test/cljd first to scaffold the cljd project.' >&2
@@ -18,17 +20,21 @@ mkdir -p bin
 echo 'Compiling sci.aot-main to Dart'
 clojure -M:cljd compile sci.aot-main
 
-echo 'AOT-compiling to a native executable'
+echo 'AOT-compiling the sci eval binary'
 echo 'export "../lib/cljd-out/sci/aot-main.dart" show main;' > bin/aot_test.dart
-bin_out="${TMPDIR:-/tmp}/sci-aot-test"
+bin_out="${TMPDIR:-/tmp}/sci-cljd-native"
 dart compile exe bin/aot_test.dart -o "$bin_out"
 
-echo 'Running the native binary'
-out="$("$bin_out")"
-echo "$out"
-if echo "$out" | grep -q 'AOT-OK'; then
-  echo 'AOT test passed'
-else
-  echo 'AOT test FAILED' >&2
-  exit 1
+echo 'Self-test: interop override survives AOT tree-shaking'
+"$bin_out" --selftest | grep -q 'SELFTEST-OK'
+
+echo 'Round-tripping the suite through the native binary'
+export SCI_TEST_ENV=native
+export SCI_NATIVE_BIN="$bin_out"
+# Namespaces whose tu/eval* ctx is plain data. fn-opts tests use sci/eval-string
+# and run in-process, as on the JVM.
+namespaces=(sci.core-test)
+if [ $# -gt 0 ]; then
+  namespaces=("$@")
 fi
+clojure -M:cljd test "${namespaces[@]}"
diff --git a/test/sci/aot_main.cljd b/test/sci/aot_main.cljd
@@ -1,20 +1,42 @@
 (ns sci.aot-main
-  "Non-interactive main for the Dart AOT test (script/test/cljd-native).
-  Exercises the reflection-free interop model under `dart compile exe`: an
-  override that calls a real Dart method must survive tree-shaking, and an
-  unlisted member must be denied. Prints AOT-OK on success, AOT-FAIL otherwise,
-  and exits non-zero on failure so the script can assert."
+  "Generic SCI eval CLI for the Dart AOT round-trip test, the cljd analogue of
+  sci.impl.main. Args: [form ctx-edn]. Reads the ctx as data, evals the form,
+  prints the result with prn. Errors go to stderr with a non-zero exit so the
+  caller can distinguish them. script/test/cljd-native AOT-compiles this and
+  tu/eval* native mode shells out to it, round-tripping the suite through the
+  native binary (like SCI_TEST_ENV=native on the JVM)."
   (:require ["dart:io" :as io]
+            [edamame.core :as e]
             [sci.core :as sci]))
 
-(defn main []
+(defn selftest
+  "The interop override path cannot round-trip (fns do not serialize), so assert
+  it here inside the AOT binary: an override that calls a real Dart method must
+  survive tree-shaking, and an unlisted member must be denied."
+  []
   (let [ctx (sci/init {:classes {'String {:class String
                                           :instance-methods {'upper (fn [s] (.toUpperCase s))}}}})
-        upper (sci/eval-string* ctx "(.upper \"hello from sci\")")
+        upper (sci/eval-string* ctx "(.upper \"ok\")")
         denied (try (sci/eval-string* ctx "(.lower \"x\")")
                     ::not-denied
                     (catch Object _ ::denied))]
-    (if (and (= "HELLO FROM SCI" upper) (= ::denied denied))
-      (println "AOT-OK" upper)
-      (do (println "AOT-FAIL upper=" (pr-str upper) "denied=" (pr-str denied))
+    (if (and (= "OK" upper) (= ::denied denied))
+      (println "SELFTEST-OK")
+      (do (.write io/stderr (str "SELFTEST-FAIL upper=" (pr-str upper)
+                                 " denied=" (pr-str denied) "\n"))
           (io/exit 1)))))
+
+(defn main [args]
+  (if (= "--selftest" (first args))
+    (selftest)
+    (let [form (first args)
+          ctx-str (second args)
+          ctx (if (and ctx-str (pos? (count ctx-str)))
+                (e/parse-string ctx-str)
+                {})]
+      (try
+        (let [v (sci/eval-string form ctx)]
+          (when (some? v) (prn v)))
+        (catch Object e
+          (.write io/stderr (str (or (ex-message e) e) "\n"))
+          (io/exit 1))))))
diff --git a/test/sci/cljd_interop_test.cljd b/test/sci/cljd_interop_test.cljd
@@ -1,42 +1,45 @@
 (ns sci.cljd-interop-test
+  ;; override fns in the ctx cannot serialize to the native binary, so these
+  ;; tests use sci/eval-string (in-process), not tu/eval*, matching the JVM.
   (:require [clojure.test :refer [deftest is testing]]
+            [sci.core :as sci]
             [sci.test-utils :as tu]))
 
 (deftest instance-method-override-test
   (testing "instance method dispatches to override fn"
-    (is (= 3 (tu/eval* "(.foo \"abc\")"
-                       {:classes {'String {:class String :instance-methods {'foo count}}}}))))
+    (is (= 3 (sci/eval-string "(.foo \"abc\")"
+                              {:classes {'String {:class String :instance-methods {'foo count}}}}))))
   (testing "override receives args"
-    (is (= "abc!" (tu/eval* "(.foo \"abc\" \"!\")"
-                            {:classes {'String {:class String :instance-methods {'foo str}}}}))))
+    (is (= "abc!" (sci/eval-string "(.foo \"abc\" \"!\")"
+                                   {:classes {'String {:class String :instance-methods {'foo str}}}}))))
   (testing "override body calls a real host method (compiled, tree-shakeable)"
-    (is (= "ABC" (tu/eval* "(.upper \"abc\")"
-                           {:classes {'String {:class String :instance-methods {'upper (fn [s] (.toUpperCase s))}}}}))))
+    (is (= "ABC" (sci/eval-string "(.upper \"abc\")"
+                                  {:classes {'String {:class String :instance-methods {'upper (fn [s] (.toUpperCase s))}}}}))))
   (testing "unlisted method throws"
     (is (thrown? cljd.core/ExceptionInfo
-                 (tu/eval* "(.bar \"abc\")"
-                           {:classes {'String {:class String :instance-methods {'foo (fn [_s] :x)}}}})))))
+                 (sci/eval-string "(.bar \"abc\")"
+                                  {:classes {'String {:class String :instance-methods {'foo (fn [_s] :x)}}}})))))
 
 (deftest instance-field-override-test
   (testing "instance field dispatches to override fn, which reads a real host field"
-    (is (= 4 (tu/eval* "(.-len \"abcd\")"
-                       {:classes {'String {:class String :instance-fields {'len (fn [s] (.-length s))}}}}))))
+    (is (= 4 (sci/eval-string "(.-len \"abcd\")"
+                              {:classes {'String {:class String :instance-fields {'len (fn [s] (.-length s))}}}}))))
   (testing "unlisted field throws"
     (is (thrown? cljd.core/ExceptionInfo
-                 (tu/eval* "(.-nope \"abcd\")"
-                           {:classes {'String {:class String :instance-fields {'len (fn [_] 1)}}}})))))
+                 (sci/eval-string "(.-nope \"abcd\")"
+                                  {:classes {'String {:class String :instance-fields {'len (fn [_] 1)}}}})))))
 
 (deftest static-method-override-test
   (testing "static method dispatches to override fn"
-    (is (= :parsed (tu/eval* "(DateTime/parse \"2020\")"
-                             {:classes {'DateTime {:class DateTime
-                                                   :static-methods {'parse (fn [_ _s] :parsed)}}}})))))
+    (is (= :parsed (sci/eval-string "(DateTime/parse \"2020\")"
+                                    {:classes {'DateTime {:class DateTime
+                                                          :static-methods {'parse (fn [_ _s] :parsed)}}}})))))
 
 (deftest static-field-override-test
   (testing "static field dispatches to override fn"
-    (is (= :field (tu/eval* "DateTime/monthsPerYear"
-                            {:classes {'DateTime {:class DateTime
-                                                  :static-fields {'monthsPerYear (fn [_] :field)}}}})))))
+    (is (= :field (sci/eval-string "DateTime/monthsPerYear"
+                                   {:classes {'DateTime {:class DateTime
+                                                         :static-fields {'monthsPerYear (fn [_] :field)}}}})))))
 
 (deftest named-arg-sugar-test
   (testing "trailing .name val pairs desugar to keyword args"
@@ -77,16 +80,16 @@
 
 (deftest string-namespace-require-test
   (testing "a namespace registered under a string name is requirable and aliasable"
-    (is (= "hi!" (tu/eval* "(require '[\"my.pkg\" :as p]) (p/shout \"hi\")"
-                           {:namespaces {"my.pkg" {'shout (fn [s] (str s "!"))}}}))))
+    (is (= "hi!" (sci/eval-string "(require '[\"my.pkg\" :as p]) (p/shout \"hi\")"
+                                  {:namespaces {"my.pkg" {'shout (fn [s] (str s "!"))}}}))))
   (testing "string require works in an ns form"
-    (is (= 42 (tu/eval* "(ns app (:require [\"my.pkg\" :as p])) (p/answer)"
-                        {:namespaces {"my.pkg" {'answer (fn [] 42)}}}))))
+    (is (= 42 (sci/eval-string "(ns app (:require [\"my.pkg\" :as p])) (p/answer)"
+                               {:namespaces {"my.pkg" {'answer (fn [] 42)}}}))))
   (testing "a string-named and a symbol-named ns coexist in loaded-libs"
     (is (= [1 2]
-           (tu/eval* "(require '[\"pkg.one\" :as a] '[reg.two :as b]) [(a/x) (b/y)]"
-                     {:namespaces {"pkg.one" {'x (fn [] 1)}
-                                   'reg.two {'y (fn [] 2)}}}))))
+           (sci/eval-string "(require '[\"pkg.one\" :as a] '[reg.two :as b]) [(a/x) (b/y)]"
+                            {:namespaces {"pkg.one" {'x (fn [] 1)}
+                                          'reg.two {'y (fn [] 2)}}}))))
   (testing "requiring the same string ns twice is idempotent"
-    (is (= 1 (tu/eval* "(require '[\"pkg.one\" :as a]) (require '[\"pkg.one\" :as a]) (a/x)"
-                       {:namespaces {"pkg.one" {'x (fn [] 1)}}})))))
+    (is (= 1 (sci/eval-string "(require '[\"pkg.one\" :as a]) (require '[\"pkg.one\" :as a]) (a/x)"
+                              {:namespaces {"pkg.one" {'x (fn [] 1)}}})))))
diff --git a/test/sci/test_utils.cljc b/test/sci/test_utils.cljc
@@ -1,5 +1,7 @@
 (ns sci.test-utils
-  (:require #?@(:cljd [] :clj [[edamame.core :as edamame]])
+  (:require #?@(:cljd [["dart:io" :as io]
+                       [edamame.core :as edamame]]
+                :clj [[edamame.core :as edamame]])
             #?@(:cljd [] :clj [[me.raynes.conch :refer [let-programs] :as sh]])
             [clojure.test :as test :refer [is]]
             ;; :refer of fns from ported namespaces breaks the cljd host pass
@@ -10,18 +12,26 @@
             [sci.test-utils.utils :as u])
   #?(:cljs (:require-macros [sci.test-utils.macros])))
 
-(def native? #?(:cljd false
+(def native? #?(:cljd (= "native" (get io/Platform.environment "SCI_TEST_ENV"))
                 :clj (= "native" (System/getenv "SCI_TEST_ENV"))
                 :cljs false))
 
 (when native? (println "Testing native version."))
 
 (defn eval* [form ctx]
-  (if #?(:cljd true
-         :clj (not native?)
-         :cljs true)
+  (if (not native?)
     (#?(:cljd sci/eval-string :default eval-string) (str form) ctx)
-    #?(:clj
+    #?(:cljd
+       ;; shell out to the AOT-compiled sci.aot-main binary, like the JVM
+       ;; SCI_TEST_ENV=native path shells out to ./sci
+       (let [bin (get io/Platform.environment "SCI_NATIVE_BIN")
+             result (io/Process.runSync bin [(str form) (str ctx)])]
+         (if (zero? (.-exitCode result))
+           (let [out (.trim (str (.-stdout result)))]
+             (when-not (= "" out)
+               (edamame/parse-string out {:all true :location? (constantly false)})))
+           (throw (ex-info (str (.-stderr result)) {}))))
+       :clj
        (let [v (let-programs [sci "./sci"]
                  (try (sci (str form) (str ctx))
                       (catch #?(:clj Exception :cljs :default) e
