f0293fb4ee
run-tests.janet runs the same file set as `jpm test` across a pool of worker processes (one `janet FILE` each, ev-based). The full gate goes from ~790s serial to ~98s here (8x), and more on CI where the heavy files don't thrash on swap. CI and the docs point at it; `jpm test` still works serially. Three things dominated the wall: - Nine integration tests cold-built a compile ctx (~8s each); switch them to api/init-cached so they share the prebuilt image. The cache key already fingerprints the ctx-shaping env vars, so the direct-link ones share one DL image and the rest share the plain one. - core-bench's main ran on every gate (~35s of benchmark loops that assert nothing); gate it behind JOLT_BENCH=1. - cli-test spawned `janet src/jolt/main.janet` ~20 times at ~8s cold each (340s under parallel load, and it was the whole wall); prefer build/jolt (~20ms baked ctx) when present, fall back to from-source for an unbuilt tree. type-check-test stays on cold init: a snapshot-loaded ctx loses the success checker's op/msg detail (jolt-vley). jolt-pria tracks caching from-source startup generally, which would let cli-test drop the build/jolt preference. Co-authored-by: Yogthos <yogthos@gmail.com>
41 lines
2.3 KiB
Text
41 lines
2.3 KiB
Text
# Collection-element types + HOF awareness, Phase 3 (jolt-d6u). A vector carries
|
|
# its element type ({:vec ELEM}); a reduce/map/filter closure over it gets that
|
|
# element type on its element param. So a lookup inside a reduce closure over a
|
|
# vector-of-structs specializes — no hint — WHEN the element type is provable.
|
|
(import ../../src/jolt/api :as api)
|
|
(import ../../src/jolt/backend :as backend)
|
|
(import ../../src/jolt/types :as types)
|
|
(import ../../src/jolt/reader :as reader)
|
|
|
|
(print "Type inference Phase 3 (jolt-d6u)...")
|
|
|
|
(os/setenv "JOLT_DIRECT_LINK" "1")
|
|
(def ctx (api/init-cached {:compile? true}))
|
|
(api/eval-string ctx "(ns p3)")
|
|
(def pns (types/ctx-find-ns ctx "jolt.passes"))
|
|
(def reinfer (types/var-get (types/ns-find pns "reinfer-def")))
|
|
# helper: analyze a defn, reinfer with seeded param types, count guards
|
|
(defn guards [src ptmap]
|
|
(def d (backend/analyze-form ctx (reader/parse-string src)))
|
|
(length (string/find-all ":jolt/type" (string/format "%p" (backend/emit-ir ctx (reinfer d ptmap))))))
|
|
|
|
# a reduce closure's element param gets the vector's element type
|
|
(def red "(defn f [coll] (reduce (fn [acc h] (+ acc (:r h))) 0 coll))")
|
|
(assert (= 0 (guards red @{"coll" {:vec {:struct {}}}})) "reduce element typed -> bare lookup in closure")
|
|
(assert (= 1 (guards red @{"coll" {:vec :any}})) "reduce over vector of unknown -> guard kept")
|
|
(assert (= 1 (guards red @{})) "untyped coll -> guard kept")
|
|
|
|
# mapv over a vector-of-structs types the closure element too
|
|
(def mp "(defn g [coll] (mapv (fn [h] (:r h)) coll))")
|
|
(assert (= 0 (guards mp @{"coll" {:vec {:struct {}}}})) "mapv element typed -> bare lookup")
|
|
(assert (= 1 (guards mp @{"coll" {:vec :any}})) "mapv over unknown element -> guard")
|
|
|
|
# element type is DERIVED, not just seeded: a vector literal of structs, reduced
|
|
(def derived "(defn h2 [] (reduce (fn [acc x] (+ acc (:r x))) 0 [{:r 1 :g 2} {:r 3 :g 4}]))")
|
|
(assert (= 0 (guards derived @{})) "vector literal of structs -> element struct -> bare lookup")
|
|
|
|
# correctness: the specialized closures compute the same
|
|
(assert (= 4 (api/eval-string ctx "((fn [coll] (reduce (fn [acc h] (+ acc (:r h))) 0 coll)) [{:r 1} {:r 3}])")) "reduce value")
|
|
(assert (= 4 (api/eval-string ctx "(reduce (fn [acc x] (+ acc (:r x))) 0 [{:r 1 :g 2} {:r 3 :g 4}])")) "derived value")
|
|
|
|
(print "Type inference Phase 3 passed!")
|