ea1d9a23e1
Closed-world (optimization mode): after a unit loads, infer-unit! runs a whole-unit fixpoint over the call graph and recompiles. A fn's param types are the lub of its in-unit call-site arg types; its return type is the lub of its tail positions; iterated to a least fixpoint. Param types are RECOMPUTED FRESH each iteration (not accumulated) because :any is the lattice top — joining an early-iteration :any would poison the result permanently. Closures inherit the enclosing tenv so captured locals keep their types (their own params shadow to :any). A fn whose var escapes as a VALUE keeps :any params (its callers aren't all visible). Each fn is then re-inferred with its param types seeded and re-emitted; recompiled bodies are semantically identical, so correctness holds regardless of order. Sound under source distribution + whole-program compile (the consumer compiles all call sites together). Plumbing: the portable pass (jolt.passes) gained inter-procedural primitives — set-rtenv!, infer-body (types a body, collects its call sites), reinfer-def (seeds param types), and escape tracking. The back end stashes each single-fixed-arity defn's :def IR (:infer-ir); the evaluator triggers infer-unit! after a unit loads (via an env hook, opt mode only). Result and honest finding: the fixpoint correctly types scalar-flowing params (ray-cast/hit-all/hit-sphere all get the ray param as :struct-map, no hint), but the ray tracer does NOT speed up — its dominant lookups are on `hittable`, the element of the `hittables` vector threaded through `reduce`, which stays :any. Typing it needs collection-element types (vector<struct>) plus HOF-element awareness (knowing reduce applies the closure to elements), which is beyond inter-procedural param inference. The explicit ^:struct hint reaches it (it types the reduce closure param directly), which is why the hinted run is 1.22x. Verified: conformance 335/335 x3, full jpm test; new type-infer-phase1-test pins the fixpoint, the escape gate, the seeded re-inference, and correctness.
54 lines
3.1 KiB
Text
54 lines
3.1 KiB
Text
# Inter-procedural collection-type inference, Phase 1 (jolt-767): closed-world.
|
|
# A whole-unit fixpoint propagates collection types through the call graph — a
|
|
# fn's param types become the lub of its in-unit call-site arg types — so a
|
|
# param that always receives a struct map gets typed and its lookups specialize,
|
|
# with no hint. Fns whose var escapes as a value keep :any params (their callers
|
|
# aren't all visible). Sound under source distribution + whole-program compile.
|
|
(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 1 (jolt-767)...")
|
|
|
|
(os/setenv "JOLT_DIRECT_LINK" "1")
|
|
(def ctx (api/init {:compile? true}))
|
|
(api/eval-string ctx "(ns p1)")
|
|
# closed-world unit. mk is small (inlined away). rd is RECURSIVE, so it survives
|
|
# inlining and is called via its var — exactly the shape (big/recursive fn with
|
|
# escaping-from-the-caller params) that inter-procedural inference targets. Its
|
|
# param v flows from mk's struct-map literal (after mk inlines into drv).
|
|
(each s ["(defn mk [a b] {:r a :g b})"
|
|
"(defn rd [v n] (if (< n 1) (:r v) (rd v (dec n))))"
|
|
"(defn drv [] (rd (mk 1 2) 3))"
|
|
# esc's var is used as a VALUE (passed to mapv) -> params must stay :any
|
|
"(defn esc [w] (:r w))"
|
|
"(defn use-esc [xs] (mapv esc xs))"]
|
|
(api/eval-string ctx s))
|
|
|
|
(def report (backend/infer-unit! ctx "p1"))
|
|
|
|
# --- the fixpoint computed the right param types -----------------------------
|
|
# rd's param v flows from mk's struct-map result (mk inlines to a struct literal
|
|
# in drv) and stays struct across the recursive self-call -> :struct-map
|
|
(assert (= :struct-map (in (get report "p1/rd") 0)) (string "rd param v: " (in (get report "p1/rd") 0)))
|
|
# esc escaped (passed to mapv) -> param stays unknown (:any / nil), NOT struct
|
|
(assert (not= :struct-map (in (get report "p1/esc") 0)) "escaping fn param not inferred struct")
|
|
|
|
# --- the seeded re-inference drops the guard for a struct param --------------
|
|
# (on a FRESH analysis, since infer-unit! re-stashes the already-specialized body)
|
|
(def pns (types/ctx-find-ns ctx "jolt.passes"))
|
|
(def reinfer (types/ns-find pns "reinfer-def"))
|
|
(def rd-def (backend/analyze-form ctx (reader/parse-string "(defn rdx [v n] (if (< n 1) (:r v) (rdx v (dec n))))")))
|
|
(defn guards-seeded [ptmap]
|
|
(length (string/find-all ":jolt/type" (string/format "%p" (backend/emit-ir ctx ((types/var-get reinfer) rd-def ptmap))))))
|
|
(assert (= 0 (guards-seeded @{"v" :struct-map})) "struct param -> bare lookup")
|
|
(assert (= 1 (guards-seeded @{})) "no param type -> guard kept")
|
|
|
|
# --- correctness: recompiled unit still computes the same --------------------
|
|
(assert (= 1 (api/eval-string ctx "(p1/drv)")) "drv correct after recompile")
|
|
(assert (= 7 (api/eval-string ctx "(p1/rd {:r 7 :g 8} 0)")) "rd correct on a struct")
|
|
(assert (= nil (api/eval-string ctx "(p1/rd (hash-map :r nil) 0)")) "rd correct on a phm (key present, nil)")
|
|
(assert (deep= [1 1] (api/normalize-pvecs (api/eval-string ctx "(p1/use-esc [{:r 1} {:r 1}])"))) "escaping fn still correct")
|
|
|
|
(print "Type inference Phase 1 passed!")
|