a3cc035782
Calls compile direct (target value embedded) iff the compiling unit has direct-linking on, the target isn't ^:redef/^:dynamic, and it's an already-defined fn; otherwise indirect (live var deref, redefinable). Direct emission is guarded to function values only — embedding a non-function would make Janet evaluate it as code. :aot-core? (init opt, default true; JOLT_AOT_CORE=0 disables) compiles the core tiers with direct-linking on so core->core calls are direct. User/REPL code compiles indirect by default, so redefining functions in the REPL works with no annotation, exactly like Clojure. :aot-core? false makes core indirect too — the whole language becomes redefinable. ^:redef / ^:dynamic on a target force it indirect even inside a direct-linked unit. Also fixes a pre-existing gap this surfaced: compiled def dropped ALL var metadata (so ^:dynamic was silently lost under compilation, and ^:redef couldn't work). def metadata now flows analyzer -> IR -> back end (new form-sym-meta host fn, def-node :meta, var-setter-meta) and is applied to the cell. Matrix test in test/integration/direct-linking-test.janet. Conformance 218/218 in all three modes under both :aot-core? true and false; battery holds 3916; binary rebuilt.
63 lines
3.1 KiB
Text
63 lines
3.1 KiB
Text
# Direct-linking / redefinition matrix (jolt-d9j, jolt-g86).
|
|
#
|
|
# Direct-linking is a per-compilation-UNIT property (Clojure model). A call
|
|
# compiles direct iff the unit has direct-linking on AND the target is not
|
|
# ^:redef/^:dynamic AND the target is an already-defined fn. Otherwise indirect
|
|
# (live var deref → redefinable). This pins the user-visible semantics:
|
|
# - default user/REPL unit (direct-linking off): redefine anything, callers see it
|
|
# - direct-linked unit: callers don't see a later redef (unless target ^:redef)
|
|
# - :aot-core? gates whether the core tiers compile direct-linked
|
|
|
|
(use ../../src/jolt/api)
|
|
|
|
(var failures 0)
|
|
(defn- check [label got want]
|
|
(unless (= got want)
|
|
(++ failures)
|
|
(printf "FAIL [%s] got %q want %q" label got want)))
|
|
|
|
# 1. Default unit (direct-linking OFF): redefinition reaches compiled callers.
|
|
(let [ctx (init {:compile? true})]
|
|
(eval-string ctx "(defn add [a b] (+ a b))")
|
|
(eval-string ctx "(defn caller [] (add 1 2))")
|
|
(check "default before redef" (eval-string ctx "(caller)") 3)
|
|
(eval-string ctx "(defn add [a b] (* a b))")
|
|
(check "default sees redef (indirect)" (eval-string ctx "(caller)") 2))
|
|
|
|
# 2. Direct-linked unit: compiled caller keeps the original target after a redef.
|
|
(let [ctx (init {:compile? true :direct-linking? true})]
|
|
(eval-string ctx "(defn add [a b] (+ a b))")
|
|
(eval-string ctx "(defn caller [] (add 1 2))")
|
|
(check "direct before redef" (eval-string ctx "(caller)") 3)
|
|
(eval-string ctx "(defn add [a b] (* a b))")
|
|
(check "direct ignores redef (sealed)" (eval-string ctx "(caller)") 3)
|
|
# the var itself is still redefined; only the direct-linked call is frozen
|
|
(check "direct var still updated" (eval-string ctx "(add 3 4)") 12))
|
|
|
|
# 3. ^:redef opts a var OUT of direct-linking even in a direct-linked unit.
|
|
(let [ctx (init {:compile? true :direct-linking? true})]
|
|
(eval-string ctx "(defn ^:redef add [a b] (+ a b))")
|
|
(eval-string ctx "(defn caller [] (add 1 2))")
|
|
(check "redef-tagged before" (eval-string ctx "(caller)") 3)
|
|
(eval-string ctx "(defn ^:redef add [a b] (* a b))")
|
|
(check "redef-tagged sees redef" (eval-string ctx "(caller)") 2))
|
|
|
|
# 4. :aot-core? true (default): redefining a core fn (in clojure.core) is still
|
|
# seen by USER code, because user calls are indirect regardless of core being
|
|
# direct-linked internally.
|
|
(let [ctx (init {:compile? true})]
|
|
(eval-string ctx "(defn uses-last [] (last [1 2 3]))")
|
|
(check "core call before" (eval-string ctx "(uses-last)") 3)
|
|
(eval-string ctx "(in-ns (quote clojure.core))")
|
|
(eval-string ctx "(def last (fn [coll] :patched))")
|
|
(eval-string ctx "(in-ns (quote user))")
|
|
(check "user sees core redef (indirect)" (eval-string ctx "(uses-last)") :patched))
|
|
|
|
# 5. :aot-core? false: core compiles indirect too, so even core-internal callers
|
|
# see a redef — the whole language is redefinable.
|
|
(let [ctx (init {:compile? true :aot-core? false})]
|
|
(check "aot-core off still correct" (eval-string ctx "(last [1 2 3])") 3))
|
|
|
|
(if (pos? failures)
|
|
(do (printf "direct-linking: %d failure(s)" failures) (os/exit 1))
|
|
(print "direct-linking: all matrix cases passed"))
|