simon/jolt
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
jolt/host/chez/seed/image.ss
Yogthos 63a8cb1cb2 Emit direct self-calls for named-fn self-recursion 
A self-recursive call to a named fn compiled to (jolt-invoke fib ...) instead of
a direct (fib ...): emit-invoke handled a :local callee only when it was NOT a
known proc, so a :local that IS in *known-procs* (the letrec-bound self-name) fell
through to the :else jolt-invoke branch. Now a :local known proc emits a direct
Scheme call — no jolt-invoke, no per-call arg-list consing; case-lambda handles
arity.

fib 30: 63.3ms -> 4.7ms (faster than JVM Clojure's 7.1ms; was 9x slower). The win
is on every self-recursive non-loop fn, including the compiler's own. No semantic
change — selfhost holds, make test green, shakesmoke/buildsmoke byte-identical.

Re-mint (backend is seed). Corpus rows pin self-recursion across fixed/multi/
variadic arities.
2026-06-26 00:34:29 -04:00

552 lines
No EOL
303 KiB
Scheme
Raw Blame History

(guard (e (#t #f))
(def-var! "jolt.ir" "const" (letrec ((const (lambda (v) (let fnrec7219 ((v v)) (let* ((_o$7220 (keyword #f "op")) (_o$7221 (keyword #f "const")) (_o$7222 (keyword #f "val")) (_o$7223 v)) (jolt-hash-map _o$7220 _o$7221 _o$7222 _o$7223)))))) const)))
(guard (e (#t #f))
(def-var! "jolt.ir" "local" (letrec ((local (lambda (name) (let fnrec7224 ((name name)) (let* ((_o$7225 (keyword #f "op")) (_o$7226 (keyword #f "local")) (_o$7227 (keyword #f "name")) (_o$7228 name)) (jolt-hash-map _o$7225 _o$7226 _o$7227 _o$7228)))))) local)))
(guard (e (#t #f))
(def-var! "jolt.ir" "var-ref" (letrec ((var-ref (lambda (ns name) (let fnrec7229 ((ns ns) (name name)) (let* ((_o$7230 (keyword #f "op")) (_o$7231 (keyword #f "var")) (_o$7232 (keyword #f "ns")) (_o$7233 ns) (_o$7234 (keyword #f "name")) (_o$7235 name)) (jolt-hash-map _o$7230 _o$7231 _o$7232 _o$7233 _o$7234 _o$7235)))))) var-ref)))
(guard (e (#t #f))
(def-var! "jolt.ir" "the-var" (letrec ((the-var (lambda (ns name) (let fnrec7236 ((ns ns) (name name)) (let* ((_o$7237 (keyword #f "op")) (_o$7238 (keyword #f "the-var")) (_o$7239 (keyword #f "ns")) (_o$7240 ns) (_o$7241 (keyword #f "name")) (_o$7242 name)) (jolt-hash-map _o$7237 _o$7238 _o$7239 _o$7240 _o$7241 _o$7242)))))) the-var)))
(guard (e (#t #f))
(def-var! "jolt.ir" "host-ref" (letrec ((host-ref (lambda (name) (let fnrec7243 ((name name)) (let* ((_o$7244 (keyword #f "op")) (_o$7245 (keyword #f "host")) (_o$7246 (keyword #f "name")) (_o$7247 name)) (jolt-hash-map _o$7244 _o$7245 _o$7246 _o$7247)))))) host-ref)))
(guard (e (#t #f))
(def-var! "jolt.ir" "host-static" (letrec ((host-static (lambda (class member) (let fnrec7248 ((class class) (member member)) (let* ((_o$7249 (keyword #f "op")) (_o$7250 (keyword #f "host-static")) (_o$7251 (keyword #f "class")) (_o$7252 class) (_o$7253 (keyword #f "member")) (_o$7254 member)) (jolt-hash-map _o$7249 _o$7250 _o$7251 _o$7252 _o$7253 _o$7254)))))) host-static)))
(guard (e (#t #f))
(def-var! "jolt.ir" "host-new" (letrec ((host-new (lambda (class args) (let fnrec7255 ((class class) (args args)) (let* ((_o$7256 (keyword #f "op")) (_o$7257 (keyword #f "host-new")) (_o$7258 (keyword #f "class")) (_o$7259 class) (_o$7260 (keyword #f "args")) (_o$7261 args)) (jolt-hash-map _o$7256 _o$7257 _o$7258 _o$7259 _o$7260 _o$7261)))))) host-new)))
(guard (e (#t #f))
(def-var! "jolt.ir" "if-node" (letrec ((if-node (lambda (test then _else) (let fnrec7262 ((test test) (then then) (_else _else)) (let* ((_o$7263 (keyword #f "op")) (_o$7264 (keyword #f "if")) (_o$7265 (keyword #f "test")) (_o$7266 test) (_o$7267 (keyword #f "then")) (_o$7268 then) (_o$7269 (keyword #f "else")) (_o$7270 _else)) (jolt-hash-map _o$7263 _o$7264 _o$7265 _o$7266 _o$7267 _o$7268 _o$7269 _o$7270)))))) if-node)))
(guard (e (#t #f))
(def-var! "jolt.ir" "do-node" (letrec ((do-node (lambda (statements ret) (let fnrec7271 ((statements statements) (ret ret)) (let* ((_o$7272 (keyword #f "op")) (_o$7273 (keyword #f "do")) (_o$7274 (keyword #f "statements")) (_o$7275 statements) (_o$7276 (keyword #f "ret")) (_o$7277 ret)) (jolt-hash-map _o$7272 _o$7273 _o$7274 _o$7275 _o$7276 _o$7277)))))) do-node)))
(guard (e (#t #f))
(def-var! "jolt.ir" "invoke" (letrec ((invoke (lambda (f args) (let fnrec7278 ((f f) (args args)) (let* ((_o$7279 (keyword #f "op")) (_o$7280 (keyword #f "invoke")) (_o$7281 (keyword #f "fn")) (_o$7282 f) (_o$7283 (keyword #f "args")) (_o$7284 args)) (jolt-hash-map _o$7279 _o$7280 _o$7281 _o$7282 _o$7283 _o$7284)))))) invoke)))
(guard (e (#t #f))
(def-var! "jolt.ir" "def-node" (letrec ((def-node (case-lambda ((ns name init) (let fnrec7285 ((ns ns) (name name) (init init)) (let* ((_o$7286 (keyword #f "op")) (_o$7287 (keyword #f "def")) (_o$7288 (keyword #f "ns")) (_o$7289 ns) (_o$7290 (keyword #f "name")) (_o$7291 name) (_o$7292 (keyword #f "init")) (_o$7293 init)) (jolt-hash-map _o$7286 _o$7287 _o$7288 _o$7289 _o$7290 _o$7291 _o$7292 _o$7293)))) ((ns name init meta) (let fnrec7294 ((ns ns) (name name) (init init) (meta meta)) (if (jolt-truthy? meta) (let* ((_o$7295 (keyword #f "op")) (_o$7296 (keyword #f "def")) (_o$7297 (keyword #f "ns")) (_o$7298 ns) (_o$7299 (keyword #f "name")) (_o$7300 name) (_o$7301 (keyword #f "init")) (_o$7302 init) (_o$7303 (keyword #f "meta")) (_o$7304 meta)) (jolt-hash-map _o$7295 _o$7296 _o$7297 _o$7298 _o$7299 _o$7300 _o$7301 _o$7302 _o$7303 _o$7304)) (let* ((_o$7305 (keyword #f "op")) (_o$7306 (keyword #f "def")) (_o$7307 (keyword #f "ns")) (_o$7308 ns) (_o$7309 (keyword #f "name")) (_o$7310 name) (_o$7311 (keyword #f "init")) (_o$7312 init)) (jolt-hash-map _o$7305 _o$7306 _o$7307 _o$7308 _o$7309 _o$7310 _o$7311 _o$7312)))))))) def-node)))
(guard (e (#t #f))
(def-var! "jolt.ir" "let-node" (letrec ((let-node (lambda (bindings body) (let fnrec7313 ((bindings bindings) (body body)) (let* ((_o$7314 (keyword #f "op")) (_o$7315 (keyword #f "let")) (_o$7316 (keyword #f "bindings")) (_o$7317 bindings) (_o$7318 (keyword #f "body")) (_o$7319 body)) (jolt-hash-map _o$7314 _o$7315 _o$7316 _o$7317 _o$7318 _o$7319)))))) let-node)))
(guard (e (#t #f))
(def-var! "jolt.ir" "fn-node" (letrec ((fn-node (lambda (name arities) (let fnrec7320 ((name name) (arities arities)) (if (jolt-truthy? name) (let* ((_o$7321 (keyword #f "op")) (_o$7322 (keyword #f "fn")) (_o$7323 (keyword #f "name")) (_o$7324 name) (_o$7325 (keyword #f "arities")) (_o$7326 arities)) (jolt-hash-map _o$7321 _o$7322 _o$7323 _o$7324 _o$7325 _o$7326)) (let* ((_o$7327 (keyword #f "op")) (_o$7328 (keyword #f "fn")) (_o$7329 (keyword #f "arities")) (_o$7330 arities)) (jolt-hash-map _o$7327 _o$7328 _o$7329 _o$7330))))))) fn-node)))
(guard (e (#t #f))
(def-var! "jolt.ir" "vector-node" (letrec ((vector-node (lambda (items) (let fnrec7331 ((items items)) (let* ((_o$7332 (keyword #f "op")) (_o$7333 (keyword #f "vector")) (_o$7334 (keyword #f "items")) (_o$7335 items)) (jolt-hash-map _o$7332 _o$7333 _o$7334 _o$7335)))))) vector-node)))
(guard (e (#t #f))
(def-var! "jolt.ir" "map-node" (letrec ((map-node (lambda (pairs) (let fnrec7336 ((pairs pairs)) (let* ((_o$7337 (keyword #f "op")) (_o$7338 (keyword #f "map")) (_o$7339 (keyword #f "pairs")) (_o$7340 pairs)) (jolt-hash-map _o$7337 _o$7338 _o$7339 _o$7340)))))) map-node)))
(guard (e (#t #f))
(def-var! "jolt.ir" "set-node" (letrec ((set-node (lambda (items) (let fnrec7341 ((items items)) (let* ((_o$7342 (keyword #f "op")) (_o$7343 (keyword #f "set")) (_o$7344 (keyword #f "items")) (_o$7345 items)) (jolt-hash-map _o$7342 _o$7343 _o$7344 _o$7345)))))) set-node)))
(guard (e (#t #f))
(def-var! "jolt.ir" "quote-node" (letrec ((quote-node (lambda (form) (let fnrec7346 ((form form)) (let* ((_o$7347 (keyword #f "op")) (_o$7348 (keyword #f "quote")) (_o$7349 (keyword #f "form")) (_o$7350 form)) (jolt-hash-map _o$7347 _o$7348 _o$7349 _o$7350)))))) quote-node)))
(guard (e (#t #f))
(def-var! "jolt.ir" "throw-node" (letrec ((throw-node (lambda (expr) (let fnrec7351 ((expr expr)) (let* ((_o$7352 (keyword #f "op")) (_o$7353 (keyword #f "throw")) (_o$7354 (keyword #f "expr")) (_o$7355 expr)) (jolt-hash-map _o$7352 _o$7353 _o$7354 _o$7355)))))) throw-node)))
(guard (e (#t #f))
(def-var! "jolt.ir" "coerce-node" (letrec ((coerce-node (lambda (kind expr) (let fnrec7356 ((kind kind) (expr expr)) (let* ((_o$7357 (keyword #f "op")) (_o$7358 (keyword #f "coerce")) (_o$7359 (keyword #f "kind")) (_o$7360 kind) (_o$7361 (keyword #f "expr")) (_o$7362 expr)) (jolt-hash-map _o$7357 _o$7358 _o$7359 _o$7360 _o$7361 _o$7362)))))) coerce-node)))
(guard (e (#t #f))
(def-var! "jolt.ir" "map-ir-children" (letrec ((map-ir-children (lambda (f node) (let fnrec7363 ((f f) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$7364 node) (_a$7365 (keyword #f "test")) (_a$7366 (jolt-invoke f (jolt-get node (keyword #f "test")))) (_a$7367 (keyword #f "then")) (_a$7368 (jolt-invoke f (jolt-get node (keyword #f "then")))) (_a$7369 (keyword #f "else")) (_a$7370 (jolt-invoke f (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$7364 _a$7365 _a$7366 _a$7367 _a$7368 _a$7369 _a$7370)) (if (jolt= op (keyword #f "do")) (let* ((_a$7371 node) (_a$7372 (keyword #f "statements")) (_a$7373 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "statements")))) (_a$7374 (keyword #f "ret")) (_a$7375 (jolt-invoke f (jolt-get node (keyword #f "ret"))))) (jolt-assoc _a$7371 _a$7372 _a$7373 _a$7374 _a$7375)) (if (jolt= op (keyword #f "throw")) (jolt-assoc node (keyword #f "expr") (jolt-invoke f (jolt-get node (keyword #f "expr")))) (if (jolt= op (keyword #f "coerce")) (jolt-assoc node (keyword #f "expr") (jolt-invoke f (jolt-get node (keyword #f "expr")))) (if (jolt= op (keyword #f "set-var")) (jolt-assoc node (keyword #f "val") (jolt-invoke f (jolt-get node (keyword #f "val")))) (if (jolt= op (keyword #f "set-field")) (let* ((_a$7376 node) (_a$7377 (keyword #f "obj")) (_a$7378 (jolt-invoke f (jolt-get node (keyword #f "obj")))) (_a$7379 (keyword #f "val")) (_a$7380 (jolt-invoke f (jolt-get node (keyword #f "val"))))) (jolt-assoc _a$7376 _a$7377 _a$7378 _a$7379 _a$7380)) (if (jolt= op (keyword #f "defmacro")) (jolt-assoc node (keyword #f "fn") (jolt-invoke f (jolt-get node (keyword #f "fn")))) (if (jolt= op (keyword #f "ffi-callable")) (jolt-assoc node (keyword #f "fn") (jolt-invoke f (jolt-get node (keyword #f "fn")))) (if (jolt= op (keyword #f "invoke")) (let* ((_a$7381 node) (_a$7382 (keyword #f "fn")) (_a$7383 (jolt-invoke f (jolt-get node (keyword #f "fn")))) (_a$7384 (keyword #f "args")) (_a$7385 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$7381 _a$7382 _a$7383 _a$7384 _a$7385)) (if (jolt= op (keyword #f "vector")) (jolt-assoc node (keyword #f "items") (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "items")))) (if (jolt= op (keyword #f "set")) (jolt-assoc node (keyword #f "items") (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "items")))) (if (jolt= op (keyword #f "map")) (jolt-assoc node (keyword #f "pairs") (let* ((_a$7389 (var-deref "clojure.core" "mapv")) (_a$7390 (lambda (pr) (let fnrec7386 ((pr pr)) (let* ((_o$7387 (jolt-invoke f (jolt-nth pr 0))) (_o$7388 (jolt-invoke f (jolt-nth pr 1)))) (jolt-vector _o$7387 _o$7388))))) (_a$7391 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$7389 _a$7390 _a$7391))) (if (jolt= op (keyword #f "let")) (let* ((_a$7398 node) (_a$7399 (keyword #f "bindings")) (_a$7400 (let* ((_a$7395 (var-deref "clojure.core" "mapv")) (_a$7396 (lambda (b) (let fnrec7392 ((b b)) (let* ((_o$7393 (jolt-nth b 0)) (_o$7394 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$7393 _o$7394))))) (_a$7397 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$7395 _a$7396 _a$7397))) (_a$7401 (keyword #f "body")) (_a$7402 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$7398 _a$7399 _a$7400 _a$7401 _a$7402)) (if (jolt= op (keyword #f "loop")) (let* ((_a$7409 node) (_a$7410 (keyword #f "bindings")) (_a$7411 (let* ((_a$7406 (var-deref "clojure.core" "mapv")) (_a$7407 (lambda (b) (let fnrec7403 ((b b)) (let* ((_o$7404 (jolt-nth b 0)) (_o$7405 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$7404 _o$7405))))) (_a$7408 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$7406 _a$7407 _a$7408))) (_a$7412 (keyword #f "body")) (_a$7413 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$7409 _a$7410 _a$7411 _a$7412 _a$7413)) (if (jolt= op (keyword #f "recur")) (jolt-assoc node (keyword #f "args") (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args")))) (if (jolt= op (keyword #f "fn")) (jolt-assoc node (keyword #f "arities") (let* ((_a$7415 (var-deref "clojure.core" "mapv")) (_a$7416 (lambda (a) (let fnrec7414 ((a a)) (jolt-assoc a (keyword #f "body") (jolt-invoke f (jolt-get a (keyword #f "body"))))))) (_a$7417 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$7415 _a$7416 _a$7417))) (if (jolt= op (keyword #f "def")) (let* ((n (jolt-assoc node (keyword #f "init") (jolt-invoke f (jolt-get node (keyword #f "init")))))) (if (jolt-truthy? (jolt-get node (keyword #f "meta-expr"))) (jolt-assoc n (keyword #f "meta-expr") (jolt-invoke f (jolt-get node (keyword #f "meta-expr")))) n)) (if (jolt= op (keyword #f "host-call")) (let* ((_a$7418 node) (_a$7419 (keyword #f "target")) (_a$7420 (jolt-invoke f (jolt-get node (keyword #f "target")))) (_a$7421 (keyword #f "args")) (_a$7422 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$7418 _a$7419 _a$7420 _a$7421 _a$7422)) (if (jolt= op (keyword #f "host-new")) (jolt-assoc node (keyword #f "args") (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args")))) (if (jolt= op (keyword #f "try")) (let* ((n (jolt-assoc node (keyword #f "body") (jolt-invoke f (jolt-get node (keyword #f "body"))))) (n (if (jolt-truthy? (jolt-get node (keyword #f "catch-body"))) (jolt-assoc n (keyword #f "catch-body") (jolt-invoke f (jolt-get node (keyword #f "catch-body")))) n)) (n (if (jolt-truthy? (jolt-get node (keyword #f "finally"))) (jolt-assoc n (keyword #f "finally") (jolt-invoke f (jolt-get node (keyword #f "finally")))) n))) n) (if (jolt-truthy? (keyword #f "else")) node jolt-nil)))))))))))))))))))))))))) map-ir-children)))
(guard (e (#t #f))
(def-var! "jolt.ir" "reduce-ir-children" (letrec ((reduce-ir-children (lambda (f acc node) (let fnrec7423 ((f f) (acc acc) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$7427 f) (_a$7428 (let* ((_a$7424 f) (_a$7425 (jolt-invoke f acc (jolt-get node (keyword #f "test")))) (_a$7426 (jolt-get node (keyword #f "then")))) (jolt-invoke _a$7424 _a$7425 _a$7426))) (_a$7429 (jolt-get node (keyword #f "else")))) (jolt-invoke _a$7427 _a$7428 _a$7429)) (if (jolt= op (keyword #f "do")) (let* ((_a$7430 f) (_a$7431 (jolt-reduce f acc (jolt-get node (keyword #f "statements")))) (_a$7432 (jolt-get node (keyword #f "ret")))) (jolt-invoke _a$7430 _a$7431 _a$7432)) (if (jolt= op (keyword #f "throw")) (jolt-invoke f acc (jolt-get node (keyword #f "expr"))) (if (jolt= op (keyword #f "coerce")) (jolt-invoke f acc (jolt-get node (keyword #f "expr"))) (if (jolt= op (keyword #f "set-var")) (jolt-invoke f acc (jolt-get node (keyword #f "val"))) (if (jolt= op (keyword #f "set-field")) (let* ((_a$7433 f) (_a$7434 (jolt-invoke f acc (jolt-get node (keyword #f "obj")))) (_a$7435 (jolt-get node (keyword #f "val")))) (jolt-invoke _a$7433 _a$7434 _a$7435)) (if (jolt= op (keyword #f "defmacro")) (jolt-invoke f acc (jolt-get node (keyword #f "fn"))) (if (jolt= op (keyword #f "ffi-callable")) (jolt-invoke f acc (jolt-get node (keyword #f "fn"))) (if (jolt= op (keyword #f "invoke")) (let* ((_a$7436 f) (_a$7437 (jolt-invoke f acc (jolt-get node (keyword #f "fn")))) (_a$7438 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$7436 _a$7437 _a$7438)) (if (jolt= op (keyword #f "vector")) (jolt-reduce f acc (jolt-get node (keyword #f "items"))) (if (jolt= op (keyword #f "set")) (jolt-reduce f acc (jolt-get node (keyword #f "items"))) (if (jolt= op (keyword #f "map")) (let* ((_a$7443 (lambda (a pr) (let fnrec7439 ((a a) (pr pr)) (let* ((_a$7440 f) (_a$7441 (jolt-invoke f a (jolt-nth pr 0))) (_a$7442 (jolt-nth pr 1))) (jolt-invoke _a$7440 _a$7441 _a$7442))))) (_a$7444 acc) (_a$7445 (jolt-get node (keyword #f "pairs")))) (jolt-reduce _a$7443 _a$7444 _a$7445)) (if (jolt= op (keyword #f "let")) (let* ((_a$7450 f) (_a$7451 (let* ((_a$7447 (lambda (a b) (let fnrec7446 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$7448 acc) (_a$7449 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$7447 _a$7448 _a$7449))) (_a$7452 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$7450 _a$7451 _a$7452)) (if (jolt= op (keyword #f "loop")) (let* ((_a$7457 f) (_a$7458 (let* ((_a$7454 (lambda (a b) (let fnrec7453 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$7455 acc) (_a$7456 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$7454 _a$7455 _a$7456))) (_a$7459 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$7457 _a$7458 _a$7459)) (if (jolt= op (keyword #f "recur")) (jolt-reduce f acc (jolt-get node (keyword #f "args"))) (if (jolt= op (keyword #f "fn")) (let* ((_a$7461 (lambda (a ar) (let fnrec7460 ((a a) (ar ar)) (jolt-invoke f a (jolt-get ar (keyword #f "body")))))) (_a$7462 acc) (_a$7463 (jolt-get node (keyword #f "arities")))) (jolt-reduce _a$7461 _a$7462 _a$7463)) (if (jolt= op (keyword #f "def")) (let* ((a (if (jolt-truthy? (jolt-get node (keyword #f "init"))) (jolt-invoke f acc (jolt-get node (keyword #f "init"))) acc))) (if (jolt-truthy? (jolt-get node (keyword #f "meta-expr"))) (jolt-invoke f a (jolt-get node (keyword #f "meta-expr"))) a)) (if (jolt= op (keyword #f "host-call")) (let* ((_a$7464 f) (_a$7465 (jolt-invoke f acc (jolt-get node (keyword #f "target")))) (_a$7466 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$7464 _a$7465 _a$7466)) (if (jolt= op (keyword #f "host-new")) (jolt-reduce f acc (jolt-get node (keyword #f "args"))) (if (jolt= op (keyword #f "try")) (let* ((a (jolt-invoke f acc (jolt-get node (keyword #f "body")))) (a (if (jolt-truthy? (jolt-get node (keyword #f "catch-body"))) (jolt-invoke f a (jolt-get node (keyword #f "catch-body"))) a)) (a (if (jolt-truthy? (jolt-get node (keyword #f "finally"))) (jolt-invoke f a (jolt-get node (keyword #f "finally"))) a))) a) (if (jolt-truthy? (keyword #f "else")) acc jolt-nil)))))))))))))))))))))))))) reduce-ir-children)))
(guard (e (#t #f))
(declare-var! "jolt.analyzer" "analyze"))
(guard (e (#t #f))
(def-var-with-meta! "jolt.analyzer" "handled" (let* ((_o$7467 "quote") (_o$7468 "if") (_o$7469 "do") (_o$7470 "def") (_o$7471 "fn*") (_o$7472 "let*") (_o$7473 "loop*") (_o$7474 "recur") (_o$7475 "throw") (_o$7476 "try") (_o$7477 "syntax-quote") (_o$7478 "var") (_o$7479 "letfn") (_o$7480 "set!") (_o$7481 "defmacro")) (jolt-hash-set _o$7467 _o$7468 _o$7469 _o$7470 _o$7471 _o$7472 _o$7473 _o$7474 _o$7475 _o$7476 _o$7477 _o$7478 _o$7479 _o$7480 _o$7481)) (let* ((_o$7482 (keyword #f "private")) (_o$7483 #t)) (jolt-hash-map _o$7482 _o$7483))))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "uncompilable" (letrec ((uncompilable (lambda (why) (let fnrec7484 ((why why)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "jolt/uncompilable: " why)))))) uncompilable)))
(guard (e (#t #f))
(def-var-with-meta! "jolt.analyzer" "gensym-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (let* ((_o$7485 (keyword #f "private")) (_o$7486 #t)) (jolt-hash-map _o$7485 _o$7486))))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "gen-name" (letrec ((gen-name (lambda (prefix) (let fnrec7487 ((prefix prefix)) (let* ((n (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.analyzer" "gensym-counter")))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.analyzer" "gensym-counter") jolt-inc) (jolt-invoke (var-deref "clojure.core" "str") "_r$" prefix n))))))) gen-name)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "empty-env" (letrec ((empty-env (lambda () (let fnrec7488 () (let* ((_o$7489 (keyword #f "locals")) (_o$7490 (jolt-hash-set)) (_o$7491 (keyword #f "hints")) (_o$7492 (jolt-hash-map))) (jolt-hash-map _o$7489 _o$7490 _o$7491 _o$7492)))))) empty-env)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "local?" (letrec ((local? (lambda (env nm) (let fnrec7493 ((env env) (nm nm)) (jolt-contains? (jolt-get env (keyword #f "locals")) nm))))) local?)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "add-locals" (letrec ((add-locals (lambda (env names) (let fnrec7494 ((env env) (names names)) (jolt-invoke (var-deref "clojure.core" "update") env (keyword #f "locals") (lambda (p__85_) (let fnrec7495 ((p__85_ p__85_)) (jolt-reduce jolt-conj p__85_ names)))))))) add-locals)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "with-recur" (letrec ((with-recur (lambda (env name) (let fnrec7496 ((env env) (name name)) (jolt-assoc env (keyword #f "recur") name))))) with-recur)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "hint-of" (letrec ((hint-of (lambda (ctx sym) (let fnrec7497 ((ctx ctx) (sym sym)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") sym))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") m)) jolt-nil (if (jolt-truthy? (jolt-get m (keyword #f "struct"))) (keyword #f "struct") (if (jolt-truthy? (keyword #f "else")) (let* ((t (jolt-get m (keyword #f "tag")))) (if (jolt-truthy? (let* ((and__25__auto t)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "record-type?") ctx t) and__25__auto))) (keyword #f "struct") jolt-nil)) jolt-nil)))))))) hint-of)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "add-hint" (letrec ((add-hint (lambda (env nm h) (let fnrec7498 ((env env) (nm nm) (h h)) (if (jolt-truthy? h) (jolt-assoc env (keyword #f "hints") (jolt-assoc (jolt-get env (keyword #f "hints")) nm h)) env))))) add-hint)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "phint-of" (letrec ((phint-of (lambda (ctx sym) (let fnrec7499 ((ctx ctx) (sym sym)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") sym))) (if (jolt-truthy? m) (let* ((t (jolt-get m (keyword #f "tag")))) (if (jolt-truthy? t) (jolt-invoke (var-deref "jolt.host" "record-ctor-key") ctx t) jolt-nil)) jolt-nil)))))) phint-of)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "tag->nkind" (letrec ((tag->nkind (lambda (t) (let fnrec7500 ((t t)) (let* ((s (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") t)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") t) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") t)) t (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))) (if (jolt= s "double") (keyword #f "double") (if (jolt= s "long") (keyword #f "long") (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))))))) tag->nkind)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "nhint-of" (letrec ((nhint-of (lambda (ctx sym) (let fnrec7501 ((ctx ctx) (sym sym)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") sym))) (if (jolt-truthy? m) (jolt-invoke (var-deref "jolt.analyzer" "tag->nkind") (jolt-get m (keyword #f "tag"))) jolt-nil)))))) nhint-of)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "with-ret-nhint" (letrec ((with-ret-nhint (lambda (node kind) (let fnrec7502 ((node node) (kind kind)) (if (jolt-truthy? (let* ((and__25__auto kind)) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "fn") (jolt-get node (keyword #f "op"))) and__25__auto))) (jolt-assoc node (keyword #f "arities") (let* ((_a$7504 (var-deref "clojure.core" "mapv")) (_a$7505 (lambda (a) (let fnrec7503 ((a a)) (if (jolt-truthy? (jolt-get a (keyword #f "ret-nhint"))) a (jolt-assoc a (keyword #f "ret-nhint") kind))))) (_a$7506 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$7504 _a$7505 _a$7506))) node))))) with-ret-nhint)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "analyze-seq" (letrec ((analyze-seq (lambda (ctx forms env) (let fnrec7507 ((ctx ctx) (forms forms) (env env)) (let* ((v (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__86_) (let fnrec7508 ((p__86_ p__86_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__86_ env))) forms)) (n (jolt-count v))) (if (jolt-zero? n) (jolt-invoke (var-deref "jolt.ir" "const") jolt-nil) (if (jolt= 1 n) (jolt-first v) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$7509 (var-deref "jolt.ir" "do-node")) (_a$7510 (jolt-invoke (var-deref "clojure.core" "subvec") v 0 (jolt-dec n))) (_a$7511 (jolt-peek v))) (jolt-invoke _a$7509 _a$7510 _a$7511)) jolt-nil)))))))) analyze-seq)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "analyze-bindings" (letrec ((analyze-bindings (lambda (ctx bvec env) (let fnrec7512 ((ctx ctx) (bvec bvec) (env env)) (let* ((i 0) (env env) (pairs (jolt-vector))) (let loop7513 ((i i) (env env) (pairs pairs)) (if (< i (jolt-count bvec)) (let* ((bsym (jolt-nth bvec i))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") bsym)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "destructuring binding") jolt-nil) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") bsym)) (init (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth bvec (jolt-inc i)) env))) (let* ((_a$7520 (+ i 2)) (_a$7521 (let* ((_a$7514 (var-deref "jolt.analyzer" "add-hint")) (_a$7515 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector nm))) (_a$7516 nm) (_a$7517 (jolt-invoke (var-deref "jolt.analyzer" "hint-of") ctx bsym))) (jolt-invoke _a$7514 _a$7515 _a$7516 _a$7517))) (_a$7522 (jolt-conj pairs (let* ((_o$7518 nm) (_o$7519 init)) (jolt-vector _o$7518 _o$7519))))) (loop7513 _a$7520 _a$7521 _a$7522))))) (let* ((_o$7523 pairs) (_o$7524 env)) (jolt-vector _o$7523 _o$7524))))))))) analyze-bindings)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "parse-params" (letrec ((parse-params (lambda (ctx pvec) (let fnrec7525 ((ctx ctx) (pvec pvec)) (let* ((i 0) (fixed (jolt-vector)) (rest-name jolt-nil) (hints (jolt-vector)) (phints (jolt-vector)) (nhints (jolt-vector))) (let loop7526 ((i i) (fixed fixed) (rest-name rest-name) (hints hints) (phints phints) (nhints nhints)) (if (< i (jolt-count pvec)) (let* ((p (jolt-nth pvec i))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") p)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "destructuring fn param") jolt-nil) (if (jolt= "&" (jolt-invoke (var-deref "jolt.host" "form-sym-name") p)) (let* ((r (jolt-nth pvec (jolt-inc i)))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") r)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "destructuring fn rest") jolt-nil) (let* ((_a$7527 (+ i 2)) (_a$7528 fixed) (_a$7529 (jolt-invoke (var-deref "jolt.host" "form-sym-name") r)) (_a$7530 hints) (_a$7531 phints) (_a$7532 nhints)) (loop7526 _a$7527 _a$7528 _a$7529 _a$7530 _a$7531 _a$7532)))) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") p)) (h (jolt-invoke (var-deref "jolt.analyzer" "hint-of") ctx p)) (ph (jolt-invoke (var-deref "jolt.analyzer" "phint-of") ctx p)) (nh (jolt-invoke (var-deref "jolt.analyzer" "nhint-of") ctx p))) (let* ((_a$7539 (jolt-inc i)) (_a$7540 (jolt-conj fixed nm)) (_a$7541 rest-name) (_a$7542 (if (jolt-truthy? h) (jolt-conj hints (let* ((_o$7533 nm) (_o$7534 h)) (jolt-vector _o$7533 _o$7534))) hints)) (_a$7543 (if (jolt-truthy? ph) (jolt-conj phints (let* ((_o$7535 nm) (_o$7536 ph)) (jolt-vector _o$7535 _o$7536))) phints)) (_a$7544 (if (jolt-truthy? nh) (jolt-conj nhints (let* ((_o$7537 nm) (_o$7538 nh)) (jolt-vector _o$7537 _o$7538))) nhints))) (loop7526 _a$7539 _a$7540 _a$7541 _a$7542 _a$7543 _a$7544)))))) (let* ((_o$7545 (keyword #f "fixed")) (_o$7546 fixed) (_o$7547 (keyword #f "rest")) (_o$7548 rest-name) (_o$7549 (keyword #f "hints")) (_o$7550 hints) (_o$7551 (keyword #f "phints")) (_o$7552 phints) (_o$7553 (keyword #f "nhints")) (_o$7554 nhints)) (jolt-hash-map _o$7545 _o$7546 _o$7547 _o$7548 _o$7549 _o$7550 _o$7551 _o$7552 _o$7553 _o$7554))))))))) parse-params)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "uniquify-params" (letrec ((uniquify-params (lambda (names) (let fnrec7555 ((names names)) (let* ((n (jolt-count names))) (let* ((i 0) (out (jolt-vector))) (let loop7556 ((i i) (out out)) (if (< i n) (let* ((nm (jolt-nth names i)) (dup? (let* ((j (jolt-inc i))) (let loop7557 ((j j)) (if (>= j n) #f (if (jolt= nm (jolt-nth names j)) #t (if (jolt-truthy? (keyword #f "else")) (loop7557 (jolt-inc j)) jolt-nil))))))) (let* ((_a$7558 (jolt-inc i)) (_a$7559 (jolt-conj out (if (jolt-truthy? dup?) (jolt-invoke (var-deref "jolt.analyzer" "gen-name") (jolt-invoke (var-deref "clojure.core" "str") nm "_")) nm)))) (loop7556 _a$7558 _a$7559))) out)))))))) uniquify-params)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "analyze-arity" (letrec ((analyze-arity (lambda (ctx pvec body env fn-name) (let fnrec7560 ((ctx ctx) (pvec pvec) (body body) (env env) (fn-name fn-name)) (let* ((pp (jolt-invoke (var-deref "jolt.analyzer" "parse-params") ctx (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") pvec)))) (fixed (jolt-invoke (var-deref "jolt.analyzer" "uniquify-params") (jolt-get pp (keyword #f "fixed")))) (rst (jolt-get pp (keyword #f "rest"))) (rname (jolt-invoke (var-deref "jolt.analyzer" "gen-name") (let* ((_a$7561 (var-deref "clojure.core" "str")) (_a$7562 (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (_a$7563 "/") (_a$7564 (let* ((or__26__auto fn-name)) (if (jolt-truthy? or__26__auto) or__26__auto "fn"))) (_a$7565 "--")) (jolt-invoke _a$7561 _a$7562 _a$7563 _a$7564 _a$7565)))) (names (let* ((G__131 (jolt-invoke (var-deref "clojure.core" "vec") fixed))) (let* ((G__132 (if (jolt-truthy? rst) (jolt-conj G__131 rst) G__131))) (let* ((G__133 (if (jolt-truthy? fn-name) (jolt-conj G__132 fn-name) G__132))) G__133)))) (env0 (jolt-invoke (var-deref "jolt.analyzer" "with-recur") (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names) rname)) (env* (let* ((_a$7571 (lambda (e pr) (let fnrec7566 ((e e) (pr pr)) (let* ((_a$7567 (var-deref "jolt.analyzer" "add-hint")) (_a$7568 e) (_a$7569 (jolt-nth pr 0)) (_a$7570 (jolt-nth pr 1))) (jolt-invoke _a$7567 _a$7568 _a$7569 _a$7570))))) (_a$7572 env0) (_a$7573 (jolt-get pp (keyword #f "hints")))) (jolt-reduce _a$7571 _a$7572 _a$7573))) (arity (let* ((_o$7574 (keyword #f "params")) (_o$7575 fixed) (_o$7576 (keyword #f "recur-name")) (_o$7577 rname) (_o$7578 (keyword #f "body")) (_o$7579 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx body env*))) (jolt-hash-map _o$7574 _o$7575 _o$7576 _o$7577 _o$7578 _o$7579))) (arity (if (jolt-truthy? (jolt-seq (jolt-get pp (keyword #f "phints")))) (jolt-assoc arity (keyword #f "phints") (jolt-get pp (keyword #f "phints"))) arity)) (arity (if (jolt-truthy? (jolt-seq (jolt-get pp (keyword #f "nhints")))) (jolt-assoc arity (keyword #f "nhints") (jolt-get pp (keyword #f "nhints"))) arity))) (if (jolt-truthy? rst) (jolt-assoc arity (keyword #f "rest") rst) arity)))))) analyze-arity)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "strip-arglist-meta" (letrec ((strip-arglist-meta (lambda (form) (let fnrec7580 ((form form)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") form)) (let* ((es (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") form)))) (if (jolt-truthy? (let* ((and__25__auto (jolt= 3 (jolt-count es)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-first es)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "with-meta" (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first es))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-vec?") (jolt-nth es 1)) and__25__auto)) and__25__auto)) and__25__auto))) (jolt-nth es 1) form)) form))))) strip-arglist-meta)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "analyze-fn" (letrec ((analyze-fn (lambda (ctx items env) (let fnrec7581 ((ctx ctx) (items items) (env env)) (let* ((named (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth items 1))) (fn-name (if (jolt-truthy? named) (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth items 1)) jolt-nil)) (rest-items (if (jolt-truthy? named) (jolt-drop 2 items) (jolt-drop 1 items))) (first* (jolt-invoke (var-deref "jolt.analyzer" "strip-arglist-meta") (jolt-first rest-items)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-vec?") first*)) (jolt-invoke (var-deref "jolt.ir" "fn-node") fn-name (jolt-vector (jolt-invoke (var-deref "jolt.analyzer" "analyze-arity") ctx first* (jolt-rest rest-items) env fn-name))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") first*)) (jolt-invoke (var-deref "jolt.ir" "fn-node") fn-name (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (clause) (let fnrec7582 ((clause clause)) (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") clause)))) (let* ((_a$7583 (var-deref "jolt.analyzer" "analyze-arity")) (_a$7584 ctx) (_a$7585 (jolt-invoke (var-deref "jolt.analyzer" "strip-arglist-meta") (jolt-first cl))) (_a$7586 (jolt-rest cl)) (_a$7587 env) (_a$7588 fn-name)) (jolt-invoke _a$7583 _a$7584 _a$7585 _a$7586 _a$7587 _a$7588))))) rest-items)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "fn: bad params") jolt-nil)))))))) analyze-fn)))
(guard (e (#t #f))
(def-var-with-meta! "jolt.analyzer" "catch-all-names" (let* ((_o$7589 "Throwable") (_o$7590 "java.lang.Throwable") (_o$7591 "Object") (_o$7592 "java.lang.Object")) (jolt-hash-set _o$7589 _o$7590 _o$7591 _o$7592)) (let* ((_o$7593 (keyword #f "private")) (_o$7594 #t)) (jolt-hash-map _o$7593 _o$7594))))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "analyze-try" (letrec ((analyze-try (lambda (ctx items env) (let fnrec7595 ((ctx ctx) (items items) (env env)) (let* ((clauses (jolt-rest items)) (body (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))) (catches (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))) (finally-body (jolt-invoke (var-deref "clojure.core" "atom") jolt-nil))) (begin (begin (jolt-count (jolt-map (lambda (c) (let fnrec7596 ((c c)) (begin (let* ((head (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") c)) (jolt-first (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") c))) jolt-nil)) (hname (if (jolt-truthy? (let* ((and__25__auto head)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") head) and__25__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") head) jolt-nil))) (if (jolt= hname "catch") (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") c)))) (begin (if (jolt-truthy? (let* ((or__26__auto (< (jolt-count cl) 3))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth cl 2)))))) (jolt-throw "Unable to parse catch clause; expected (catch class binding body*)") jolt-nil) (jolt-invoke (var-deref "clojure.core" "swap!") catches jolt-conj cl))) (if (jolt= hname "finally") (jolt-invoke (var-deref "clojure.core" "reset!") finally-body (jolt-rest (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") c)))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "swap!") body jolt-conj c) jolt-nil)))) jolt-nil))) clauses)) jolt-nil) (let* ((n (let* ((_o$7597 (keyword #f "op")) (_o$7598 (keyword #f "try")) (_o$7599 (keyword #f "body")) (_o$7600 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-invoke (var-deref "clojure.core" "deref") body) env))) (jolt-hash-map _o$7597 _o$7598 _o$7599 _o$7600))) (n (if (jolt-truthy? (jolt-seq (jolt-invoke (var-deref "clojure.core" "deref") catches))) (let* ((evar-name (jolt-invoke (var-deref "jolt.analyzer" "gen-name") "catch")) (evar (jolt-invoke (var-deref "clojure.core" "symbol") evar-name)) (dispatch (let* ((_a$7605 (lambda (_else cl) (let fnrec7601 ((_else _else) (cl cl)) (let* ((cform (jolt-nth cl 1)) (bindsym (jolt-nth cl 2)) (bodyf (jolt-drop 3 cl)) (letform (jolt-cons (jolt-symbol #f "let") (jolt-cons (jolt-vector bindsym evar) bodyf))) (fullname (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") cform)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") cform) jolt-nil)) (catch-all? (let* ((or__26__auto (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") cform)))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-contains? (var-deref "jolt.analyzer" "catch-all-names") fullname))))) (if (jolt-truthy? catch-all?) letform (jolt-list (jolt-symbol #f "if") (let* ((_a$7602 (jolt-symbol #f "or")) (_a$7603 (jolt-list (jolt-symbol #f "instance?") cform evar)) (_a$7604 (jolt-list (jolt-symbol #f "__catch-broad?") fullname evar))) (jolt-list _a$7602 _a$7603 _a$7604)) letform _else)))))) (_a$7606 (jolt-list (jolt-symbol #f "throw") evar)) (_a$7607 (jolt-reverse (jolt-invoke (var-deref "clojure.core" "deref") catches)))) (jolt-reduce _a$7605 _a$7606 _a$7607)))) (jolt-assoc n (keyword #f "catch-sym") evar-name (keyword #f "catch-body") (let* ((_a$7608 (var-deref "jolt.analyzer" "analyze-seq")) (_a$7609 ctx) (_a$7610 (jolt-list dispatch)) (_a$7611 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector evar-name)))) (jolt-invoke _a$7608 _a$7609 _a$7610 _a$7611)))) n)) (n (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "deref") finally-body)) (jolt-assoc n (keyword #f "finally") (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-invoke (var-deref "clojure.core" "deref") finally-body) env)) n))) n))))))) analyze-try)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "analyze-letfn" (letrec ((analyze-letfn (lambda (ctx items env) (let fnrec7612 ((ctx ctx) (items items) (env env)) (let* ((specs (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 1)))) (names (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__87_) (let fnrec7613 ((p__87_ p__87_)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") p__87_)))))) specs)) (env* (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names)) (binds (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (spec) (let fnrec7614 ((spec spec)) (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") spec)))) (let* ((_o$7615 (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first cl))) (_o$7616 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-cons (jolt-invoke (var-deref "clojure.core" "symbol") "fn") cl) env*))) (jolt-vector _o$7615 _o$7616))))) specs))) (let* ((_o$7617 (keyword #f "op")) (_o$7618 (keyword #f "let")) (_o$7619 (keyword #f "letrec")) (_o$7620 #t) (_o$7621 (keyword #f "bindings")) (_o$7622 binds) (_o$7623 (keyword #f "body")) (_o$7624 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env*))) (jolt-hash-map _o$7617 _o$7618 _o$7619 _o$7620 _o$7621 _o$7622 _o$7623 _o$7624))))))) analyze-letfn)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "field-head?" (letrec ((field-head? (lambda (nm) (let fnrec7625 ((nm nm)) (let* ((and__25__auto (> (jolt-count nm) 2))) (if (jolt-truthy? and__25__auto) (jolt= ".-" (jolt-invoke (var-deref "clojure.core" "subs") nm 0 2)) and__25__auto)))))) field-head?)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "def-meta-expr" (letrec ((def-meta-expr (lambda (ctx base env) (let fnrec7626 ((ctx ctx) (base base) (env env)) (if (jolt-pos? (jolt-count base)) (jolt-invoke (var-deref "jolt.ir" "map-node") (let* ((_a$7630 (var-deref "clojure.core" "mapv")) (_a$7631 (lambda (p) (let fnrec7627 ((p p)) (let* ((k (jolt-first p)) (v (jolt-invoke (var-deref "clojure.core" "second") p))) (let* ((_o$7628 (jolt-invoke (var-deref "jolt.ir" "const") k)) (_o$7629 (if (jolt= k (keyword #f "tag")) (jolt-invoke (var-deref "jolt.ir" "quote-node") v) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx v env)))) (jolt-vector _o$7628 _o$7629)))))) (_a$7632 (jolt-seq base))) (jolt-invoke _a$7630 _a$7631 _a$7632))) jolt-nil))))) def-meta-expr)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "analyze-def" (letrec ((analyze-def (lambda (ctx items env) (let fnrec7633 ((ctx ctx) (items items) (env env)) (let* ((name-sym (jolt-nth items 1))) (begin (if (jolt-not (jolt-invoke (var-deref "jolt.host" "form-sym?") name-sym)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "def name with map metadata") jolt-nil) (if (< (jolt-count items) 3) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") name-sym)) (cur (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx))) (begin (jolt-invoke (var-deref "jolt.host" "host-intern!") ctx cur nm) (let* ((_o$7634 (keyword #f "op")) (_o$7635 (keyword #f "def")) (_o$7636 (keyword #f "ns")) (_o$7637 cur) (_o$7638 (keyword #f "name")) (_o$7639 nm) (_o$7640 (keyword #f "no-init")) (_o$7641 #t)) (jolt-hash-map _o$7634 _o$7635 _o$7636 _o$7637 _o$7638 _o$7639 _o$7640 _o$7641)))) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") name-sym)) (cur (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (has-doc (let* ((and__25__auto (> (jolt-count items) 3))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "string?") (jolt-nth items 2)) and__25__auto))) (val-form (jolt-nth items (if (jolt-truthy? has-doc) 3 2))) (base0 (let* ((or__26__auto (jolt-invoke (var-deref "jolt.host" "form-sym-meta") name-sym))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-hash-map)))) (tag (jolt-get base0 (keyword #f "tag"))) (tag-name (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") tag)) (jolt-invoke (var-deref "jolt.host" "form-sym-name") tag) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") tag)) tag (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))) (base-meta (if (jolt-truthy? tag-name) (let* ((c (jolt-invoke (var-deref "jolt.host" "resolve-class-hint") tag-name))) (if (jolt-truthy? c) (jolt-assoc base0 (keyword #f "tag") c) base0)) base0)) (node-meta (if (jolt-truthy? has-doc) (jolt-assoc base-meta (keyword #f "doc") (jolt-nth items 2)) base-meta))) (begin (jolt-invoke (var-deref "jolt.host" "host-intern!") ctx cur nm) (let* ((node (jolt-invoke (var-deref "jolt.ir" "def-node") cur nm (let* ((_a$7642 (var-deref "jolt.analyzer" "with-ret-nhint")) (_a$7643 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx val-form env)) (_a$7644 (jolt-invoke (var-deref "jolt.analyzer" "tag->nkind") tag))) (jolt-invoke _a$7642 _a$7643 _a$7644)) node-meta)) (me (jolt-invoke (var-deref "jolt.analyzer" "def-meta-expr") ctx node-meta env))) (if (jolt-truthy? me) (jolt-assoc node (keyword #f "meta-expr") me) node))))))))))) analyze-def)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "analyze-set!" (letrec ((analyze-set! (lambda (ctx items env) (let fnrec7645 ((ctx ctx) (items items) (env env)) (let* ((target (jolt-nth items 1)) (val-node (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 2) env)) (ti (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") target)) (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") target)) jolt-nil)) (thead (if (jolt-truthy? (let* ((and__25__auto ti)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-pos? (jolt-count ti)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-first ti)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first ti)) jolt-nil))) (if (jolt-truthy? (let* ((and__25__auto thead)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "field-head?") thead) and__25__auto))) (let* ((_o$7646 (keyword #f "op")) (_o$7647 (keyword #f "set-field")) (_o$7648 (keyword #f "obj")) (_o$7649 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth ti 1) env)) (_o$7650 (keyword #f "field")) (_o$7651 (jolt-invoke (var-deref "clojure.core" "subs") thead 2)) (_o$7652 (keyword #f "val")) (_o$7653 val-node)) (jolt-hash-map _o$7646 _o$7647 _o$7648 _o$7649 _o$7650 _o$7651 _o$7652 _o$7653)) (if (jolt-truthy? (let* ((and__25__auto (jolt= thead "."))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (>= (jolt-count ti) 3))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth ti 1)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth ti 2)))) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "class") (jolt-get (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx (jolt-nth ti 1)) (keyword #f "kind"))) and__25__auto)) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((_a$7657 (var-deref "jolt.ir" "invoke")) (_a$7658 (jolt-invoke (var-deref "jolt.ir" "var-ref") "jolt.host" "set-static-field!")) (_a$7659 (let* ((_o$7654 (jolt-invoke (var-deref "jolt.ir" "const") (jolt-get (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx (jolt-nth ti 1)) (keyword #f "name")))) (_o$7655 (jolt-invoke (var-deref "jolt.ir" "const") (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth ti 2)))) (_o$7656 val-node)) (jolt-vector _o$7654 _o$7655 _o$7656)))) (jolt-invoke _a$7657 _a$7658 _a$7659)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") target)) (begin (if (jolt-truthy? (jolt-invoke (var-deref "jolt.analyzer" "local?") env (jolt-invoke (var-deref "jolt.host" "form-sym-name") target))) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "set! of a local") jolt-nil) (let* ((r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx target))) (begin (if (jolt-not (jolt= (keyword #f "var") (jolt-get r (keyword #f "kind")))) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "set! of a non-var") jolt-nil) (let* ((_o$7663 (keyword #f "op")) (_o$7664 (keyword #f "set-var")) (_o$7665 (keyword #f "the-var")) (_o$7666 (let* ((_a$7660 (var-deref "jolt.ir" "the-var")) (_a$7661 (jolt-get r (keyword #f "ns"))) (_a$7662 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$7660 _a$7661 _a$7662))) (_o$7667 (keyword #f "val")) (_o$7668 val-node)) (jolt-hash-map _o$7663 _o$7664 _o$7665 _o$7666 _o$7667 _o$7668))))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "set! of an unsupported target") jolt-nil))))))))) analyze-set!)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "analyze-special" (letrec ((analyze-special (lambda (ctx op items env) (let fnrec7669 ((ctx ctx) (op op) (items items) (env env)) (let* ((G__134 op)) (if (jolt= G__134 "quote") (jolt-invoke (var-deref "jolt.ir" "quote-node") (jolt-invoke (var-deref "clojure.core" "second") items)) (if (jolt= G__134 "if") (begin (if (jolt-truthy? (let* ((or__26__auto (< (jolt-count items) 3))) (if (jolt-truthy? or__26__auto) or__26__auto (> (jolt-count items) 4)))) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Wrong number of args (" (jolt-dec (jolt-count items)) ") passed to: if")) jolt-nil) (let* ((_a$7670 (var-deref "jolt.ir" "if-node")) (_a$7671 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_a$7672 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 2) env)) (_a$7673 (if (> (jolt-count items) 3) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 3) env) (jolt-invoke (var-deref "jolt.ir" "const") jolt-nil)))) (jolt-invoke _a$7670 _a$7671 _a$7672 _a$7673))) (if (jolt= G__134 "do") (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-rest items) env) (if (jolt= G__134 "throw") (jolt-invoke (var-deref "jolt.ir" "throw-node") (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (if (jolt= G__134 "def") (jolt-invoke (var-deref "jolt.analyzer" "analyze-def") ctx items env) (if (jolt= G__134 "let*") (let* ((bvec (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 1)))) (r (jolt-invoke (var-deref "jolt.analyzer" "analyze-bindings") ctx bvec env))) (let* ((_a$7678 (var-deref "jolt.ir" "let-node")) (_a$7679 (jolt-first r)) (_a$7680 (let* ((_a$7674 (var-deref "jolt.analyzer" "analyze-seq")) (_a$7675 ctx) (_a$7676 (jolt-drop 2 items)) (_a$7677 (jolt-invoke (var-deref "clojure.core" "second") r))) (jolt-invoke _a$7674 _a$7675 _a$7676 _a$7677)))) (jolt-invoke _a$7678 _a$7679 _a$7680))) (if (jolt= G__134 "loop*") (let* ((bvec (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 1)))) (rname (jolt-invoke (var-deref "jolt.analyzer" "gen-name") "loop")) (r (jolt-invoke (var-deref "jolt.analyzer" "analyze-bindings") ctx bvec env)) (env** (jolt-invoke (var-deref "jolt.analyzer" "with-recur") (jolt-invoke (var-deref "clojure.core" "second") r) rname))) (let* ((_o$7681 (keyword #f "op")) (_o$7682 (keyword #f "loop")) (_o$7683 (keyword #f "recur-name")) (_o$7684 rname) (_o$7685 (keyword #f "bindings")) (_o$7686 (jolt-first r)) (_o$7687 (keyword #f "body")) (_o$7688 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env**))) (jolt-hash-map _o$7681 _o$7682 _o$7683 _o$7684 _o$7685 _o$7686 _o$7687 _o$7688))) (if (jolt= G__134 "recur") (let* ((rt (jolt-get env (keyword #f "recur")))) (begin (if (jolt-not rt) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "recur outside loop/fn") jolt-nil) (let* ((_o$7693 (keyword #f "op")) (_o$7694 (keyword #f "recur")) (_o$7695 (keyword #f "recur-name")) (_o$7696 rt) (_o$7697 (keyword #f "args")) (_o$7698 (let* ((_a$7690 (var-deref "clojure.core" "mapv")) (_a$7691 (lambda (p__88_) (let fnrec7689 ((p__88_ p__88_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__88_ env)))) (_a$7692 (jolt-rest items))) (jolt-invoke _a$7690 _a$7691 _a$7692)))) (jolt-hash-map _o$7693 _o$7694 _o$7695 _o$7696 _o$7697 _o$7698)))) (if (jolt= G__134 "try") (jolt-invoke (var-deref "jolt.analyzer" "analyze-try") ctx items env) (if (jolt= G__134 "letfn") (jolt-invoke (var-deref "jolt.analyzer" "analyze-letfn") ctx items env) (if (jolt= G__134 "fn*") (jolt-invoke (var-deref "jolt.analyzer" "analyze-fn") ctx items env) (if (jolt= G__134 "syntax-quote") (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-invoke (var-deref "jolt.host" "form-syntax-quote-lower") ctx (jolt-invoke (var-deref "clojure.core" "second") items)) env) (if (jolt= G__134 "var") (let* ((sym (jolt-invoke (var-deref "clojure.core" "second") items)) (r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx sym))) (if (jolt= (keyword #f "var") (jolt-get r (keyword #f "kind"))) (let* ((_a$7699 (var-deref "jolt.ir" "the-var")) (_a$7700 (jolt-get r (keyword #f "ns"))) (_a$7701 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$7699 _a$7700 _a$7701)) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") (jolt-invoke (var-deref "clojure.core" "str") "var of non-var " (jolt-invoke (var-deref "jolt.host" "form-sym-name") sym))))) (if (jolt= G__134 "defmacro") (let* ((name-sym (jolt-nth items 1)) (nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") name-sym)) (cur (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (after (jolt-drop 2 items)) (after (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") (jolt-first after))) (jolt-rest after) after)) (after (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-map?") (jolt-first after))) (jolt-rest after) after)) (fn-form (jolt-cons (jolt-invoke (var-deref "clojure.core" "symbol") "fn") after))) (begin (jolt-invoke (var-deref "jolt.host" "host-intern!") ctx cur nm) (let* ((_o$7702 (keyword #f "op")) (_o$7703 (keyword #f "defmacro")) (_o$7704 (keyword #f "ns")) (_o$7705 cur) (_o$7706 (keyword #f "name")) (_o$7707 nm) (_o$7708 (keyword #f "fn")) (_o$7709 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx fn-form env))) (jolt-hash-map _o$7702 _o$7703 _o$7704 _o$7705 _o$7706 _o$7707 _o$7708 _o$7709)))) (if (jolt= G__134 "set!") (jolt-invoke (var-deref "jolt.analyzer" "analyze-set!") ctx items env) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") (jolt-invoke (var-deref "clojure.core" "str") "special form " op)))))))))))))))))))))) analyze-special)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "method-head?" (letrec ((method-head? (lambda (nm) (let fnrec7710 ((nm nm)) (let* ((and__25__auto (> (jolt-count nm) 1))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 0 1)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt= "-" (jolt-invoke (var-deref "clojure.core" "subs") nm 1 2))))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 1 2))) and__25__auto)) and__25__auto)) and__25__auto)))))) method-head?)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "analyze-host-call" (letrec ((analyze-host-call (lambda (ctx hname items env) (let fnrec7711 ((ctx ctx) (hname hname) (items items) (env env)) (begin (if (< (jolt-count items) 2) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed member expression, expecting (.method target ...): " hname)) jolt-nil) (let* ((_o$7716 (keyword #f "op")) (_o$7717 (keyword #f "host-call")) (_o$7718 (keyword #f "method")) (_o$7719 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$7720 (keyword #f "target")) (_o$7721 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$7722 (keyword #f "args")) (_o$7723 (let* ((_a$7713 (var-deref "clojure.core" "mapv")) (_a$7714 (lambda (p__89_) (let fnrec7712 ((p__89_ p__89_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__89_ env)))) (_a$7715 (jolt-drop 2 items))) (jolt-invoke _a$7713 _a$7714 _a$7715)))) (jolt-hash-map _o$7716 _o$7717 _o$7718 _o$7719 _o$7720 _o$7721 _o$7722 _o$7723))))))) analyze-host-call)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "ctor-head?" (letrec ((ctor-head? (lambda (nm) (let fnrec7724 ((nm nm)) (let* ((and__25__auto (> (jolt-count nm) 1))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "." (let* ((_a$7725 (var-deref "clojure.core" "subs")) (_a$7726 nm) (_a$7727 (jolt-dec (jolt-count nm))) (_a$7728 (jolt-count nm))) (jolt-invoke _a$7725 _a$7726 _a$7727 _a$7728))))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt= "." (jolt-invoke (var-deref "clojure.core" "subs") nm 0 1))) and__25__auto)) and__25__auto)))))) ctor-head?)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "analyze-ctor" (letrec ((analyze-ctor (lambda (ctx class args env) (let fnrec7729 ((ctx ctx) (class class) (args args) (env env)) (jolt-invoke (var-deref "jolt.ir" "host-new") class (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__90_) (let fnrec7730 ((p__90_ p__90_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__90_ env))) args)))))) analyze-ctor)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "analyze-ffi-fn" (letrec ((analyze-ffi-fn (lambda (ctx items env) (let fnrec7731 ((ctx ctx) (items items) (env env)) (begin (if (jolt-not (<= 4 (jolt-count items) 5)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi/foreign-fn expects (foreign-fn \"sym\" [argtypes] rettype [:blocking])")) jolt-nil) (let* ((_o$7732 (keyword #f "op")) (_o$7733 (keyword #f "ffi-fn")) (_o$7734 (keyword #f "csym")) (_o$7735 (jolt-nth items 1)) (_o$7736 (keyword #f "argtypes")) (_o$7737 (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "clojure.core" "name") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 2)))) (_o$7738 (keyword #f "rettype")) (_o$7739 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$7740 (keyword #f "blocking")) (_o$7741 (let* ((and__25__auto (jolt= 5 (jolt-count items)))) (if (jolt-truthy? and__25__auto) (jolt= "blocking" (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 4))) and__25__auto)))) (jolt-hash-map _o$7732 _o$7733 _o$7734 _o$7735 _o$7736 _o$7737 _o$7738 _o$7739 _o$7740 _o$7741))))))) analyze-ffi-fn)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "analyze-ffi-callable" (letrec ((analyze-ffi-callable (lambda (ctx items env) (let fnrec7742 ((ctx ctx) (items items) (env env)) (begin (if (jolt-not (<= 4 (jolt-count items) 5)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi/foreign-callable expects (foreign-callable f [argtypes] rettype [:collect-safe])")) jolt-nil) (let* ((_o$7743 (keyword #f "op")) (_o$7744 (keyword #f "ffi-callable")) (_o$7745 (keyword #f "fn")) (_o$7746 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$7747 (keyword #f "argtypes")) (_o$7748 (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "clojure.core" "name") (jolt-invoke (var-deref "jolt.host" "form-vec-items") (jolt-nth items 2)))) (_o$7749 (keyword #f "rettype")) (_o$7750 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$7751 (keyword #f "collect-safe")) (_o$7752 (let* ((and__25__auto (jolt= 5 (jolt-count items)))) (if (jolt-truthy? and__25__auto) (jolt= "collect-safe" (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 4))) and__25__auto)))) (jolt-hash-map _o$7743 _o$7744 _o$7745 _o$7746 _o$7747 _o$7748 _o$7749 _o$7750 _o$7751 _o$7752))))))) analyze-ffi-callable)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "analyze-dot" (letrec ((analyze-dot (lambda (ctx items env) (let fnrec7753 ((ctx ctx) (items items) (env env)) (begin (if (< (jolt-count items) 3) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed (. target member ...) form")) jolt-nil) (let* ((target (jolt-nth items 1)) (member (jolt-nth items 2)) (class-target (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") target))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "jolt.analyzer" "local?") env (jolt-invoke (var-deref "jolt.host" "form-sym-name") target))) and__25__auto))) (let* ((r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx target))) (if (jolt= (keyword #f "class") (jolt-get r (keyword #f "kind"))) (jolt-get r (keyword #f "name")) jolt-nil)) jolt-nil))) (if (jolt-truthy? (let* ((and__25__auto class-target)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") member) and__25__auto))) (let* ((_a$7758 (var-deref "jolt.ir" "invoke")) (_a$7759 (jolt-invoke (var-deref "jolt.ir" "host-static") class-target (jolt-invoke (var-deref "jolt.host" "form-sym-name") member))) (_a$7760 (let* ((_a$7755 (var-deref "clojure.core" "mapv")) (_a$7756 (lambda (p__91_) (let fnrec7754 ((p__91_ p__91_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__91_ env)))) (_a$7757 (jolt-drop 3 items))) (jolt-invoke _a$7755 _a$7756 _a$7757)))) (jolt-invoke _a$7758 _a$7759 _a$7760)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") member)) (let* ((_o$7765 (keyword #f "op")) (_o$7766 (keyword #f "host-call")) (_o$7767 (keyword #f "method")) (_o$7768 (jolt-invoke (var-deref "jolt.host" "form-sym-name") member)) (_o$7769 (keyword #f "target")) (_o$7770 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx target env)) (_o$7771 (keyword #f "args")) (_o$7772 (let* ((_a$7762 (var-deref "clojure.core" "mapv")) (_a$7763 (lambda (p__92_) (let fnrec7761 ((p__92_ p__92_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__92_ env)))) (_a$7764 (jolt-drop 3 items))) (jolt-invoke _a$7762 _a$7763 _a$7764)))) (jolt-hash-map _o$7765 _o$7766 _o$7767 _o$7768 _o$7769 _o$7770 _o$7771 _o$7772)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-keyword?") member)) (let* ((_a$7773 (var-deref "jolt.ir" "invoke")) (_a$7774 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx member env)) (_a$7775 (jolt-vector (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)))) (jolt-invoke _a$7773 _a$7774 _a$7775)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "special form . (non-symbol member)") jolt-nil)))))))))) analyze-dot)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "analyze-field" (letrec ((analyze-field (lambda (ctx hname items env) (let fnrec7776 ((ctx ctx) (hname hname) (items items) (env env)) (begin (if (< (jolt-count items) 2) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "Malformed (.-field target) form")) jolt-nil) (let* ((_o$7777 (keyword #f "op")) (_o$7778 (keyword #f "host-call")) (_o$7779 (keyword #f "method")) (_o$7780 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$7781 (keyword #f "target")) (_o$7782 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$7783 (keyword #f "args")) (_o$7784 (jolt-vector))) (jolt-hash-map _o$7777 _o$7778 _o$7779 _o$7780 _o$7781 _o$7782 _o$7783 _o$7784))))))) analyze-field)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "analyze-symbol" (letrec ((analyze-symbol (lambda (ctx form env) (let fnrec7785 ((ctx ctx) (form form) (env env)) (let* ((nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") form)) (ns (jolt-invoke (var-deref "jolt.host" "form-sym-ns") form))) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "nil?") ns))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "local?") env nm) and__25__auto))) (let* ((h (jolt-get (jolt-get env (keyword #f "hints")) nm))) (if (jolt-truthy? h) (jolt-assoc (jolt-invoke (var-deref "jolt.ir" "local") nm) (keyword #f "hint") h) (jolt-invoke (var-deref "jolt.ir" "local") nm))) (if (jolt-truthy? ns) (let* ((r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx form))) (if (jolt= (keyword #f "var") (jolt-get r (keyword #f "kind"))) (let* ((G__135 (let* ((_a$7786 (var-deref "jolt.ir" "var-ref")) (_a$7787 (jolt-get r (keyword #f "ns"))) (_a$7788 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$7786 _a$7787 _a$7788)))) (let* ((G__136 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__135 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__135))) G__136)) (jolt-invoke (var-deref "jolt.ir" "host-static") ns nm))) (if (jolt-truthy? (keyword #f "else")) (let* ((r (jolt-invoke (var-deref "jolt.host" "resolve-global") ctx form))) (let* ((G__137 (jolt-get r (keyword #f "kind")))) (if (jolt= G__137 (keyword #f "var")) (let* ((G__138 (let* ((_a$7789 (var-deref "jolt.ir" "var-ref")) (_a$7790 (jolt-get r (keyword #f "ns"))) (_a$7791 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$7789 _a$7790 _a$7791)))) (let* ((G__139 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__138 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__138))) G__139)) (if (jolt= G__137 (keyword #f "host")) (jolt-invoke (var-deref "jolt.ir" "host-ref") (jolt-get r (keyword #f "name"))) (if (jolt= G__137 (keyword #f "class")) (jolt-invoke (var-deref "jolt.ir" "const") (jolt-get r (keyword #f "name"))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "late-bind?") ctx)) (jolt-invoke (var-deref "jolt.ir" "var-ref") (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx) nm) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") (jolt-invoke (var-deref "clojure.core" "str") "Unable to resolve symbol: " nm " in this context")))))))) jolt-nil)))))))) analyze-symbol)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "analyze-list" (letrec ((analyze-list (lambda (ctx form env) (let fnrec7792 ((ctx ctx) (form form) (env env)) (let* ((items (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") form)))) (if (jolt-zero? (jolt-count items)) (jolt-invoke (var-deref "jolt.ir" "quote-node") form) (let* ((head (jolt-first items)) (hname (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)) and__25__auto))) (jolt-invoke (var-deref "jolt.host" "form-sym-name") head) jolt-nil)) (shadowed (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "local?") env hname) and__25__auto)))) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-contains? (var-deref "jolt.analyzer" "handled") hname)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-macro?") ctx head) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((node (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-invoke (var-deref "jolt.host" "form-expand-1") ctx form) env)) (p (jolt-invoke (var-deref "jolt.host" "form-position") form))) (if (jolt-truthy? (let* ((and__25__auto p)) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))) and__25__auto))) (jolt-assoc node (keyword #f "pos") p) node)) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "jolt.ffi" (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)))) (if (jolt-truthy? and__25__auto) (jolt= "__cfn" (jolt-invoke (var-deref "jolt.host" "form-sym-name") head)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-ffi-fn") ctx items env) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "form-sym?") head))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "jolt.ffi" (jolt-invoke (var-deref "jolt.host" "form-sym-ns") head)))) (if (jolt-truthy? and__25__auto) (jolt= "__ccallable" (jolt-invoke (var-deref "jolt.host" "form-sym-name") head)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-ffi-callable") ctx items env) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (jolt-contains? (var-deref "jolt.analyzer" "handled") hname) and__25__auto))) (let* ((node (jolt-invoke (var-deref "jolt.analyzer" "analyze-special") ctx hname items env)) (p (jolt-invoke (var-deref "jolt.host" "form-position") form))) (if (jolt-truthy? (let* ((and__25__auto p)) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))) and__25__auto))) (jolt-assoc node (keyword #f "pos") p) node)) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "method-head?") hname) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-host-call") ctx hname items env) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "ctor-head?") hname) and__25__auto)) and__25__auto))) (let* ((_a$7793 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$7794 ctx) (_a$7795 (jolt-invoke (var-deref "clojure.core" "subs") hname 0 (jolt-dec (jolt-count hname)))) (_a$7796 (jolt-rest items)) (_a$7797 env)) (jolt-invoke _a$7793 _a$7794 _a$7795 _a$7796 _a$7797)) (if (jolt-truthy? (let* ((and__25__auto (jolt= hname "new"))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (>= (jolt-count items) 2))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-sym?") (jolt-nth items 1)) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((_a$7798 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$7799 ctx) (_a$7800 (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth items 1))) (_a$7801 (jolt-drop 2 items)) (_a$7802 env)) (jolt-invoke _a$7798 _a$7799 _a$7800 _a$7801 _a$7802)) (if (jolt-truthy? (let* ((and__25__auto (jolt= hname "."))) (if (jolt-truthy? and__25__auto) (jolt-not shadowed) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-dot") ctx items env) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.analyzer" "field-head?") hname) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "analyze-field") ctx hname items env) (if (jolt-truthy? (let* ((and__25__auto hname)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not shadowed))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.host" "form-special?") hname) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") (jolt-invoke (var-deref "clojure.core" "str") "special form " hname)) (if (jolt-truthy? (keyword #f "else")) (let* ((n (let* ((_a$7807 (var-deref "jolt.ir" "invoke")) (_a$7808 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx head env)) (_a$7809 (let* ((_a$7804 (var-deref "clojure.core" "mapv")) (_a$7805 (lambda (p__93_) (let fnrec7803 ((p__93_ p__93_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__93_ env)))) (_a$7806 (jolt-rest items))) (jolt-invoke _a$7804 _a$7805 _a$7806)))) (jolt-invoke _a$7807 _a$7808 _a$7809))) (p (jolt-invoke (var-deref "jolt.host" "form-position") form))) (if (jolt-truthy? p) (jolt-assoc n (keyword #f "pos") p) n)) jolt-nil)))))))))))))))))) analyze-list)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "with-coll-meta" (letrec ((with-coll-meta (lambda (ctx form env node) (let fnrec7810 ((ctx ctx) (form form) (env env) (node node)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-coll-meta") form))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") m)) node (let* ((_a$7813 (var-deref "jolt.ir" "invoke")) (_a$7814 (jolt-invoke (var-deref "jolt.ir" "var-ref") "clojure.core" "with-meta")) (_a$7815 (let* ((_o$7811 node) (_o$7812 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx m env))) (jolt-vector _o$7811 _o$7812)))) (jolt-invoke _a$7813 _a$7814 _a$7815)))))))) with-coll-meta)))
(guard (e (#t #f))
(def-var! "jolt.analyzer" "analyze" (letrec ((analyze (case-lambda ((ctx form) (let fnrec7816 ((ctx ctx) (form form)) (analyze ctx form (jolt-invoke (var-deref "jolt.analyzer" "empty-env"))))) ((ctx form env) (let fnrec7817 ((ctx ctx) (form form) (env env)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-literal?") form)) (jolt-invoke (var-deref "jolt.ir" "const") form) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") form)) (jolt-invoke (var-deref "jolt.analyzer" "analyze-symbol") ctx form env) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-vec?") form)) (jolt-invoke (var-deref "jolt.analyzer" "with-coll-meta") ctx form env (jolt-invoke (var-deref "jolt.ir" "vector-node") (let* ((_a$7819 (var-deref "clojure.core" "mapv")) (_a$7820 (lambda (p__94_) (let fnrec7818 ((p__94_ p__94_)) (analyze ctx p__94_ env)))) (_a$7821 (jolt-invoke (var-deref "jolt.host" "form-vec-items") form))) (jolt-invoke _a$7819 _a$7820 _a$7821)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-map?") form)) (jolt-invoke (var-deref "jolt.analyzer" "with-coll-meta") ctx form env (jolt-invoke (var-deref "jolt.ir" "map-node") (let* ((_a$7825 (var-deref "clojure.core" "mapv")) (_a$7826 (lambda (p) (let fnrec7822 ((p p)) (let* ((_o$7823 (analyze ctx (jolt-first p) env)) (_o$7824 (analyze ctx (jolt-invoke (var-deref "clojure.core" "second") p) env))) (jolt-vector _o$7823 _o$7824))))) (_a$7827 (jolt-invoke (var-deref "jolt.host" "form-map-pairs") form))) (jolt-invoke _a$7825 _a$7826 _a$7827)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-set?") form)) (jolt-invoke (var-deref "jolt.analyzer" "with-coll-meta") ctx form env (jolt-invoke (var-deref "jolt.ir" "set-node") (let* ((_a$7829 (var-deref "clojure.core" "mapv")) (_a$7830 (lambda (p__95_) (let fnrec7828 ((p__95_ p__95_)) (analyze ctx p__95_ env)))) (_a$7831 (jolt-invoke (var-deref "jolt.host" "form-set-items") form))) (jolt-invoke _a$7829 _a$7830 _a$7831)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") form)) (jolt-invoke (var-deref "jolt.analyzer" "analyze-list") ctx form env) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-regex?") form)) (let* ((_o$7832 (keyword #f "op")) (_o$7833 (keyword #f "regex")) (_o$7834 (keyword #f "source")) (_o$7835 (jolt-invoke (var-deref "jolt.host" "form-regex-source") form))) (jolt-hash-map _o$7832 _o$7833 _o$7834 _o$7835)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-inst?") form)) (let* ((_o$7836 (keyword #f "op")) (_o$7837 (keyword #f "inst")) (_o$7838 (keyword #f "source")) (_o$7839 (jolt-invoke (var-deref "jolt.host" "form-inst-source") form))) (jolt-hash-map _o$7836 _o$7837 _o$7838 _o$7839)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-uuid?") form)) (let* ((_o$7840 (keyword #f "op")) (_o$7841 (keyword #f "uuid")) (_o$7842 (keyword #f "source")) (_o$7843 (jolt-invoke (var-deref "jolt.host" "form-uuid-source") form))) (jolt-hash-map _o$7840 _o$7841 _o$7842 _o$7843)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-bigdec?") form)) (let* ((_o$7844 (keyword #f "op")) (_o$7845 (keyword #f "bigdec")) (_o$7846 (keyword #f "source")) (_o$7847 (jolt-invoke (var-deref "jolt.host" "form-bigdec-source") form))) (jolt-hash-map _o$7844 _o$7845 _o$7846 _o$7847)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-ns-value?") form)) (let* ((_o$7848 (keyword #f "op")) (_o$7849 (keyword #f "the-ns")) (_o$7850 (keyword #f "name")) (_o$7851 (jolt-invoke (var-deref "jolt.host" "form-ns-value-name") form))) (jolt-hash-map _o$7848 _o$7849 _o$7850 _o$7851)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "unsupported form") jolt-nil))))))))))))))))) analyze)))
(guard (e (#t #f))
(def-var-with-meta! "jolt.backend-scheme" "native-ops" (let* ((_o$6297 "+") (_o$6298 "+") (_o$6299 "-") (_o$6300 "-") (_o$6301 "*") (_o$6302 "*") (_o$6303 "/") (_o$6304 "/") (_o$6305 "<") (_o$6306 "<") (_o$6307 ">") (_o$6308 ">") (_o$6309 "<=") (_o$6310 "<=") (_o$6311 ">=") (_o$6312 ">=") (_o$6313 "=") (_o$6314 "jolt=") (_o$6315 "inc") (_o$6316 "jolt-inc") (_o$6317 "dec") (_o$6318 "jolt-dec") (_o$6319 "not") (_o$6320 "jolt-not") (_o$6321 "min") (_o$6322 "min") (_o$6323 "max") (_o$6324 "max") (_o$6325 "mod") (_o$6326 "modulo") (_o$6327 "rem") (_o$6328 "remainder") (_o$6329 "quot") (_o$6330 "quotient") (_o$6331 "vector") (_o$6332 "jolt-vector") (_o$6333 "hash-map") (_o$6334 "jolt-hash-map") (_o$6335 "hash-set") (_o$6336 "jolt-hash-set") (_o$6337 "conj") (_o$6338 "jolt-conj") (_o$6339 "get") (_o$6340 "jolt-get") (_o$6341 "nth") (_o$6342 "jolt-nth") (_o$6343 "count") (_o$6344 "jolt-count") (_o$6345 "assoc") (_o$6346 "jolt-assoc") (_o$6347 "dissoc") (_o$6348 "jolt-dissoc") (_o$6349 "contains?") (_o$6350 "jolt-contains?") (_o$6351 "empty?") (_o$6352 "jolt-empty?") (_o$6353 "peek") (_o$6354 "jolt-peek") (_o$6355 "pop") (_o$6356 "jolt-pop") (_o$6357 "first") (_o$6358 "jolt-first") (_o$6359 "rest") (_o$6360 "jolt-rest") (_o$6361 "next") (_o$6362 "jolt-next") (_o$6363 "seq") (_o$6364 "jolt-seq") (_o$6365 "cons") (_o$6366 "jolt-cons") (_o$6367 "list") (_o$6368 "jolt-list") (_o$6369 "reverse") (_o$6370 "jolt-reverse") (_o$6371 "last") (_o$6372 "jolt-last") (_o$6373 "map") (_o$6374 "jolt-map") (_o$6375 "filter") (_o$6376 "jolt-filter") (_o$6377 "remove") (_o$6378 "jolt-remove") (_o$6379 "reduce") (_o$6380 "jolt-reduce") (_o$6381 "into") (_o$6382 "jolt-into") (_o$6383 "concat") (_o$6384 "jolt-concat") (_o$6385 "apply") (_o$6386 "jolt-apply") (_o$6387 "range") (_o$6388 "jolt-range") (_o$6389 "take") (_o$6390 "jolt-take") (_o$6391 "drop") (_o$6392 "jolt-drop") (_o$6393 "keys") (_o$6394 "jolt-keys") (_o$6395 "vals") (_o$6396 "jolt-vals") (_o$6397 "even?") (_o$6398 "jolt-even?") (_o$6399 "odd?") (_o$6400 "jolt-odd?") (_o$6401 "pos?") (_o$6402 "jolt-pos?") (_o$6403 "neg?") (_o$6404 "jolt-neg?") (_o$6405 "zero?") (_o$6406 "jolt-zero?") (_o$6407 "identity") (_o$6408 "jolt-identity") (_o$6409 "ex-info") (_o$6410 "jolt-ex-info")) (jolt-hash-map _o$6297 _o$6298 _o$6299 _o$6300 _o$6301 _o$6302 _o$6303 _o$6304 _o$6305 _o$6306 _o$6307 _o$6308 _o$6309 _o$6310 _o$6311 _o$6312 _o$6313 _o$6314 _o$6315 _o$6316 _o$6317 _o$6318 _o$6319 _o$6320 _o$6321 _o$6322 _o$6323 _o$6324 _o$6325 _o$6326 _o$6327 _o$6328 _o$6329 _o$6330 _o$6331 _o$6332 _o$6333 _o$6334 _o$6335 _o$6336 _o$6337 _o$6338 _o$6339 _o$6340 _o$6341 _o$6342 _o$6343 _o$6344 _o$6345 _o$6346 _o$6347 _o$6348 _o$6349 _o$6350 _o$6351 _o$6352 _o$6353 _o$6354 _o$6355 _o$6356 _o$6357 _o$6358 _o$6359 _o$6360 _o$6361 _o$6362 _o$6363 _o$6364 _o$6365 _o$6366 _o$6367 _o$6368 _o$6369 _o$6370 _o$6371 _o$6372 _o$6373 _o$6374 _o$6375 _o$6376 _o$6377 _o$6378 _o$6379 _o$6380 _o$6381 _o$6382 _o$6383 _o$6384 _o$6385 _o$6386 _o$6387 _o$6388 _o$6389 _o$6390 _o$6391 _o$6392 _o$6393 _o$6394 _o$6395 _o$6396 _o$6397 _o$6398 _o$6399 _o$6400 _o$6401 _o$6402 _o$6403 _o$6404 _o$6405 _o$6406 _o$6407 _o$6408 _o$6409 _o$6410)) (let* ((_o$6411 (keyword #f "private")) (_o$6412 #t)) (jolt-hash-map _o$6411 _o$6412))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.backend-scheme" "core-value-procs" (jolt-invoke (var-deref "clojure.core" "merge") (var-deref "jolt.backend-scheme" "native-ops") (let* ((_o$6413 "+") (_o$6414 "jolt-add") (_o$6415 "-") (_o$6416 "jolt-sub") (_o$6417 "*") (_o$6418 "jolt-mul") (_o$6419 "/") (_o$6420 "jolt-div") (_o$6421 "min") (_o$6422 "jolt-min") (_o$6423 "max") (_o$6424 "jolt-max")) (jolt-hash-map _o$6413 _o$6414 _o$6415 _o$6416 _o$6417 _o$6418 _o$6419 _o$6420 _o$6421 _o$6422 _o$6423 _o$6424))) (let* ((_o$6425 (keyword #f "private")) (_o$6426 #t)) (jolt-hash-map _o$6425 _o$6426))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.backend-scheme" "op-arity" (let* ((_o$6468 "inc") (_o$6469 (lambda (p__42_) (let fnrec6427 ((p__42_ p__42_)) (jolt= p__42_ 1)))) (_o$6470 "dec") (_o$6471 (lambda (p__43_) (let fnrec6428 ((p__43_ p__43_)) (jolt= p__43_ 1)))) (_o$6472 "not") (_o$6473 (lambda (p__44_) (let fnrec6429 ((p__44_ p__44_)) (jolt= p__44_ 1)))) (_o$6474 "count") (_o$6475 (lambda (p__45_) (let fnrec6430 ((p__45_ p__45_)) (jolt= p__45_ 1)))) (_o$6476 "empty?") (_o$6477 (lambda (p__46_) (let fnrec6431 ((p__46_ p__46_)) (jolt= p__46_ 1)))) (_o$6478 "peek") (_o$6479 (lambda (p__47_) (let fnrec6432 ((p__47_ p__47_)) (jolt= p__47_ 1)))) (_o$6480 "pop") (_o$6481 (lambda (p__48_) (let fnrec6433 ((p__48_ p__48_)) (jolt= p__48_ 1)))) (_o$6482 "mod") (_o$6483 (lambda (p__49_) (let fnrec6434 ((p__49_ p__49_)) (jolt= p__49_ 2)))) (_o$6484 "rem") (_o$6485 (lambda (p__50_) (let fnrec6435 ((p__50_ p__50_)) (jolt= p__50_ 2)))) (_o$6486 "quot") (_o$6487 (lambda (p__51_) (let fnrec6436 ((p__51_ p__51_)) (jolt= p__51_ 2)))) (_o$6488 "contains?") (_o$6489 (lambda (p__52_) (let fnrec6437 ((p__52_ p__52_)) (jolt= p__52_ 2)))) (_o$6490 "get") (_o$6491 (lambda (p__53_) (let fnrec6438 ((p__53_ p__53_)) (let* ((or__26__auto (jolt= p__53_ 2))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= p__53_ 3)))))) (_o$6492 "nth") (_o$6493 (lambda (p__54_) (let fnrec6439 ((p__54_ p__54_)) (let* ((or__26__auto (jolt= p__54_ 2))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= p__54_ 3)))))) (_o$6494 "assoc") (_o$6495 (lambda (p__55_) (let fnrec6440 ((p__55_ p__55_)) (let* ((and__25__auto (>= p__55_ 3))) (if (jolt-truthy? and__25__auto) (jolt-odd? p__55_) and__25__auto))))) (_o$6496 "dissoc") (_o$6497 (lambda (p__56_) (let fnrec6441 ((p__56_ p__56_)) (>= p__56_ 1)))) (_o$6498 "conj") (_o$6499 (lambda (p__57_) (let fnrec6442 ((p__57_ p__57_)) (>= p__57_ 1)))) (_o$6500 "first") (_o$6501 (lambda (p__58_) (let fnrec6443 ((p__58_ p__58_)) (jolt= p__58_ 1)))) (_o$6502 "rest") (_o$6503 (lambda (p__59_) (let fnrec6444 ((p__59_ p__59_)) (jolt= p__59_ 1)))) (_o$6504 "next") (_o$6505 (lambda (p__60_) (let fnrec6445 ((p__60_ p__60_)) (jolt= p__60_ 1)))) (_o$6506 "seq") (_o$6507 (lambda (p__61_) (let fnrec6446 ((p__61_ p__61_)) (jolt= p__61_ 1)))) (_o$6508 "reverse") (_o$6509 (lambda (p__62_) (let fnrec6447 ((p__62_ p__62_)) (jolt= p__62_ 1)))) (_o$6510 "last") (_o$6511 (lambda (p__63_) (let fnrec6448 ((p__63_ p__63_)) (jolt= p__63_ 1)))) (_o$6512 "keys") (_o$6513 (lambda (p__64_) (let fnrec6449 ((p__64_ p__64_)) (jolt= p__64_ 1)))) (_o$6514 "vals") (_o$6515 (lambda (p__65_) (let fnrec6450 ((p__65_ p__65_)) (jolt= p__65_ 1)))) (_o$6516 "even?") (_o$6517 (lambda (p__66_) (let fnrec6451 ((p__66_ p__66_)) (jolt= p__66_ 1)))) (_o$6518 "odd?") (_o$6519 (lambda (p__67_) (let fnrec6452 ((p__67_ p__67_)) (jolt= p__67_ 1)))) (_o$6520 "pos?") (_o$6521 (lambda (p__68_) (let fnrec6453 ((p__68_ p__68_)) (jolt= p__68_ 1)))) (_o$6522 "neg?") (_o$6523 (lambda (p__69_) (let fnrec6454 ((p__69_ p__69_)) (jolt= p__69_ 1)))) (_o$6524 "zero?") (_o$6525 (lambda (p__70_) (let fnrec6455 ((p__70_ p__70_)) (jolt= p__70_ 1)))) (_o$6526 "identity") (_o$6527 (lambda (p__71_) (let fnrec6456 ((p__71_ p__71_)) (jolt= p__71_ 1)))) (_o$6528 "cons") (_o$6529 (lambda (p__72_) (let fnrec6457 ((p__72_ p__72_)) (jolt= p__72_ 2)))) (_o$6530 "filter") (_o$6531 (lambda (p__73_) (let fnrec6458 ((p__73_ p__73_)) (jolt= p__73_ 2)))) (_o$6532 "remove") (_o$6533 (lambda (p__74_) (let fnrec6459 ((p__74_ p__74_)) (jolt= p__74_ 2)))) (_o$6534 "into") (_o$6535 (lambda (p__75_) (let fnrec6460 ((p__75_ p__75_)) (jolt= p__75_ 2)))) (_o$6536 "take") (_o$6537 (lambda (p__76_) (let fnrec6461 ((p__76_ p__76_)) (jolt= p__76_ 2)))) (_o$6538 "drop") (_o$6539 (lambda (p__77_) (let fnrec6462 ((p__77_ p__77_)) (jolt= p__77_ 2)))) (_o$6540 "map") (_o$6541 (lambda (p__78_) (let fnrec6463 ((p__78_ p__78_)) (>= p__78_ 2)))) (_o$6542 "apply") (_o$6543 (lambda (p__79_) (let fnrec6464 ((p__79_ p__79_)) (>= p__79_ 2)))) (_o$6544 "reduce") (_o$6545 (lambda (p__80_) (let fnrec6465 ((p__80_ p__80_)) (let* ((or__26__auto (jolt= p__80_ 2))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= p__80_ 3)))))) (_o$6546 "range") (_o$6547 (lambda (p__81_) (let fnrec6466 ((p__81_ p__81_)) (let* ((and__25__auto (>= p__81_ 0))) (if (jolt-truthy? and__25__auto) (<= p__81_ 3) and__25__auto))))) (_o$6548 "ex-info") (_o$6549 (lambda (p__82_) (let fnrec6467 ((p__82_ p__82_)) (let* ((or__26__auto (jolt= p__82_ 2))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= p__82_ 3))))))) (jolt-hash-map _o$6468 _o$6469 _o$6470 _o$6471 _o$6472 _o$6473 _o$6474 _o$6475 _o$6476 _o$6477 _o$6478 _o$6479 _o$6480 _o$6481 _o$6482 _o$6483 _o$6484 _o$6485 _o$6486 _o$6487 _o$6488 _o$6489 _o$6490 _o$6491 _o$6492 _o$6493 _o$6494 _o$6495 _o$6496 _o$6497 _o$6498 _o$6499 _o$6500 _o$6501 _o$6502 _o$6503 _o$6504 _o$6505 _o$6506 _o$6507 _o$6508 _o$6509 _o$6510 _o$6511 _o$6512 _o$6513 _o$6514 _o$6515 _o$6516 _o$6517 _o$6518 _o$6519 _o$6520 _o$6521 _o$6522 _o$6523 _o$6524 _o$6525 _o$6526 _o$6527 _o$6528 _o$6529 _o$6530 _o$6531 _o$6532 _o$6533 _o$6534 _o$6535 _o$6536 _o$6537 _o$6538 _o$6539 _o$6540 _o$6541 _o$6542 _o$6543 _o$6544 _o$6545 _o$6546 _o$6547 _o$6548 _o$6549)) (let* ((_o$6550 (keyword #f "private")) (_o$6551 #t)) (jolt-hash-map _o$6550 _o$6551))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.backend-scheme" "cmp1-ops" (let* ((_o$6552 "<") (_o$6553 ">") (_o$6554 "<=") (_o$6555 ">=")) (jolt-hash-set _o$6552 _o$6553 _o$6554 _o$6555)) (let* ((_o$6556 (keyword #f "private")) (_o$6557 #t)) (jolt-hash-map _o$6556 _o$6557))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.backend-scheme" "supported-host-methods" (let* ((_o$6558 "isDirectory") (_o$6559 "listFiles")) (jolt-hash-set _o$6558 _o$6559)) (let* ((_o$6560 (keyword #f "private")) (_o$6561 #t)) (jolt-hash-map _o$6560 _o$6561))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.backend-scheme" "bool-returning-ops" (let* ((_o$6562 "<") (_o$6563 "<=") (_o$6564 ">") (_o$6565 ">=") (_o$6566 "jolt=") (_o$6567 "jolt-not") (_o$6568 "jolt-even?") (_o$6569 "jolt-odd?") (_o$6570 "jolt-pos?") (_o$6571 "jolt-neg?") (_o$6572 "jolt-zero?") (_o$6573 "jolt-empty?") (_o$6574 "jolt-contains?")) (jolt-hash-set _o$6562 _o$6563 _o$6564 _o$6565 _o$6566 _o$6567 _o$6568 _o$6569 _o$6570 _o$6571 _o$6572 _o$6573 _o$6574)) (let* ((_o$6575 (keyword #f "private")) (_o$6576 #t)) (jolt-hash-map _o$6575 _o$6576))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.backend-scheme" "dbl-ops" (let* ((_o$6577 "+") (_o$6578 "fl+") (_o$6579 "-") (_o$6580 "fl-") (_o$6581 "*") (_o$6582 "fl*") (_o$6583 "/") (_o$6584 "fl/") (_o$6585 "min") (_o$6586 "flmin") (_o$6587 "max") (_o$6588 "flmax") (_o$6589 "<") (_o$6590 "fl<?") (_o$6591 ">") (_o$6592 "fl>?") (_o$6593 "<=") (_o$6594 "fl<=?") (_o$6595 ">=") (_o$6596 "fl>=?") (_o$6597 "=") (_o$6598 "fl=?") (_o$6599 "==") (_o$6600 "fl=?")) (jolt-hash-map _o$6577 _o$6578 _o$6579 _o$6580 _o$6581 _o$6582 _o$6583 _o$6584 _o$6585 _o$6586 _o$6587 _o$6588 _o$6589 _o$6590 _o$6591 _o$6592 _o$6593 _o$6594 _o$6595 _o$6596 _o$6597 _o$6598 _o$6599 _o$6600)) (let* ((_o$6601 (keyword #f "private")) (_o$6602 #t)) (jolt-hash-map _o$6601 _o$6602))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.backend-scheme" "lng-ops" (let* ((_o$6603 "+") (_o$6604 "fx+") (_o$6605 "-") (_o$6606 "fx-") (_o$6607 "*") (_o$6608 "fx*") (_o$6609 "min") (_o$6610 "fxmin") (_o$6611 "max") (_o$6612 "fxmax") (_o$6613 "unchecked-add") (_o$6614 "fx+") (_o$6615 "unchecked-subtract") (_o$6616 "fx-") (_o$6617 "unchecked-multiply") (_o$6618 "fx*") (_o$6619 "quot") (_o$6620 "fxquotient") (_o$6621 "rem") (_o$6622 "fxremainder") (_o$6623 "mod") (_o$6624 "fxmodulo") (_o$6625 "<") (_o$6626 "fx<?") (_o$6627 ">") (_o$6628 "fx>?") (_o$6629 "<=") (_o$6630 "fx<=?") (_o$6631 ">=") (_o$6632 "fx>=?") (_o$6633 "=") (_o$6634 "fx=?") (_o$6635 "==") (_o$6636 "fx=?")) (jolt-hash-map _o$6603 _o$6604 _o$6605 _o$6606 _o$6607 _o$6608 _o$6609 _o$6610 _o$6611 _o$6612 _o$6613 _o$6614 _o$6615 _o$6616 _o$6617 _o$6618 _o$6619 _o$6620 _o$6621 _o$6622 _o$6623 _o$6624 _o$6625 _o$6626 _o$6627 _o$6628 _o$6629 _o$6630 _o$6631 _o$6632 _o$6633 _o$6634 _o$6635 _o$6636)) (let* ((_o$6637 (keyword #f "private")) (_o$6638 #t)) (jolt-hash-map _o$6637 _o$6638))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.backend-scheme" "bd-ops" (let* ((_o$6639 "+") (_o$6640 "jbd-add") (_o$6641 "-") (_o$6642 "jbd-sub") (_o$6643 "*") (_o$6644 "jbd-mul") (_o$6645 "/") (_o$6646 "jbd-div") (_o$6647 "min") (_o$6648 "jbd-min") (_o$6649 "max") (_o$6650 "jbd-max") (_o$6651 "quot") (_o$6652 "jbd-quot") (_o$6653 "rem") (_o$6654 "jbd-rem") (_o$6655 "<") (_o$6656 "jbd-lt?") (_o$6657 ">") (_o$6658 "jbd-gt?") (_o$6659 "<=") (_o$6660 "jbd-le?") (_o$6661 ">=") (_o$6662 "jbd-ge?") (_o$6663 "zero?") (_o$6664 "jbd-zero?") (_o$6665 "pos?") (_o$6666 "jbd-pos?") (_o$6667 "neg?") (_o$6668 "jbd-neg?")) (jolt-hash-map _o$6639 _o$6640 _o$6641 _o$6642 _o$6643 _o$6644 _o$6645 _o$6646 _o$6647 _o$6648 _o$6649 _o$6650 _o$6651 _o$6652 _o$6653 _o$6654 _o$6655 _o$6656 _o$6657 _o$6658 _o$6659 _o$6660 _o$6661 _o$6662 _o$6663 _o$6664 _o$6665 _o$6666 _o$6667 _o$6668)) (let* ((_o$6669 (keyword #f "private")) (_o$6670 #t)) (jolt-hash-map _o$6669 _o$6670))))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "prelude-mode?" (jolt-invoke (var-deref "clojure.core" "atom") #f)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "set-prelude-mode!" (letrec ((set-prelude-mode! (lambda (on) (let fnrec6671 ((on on)) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "prelude-mode?") on))))) set-prelude-mode!)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "direct-link?" (jolt-invoke (var-deref "clojure.core" "atom") #f)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "set-direct-link!" (letrec ((set-direct-link! (lambda (on) (let fnrec6672 ((on on)) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "direct-link?") on))))) set-direct-link!)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "direct-link-defined" (jolt-invoke (var-deref "clojure.core" "atom") (jolt-hash-set))))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "direct-link-fns" (jolt-invoke (var-deref "clojure.core" "atom") (jolt-hash-set))))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "direct-link-reset!" (letrec ((direct-link-reset! (lambda () (let fnrec6673 () (begin (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "direct-link-defined") (jolt-hash-set)) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "direct-link-fns") (jolt-hash-set))))))) direct-link-reset!)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "dl-munge" (letrec ((dl-munge (lambda (s) (let fnrec6674 ((s s)) (jolt-invoke (var-deref "clojure.string" "replace") (jolt-invoke (var-deref "clojure.string" "replace") (jolt-invoke (var-deref "clojure.string" "replace") s "$" "_D_") "#" "_H_") "'" "_Q_"))))) dl-munge)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "dl-name" (letrec ((dl-name (lambda (ns nm) (let fnrec6675 ((ns ns) (nm nm)) (let* ((_a$6676 (var-deref "clojure.core" "str")) (_a$6677 "jv$") (_a$6678 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-munge") ns)) (_a$6679 "$") (_a$6680 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-munge") nm))) (jolt-invoke _a$6676 _a$6677 _a$6678 _a$6679 _a$6680)))))) dl-name)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "dl-fqn" (letrec ((dl-fqn (lambda (ns nm) (let fnrec6681 ((ns ns) (nm nm)) (jolt-invoke (var-deref "clojure.core" "str") ns "/" nm))))) dl-fqn)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "direct-linkable?" (letrec ((direct-linkable? (lambda (ns nm) (let fnrec6682 ((ns ns) (nm nm)) (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link?")))) (if (jolt-truthy? and__25__auto) (let* ((_a$6683 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link-defined"))) (_a$6684 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm))) (jolt-contains? _a$6683 _a$6684)) and__25__auto)))))) direct-linkable?)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "direct-link-fn?" (letrec ((direct-link-fn? (lambda (ns nm) (let fnrec6685 ((ns ns) (nm nm)) (let* ((_a$6686 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link-fns"))) (_a$6687 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm))) (jolt-contains? _a$6686 _a$6687)))))) direct-link-fn?)))
(guard (e (#t #f))
(def-var-with-meta! "jolt.backend-scheme" "*recur-target*" jolt-nil (let* ((_o$6688 (keyword #f "dynamic")) (_o$6689 #t)) (jolt-hash-map _o$6688 _o$6689))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.backend-scheme" "*known-procs*" (jolt-hash-set) (let* ((_o$6690 (keyword #f "dynamic")) (_o$6691 #t)) (jolt-hash-map _o$6690 _o$6691))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.backend-scheme" "gensym-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (let* ((_o$6692 (keyword #f "private")) (_o$6693 #t)) (jolt-hash-map _o$6692 _o$6693))))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "fresh-label" (letrec ((fresh-label (lambda (prefix) (let fnrec6694 ((prefix prefix)) (jolt-invoke (var-deref "clojure.core" "str") prefix (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.backend-scheme" "gensym-counter") jolt-inc)))))) fresh-label)))
(guard (e (#t #f))
(def-var-with-meta! "jolt.backend-scheme" "scheme-reserved" (let* ((_o$6695 "if") (_o$6696 "begin") (_o$6697 "lambda") (_o$6698 "let") (_o$6699 "let*") (_o$6700 "letrec") (_o$6701 "letrec*") (_o$6702 "quote") (_o$6703 "quasiquote") (_o$6704 "unquote") (_o$6705 "set!") (_o$6706 "define") (_o$6707 "define-syntax") (_o$6708 "cond") (_o$6709 "case") (_o$6710 "when") (_o$6711 "unless") (_o$6712 "and") (_o$6713 "or") (_o$6714 "do") (_o$6715 "else") (_o$6716 "guard") (_o$6717 "parameterize") (_o$6718 "delay") (_o$6719 "values")) (jolt-hash-set _o$6695 _o$6696 _o$6697 _o$6698 _o$6699 _o$6700 _o$6701 _o$6702 _o$6703 _o$6704 _o$6705 _o$6706 _o$6707 _o$6708 _o$6709 _o$6710 _o$6711 _o$6712 _o$6713 _o$6714 _o$6715 _o$6716 _o$6717 _o$6718 _o$6719)) (let* ((_o$6720 (keyword #f "private")) (_o$6721 #t)) (jolt-hash-map _o$6720 _o$6721))))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "munge-name" (letrec ((munge-name (lambda (s) (let fnrec6722 ((s s)) (let* ((s (jolt-invoke (var-deref "clojure.string" "replace") (jolt-invoke (var-deref "clojure.string" "replace") s "#" "_") "'" "_PRIME_"))) (if (jolt-contains? (var-deref "jolt.backend-scheme" "scheme-reserved") s) (jolt-invoke (var-deref "clojure.core" "str") "_" s) s)))))) munge-name)))
(guard (e (#t #f))
(declare-var! "jolt.backend-scheme" "emit"))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "char-escape" (letrec ((char-escape (lambda (cp) (let fnrec6723 ((cp cp)) (if (jolt= cp 34) "\\\"" (if (jolt= cp 92) "\\\\" (if (jolt= cp 10) "\\n" (if (jolt= cp 9) "\\t" (if (jolt= cp 13) "\\r" (if (jolt-truthy? (let* ((and__25__auto (>= cp 32))) (if (jolt-truthy? and__25__auto) (< cp 127) and__25__auto))) (jolt-invoke (var-deref "clojure.core" "str") (jolt-invoke (var-deref "clojure.core" "char") cp)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "str") "\\x" (jolt-invoke (var-deref "clojure.core" "format") "%x" cp) ";") jolt-nil))))))))))) char-escape)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "chez-str-lit" (letrec ((chez-str-lit (lambda (s) (let fnrec6724 ((s s)) (jolt-invoke (var-deref "clojure.core" "str") "\"" (jolt-apply (var-deref "clojure.core" "str") (jolt-map (lambda (c) (let fnrec6725 ((c c)) (jolt-invoke (var-deref "jolt.backend-scheme" "char-escape") (jolt-invoke (var-deref "clojure.core" "int") c)))) s)) "\""))))) chez-str-lit)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "emit-const" (letrec ((emit-const (lambda (v) (let fnrec6726 ((v v)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") v)) "jolt-nil" (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "boolean?") v)) (if (jolt-truthy? v) "#t" "#f") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "number?") v)) (if (jolt= v +inf.0) "+inf.0" (if (jolt= v -inf.0) "-inf.0" (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "not=") v v)) "+nan.0" (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "float?") v)) (let* ((s (jolt-invoke (var-deref "clojure.core" "str") v))) (if (jolt-truthy? (let* ((or__26__auto (jolt-invoke (var-deref "clojure.string" "includes?") s "."))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-invoke (var-deref "clojure.string" "includes?") s "e")))) s (jolt-invoke (var-deref "clojure.core" "str") s ".0"))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "str") v) jolt-nil))))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") v)) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") v) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "keyword?") v)) (let* ((temp__16__auto (jolt-invoke (var-deref "clojure.core" "namespace") v))) (if (jolt-truthy? temp__16__auto) (let* ((kns temp__16__auto)) (let* ((_a$6727 (var-deref "clojure.core" "str")) (_a$6728 "(keyword ") (_a$6729 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") kns)) (_a$6730 " ") (_a$6731 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "clojure.core" "name") v))) (_a$6732 ")")) (jolt-invoke _a$6727 _a$6728 _a$6729 _a$6730 _a$6731 _a$6732))) (jolt-invoke (var-deref "clojure.core" "str") "(keyword #f " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "clojure.core" "name") v)) ")"))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-char?") v)) (jolt-invoke (var-deref "clojure.core" "str") "(integer->char " (jolt-invoke (var-deref "jolt.host" "form-char-code") v) ")") (if (jolt-truthy? (keyword #f "else")) (jolt-throw (let* ((_a$6733 (jolt-invoke (var-deref "clojure.core" "str") "emit-const: unsupported literal " (jolt-invoke (var-deref "clojure.core" "pr-str") v))) (_a$6734 (jolt-hash-map))) (jolt-ex-info _a$6733 _a$6734))) jolt-nil))))))))))) emit-const)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "emit-ordered" (letrec ((emit-ordered (lambda (ctor arg-strs) (let fnrec6735 ((ctor ctor) (arg-strs arg-strs)) (if (< (jolt-count arg-strs) 2) (jolt-invoke (var-deref "clojure.core" "str") "(" ctor (if (jolt-empty? arg-strs) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " arg-strs))) ")") (let* ((tmps (jolt-map (lambda (_) (let fnrec6736 ((_ _)) (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_o$"))) arg-strs)) (binds (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (t a) (let fnrec6737 ((t t) (a a)) (jolt-invoke (var-deref "clojure.core" "str") "(" t " " a ")"))) tmps arg-strs)))) (jolt-invoke (var-deref "clojure.core" "str") "(let* (" binds ") (" ctor " " (jolt-invoke (var-deref "clojure.string" "join") " " tmps) "))"))))))) emit-ordered)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "side-effect-free?" (letrec ((side-effect-free? (lambda (n) (let fnrec6738 ((n n)) (let* ((_a$6744 (let* ((_o$6739 (keyword #f "const")) (_o$6740 (keyword #f "local")) (_o$6741 (keyword #f "var")) (_o$6742 (keyword #f "the-var")) (_o$6743 (keyword #f "quote"))) (jolt-hash-set _o$6739 _o$6740 _o$6741 _o$6742 _o$6743))) (_a$6745 (jolt-get n (keyword #f "op")))) (jolt-contains? _a$6744 _a$6745)))))) side-effect-free?)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "needs-order?" (letrec ((needs-order? (lambda (nodes) (let fnrec6746 ((nodes nodes)) (> (jolt-count (jolt-remove (var-deref "jolt.backend-scheme" "side-effect-free?") nodes)) 1))))) needs-order?)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "ordered-call" (letrec ((ordered-call (lambda (nodes strs build) (let fnrec6747 ((nodes nodes) (strs strs) (build build)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "needs-order?") nodes)) (let* ((tmps (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (_) (let fnrec6748 ((_ _)) (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_a$"))) strs)) (binds (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (t a) (let fnrec6749 ((t t) (a a)) (jolt-invoke (var-deref "clojure.core" "str") "(" t " " a ")"))) tmps strs)))) (jolt-invoke (var-deref "clojure.core" "str") "(let* (" binds ") " (jolt-invoke build tmps) ")")) (jolt-invoke build strs)))))) ordered-call)))
(guard (e (#t #f))
(declare-var! "jolt.backend-scheme" "emit-quoted"))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "emit-quoted-map" (letrec ((emit-quoted-map (lambda (pairs) (let fnrec6750 ((pairs pairs)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-map " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-invoke (var-deref "clojure.core" "mapcat") (lambda (p) (let fnrec6751 ((p p)) (let* ((_o$6752 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-nth p 0))) (_o$6753 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-nth p 1)))) (jolt-vector _o$6752 _o$6753)))) pairs)) ")"))))) emit-quoted-map)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "emit-quoted-map-value" (letrec ((emit-quoted-map-value (lambda (m) (let fnrec6754 ((m m)) (let* ((pairs (jolt-invoke (var-deref "clojure.core" "sort") (let* ((_a$6760 (lambda (k) (let fnrec6755 ((k k)) (let* ((_a$6756 (var-deref "clojure.core" "str")) (_a$6757 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") k)) (_a$6758 " ") (_a$6759 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get m k)))) (jolt-invoke _a$6756 _a$6757 _a$6758 _a$6759))))) (_a$6761 (jolt-keys m))) (jolt-map _a$6760 _a$6761))))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-map " (jolt-invoke (var-deref "clojure.string" "join") " " pairs) ")")))))) emit-quoted-map-value)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "emit-quoted" (letrec ((emit-quoted (lambda (form) (let fnrec6762 ((form form)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-char?") form)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-const") form) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-literal?") form)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-const") form) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") form)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") form)) (sns (jolt-invoke (var-deref "jolt.host" "form-sym-ns") form)) (nm (jolt-invoke (var-deref "jolt.host" "form-sym-name") form))) (if (jolt-truthy? (let* ((and__25__auto m)) (if (jolt-truthy? and__25__auto) (jolt-pos? (jolt-count m)) and__25__auto))) (let* ((_a$6763 (var-deref "clojure.core" "str")) (_a$6764 "(jolt-symbol/meta ") (_a$6765 (if (jolt-truthy? sns) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") sns) "#f")) (_a$6766 " ") (_a$6767 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$6768 " ") (_a$6769 (emit-quoted m)) (_a$6770 ")")) (jolt-invoke _a$6763 _a$6764 _a$6765 _a$6766 _a$6767 _a$6768 _a$6769 _a$6770)) (let* ((_a$6771 (var-deref "clojure.core" "str")) (_a$6772 "(jolt-symbol ") (_a$6773 (if (jolt-truthy? sns) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") sns) "#f")) (_a$6774 " ") (_a$6775 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$6776 ")")) (jolt-invoke _a$6771 _a$6772 _a$6773 _a$6774 _a$6775 _a$6776)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-set?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-set " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-invoke (var-deref "clojure.core" "sort") (jolt-map emit-quoted (jolt-invoke (var-deref "jolt.host" "form-set-items") form)))) ")") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-list?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-list " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-quoted (jolt-invoke (var-deref "jolt.host" "form-elements") form))) ")") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-vec?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-vector " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-quoted (jolt-invoke (var-deref "jolt.host" "form-vec-items") form))) ")") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-map?") form)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted-map") (jolt-invoke (var-deref "jolt.host" "form-map-pairs") form)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-regex?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-regex " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "jolt.host" "form-regex-source") form)) ")") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "map?") form)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted-map-value") form) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "vector?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-vector " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-quoted form)) ")") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "set?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-set " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-invoke (var-deref "clojure.core" "sort") (jolt-map emit-quoted form))) ")") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "seq?") form)) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-list " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-quoted form)) ")") (if (jolt-truthy? (keyword #f "else")) (jolt-throw (let* ((_a$6777 (jolt-invoke (var-deref "clojure.core" "str") "emit-quoted: unsupported quoted form " (jolt-invoke (var-deref "clojure.core" "pr-str") form))) (_a$6778 (jolt-hash-map))) (jolt-ex-info _a$6777 _a$6778))) jolt-nil))))))))))))))))) emit-quoted)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "jmeta-nonempty?" (letrec ((jmeta-nonempty? (lambda (m) (let fnrec6779 ((m m)) (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "map?") m))) (if (jolt-truthy? and__25__auto) (jolt-pos? (jolt-count m)) and__25__auto)))))) jmeta-nonempty?)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "emit-def-meta" (letrec ((emit-def-meta (lambda (node) (let fnrec6780 ((node node)) (if (jolt-truthy? (jolt-get node (keyword #f "meta-expr"))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "meta-expr"))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get node (keyword #f "meta")))))))) emit-def-meta)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "emit-binding" (letrec ((emit-binding (lambda (b) (let fnrec6781 ((b b)) (let* ((_a$6782 (var-deref "clojure.core" "str")) (_a$6783 "(") (_a$6784 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-nth b 0))) (_a$6785 " ") (_a$6786 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-nth b 1))) (_a$6787 ")")) (jolt-invoke _a$6782 _a$6783 _a$6784 _a$6785 _a$6786 _a$6787)))))) emit-binding)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "emit-let" (letrec ((emit-let (lambda (node) (let fnrec6788 ((node node)) (let* ((kw (if (jolt-truthy? (jolt-get node (keyword #f "letrec"))) "letrec*" "let*"))) (let* ((_a$6789 (var-deref "clojure.core" "str")) (_a$6790 "(") (_a$6791 kw) (_a$6792 " (") (_a$6793 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "emit-binding") (jolt-get node (keyword #f "bindings"))))) (_a$6794 ") ") (_a$6795 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (_a$6796 ")")) (jolt-invoke _a$6789 _a$6790 _a$6791 _a$6792 _a$6793 _a$6794 _a$6795 _a$6796))))))) emit-let)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "emit-loop" (letrec ((emit-loop (lambda (node) (let fnrec6797 ((node node)) (let* ((label (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "loop")) (pairs (jolt-get node (keyword #f "bindings"))) (names (jolt-map (lambda (p__83_) (let fnrec6798 ((p__83_ p__83_)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-nth p__83_ 0)))) pairs)) (inits (jolt-map (lambda (p__84_) (let fnrec6799 ((p__84_ p__84_)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-nth p__84_ 1)))) pairs)) (seq-bs (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (n i) (let fnrec6800 ((n n) (i i)) (jolt-invoke (var-deref "clojure.core" "str") "(" n " " i ")"))) names inits))) (rebinds (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (n) (let fnrec6801 ((n n)) (jolt-invoke (var-deref "clojure.core" "str") "(" n " " n ")"))) names))) (body (let* ((frame__20__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "jolt.backend-scheme" "*recur-target*") label))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__20__auto) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings")))))))) (jolt-invoke (var-deref "clojure.core" "str") "(let* (" seq-bs ") (let " label " (" rebinds ") " body "))")))))) emit-loop)))
(guard (e (#t #f))
(def-var-with-meta! "jolt.backend-scheme" "ffi-types" (let* ((_o$6802 "int") (_o$6803 "int") (_o$6804 "uint") (_o$6805 "unsigned-int") (_o$6806 "long") (_o$6807 "long") (_o$6808 "ulong") (_o$6809 "unsigned-long") (_o$6810 "int64") (_o$6811 "integer-64") (_o$6812 "uint64") (_o$6813 "unsigned-64") (_o$6814 "size_t") (_o$6815 "size_t") (_o$6816 "ssize_t") (_o$6817 "ssize_t") (_o$6818 "iptr") (_o$6819 "iptr") (_o$6820 "uptr") (_o$6821 "uptr") (_o$6822 "double") (_o$6823 "double") (_o$6824 "float") (_o$6825 "float") (_o$6826 "pointer") (_o$6827 "void*") (_o$6828 "void*") (_o$6829 "void*") (_o$6830 "string") (_o$6831 "string") (_o$6832 "void") (_o$6833 "void") (_o$6834 "uint8") (_o$6835 "unsigned-8") (_o$6836 "u8") (_o$6837 "unsigned-8") (_o$6838 "byte") (_o$6839 "unsigned-8") (_o$6840 "char") (_o$6841 "char")) (jolt-hash-map _o$6802 _o$6803 _o$6804 _o$6805 _o$6806 _o$6807 _o$6808 _o$6809 _o$6810 _o$6811 _o$6812 _o$6813 _o$6814 _o$6815 _o$6816 _o$6817 _o$6818 _o$6819 _o$6820 _o$6821 _o$6822 _o$6823 _o$6824 _o$6825 _o$6826 _o$6827 _o$6828 _o$6829 _o$6830 _o$6831 _o$6832 _o$6833 _o$6834 _o$6835 _o$6836 _o$6837 _o$6838 _o$6839 _o$6840 _o$6841)) (let* ((_o$6842 (keyword #f "private")) (_o$6843 #t)) (jolt-hash-map _o$6842 _o$6843))))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "ffi-type->chez" (letrec ((ffi-type->chez (lambda (t) (let fnrec6844 ((t t)) (let* ((or__26__auto (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-types") t))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-throw (let* ((_a$6845 (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi: unknown foreign type :" t)) (_a$6846 (jolt-hash-map))) (jolt-ex-info _a$6845 _a$6846))))))))) ffi-type->chez)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "emit-ffi-fn" (letrec ((emit-ffi-fn (lambda (node) (let fnrec6847 ((node node)) (let* ((_a$6848 (var-deref "clojure.core" "str")) (_a$6849 "(foreign-procedure ") (_a$6850 (if (jolt-truthy? (jolt-get node (keyword #f "blocking"))) "__collect_safe " jolt-nil)) (_a$6851 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "csym")))) (_a$6852 " (") (_a$6853 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "argtypes"))))) (_a$6854 ") ") (_a$6855 (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "rettype")))) (_a$6856 ")")) (jolt-invoke _a$6848 _a$6849 _a$6850 _a$6851 _a$6852 _a$6853 _a$6854 _a$6855 _a$6856)))))) emit-ffi-fn)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "emit-ffi-callable" (letrec ((emit-ffi-callable (lambda (node) (let fnrec6857 ((node node)) (let* ((_a$6858 (var-deref "clojure.core" "str")) (_a$6859 "(jolt-ffi-register-callable! (foreign-callable ") (_a$6860 (if (jolt-truthy? (jolt-get node (keyword #f "collect-safe"))) "__collect_safe " jolt-nil)) (_a$6861 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "fn")))) (_a$6862 " (") (_a$6863 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "argtypes"))))) (_a$6864 ") ") (_a$6865 (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "rettype")))) (_a$6866 "))")) (jolt-invoke _a$6858 _a$6859 _a$6860 _a$6861 _a$6862 _a$6863 _a$6864 _a$6865 _a$6866)))))) emit-ffi-callable)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "emit-recur" (letrec ((emit-recur (lambda (node) (let fnrec6867 ((node node)) (begin (if (jolt-not (var-deref "jolt.backend-scheme" "*recur-target*")) (jolt-throw (jolt-ex-info "emit: recur outside a loop/fn target" (jolt-hash-map))) jolt-nil) (let* ((arg-nodes (jolt-get node (keyword #f "args")))) (let* ((_a$6869 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$6870 arg-nodes) (_a$6871 (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "jolt.backend-scheme" "emit") arg-nodes)) (_a$6872 (lambda (as) (let fnrec6868 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" (var-deref "jolt.backend-scheme" "*recur-target*") " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")"))))) (jolt-invoke _a$6869 _a$6870 _a$6871 _a$6872)))))))) emit-recur)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "nhint-init" (letrec ((nhint-init (lambda (nh orig munged) (let fnrec6873 ((nh nh) (orig orig) (munged munged)) (let* ((k (jolt-get nh orig))) (if (jolt= k (keyword #f "double")) (jolt-invoke (var-deref "clojure.core" "str") "(exact->inexact " munged ")") (if (jolt= k (keyword #f "long")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt->fx " munged ")") (if (jolt-truthy? (keyword #f "else")) munged jolt-nil)))))))) nhint-init)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "emit-arity-clause" (letrec ((emit-arity-clause (lambda (a) (let fnrec6874 ((a a)) (let* ((orig (jolt-get a (keyword #f "params"))) (nh (let* ((_a$6875 (jolt-hash-map)) (_a$6876 (jolt-get a (keyword #f "nhints")))) (jolt-into _a$6875 _a$6876))) (params (jolt-map (var-deref "jolt.backend-scheme" "munge-name") orig)) (restp (let* ((temp__27__auto (jolt-get a (keyword #f "rest")))) (if (jolt-truthy? temp__27__auto) (let* ((r temp__27__auto)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") r)) jolt-nil))) (label (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "fnrec")) (body (let* ((frame__20__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "jolt.backend-scheme" "*recur-target*") label))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__20__auto) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get a (keyword #f "body")))) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings"))))))) (paramlist (if (jolt-truthy? (let* ((and__25__auto restp)) (if (jolt-truthy? and__25__auto) (jolt-empty? params) and__25__auto))) restp (if (jolt-truthy? restp) (jolt-invoke (var-deref "clojure.core" "str") "(" (jolt-invoke (var-deref "clojure.string" "join") " " params) " . " restp ")") (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "str") "(" (jolt-invoke (var-deref "clojure.string" "join") " " params) ")") jolt-nil)))) (pbind (jolt-map (lambda (o p) (let fnrec6877 ((o o) (p p)) (jolt-invoke (var-deref "clojure.core" "str") "(" p " " (jolt-invoke (var-deref "jolt.backend-scheme" "nhint-init") nh o p) ")"))) orig params)) (binds (if (jolt-truthy? restp) (jolt-concat pbind (jolt-vector (jolt-invoke (var-deref "clojure.core" "str") "(" restp " (list->cseq " restp "))"))) pbind)) (lett (jolt-invoke (var-deref "clojure.core" "str") "(let " label " (" (jolt-invoke (var-deref "clojure.string" "join") " " binds) ") " body ")")) (ret (jolt-get a (keyword #f "ret-nhint")))) (let* ((_o$6878 paramlist) (_o$6879 (if (jolt= ret (keyword #f "double")) (jolt-invoke (var-deref "clojure.core" "str") "(exact->inexact " lett ")") (if (jolt= ret (keyword #f "long")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt->fx " lett ")") (if (jolt-truthy? (keyword #f "else")) lett jolt-nil))))) (jolt-vector _o$6878 _o$6879))))))) emit-arity-clause)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "emit-fn" (letrec ((emit-fn (lambda (node) (let fnrec6880 ((node node)) (let* ((arities (jolt-get node (keyword #f "arities"))) (self (let* ((temp__27__auto (jolt-get node (keyword #f "name")))) (if (jolt-truthy? temp__27__auto) (let* ((nm temp__27__auto)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") nm)) jolt-nil))) (clauses (let* ((frame__20__auto (jolt-invoke (var-deref "clojure.core" "array-map") (jolt-var "jolt.backend-scheme" "*known-procs*") (if (jolt-truthy? self) (jolt-conj (var-deref "jolt.backend-scheme" "*known-procs*") self) (var-deref "jolt.backend-scheme" "*known-procs*"))))) (begin (jolt-invoke (var-deref "clojure.core" "push-thread-bindings") frame__20__auto) (dynamic-wind (lambda () #f) (lambda () (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "jolt.backend-scheme" "emit-arity-clause") arities)) (lambda () (jolt-invoke (var-deref "clojure.core" "pop-thread-bindings"))))))) (_lambda (if (jolt= 1 (jolt-count clauses)) (let* ((c (jolt-first clauses))) (let* ((_a$6881 (var-deref "clojure.core" "str")) (_a$6882 "(lambda ") (_a$6883 (jolt-nth c 0)) (_a$6884 " ") (_a$6885 (jolt-nth c 1)) (_a$6886 ")")) (jolt-invoke _a$6881 _a$6882 _a$6883 _a$6884 _a$6885 _a$6886))) (jolt-invoke (var-deref "clojure.core" "str") "(case-lambda " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (c) (let fnrec6887 ((c c)) (let* ((_a$6888 (var-deref "clojure.core" "str")) (_a$6889 "(") (_a$6890 (jolt-nth c 0)) (_a$6891 " ") (_a$6892 (jolt-nth c 1)) (_a$6893 ")")) (jolt-invoke _a$6888 _a$6889 _a$6890 _a$6891 _a$6892 _a$6893)))) clauses)) ")")))) (let* ((temp__16__auto (jolt-get node (keyword #f "name")))) (if (jolt-truthy? temp__16__auto) (let* ((nm temp__16__auto)) (let* ((m (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") nm))) (jolt-invoke (var-deref "clojure.core" "str") "(letrec ((" m " " _lambda ")) " m ")"))) _lambda))))))) emit-fn)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "native-op" (letrec ((native-op (lambda (fnode nargs) (let fnrec6894 ((fnode fnode) (nargs nargs)) (let* ((nm (let* ((G__123 (jolt-get fnode (keyword #f "op")))) (if (jolt= G__123 (keyword #f "var")) (if (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) (jolt-get fnode (keyword #f "name")) jolt-nil) (if (jolt= G__123 (keyword #f "host")) (jolt-get fnode (keyword #f "name")) jolt-nil)))) (op (if (jolt-truthy? nm) (jolt-invoke (var-deref "jolt.backend-scheme" "native-ops") nm) jolt-nil)) (arity-ok (if (jolt-truthy? nm) (jolt-invoke (var-deref "jolt.backend-scheme" "op-arity") nm) jolt-nil))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") op)) jolt-nil (if (jolt-truthy? (let* ((and__25__auto arity-ok)) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke arity-ok nargs)) and__25__auto))) jolt-nil (if (jolt-truthy? (keyword #f "else")) op jolt-nil)))))))) native-op)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "ifn-kind" (letrec ((ifn-kind (lambda (fnode) (let fnrec6895 ((fnode fnode)) (let* ((G__124 (jolt-get fnode (keyword #f "op")))) (if (jolt= G__124 (keyword #f "const")) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "keyword?") (jolt-get fnode (keyword #f "val")))) (keyword #f "keyword") jolt-nil) (if (jolt-truthy? (let* ((or__26__auto (jolt= G__124 (keyword #f "map")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= G__124 (keyword #f "set")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= G__124 (keyword #f "vector"))))))) (keyword #f "coll") jolt-nil))))))) ifn-kind)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "stdlib-var?" (letrec ((stdlib-var? (lambda (n) (let fnrec6896 ((n n)) (let* ((and__25__auto (jolt= (keyword #f "var") (jolt-get n (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.string" "starts-with?") (let* ((or__26__auto (jolt-get n (keyword #f "ns")))) (if (jolt-truthy? or__26__auto) or__26__auto "")) "clojure.") and__25__auto)))))) stdlib-var?)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "emit-numeric" (letrec ((emit-numeric (lambda (kind nm args order-args) (let fnrec6897 ((kind kind) (nm nm) (args args) (order-args order-args)) (if (jolt-truthy? (let* ((and__25__auto (jolt= kind (keyword #f "double")))) (if (jolt-truthy? and__25__auto) (jolt= nm "inc") and__25__auto))) (jolt-invoke (var-deref "clojure.core" "str") "(fl+ " (jolt-first args) " 1.0)") (if (jolt-truthy? (let* ((and__25__auto (jolt= kind (keyword #f "double")))) (if (jolt-truthy? and__25__auto) (jolt= nm "dec") and__25__auto))) (jolt-invoke (var-deref "clojure.core" "str") "(fl- " (jolt-first args) " 1.0)") (if (jolt-truthy? (let* ((and__25__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__25__auto) (let* ((or__26__auto (jolt= nm "inc"))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= nm "unchecked-inc"))) and__25__auto))) (jolt-invoke (var-deref "clojure.core" "str") "(fx1+ " (jolt-first args) ")") (if (jolt-truthy? (let* ((and__25__auto (jolt= kind (keyword #f "long")))) (if (jolt-truthy? and__25__auto) (let* ((or__26__auto (jolt= nm "dec"))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= nm "unchecked-dec"))) and__25__auto))) (jolt-invoke (var-deref "clojure.core" "str") "(fx1- " (jolt-first args) ")") (if (jolt-truthy? (keyword #f "else")) (let* ((op (let* ((G__125 kind)) (if (jolt= G__125 (keyword #f "double")) (jolt-invoke (var-deref "jolt.backend-scheme" "dbl-ops") nm) (if (jolt= G__125 (keyword #f "long")) (jolt-invoke (var-deref "jolt.backend-scheme" "lng-ops") nm) (if (jolt= G__125 (keyword #f "bigdec")) (jolt-invoke (var-deref "jolt.backend-scheme" "bd-ops") nm) (jolt-throw (let* ((_a$6898 (jolt-invoke (var-deref "clojure.core" "str") "No matching clause: " G__125)) (_a$6899 (jolt-hash-map))) (jolt-ex-info _a$6898 _a$6899))))))))) (jolt-invoke order-args (lambda (as) (let fnrec6900 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" op " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")"))))) jolt-nil))))))))) emit-numeric)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "emit-invoke" (letrec ((emit-invoke (lambda (node) (let fnrec6901 ((node node)) (let* ((fnode (jolt-get node (keyword #f "fn"))) (arg-nodes (jolt-get node (keyword #f "args"))) (args (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "jolt.backend-scheme" "emit") arg-nodes)) (nop (jolt-invoke (var-deref "jolt.backend-scheme" "native-op") fnode (jolt-count args))) (kind (jolt-invoke (var-deref "jolt.backend-scheme" "ifn-kind") fnode)) (order-args (lambda (build) (let fnrec6902 ((build build)) (jolt-invoke (var-deref "jolt.backend-scheme" "ordered-call") arg-nodes args build)))) (defstr (lambda (as) (let fnrec6903 ((as as)) (if (> (jolt-count as) 1) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-nth as 1)) "")))) (invoke (lambda () (let fnrec6904 () (let* ((_a$6906 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$6907 (jolt-cons fnode arg-nodes)) (_a$6908 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$6909 (lambda (G__126) (let fnrec6905 ((G__126 G__126)) (let* ((G__127 G__126) (f (jolt-nth G__127 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__127 1))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-invoke " f (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "") ")")))))) (jolt-invoke _a$6906 _a$6907 _a$6908 _a$6909)))))) (if (jolt-truthy? (jolt-get node (keyword #f "num-kind"))) (let* ((_a$6910 (var-deref "jolt.backend-scheme" "emit-numeric")) (_a$6911 (jolt-get node (keyword #f "num-kind"))) (_a$6912 (jolt-get fnode (keyword #f "name"))) (_a$6913 args) (_a$6914 order-args)) (jolt-invoke _a$6910 _a$6911 _a$6912 _a$6913 _a$6914)) (if (jolt-truthy? (let* ((and__25__auto nop)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-empty? args))) (if (jolt-truthy? and__25__auto) (jolt= nop "+") and__25__auto)) and__25__auto))) "0" (if (jolt-truthy? (let* ((and__25__auto nop)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-empty? args))) (if (jolt-truthy? and__25__auto) (jolt= nop "*") and__25__auto)) and__25__auto))) "1" (if (jolt-truthy? (let* ((and__25__auto nop)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= 1 (jolt-count args)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.backend-scheme" "cmp1-ops") nop) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "clojure.core" "str") "(begin " (jolt-first args) " #t)") (if (jolt-truthy? nop) (jolt-invoke order-args (lambda (as) (let fnrec6915 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" nop " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")")))) (if (jolt= kind (keyword #f "keyword")) (jolt-invoke order-args (lambda (as) (let fnrec6916 ((as as)) (let* ((_a$6917 (var-deref "clojure.core" "str")) (_a$6918 "(jolt-get ") (_a$6919 (jolt-first as)) (_a$6920 " ") (_a$6921 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode)) (_a$6922 (jolt-invoke defstr as)) (_a$6923 ")")) (jolt-invoke _a$6917 _a$6918 _a$6919 _a$6920 _a$6921 _a$6922 _a$6923))))) (if (jolt= kind (keyword #f "coll")) (let* ((_a$6925 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$6926 (jolt-cons fnode arg-nodes)) (_a$6927 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$6928 (lambda (G__128) (let fnrec6924 ((G__128 G__128)) (let* ((G__129 G__128) (c (jolt-nth G__129 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__129 1))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-get " c " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")")))))) (jolt-invoke _a$6925 _a$6926 _a$6927 _a$6928)) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.backend-scheme" "stdlib-var?") fnode))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "prelude-mode?"))) and__25__auto))) (jolt-throw (let* ((_a$6935 (let* ((_a$6929 (var-deref "clojure.core" "str")) (_a$6930 "emit: unsupported stdlib fn `") (_a$6931 (jolt-get fnode (keyword #f "ns"))) (_a$6932 "/") (_a$6933 (jolt-get fnode (keyword #f "name"))) (_a$6934 "` (no core on Chez yet)")) (jolt-invoke _a$6929 _a$6930 _a$6931 _a$6932 _a$6933 _a$6934))) (_a$6936 (jolt-hash-map))) (jolt-ex-info _a$6935 _a$6936))) (if (jolt= (keyword #f "host-static") (jolt-get fnode (keyword #f "op"))) (jolt-invoke order-args (lambda (as) (let fnrec6937 ((as as)) (let* ((_a$6938 (var-deref "clojure.core" "str")) (_a$6939 "(host-static-call ") (_a$6940 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "class")))) (_a$6941 " ") (_a$6942 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "member")))) (_a$6943 (if (jolt-empty? as) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)))) (_a$6944 ")")) (jolt-invoke _a$6938 _a$6939 _a$6940 _a$6941 _a$6942 _a$6943 _a$6944))))) (if (jolt= (keyword #f "host") (jolt-get fnode (keyword #f "op"))) (jolt-throw (let* ((_a$6945 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host call `" (jolt-get fnode (keyword #f "name")) "`")) (_a$6946 (jolt-hash-map))) (jolt-ex-info _a$6945 _a$6946))) (if (jolt= (keyword #f "local") (jolt-get fnode (keyword #f "op"))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "*known-procs*") (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get fnode (keyword #f "name"))))) (jolt-invoke order-args (lambda (as) (let fnrec6947 ((as as)) (let* ((_a$6948 (var-deref "clojure.core" "str")) (_a$6949 "(") (_a$6950 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get fnode (keyword #f "name")))) (_a$6951 (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "")) (_a$6952 ")")) (jolt-invoke _a$6948 _a$6949 _a$6950 _a$6951 _a$6952))))) (jolt-invoke invoke)) (if (jolt-truthy? (let* ((and__25__auto (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (let* ((_a$6953 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$6954 (jolt-get fnode (keyword #f "ns"))) (_a$6955 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$6953 _a$6954 _a$6955)))) (if (jolt-truthy? and__25__auto) (let* ((_a$6956 (var-deref "jolt.backend-scheme" "direct-link-fn?")) (_a$6957 (jolt-get fnode (keyword #f "ns"))) (_a$6958 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$6956 _a$6957 _a$6958)) and__25__auto)) and__25__auto))) (jolt-invoke order-args (lambda (as) (let fnrec6959 ((as as)) (let* ((_a$6963 (var-deref "clojure.core" "str")) (_a$6964 "(") (_a$6965 (let* ((_a$6960 (var-deref "jolt.backend-scheme" "dl-name")) (_a$6961 (jolt-get fnode (keyword #f "ns"))) (_a$6962 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$6960 _a$6961 _a$6962))) (_a$6966 (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "")) (_a$6967 ")")) (jolt-invoke _a$6963 _a$6964 _a$6965 _a$6966 _a$6967))))) (if (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))) (jolt-invoke invoke) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke invoke) jolt-nil))))))))))))))))))) emit-invoke)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "emit-try" (letrec ((emit-try (lambda (node) (let fnrec6968 ((node node)) (let* ((core (let* ((temp__16__auto (jolt-get node (keyword #f "catch-sym")))) (if (jolt-truthy? temp__16__auto) (let* ((cs temp__16__auto)) (let* ((_a$6969 (var-deref "clojure.core" "str")) (_a$6970 "(guard (") (_a$6971 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") cs)) (_a$6972 " (else ") (_a$6973 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "catch-body")))) (_a$6974 ")) ") (_a$6975 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (_a$6976 ")")) (jolt-invoke _a$6969 _a$6970 _a$6971 _a$6972 _a$6973 _a$6974 _a$6975 _a$6976))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body"))))))) (let* ((temp__16__auto (jolt-get node (keyword #f "finally")))) (if (jolt-truthy? temp__16__auto) (let* ((fin temp__16__auto)) (jolt-invoke (var-deref "clojure.core" "str") "(dynamic-wind (lambda () #f) (lambda () " core ") (lambda () " (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fin) "))")) core))))))) emit-try)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "returns-scheme-bool?" (letrec ((returns-scheme-bool? (lambda (node) (let fnrec6977 ((node node)) (if (jolt-truthy? (let* ((and__25__auto (jolt= (keyword #f "const") (jolt-get node (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "boolean?") (jolt-get node (keyword #f "val"))) and__25__auto))) #t (if (jolt= (keyword #f "invoke") (jolt-get node (keyword #f "op"))) (let* ((nop (let* ((_a$6978 (var-deref "jolt.backend-scheme" "native-op")) (_a$6979 (jolt-get node (keyword #f "fn"))) (_a$6980 (jolt-count (jolt-get node (keyword #f "args"))))) (jolt-invoke _a$6978 _a$6979 _a$6980)))) (if (jolt-truthy? (let* ((and__25__auto nop)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.backend-scheme" "bool-returning-ops") nop) and__25__auto))) #t #f)) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil))))))) returns-scheme-bool?)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "emit" (letrec ((emit (lambda (node) (let fnrec6981 ((node node)) (let* ((G__130 (jolt-get node (keyword #f "op")))) (if (jolt= G__130 (keyword #f "const")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-const") (jolt-get node (keyword #f "val"))) (if (jolt= G__130 (keyword #f "local")) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get node (keyword #f "name"))) (if (jolt= G__130 (keyword #f "var")) (let* ((core-proc (let* ((and__25__auto (jolt= "clojure.core" (jolt-get node (keyword #f "ns"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.backend-scheme" "core-value-procs") (jolt-get node (keyword #f "name"))) and__25__auto)))) (if (jolt-truthy? core-proc) core-proc (if (jolt-truthy? (let* ((_a$6982 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$6983 (jolt-get node (keyword #f "ns"))) (_a$6984 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$6982 _a$6983 _a$6984))) (let* ((_a$6985 (var-deref "jolt.backend-scheme" "dl-name")) (_a$6986 (jolt-get node (keyword #f "ns"))) (_a$6987 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$6985 _a$6986 _a$6987)) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.backend-scheme" "stdlib-var?") node))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "prelude-mode?"))) and__25__auto))) (jolt-throw (let* ((_a$6994 (let* ((_a$6988 (var-deref "clojure.core" "str")) (_a$6989 "emit: unsupported stdlib ref `") (_a$6990 (jolt-get node (keyword #f "ns"))) (_a$6991 "/") (_a$6992 (jolt-get node (keyword #f "name"))) (_a$6993 "` (no core on Chez yet)")) (jolt-invoke _a$6988 _a$6989 _a$6990 _a$6991 _a$6992 _a$6993))) (_a$6995 (jolt-hash-map))) (jolt-ex-info _a$6994 _a$6995))) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$6996 (var-deref "clojure.core" "str")) (_a$6997 "(var-deref ") (_a$6998 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$6999 " ") (_a$7000 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7001 ")")) (jolt-invoke _a$6996 _a$6997 _a$6998 _a$6999 _a$7000 _a$7001)) jolt-nil))))) (if (jolt= G__130 (keyword #f "the-var")) (let* ((_a$7002 (var-deref "clojure.core" "str")) (_a$7003 "(jolt-var ") (_a$7004 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7005 " ") (_a$7006 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7007 ")")) (jolt-invoke _a$7002 _a$7003 _a$7004 _a$7005 _a$7006 _a$7007)) (if (jolt= G__130 (keyword #f "set-var")) (let* ((_a$7008 (var-deref "clojure.core" "str")) (_a$7009 "(jolt-var-set ") (_a$7010 (emit (jolt-get node (keyword #f "the-var")))) (_a$7011 " ") (_a$7012 (emit (jolt-get node (keyword #f "val")))) (_a$7013 ")")) (jolt-invoke _a$7008 _a$7009 _a$7010 _a$7011 _a$7012 _a$7013)) (if (jolt= G__130 (keyword #f "set-field")) (let* ((_a$7014 (var-deref "clojure.core" "str")) (_a$7015 "(jolt-set-field! ") (_a$7016 (emit (jolt-get node (keyword #f "obj")))) (_a$7017 " (keyword #f ") (_a$7018 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "field")))) (_a$7019 ") ") (_a$7020 (emit (jolt-get node (keyword #f "val")))) (_a$7021 ")")) (jolt-invoke _a$7014 _a$7015 _a$7016 _a$7017 _a$7018 _a$7019 _a$7020 _a$7021)) (if (jolt= G__130 (keyword #f "defmacro")) (let* ((_a$7022 (var-deref "clojure.core" "str")) (_a$7023 "(begin (def-var! ") (_a$7024 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7025 " ") (_a$7026 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7027 " ") (_a$7028 (emit (jolt-get node (keyword #f "fn")))) (_a$7029 ") (mark-macro! ") (_a$7030 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7031 " ") (_a$7032 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7033 ") jolt-nil)")) (jolt-invoke _a$7022 _a$7023 _a$7024 _a$7025 _a$7026 _a$7027 _a$7028 _a$7029 _a$7030 _a$7031 _a$7032 _a$7033)) (if (jolt= G__130 (keyword #f "host")) (jolt-throw (let* ((_a$7034 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host ref `" (jolt-get node (keyword #f "name")) "`")) (_a$7035 (jolt-hash-map))) (jolt-ex-info _a$7034 _a$7035))) (if (jolt= G__130 (keyword #f "host-static")) (let* ((_a$7036 (var-deref "clojure.core" "str")) (_a$7037 "(host-static-ref ") (_a$7038 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$7039 " ") (_a$7040 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "member")))) (_a$7041 ")")) (jolt-invoke _a$7036 _a$7037 _a$7038 _a$7039 _a$7040 _a$7041)) (if (jolt= G__130 (keyword #f "host-new")) (let* ((_a$7042 (var-deref "clojure.core" "str")) (_a$7043 "(host-new ") (_a$7044 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$7045 (let* ((args (jolt-map emit (jolt-get node (keyword #f "args"))))) (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args))))) (_a$7046 ")")) (jolt-invoke _a$7042 _a$7043 _a$7044 _a$7045 _a$7046)) (if (jolt= G__130 (keyword #f "if")) (let* ((test (jolt-get node (keyword #f "test"))) (t (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "returns-scheme-bool?") test)) (emit test) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-truthy? " (emit test) ")")))) (let* ((_a$7047 (var-deref "clojure.core" "str")) (_a$7048 "(if ") (_a$7049 t) (_a$7050 " ") (_a$7051 (emit (jolt-get node (keyword #f "then")))) (_a$7052 " ") (_a$7053 (emit (jolt-get node (keyword #f "else")))) (_a$7054 ")")) (jolt-invoke _a$7047 _a$7048 _a$7049 _a$7050 _a$7051 _a$7052 _a$7053 _a$7054))) (if (jolt= G__130 (keyword #f "do")) (let* ((_a$7055 (var-deref "clojure.core" "str")) (_a$7056 "(begin ") (_a$7057 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit (jolt-get node (keyword #f "statements"))))) (_a$7058 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$7059 (emit (jolt-get node (keyword #f "ret")))) (_a$7060 ")")) (jolt-invoke _a$7055 _a$7056 _a$7057 _a$7058 _a$7059 _a$7060)) (if (jolt= G__130 (keyword #f "invoke")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-invoke") node) (if (jolt= G__130 (keyword #f "vector")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-vector" (jolt-map emit (jolt-get node (keyword #f "items")))) (if (jolt= G__130 (keyword #f "set")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-hash-set" (jolt-map emit (jolt-get node (keyword #f "items")))) (if (jolt= G__130 (keyword #f "map")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-hash-map" (let* ((_a$7064 (var-deref "clojure.core" "mapcat")) (_a$7065 (lambda (p) (let fnrec7061 ((p p)) (let* ((_o$7062 (emit (jolt-nth p 0))) (_o$7063 (emit (jolt-nth p 1)))) (jolt-vector _o$7062 _o$7063))))) (_a$7066 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$7064 _a$7065 _a$7066))) (if (jolt= G__130 (keyword #f "quote")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get node (keyword #f "form"))) (if (jolt= G__130 (keyword #f "throw")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-throw " (emit (jolt-get node (keyword #f "expr"))) ")") (if (jolt= G__130 (keyword #f "coerce")) (let* ((e (emit (jolt-get node (keyword #f "expr"))))) (if (jolt= (keyword #f "double") (jolt-get node (keyword #f "kind"))) (jolt-invoke (var-deref "clojure.core" "str") "(exact->inexact " e ")") (if (jolt= (keyword #f "long") (jolt-get node (keyword #f "kind"))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt->fx " e ")") (if (jolt-truthy? (keyword #f "else")) e jolt-nil)))) (if (jolt= G__130 (keyword #f "try")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-try") node) (if (jolt= G__130 (keyword #f "regex")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-regex " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "source"))) ")") (if (jolt= G__130 (keyword #f "inst")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-inst-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "source"))) ")") (if (jolt= G__130 (keyword #f "uuid")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-uuid-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "source"))) ")") (if (jolt= G__130 (keyword #f "bigdec")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-bigdec-from-string " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "source"))) ")") (if (jolt= G__130 (keyword #f "the-ns")) (jolt-invoke (var-deref "clojure.core" "str") "(intern-ns! " (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name"))) ")") (if (jolt= G__130 (keyword #f "host-call")) (let* ((m (jolt-get node (keyword #f "method"))) (target (emit (jolt-get node (keyword #f "target")))) (args (jolt-map emit (jolt-get node (keyword #f "args"))))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "supported-host-methods") m)) (let* ((_a$7067 (var-deref "clojure.core" "str")) (_a$7068 "(jolt-host-call ") (_a$7069 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$7070 " ") (_a$7071 target) (_a$7072 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$7073 ")")) (jolt-invoke _a$7067 _a$7068 _a$7069 _a$7070 _a$7071 _a$7072 _a$7073)) (let* ((_a$7074 (var-deref "clojure.core" "str")) (_a$7075 "(record-method-dispatch ") (_a$7076 target) (_a$7077 " ") (_a$7078 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$7079 " (jolt-vector") (_a$7080 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$7081 "))")) (jolt-invoke _a$7074 _a$7075 _a$7076 _a$7077 _a$7078 _a$7079 _a$7080 _a$7081)))) (if (jolt= G__130 (keyword #f "let")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-let") node) (if (jolt= G__130 (keyword #f "loop")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-loop") node) (if (jolt= G__130 (keyword #f "recur")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-recur") node) (if (jolt= G__130 (keyword #f "ffi-fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-fn") node) (if (jolt= G__130 (keyword #f "ffi-callable")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-callable") node) (if (jolt= G__130 (keyword #f "fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-fn") node) (if (jolt= G__130 (keyword #f "def")) (if (jolt-truthy? (jolt-get node (keyword #f "no-init"))) (let* ((_a$7082 (var-deref "clojure.core" "str")) (_a$7083 "(declare-var! ") (_a$7084 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7085 " ") (_a$7086 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7087 ")")) (jolt-invoke _a$7082 _a$7083 _a$7084 _a$7085 _a$7086 _a$7087)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$7088 (var-deref "clojure.core" "str")) (_a$7089 "(def-var-with-meta! ") (_a$7090 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7091 " ") (_a$7092 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7093 " ") (_a$7094 (emit (jolt-get node (keyword #f "init")))) (_a$7095 " ") (_a$7096 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$7097 ")")) (jolt-invoke _a$7088 _a$7089 _a$7090 _a$7091 _a$7092 _a$7093 _a$7094 _a$7095 _a$7096 _a$7097)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$7098 (var-deref "clojure.core" "str")) (_a$7099 "(def-var! ") (_a$7100 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7101 " ") (_a$7102 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7103 " ") (_a$7104 (emit (jolt-get node (keyword #f "init")))) (_a$7105 ")")) (jolt-invoke _a$7098 _a$7099 _a$7100 _a$7101 _a$7102 _a$7103 _a$7104 _a$7105)) jolt-nil))) (jolt-throw (let* ((_a$7106 (jolt-invoke (var-deref "clojure.core" "str") "emit: op not yet ported / unhandled: " (jolt-invoke (var-deref "clojure.core" "pr-str") (jolt-get node (keyword #f "op"))))) (_a$7107 (jolt-hash-map))) (jolt-ex-info _a$7106 _a$7107))))))))))))))))))))))))))))))))))))))))) emit)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "dl-opt-out?" (letrec ((dl-opt-out? (lambda (m) (let fnrec7108 ((m m)) (let* ((or__26__auto (jolt-get m (keyword #f "dynamic")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-get m (keyword #f "redef")))))))) dl-opt-out?)))
(guard (e (#t #f))
(def-var! "jolt.backend-scheme" "emit-top-form" (letrec ((emit-top-form (lambda (node) (let fnrec7109 ((node node)) (if (jolt-not (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link?"))) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") node) (if (jolt= (keyword #f "do") (jolt-get node (keyword #f "op"))) (let* ((_a$7110 (var-deref "clojure.core" "str")) (_a$7111 "(begin ") (_a$7112 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-top-form (jolt-get node (keyword #f "statements"))))) (_a$7113 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$7114 (emit-top-form (jolt-get node (keyword #f "ret")))) (_a$7115 ")")) (jolt-invoke _a$7110 _a$7111 _a$7112 _a$7113 _a$7114 _a$7115)) (if (jolt-truthy? (let* ((and__25__auto (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-get node (keyword #f "no-init"))))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-invoke (var-deref "jolt.backend-scheme" "dl-opt-out?") (jolt-get node (keyword #f "meta")))) and__25__auto)) and__25__auto))) (let* ((ns (jolt-get node (keyword #f "ns"))) (nm (jolt-get node (keyword #f "name"))) (b (jolt-invoke (var-deref "jolt.backend-scheme" "dl-name") ns nm)) (fn? (jolt= (keyword #f "fn") (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "op")))) (pos (jolt-get node (keyword #f "pos"))) (frame-name (if (jolt-truthy? fn?) (let* ((temp__16__auto (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "name")))) (if (jolt-truthy? temp__16__auto) (let* ((fnm temp__16__auto)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") fnm)) b)) jolt-nil)) (reg (if (jolt-truthy? (let* ((and__25__auto fn?)) (if (jolt-truthy? and__25__auto) pos and__25__auto))) (let* ((_a$7116 (var-deref "clojure.core" "str")) (_a$7117 " (jolt-register-source! ") (_a$7118 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") frame-name)) (_a$7119 " ") (_a$7120 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$7121 " ") (_a$7122 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7123 " ") (_a$7124 (if (jolt-truthy? (jolt-get pos (keyword #f "file"))) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get pos (keyword #f "file"))) "jolt-nil")) (_a$7125 " ") (_a$7126 (let* ((or__26__auto (jolt-get pos (keyword #f "line")))) (if (jolt-truthy? or__26__auto) or__26__auto 0))) (_a$7127 ")")) (jolt-invoke _a$7116 _a$7117 _a$7118 _a$7119 _a$7120 _a$7121 _a$7122 _a$7123 _a$7124 _a$7125 _a$7126 _a$7127)) jolt-nil))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.backend-scheme" "direct-link-defined") jolt-conj (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm)) (if (jolt-truthy? fn?) (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.backend-scheme" "direct-link-fns") jolt-conj (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm)) jolt-nil) (let* ((init (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "init"))))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$7128 (var-deref "clojure.core" "str")) (_a$7129 "(begin (define ") (_a$7130 b) (_a$7131 " ") (_a$7132 init) (_a$7133 ") (def-var-with-meta! ") (_a$7134 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$7135 " ") (_a$7136 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7137 " ") (_a$7138 b) (_a$7139 " ") (_a$7140 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$7141 ")") (_a$7142 (let* ((or__26__auto reg)) (if (jolt-truthy? or__26__auto) or__26__auto ""))) (_a$7143 ")")) (jolt-invoke _a$7128 _a$7129 _a$7130 _a$7131 _a$7132 _a$7133 _a$7134 _a$7135 _a$7136 _a$7137 _a$7138 _a$7139 _a$7140 _a$7141 _a$7142 _a$7143)) (let* ((_a$7144 (var-deref "clojure.core" "str")) (_a$7145 "(begin (define ") (_a$7146 b) (_a$7147 " ") (_a$7148 init) (_a$7149 ") (def-var! ") (_a$7150 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$7151 " ") (_a$7152 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7153 " ") (_a$7154 b) (_a$7155 ")") (_a$7156 (let* ((or__26__auto reg)) (if (jolt-truthy? or__26__auto) or__26__auto ""))) (_a$7157 ")")) (jolt-invoke _a$7144 _a$7145 _a$7146 _a$7147 _a$7148 _a$7149 _a$7150 _a$7151 _a$7152 _a$7153 _a$7154 _a$7155 _a$7156 _a$7157)))))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") node) jolt-nil)))))))) emit-top-form)))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.fold" "foldable" (let* ((_o$7158 "+") (_o$7159 jolt-add) (_o$7160 "-") (_o$7161 jolt-sub) (_o$7162 "*") (_o$7163 jolt-mul) (_o$7164 "/") (_o$7165 jolt-div) (_o$7166 "<") (_o$7167 <) (_o$7168 ">") (_o$7169 >) (_o$7170 "<=") (_o$7171 <=) (_o$7172 ">=") (_o$7173 >=) (_o$7174 "=") (_o$7175 jolt=) (_o$7176 "inc") (_o$7177 jolt-inc) (_o$7178 "dec") (_o$7179 jolt-dec) (_o$7180 "mod") (_o$7181 modulo) (_o$7182 "rem") (_o$7183 remainder) (_o$7184 "quot") (_o$7185 quotient) (_o$7186 "bit-and") (_o$7187 (var-deref "clojure.core" "__bit-and")) (_o$7188 "bit-or") (_o$7189 (var-deref "clojure.core" "__bit-or")) (_o$7190 "bit-xor") (_o$7191 (var-deref "clojure.core" "__bit-xor"))) (jolt-hash-map _o$7158 _o$7159 _o$7160 _o$7161 _o$7162 _o$7163 _o$7164 _o$7165 _o$7166 _o$7167 _o$7168 _o$7169 _o$7170 _o$7171 _o$7172 _o$7173 _o$7174 _o$7175 _o$7176 _o$7177 _o$7178 _o$7179 _o$7180 _o$7181 _o$7182 _o$7183 _o$7184 _o$7185 _o$7186 _o$7187 _o$7188 _o$7189 _o$7190 _o$7191)) (let* ((_o$7192 (keyword #f "private")) (_o$7193 #t)) (jolt-hash-map _o$7192 _o$7193))))
(guard (e (#t #f))
(def-var! "jolt.passes.fold" "const?" (letrec ((const? (lambda (n) (let fnrec7194 ((n n)) (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))))) const?)))
(guard (e (#t #f))
(def-var! "jolt.passes.fold" "const-num?" (letrec ((const-num? (lambda (n) (let fnrec7195 ((n n)) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.fold" "const?") n))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "number?") (jolt-get n (keyword #f "val"))) and__25__auto)))))) const-num?)))
(guard (e (#t #f))
(def-var! "jolt.passes.fold" "fold-fn" (letrec ((fold-fn (lambda (fnode) (let fnrec7196 ((fnode fnode)) (let* ((op (jolt-get fnode (keyword #f "op")))) (if (jolt-truthy? (let* ((or__26__auto (let* ((and__25__auto (jolt= op (keyword #f "var")))) (if (jolt-truthy? and__25__auto) (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) and__25__auto)))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= op (keyword #f "host"))))) (jolt-get (var-deref "jolt.passes.fold" "foldable") (jolt-get fnode (keyword #f "name"))) jolt-nil)))))) fold-fn)))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.fold" "const-fold" (letrec ((const-fold (lambda (node) (let fnrec7197 ((node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "invoke")) (let* ((n (jolt-invoke (var-deref "jolt.ir" "map-ir-children") const-fold node)) (ff (jolt-invoke (var-deref "jolt.passes.fold" "fold-fn") (jolt-get n (keyword #f "fn")))) (args (jolt-get n (keyword #f "args"))) (folded (if (jolt-truthy? (let* ((and__25__auto ff)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-pos? (jolt-count args)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "every?") (var-deref "jolt.passes.fold" "const-num?") args) and__25__auto)) and__25__auto))) (guard (_r$catch1502 (else (let* ((e _r$catch1502)) jolt-nil))) (let* ((_o$7199 (keyword #f "op")) (_o$7200 (keyword #f "const")) (_o$7201 (keyword #f "val")) (_o$7202 (jolt-apply ff (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (a) (let fnrec7198 ((a a)) (jolt-get a (keyword #f "val")))) args)))) (jolt-hash-map _o$7199 _o$7200 _o$7201 _o$7202))) jolt-nil))) (let* ((or__26__auto folded)) (if (jolt-truthy? or__26__auto) or__26__auto n))) (if (jolt= op (keyword #f "if")) (let* ((t (const-fold (jolt-get node (keyword #f "test"))))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.fold" "const?") t)) (if (jolt-truthy? (let* ((or__26__auto (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-get t (keyword #f "val"))))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= #f (jolt-get t (keyword #f "val")))))) (const-fold (jolt-get node (keyword #f "else"))) (const-fold (jolt-get node (keyword #f "then")))) (let* ((_a$7203 node) (_a$7204 (keyword #f "test")) (_a$7205 t) (_a$7206 (keyword #f "then")) (_a$7207 (const-fold (jolt-get node (keyword #f "then")))) (_a$7208 (keyword #f "else")) (_a$7209 (const-fold (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$7203 _a$7204 _a$7205 _a$7206 _a$7207 _a$7208 _a$7209)))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") const-fold node) jolt-nil)))))))) const-fold) (let* ((_o$7210 (keyword #f "doc")) (_o$7211 "Bottom-up constant folding: a call of a foldable numeric fn whose args are\n all constant numbers becomes a constant; an if with a constant test becomes\n the taken branch.")) (jolt-hash-map _o$7210 _o$7211))))
(guard (e (#t #f))
(def-var! "jolt.passes.fold" "scalar-const?" (letrec ((scalar-const? (lambda (n) (let fnrec7212 ((n n)) (let* ((and__25__auto (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((v (jolt-get n (keyword #f "val")))) (let* ((or__26__auto (jolt-invoke (var-deref "clojure.core" "keyword?") v))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt-invoke (var-deref "clojure.core" "string?") v))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt-invoke (var-deref "clojure.core" "number?") v))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-invoke (var-deref "clojure.core" "boolean?") v)))))))) and__25__auto)))))) scalar-const?)))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.fold" "kw-callee?" (letrec ((kw-callee? (lambda (fnode) (let fnrec7213 ((fnode fnode)) (let* ((and__25__auto (jolt= (keyword #f "const") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "keyword?") (jolt-get fnode (keyword #f "val"))) and__25__auto)))))) kw-callee?) (let* ((_o$7214 (keyword #f "doc")) (_o$7215 "True if fnode is a constant keyword used as a function head \x2014; the (:k m) form.")) (jolt-hash-map _o$7214 _o$7215))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.fold" "get-callee?" (letrec ((get-callee? (lambda (fnode) (let fnrec7216 ((fnode fnode)) (let* ((or__26__auto (let* ((and__25__auto (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))))) (if (jolt-truthy? and__25__auto) (jolt= "get" (jolt-get fnode (keyword #f "name"))) and__25__auto)) and__25__auto)))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((and__25__auto (jolt= (keyword #f "host") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt= "get" (jolt-get fnode (keyword #f "name"))) and__25__auto)))))))) get-callee?) (let* ((_o$7217 (keyword #f "doc")) (_o$7218 "True if fnode is the clojure.core/get (or host get) callee \x2014; the (get m k) form.")) (jolt-hash-map _o$7217 _o$7218))))
(guard (e (#t #f))
(def-var! "jolt.passes.numeric" "int-lit?" (letrec ((int-lit? (lambda (n) (let fnrec5823 ((n n)) (let* ((and__25__auto (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((v (jolt-get n (keyword #f "val")))) (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "number?") v))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "integer?") v) and__25__auto))) and__25__auto)))))) int-lit?)))
(guard (e (#t #f))
(def-var! "jolt.passes.numeric" "float-lit?" (letrec ((float-lit? (lambda (n) (let fnrec5824 ((n n)) (let* ((and__25__auto (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((v (jolt-get n (keyword #f "val")))) (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "number?") v))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "float?") v) and__25__auto))) and__25__auto)))))) float-lit?)))
(guard (e (#t #f))
(def-var! "jolt.passes.numeric" "dbl-spec" (letrec ((dbl-spec (lambda (nm n) (let fnrec5825 ((nm nm) (n n)) (if (jolt-truthy? (let* ((and__25__auto (>= n 1))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$5826 "+") (_o$5827 "-") (_o$5828 "*") (_o$5829 "/") (_o$5830 "min") (_o$5831 "max")) (jolt-hash-set _o$5826 _o$5827 _o$5828 _o$5829 _o$5830 _o$5831)) nm) and__25__auto))) (keyword #f "double") (if (jolt-truthy? (let* ((and__25__auto (jolt= n 1))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$5832 "inc") (_o$5833 "dec")) (jolt-hash-set _o$5832 _o$5833)) nm) and__25__auto))) (keyword #f "double") (if (jolt-truthy? (let* ((and__25__auto (>= n 2))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$5834 "<") (_o$5835 ">") (_o$5836 "<=") (_o$5837 ">=") (_o$5838 "=") (_o$5839 "==")) (jolt-hash-set _o$5834 _o$5835 _o$5836 _o$5837 _o$5838 _o$5839)) nm) and__25__auto))) (keyword #f "bool") (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))))))) dbl-spec)))
(guard (e (#t #f))
(def-var! "jolt.passes.numeric" "lng-spec" (letrec ((lng-spec (lambda (nm n) (let fnrec5840 ((nm nm) (n n)) (if (jolt-truthy? (let* ((and__25__auto (>= n 1))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$5841 "+") (_o$5842 "-") (_o$5843 "*") (_o$5844 "min") (_o$5845 "max") (_o$5846 "unchecked-add") (_o$5847 "unchecked-subtract") (_o$5848 "unchecked-multiply")) (jolt-hash-set _o$5841 _o$5842 _o$5843 _o$5844 _o$5845 _o$5846 _o$5847 _o$5848)) nm) and__25__auto))) (keyword #f "long") (if (jolt-truthy? (let* ((and__25__auto (jolt= n 1))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$5849 "inc") (_o$5850 "dec") (_o$5851 "unchecked-inc") (_o$5852 "unchecked-dec")) (jolt-hash-set _o$5849 _o$5850 _o$5851 _o$5852)) nm) and__25__auto))) (keyword #f "long") (if (jolt-truthy? (let* ((and__25__auto (jolt= n 2))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$5853 "quot") (_o$5854 "rem") (_o$5855 "mod")) (jolt-hash-set _o$5853 _o$5854 _o$5855)) nm) and__25__auto))) (keyword #f "long") (if (jolt-truthy? (let* ((and__25__auto (>= n 2))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$5856 "<") (_o$5857 ">") (_o$5858 "<=") (_o$5859 ">=") (_o$5860 "=") (_o$5861 "==")) (jolt-hash-set _o$5856 _o$5857 _o$5858 _o$5859 _o$5860 _o$5861)) nm) and__25__auto))) (keyword #f "bool") (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))))))) lng-spec)))
(guard (e (#t #f))
(def-var! "jolt.passes.numeric" "bd-spec" (letrec ((bd-spec (lambda (nm n) (let fnrec5862 ((nm nm) (n n)) (if (jolt-truthy? (let* ((and__25__auto (>= n 1))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$5863 "+") (_o$5864 "-") (_o$5865 "*") (_o$5866 "/") (_o$5867 "min") (_o$5868 "max")) (jolt-hash-set _o$5863 _o$5864 _o$5865 _o$5866 _o$5867 _o$5868)) nm) and__25__auto))) (keyword #f "bigdec") (if (jolt-truthy? (let* ((and__25__auto (jolt= n 2))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$5869 "quot") (_o$5870 "rem")) (jolt-hash-set _o$5869 _o$5870)) nm) and__25__auto))) (keyword #f "bigdec") (if (jolt-truthy? (let* ((and__25__auto (jolt= n 1))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$5871 "zero?") (_o$5872 "pos?") (_o$5873 "neg?")) (jolt-hash-set _o$5871 _o$5872 _o$5873)) nm) and__25__auto))) (keyword #f "bool") (if (jolt-truthy? (let* ((and__25__auto (>= n 2))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$5874 "<") (_o$5875 ">") (_o$5876 "<=") (_o$5877 ">=")) (jolt-hash-set _o$5874 _o$5875 _o$5876 _o$5877)) nm) and__25__auto))) (keyword #f "bool") (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))))))) bd-spec)))
(guard (e (#t #f))
(def-var! "jolt.passes.numeric" "propagate" (letrec ((propagate (lambda (spec) (let fnrec5878 ((spec spec)) (if (jolt= spec (keyword #f "bool")) jolt-nil spec))))) propagate)))
(guard (e (#t #f))
(declare-var! "jolt.passes.numeric" "an"))
(guard (e (#t #f))
(def-var! "jolt.passes.numeric" "recur-kinds" (letrec ((recur-kinds (lambda (node tenv) (let fnrec5879 ((node node) (tenv tenv)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "recur")) (jolt-vector (let* ((_a$5881 (var-deref "clojure.core" "mapv")) (_a$5882 (lambda (a) (let fnrec5880 ((a a)) (jolt-nth (jolt-invoke (var-deref "jolt.passes.numeric" "an") a tenv) 0)))) (_a$5883 (jolt-get node (keyword #f "args")))) (jolt-invoke _a$5881 _a$5882 _a$5883))) (if (jolt= op (keyword #f "let")) (let* ((_a$5891 (jolt-get node (keyword #f "body"))) (_a$5892 (let* ((_a$5888 (lambda (te b) (let fnrec5884 ((te te) (b b)) (let* ((_a$5885 te) (_a$5886 (jolt-nth b 0)) (_a$5887 (jolt-nth (jolt-invoke (var-deref "jolt.passes.numeric" "an") (jolt-nth b 1) te) 0))) (jolt-assoc _a$5885 _a$5886 _a$5887))))) (_a$5889 tenv) (_a$5890 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$5888 _a$5889 _a$5890)))) (recur-kinds _a$5891 _a$5892)) (if (jolt= op (keyword #f "if")) (let* ((_a$5893 (recur-kinds (jolt-get node (keyword #f "then")) tenv)) (_a$5894 (recur-kinds (jolt-get node (keyword #f "else")) tenv))) (jolt-concat _a$5893 _a$5894)) (if (jolt= op (keyword #f "do")) (recur-kinds (jolt-get node (keyword #f "ret")) tenv) (if (jolt-truthy? (keyword #f "else")) (jolt-vector) jolt-nil)))))))))) recur-kinds)))
(guard (e (#t #f))
(def-var! "jolt.passes.numeric" "recur-arg-lists" (letrec ((recur-arg-lists (lambda (node) (let fnrec5895 ((node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "recur")) (jolt-vector (jolt-get node (keyword #f "args"))) (if (jolt= op (keyword #f "let")) (recur-arg-lists (jolt-get node (keyword #f "body"))) (if (jolt= op (keyword #f "if")) (let* ((_a$5896 (recur-arg-lists (jolt-get node (keyword #f "then")))) (_a$5897 (recur-arg-lists (jolt-get node (keyword #f "else"))))) (jolt-concat _a$5896 _a$5897)) (if (jolt= op (keyword #f "do")) (recur-arg-lists (jolt-get node (keyword #f "ret"))) (if (jolt-truthy? (keyword #f "else")) (jolt-vector) jolt-nil)))))))))) recur-arg-lists)))
(guard (e (#t #f))
(def-var! "jolt.passes.numeric" "counter-step?" (letrec ((counter-step? (lambda (arg vname) (let fnrec5898 ((arg arg) (vname vname)) (if (jolt-truthy? (let* ((and__25__auto (jolt= (keyword #f "local") (jolt-get arg (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt= vname (jolt-get arg (keyword #f "name"))) and__25__auto))) #t (if (jolt= (keyword #f "invoke") (jolt-get arg (keyword #f "op"))) (let* ((f (jolt-get arg (keyword #f "fn"))) (as (jolt-get arg (keyword #f "args")))) (let* ((and__25__auto (jolt= (keyword #f "var") (jolt-get f (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "clojure.core" (jolt-get f (keyword #f "ns"))))) (if (jolt-truthy? and__25__auto) (let* ((nm (jolt-get f (keyword #f "name"))) (v? (lambda (n) (let fnrec5899 ((n n)) (let* ((and__25__auto (jolt= (keyword #f "local") (jolt-get n (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt= vname (jolt-get n (keyword #f "name"))) and__25__auto)))))) (if (jolt-truthy? (let* ((and__25__auto (jolt-contains? (let* ((_o$5900 "inc") (_o$5901 "dec") (_o$5902 "unchecked-inc") (_o$5903 "unchecked-dec")) (jolt-hash-set _o$5900 _o$5901 _o$5902 _o$5903)) nm))) (if (jolt-truthy? and__25__auto) (jolt= 1 (jolt-count as)) and__25__auto))) (jolt-invoke v? (jolt-nth as 0)) (if (jolt-truthy? (let* ((and__25__auto (jolt-contains? (let* ((_o$5904 "+") (_o$5905 "unchecked-add")) (jolt-hash-set _o$5904 _o$5905)) nm))) (if (jolt-truthy? and__25__auto) (jolt= 2 (jolt-count as)) and__25__auto))) (let* ((or__26__auto (let* ((and__25__auto (jolt-invoke v? (jolt-nth as 0)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.numeric" "int-lit?") (jolt-nth as 1)) and__25__auto)))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((and__25__auto (jolt-invoke v? (jolt-nth as 1)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.numeric" "int-lit?") (jolt-nth as 0)) and__25__auto)))) (if (jolt-truthy? (let* ((and__25__auto (jolt-contains? (let* ((_o$5906 "-") (_o$5907 "unchecked-subtract")) (jolt-hash-set _o$5906 _o$5907)) nm))) (if (jolt-truthy? and__25__auto) (jolt= 2 (jolt-count as)) and__25__auto))) (let* ((and__25__auto (jolt-invoke v? (jolt-nth as 0)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.numeric" "int-lit?") (jolt-nth as 1)) and__25__auto)) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil))))) and__25__auto)) and__25__auto))) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil))))))) counter-step?)))
(guard (e (#t #f))
(def-var! "jolt.passes.numeric" "loop-kinds" (letrec ((loop-kinds (lambda (names seed body tenv) (let fnrec5908 ((names names) (seed seed) (body body) (tenv tenv)) (let* ((cur seed) (iter 0)) (let loop5909 ((cur cur) (iter iter)) (if (> iter (jolt-count names)) cur (let* ((te (let* ((_a$5914 (lambda (t i) (let fnrec5910 ((t t) (i i)) (let* ((_a$5911 t) (_a$5912 (jolt-nth names i)) (_a$5913 (jolt-nth cur i))) (jolt-assoc _a$5911 _a$5912 _a$5913))))) (_a$5915 tenv) (_a$5916 (jolt-range (jolt-count names)))) (jolt-reduce _a$5914 _a$5915 _a$5916))) (rks (jolt-invoke (var-deref "jolt.passes.numeric" "recur-kinds") body te)) (nxt (let* ((_a$5919 (var-deref "clojure.core" "mapv")) (_a$5920 (lambda (j) (let fnrec5917 ((j j)) (let* ((k (jolt-nth cur j))) (if (jolt-truthy? (let* ((and__25__auto k)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (rk) (let fnrec5918 ((rk rk)) (jolt= k (jolt-nth rk j)))) rks) and__25__auto))) k jolt-nil))))) (_a$5921 (jolt-range (jolt-count names)))) (jolt-invoke _a$5919 _a$5920 _a$5921)))) (if (jolt= nxt cur) cur (loop5909 nxt (jolt-inc iter))))))))))) loop-kinds)))
(guard (e (#t #f))
(def-var! "jolt.passes.numeric" "arity-env" (letrec ((arity-env (lambda (tenv a) (let fnrec5922 ((tenv tenv) (a a)) (let* ((nh (let* ((_a$5923 (jolt-hash-map)) (_a$5924 (jolt-get a (keyword #f "nhints")))) (jolt-into _a$5923 _a$5924))) (pe (let* ((_a$5926 (lambda (e p) (let fnrec5925 ((e e) (p p)) (jolt-assoc e p (jolt-get nh p))))) (_a$5927 tenv) (_a$5928 (jolt-get a (keyword #f "params")))) (jolt-reduce _a$5926 _a$5927 _a$5928)))) (if (jolt-truthy? (jolt-get a (keyword #f "rest"))) (jolt-assoc pe (jolt-get a (keyword #f "rest")) jolt-nil) pe)))))) arity-env)))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.numeric" "an-invoke" (letrec ((an-invoke (lambda (node tenv) (let fnrec5929 ((node node) (tenv tenv)) (let* ((fnode (jolt-get node (keyword #f "fn"))) (nm (if (jolt-truthy? (let* ((and__25__auto (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) and__25__auto))) (jolt-get fnode (keyword #f "name")) jolt-nil)) (ars (let* ((_a$5931 (var-deref "clojure.core" "mapv")) (_a$5932 (lambda (a) (let fnrec5930 ((a a)) (jolt-invoke (var-deref "jolt.passes.numeric" "an") a tenv)))) (_a$5933 (jolt-get node (keyword #f "args")))) (jolt-invoke _a$5931 _a$5932 _a$5933))) (argnodes (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5934 ((r r)) (jolt-nth r 1))) ars)) (node1 (jolt-assoc node (keyword #f "args") argnodes)) (n (jolt-count ars))) (if (jolt-truthy? (jolt-get fnode (keyword #f "num-ret"))) (let* ((_o$5935 (jolt-get fnode (keyword #f "num-ret"))) (_o$5936 node1)) (jolt-vector _o$5935 _o$5936)) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") nm)) (let* ((_o$5937 jolt-nil) (_o$5938 node1)) (jolt-vector _o$5937 _o$5938)) (if (jolt-truthy? (keyword #f "else")) (let* ((cls (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5939 ((r r)) (let* ((k (jolt-nth r 0)) (nd (jolt-nth r 1))) (if (jolt= k (keyword #f "double")) (keyword #f "double") (if (jolt= k (keyword #f "long")) (keyword #f "long") (if (jolt= k (keyword #f "bigdec")) (keyword #f "bigdec") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.numeric" "int-lit?") nd)) (keyword #f "wild") (if (jolt-truthy? (keyword #f "else")) (keyword #f "no") jolt-nil)))))))) ars)) (ok? (lambda (allowed need) (let fnrec5940 ((allowed allowed) (need need)) (let* ((and__25__auto (jolt-pos? n))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "every?") (lambda (c) (let fnrec5941 ((c c)) (let* ((or__26__auto (jolt= c (keyword #f "wild")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= c allowed))))) cls))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "some") (lambda (c) (let fnrec5942 ((c c)) (jolt= c need))) cls) and__25__auto)) and__25__auto))))) (ds (jolt-invoke (var-deref "jolt.passes.numeric" "dbl-spec") nm n)) (ls (jolt-invoke (var-deref "jolt.passes.numeric" "lng-spec") nm n)) (bs (jolt-invoke (var-deref "jolt.passes.numeric" "bd-spec") nm n))) (if (jolt-truthy? (let* ((and__25__auto ds)) (if (jolt-truthy? and__25__auto) (jolt-invoke ok? (keyword #f "double") (keyword #f "double")) and__25__auto))) (let* ((args_PRIME_ (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (nd) (let fnrec5943 ((nd nd)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.numeric" "int-lit?") nd)) (jolt-assoc nd (keyword #f "val") (jolt-invoke (var-deref "clojure.core" "double") (jolt-get nd (keyword #f "val")))) nd))) argnodes))) (let* ((_o$5944 (jolt-invoke (var-deref "jolt.passes.numeric" "propagate") ds)) (_o$5945 (jolt-assoc node1 (keyword #f "args") args_PRIME_ (keyword #f "num-kind") (keyword #f "double")))) (jolt-vector _o$5944 _o$5945))) (if (jolt-truthy? (let* ((and__25__auto ls)) (if (jolt-truthy? and__25__auto) (jolt-invoke ok? (keyword #f "long") (keyword #f "long")) and__25__auto))) (let* ((_o$5946 (jolt-invoke (var-deref "jolt.passes.numeric" "propagate") ls)) (_o$5947 (jolt-assoc node1 (keyword #f "num-kind") (keyword #f "long")))) (jolt-vector _o$5946 _o$5947)) (if (jolt-truthy? (let* ((and__25__auto bs)) (if (jolt-truthy? and__25__auto) (jolt-invoke ok? (keyword #f "bigdec") (keyword #f "bigdec")) and__25__auto))) (let* ((_o$5948 (jolt-invoke (var-deref "jolt.passes.numeric" "propagate") bs)) (_o$5949 (jolt-assoc node1 (keyword #f "num-kind") (keyword #f "bigdec")))) (jolt-vector _o$5948 _o$5949)) (if (jolt-truthy? (keyword #f "else")) (let* ((_o$5950 jolt-nil) (_o$5951 node1)) (jolt-vector _o$5950 _o$5951)) jolt-nil))))) jolt-nil)))))))) an-invoke) (let* ((_o$5952 (keyword #f "doc")) (_o$5953 "Annotate an :invoke with its numeric kind. An arithmetic core op specializes to\n the Chez fl*/fx* op only when every operand is the same kind (:double or :long),\n except an integer literal is :wild \x2014; valid in either \x2014; so (+ ^double x 2) stays\n double. A call to a ^double/^long-returning var yields that kind without lowering\n the call (its body already coerces the return).")) (jolt-hash-map _o$5952 _o$5953))))
(guard (e (#t #f))
(def-var! "jolt.passes.numeric" "an" (letrec ((an (lambda (node tenv) (let fnrec5954 ((node node) (tenv tenv)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "const")) (let* ((_o$5955 (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.numeric" "float-lit?") node)) (keyword #f "double") jolt-nil)) (_o$5956 node)) (jolt-vector _o$5955 _o$5956)) (if (jolt= op (keyword #f "bigdec")) (let* ((_o$5957 (keyword #f "bigdec")) (_o$5958 node)) (jolt-vector _o$5957 _o$5958)) (if (jolt= op (keyword #f "local")) (let* ((_o$5959 (jolt-get tenv (jolt-get node (keyword #f "name")))) (_o$5960 node)) (jolt-vector _o$5959 _o$5960)) (if (jolt= op (keyword #f "coerce")) (let* ((_o$5961 (jolt-get node (keyword #f "kind"))) (_o$5962 (jolt-assoc node (keyword #f "expr") (jolt-nth (an (jolt-get node (keyword #f "expr")) tenv) 1)))) (jolt-vector _o$5961 _o$5962)) (if (jolt= op (keyword #f "invoke")) (jolt-invoke (var-deref "jolt.passes.numeric" "an-invoke") node tenv) (if (jolt= op (keyword #f "let")) (let* ((res (let* ((_a$5973 (lambda (acc b) (let fnrec5963 ((acc acc) (b b)) (let* ((te (jolt-nth acc 0)) (binds (jolt-nth acc 1)) (ir (an (jolt-nth b 1) te))) (let* ((_o$5969 (let* ((_a$5964 te) (_a$5965 (jolt-nth b 0)) (_a$5966 (jolt-nth ir 0))) (jolt-assoc _a$5964 _a$5965 _a$5966))) (_o$5970 (jolt-conj binds (let* ((_o$5967 (jolt-nth b 0)) (_o$5968 (jolt-nth ir 1))) (jolt-vector _o$5967 _o$5968))))) (jolt-vector _o$5969 _o$5970)))))) (_a$5974 (let* ((_o$5971 tenv) (_o$5972 (jolt-vector))) (jolt-vector _o$5971 _o$5972))) (_a$5975 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$5973 _a$5974 _a$5975))) (br (let* ((_a$5976 (jolt-get node (keyword #f "body"))) (_a$5977 (jolt-nth res 0))) (an _a$5976 _a$5977)))) (let* ((_o$5983 (jolt-nth br 0)) (_o$5984 (let* ((_a$5978 node) (_a$5979 (keyword #f "bindings")) (_a$5980 (jolt-nth res 1)) (_a$5981 (keyword #f "body")) (_a$5982 (jolt-nth br 1))) (jolt-assoc _a$5978 _a$5979 _a$5980 _a$5981 _a$5982)))) (jolt-vector _o$5983 _o$5984))) (if (jolt= op (keyword #f "loop")) (let* ((binds (jolt-get node (keyword #f "bindings"))) (names (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (b) (let fnrec5985 ((b b)) (jolt-nth b 0))) binds)) (ik (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (b) (let fnrec5986 ((b b)) (jolt-nth (an (jolt-nth b 1) tenv) 0))) binds)) (rlists (jolt-invoke (var-deref "jolt.passes.numeric" "recur-arg-lists") (jolt-get node (keyword #f "body")))) (seed (let* ((_a$5992 (var-deref "clojure.core" "mapv")) (_a$5993 (lambda (j) (let fnrec5987 ((j j)) (let* ((k (jolt-nth ik j)) (b (jolt-nth binds j))) (if (jolt-truthy? k) k (if (jolt-truthy? (let* ((and__25__auto (jolt-seq rlists))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.numeric" "int-lit?") (jolt-nth b 1)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (args) (let fnrec5988 ((args args)) (let* ((_a$5989 (var-deref "jolt.passes.numeric" "counter-step?")) (_a$5990 (jolt-nth args j)) (_a$5991 (jolt-nth b 0))) (jolt-invoke _a$5989 _a$5990 _a$5991)))) rlists) and__25__auto)) and__25__auto))) (keyword #f "long") (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))))) (_a$5994 (jolt-range (jolt-count names)))) (jolt-invoke _a$5992 _a$5993 _a$5994))) (lk (jolt-invoke (var-deref "jolt.passes.numeric" "loop-kinds") names seed (jolt-get node (keyword #f "body")) tenv)) (te (let* ((_a$5999 (lambda (t i) (let fnrec5995 ((t t) (i i)) (let* ((_a$5996 t) (_a$5997 (jolt-nth names i)) (_a$5998 (jolt-nth lk i))) (jolt-assoc _a$5996 _a$5997 _a$5998))))) (_a$6000 tenv) (_a$6001 (jolt-range (jolt-count names)))) (jolt-reduce _a$5999 _a$6000 _a$6001)))) (let* ((_o$6010 jolt-nil) (_o$6011 (let* ((_a$6005 node) (_a$6006 (keyword #f "bindings")) (_a$6007 (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (b) (let fnrec6002 ((b b)) (let* ((_o$6003 (jolt-nth b 0)) (_o$6004 (jolt-nth (an (jolt-nth b 1) tenv) 1))) (jolt-vector _o$6003 _o$6004)))) binds)) (_a$6008 (keyword #f "body")) (_a$6009 (jolt-nth (an (jolt-get node (keyword #f "body")) te) 1))) (jolt-assoc _a$6005 _a$6006 _a$6007 _a$6008 _a$6009)))) (jolt-vector _o$6010 _o$6011))) (if (jolt= op (keyword #f "if")) (let* ((tr (an (jolt-get node (keyword #f "test")) tenv)) (thn (an (jolt-get node (keyword #f "then")) tenv)) (els (an (jolt-get node (keyword #f "else")) tenv)) (tk (jolt-nth thn 0)) (ek (jolt-nth els 0))) (let* ((_o$6019 (if (jolt= tk ek) tk jolt-nil)) (_o$6020 (let* ((_a$6012 node) (_a$6013 (keyword #f "test")) (_a$6014 (jolt-nth tr 1)) (_a$6015 (keyword #f "then")) (_a$6016 (jolt-nth thn 1)) (_a$6017 (keyword #f "else")) (_a$6018 (jolt-nth els 1))) (jolt-assoc _a$6012 _a$6013 _a$6014 _a$6015 _a$6016 _a$6017 _a$6018)))) (jolt-vector _o$6019 _o$6020))) (if (jolt= op (keyword #f "do")) (let* ((stmts (let* ((_a$6022 (var-deref "clojure.core" "mapv")) (_a$6023 (lambda (s) (let fnrec6021 ((s s)) (jolt-nth (an s tenv) 1)))) (_a$6024 (jolt-get node (keyword #f "statements")))) (jolt-invoke _a$6022 _a$6023 _a$6024))) (r (an (jolt-get node (keyword #f "ret")) tenv))) (let* ((_o$6025 (jolt-nth r 0)) (_o$6026 (jolt-assoc node (keyword #f "statements") stmts (keyword #f "ret") (jolt-nth r 1)))) (jolt-vector _o$6025 _o$6026))) (if (jolt= op (keyword #f "fn")) (let* ((_o$6033 jolt-nil) (_o$6034 (jolt-assoc node (keyword #f "arities") (let* ((_a$6030 (var-deref "clojure.core" "mapv")) (_a$6031 (lambda (a) (let fnrec6027 ((a a)) (jolt-assoc a (keyword #f "body") (jolt-nth (let* ((_a$6028 (jolt-get a (keyword #f "body"))) (_a$6029 (jolt-invoke (var-deref "jolt.passes.numeric" "arity-env") tenv a))) (an _a$6028 _a$6029)) 1))))) (_a$6032 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$6030 _a$6031 _a$6032))))) (jolt-vector _o$6033 _o$6034)) (if (jolt= op (keyword #f "def")) (let* ((_o$6035 jolt-nil) (_o$6036 (jolt-assoc node (keyword #f "init") (jolt-nth (an (jolt-get node (keyword #f "init")) tenv) 1)))) (jolt-vector _o$6035 _o$6036)) (if (jolt-truthy? (keyword #f "else")) (let* ((_o$6038 jolt-nil) (_o$6039 (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec6037 ((c c)) (jolt-nth (an c tenv) 1))) node))) (jolt-vector _o$6038 _o$6039)) jolt-nil))))))))))))))))) an)))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.numeric" "annotate" (letrec ((annotate (lambda (node) (let fnrec6040 ((node node)) (jolt-nth (jolt-invoke (var-deref "jolt.passes.numeric" "an") node (jolt-hash-map)) 1))))) annotate) (let* ((_o$6041 (keyword #f "doc")) (_o$6042 "Tag arithmetic nodes with :num-kind from local numeric type-flow. Returns the\n rewritten IR (no kind escapes to the caller).")) (jolt-hash-map _o$6041 _o$6042))))
(guard (e (#t #f))
(def-var! "jolt.passes.inline" "dirty" (jolt-invoke (var-deref "clojure.core" "atom") #f)))
(guard (e (#t #f))
(def-var! "jolt.passes.inline" "mark!" (letrec ((mark! (lambda () (let fnrec6043 () (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.passes.inline" "dirty") #t))))) mark!)))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.inline" "rec-shapes" (jolt-invoke (var-deref "clojure.core" "atom") (jolt-hash-map)) (let* ((_o$6044 (keyword #f "private")) (_o$6045 #t)) (jolt-hash-map _o$6044 _o$6045))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.inline" "set-rec-shapes!" (letrec ((set-rec-shapes! (lambda (m) (let fnrec6046 ((m m)) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.passes.inline" "rec-shapes") (let* ((or__26__auto m)) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-hash-map)))))))) set-rec-shapes!) (let* ((_o$6047 (keyword #f "doc")) (_o$6048 "Install the record-ctor shape registry the record fold consults.")) (jolt-hash-map _o$6047 _o$6048))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.inline" "fresh-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (let* ((_o$6049 (keyword #f "private")) (_o$6050 #t)) (jolt-hash-map _o$6049 _o$6050))))
(guard (e (#t #f))
(def-var! "jolt.passes.inline" "fresh" (letrec ((fresh (lambda (base) (let fnrec6051 ((base base)) (let* ((n (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.inline" "fresh-counter")))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.passes.inline" "fresh-counter") jolt-inc) (jolt-invoke (var-deref "clojure.core" "str") base "__il" n))))))) fresh)))
(guard (e (#t #f))
(def-var! "jolt.passes.inline" "safe-op?" (letrec ((safe-op? (lambda (op) (let fnrec6052 ((op op)) (let* ((or__26__auto (jolt= op (keyword #f "const")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "local")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "var")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "host")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "the-var")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "quote")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "if")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "do")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "let")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "invoke")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "map")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "vector")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "set")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= op (keyword #f "throw")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= op (keyword #f "coerce")))))))))))))))))))))))))))))))))) safe-op?)))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.inline" "inline-budget" 120 (let* ((_o$6053 (keyword #f "private")) (_o$6054 #t)) (jolt-hash-map _o$6053 _o$6054))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.inline" "body-size" (letrec ((body-size (lambda (node) (let fnrec6055 ((node node)) (if (jolt-not (jolt-invoke (var-deref "jolt.passes.inline" "safe-op?") (jolt-get node (keyword #f "op")))) 100000 (jolt-invoke (var-deref "jolt.ir" "reduce-ir-children") (lambda (acc c) (let fnrec6056 ((acc acc) (c c)) (+ acc (body-size c)))) 1 node)))))) body-size) (let* ((_o$6057 (keyword #f "doc")) (_o$6058 "Node count of an inline-eligible body. A disallowed op contributes a number\n larger than any budget, so the caller's (<= size budget) test fails and we\n never try to inline (or alpha-rename) such a body. Only reached for safe ops,\n so the shared child fold covers it exactly (leaves fold to 1).")) (jolt-hash-map _o$6057 _o$6058))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.inline" "subst" (letrec ((subst (lambda (node env) (let fnrec6059 ((node node) (env env)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "local")) (let* ((r (jolt-get env (jolt-get node (keyword #f "name"))))) (if (jolt-truthy? r) (if (jolt-truthy? (let* ((and__25__auto (jolt= (keyword #f "local") (jolt-get r (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-get node (keyword #f "hint")))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-get r (keyword #f "hint"))) and__25__auto)) and__25__auto))) (jolt-assoc r (keyword #f "hint") (jolt-get node (keyword #f "hint"))) r) node)) (if (jolt= op (keyword #f "let")) (let* ((res (let* ((_a$6071 (lambda (acc b) (let fnrec6060 ((acc acc) (b b)) (let* ((e (jolt-nth acc 0)) (binds (jolt-nth acc 1)) (nm (jolt-nth b 0)) (init (subst (jolt-nth b 1) e)) (f (jolt-invoke (var-deref "jolt.passes.inline" "fresh") nm))) (let* ((_o$6067 (jolt-assoc e nm (let* ((_o$6061 (keyword #f "op")) (_o$6062 (keyword #f "local")) (_o$6063 (keyword #f "name")) (_o$6064 f)) (jolt-hash-map _o$6061 _o$6062 _o$6063 _o$6064)))) (_o$6068 (jolt-conj binds (let* ((_o$6065 f) (_o$6066 init)) (jolt-vector _o$6065 _o$6066))))) (jolt-vector _o$6067 _o$6068)))))) (_a$6072 (let* ((_o$6069 env) (_o$6070 (jolt-vector))) (jolt-vector _o$6069 _o$6070))) (_a$6073 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$6071 _a$6072 _a$6073)))) (let* ((_a$6076 node) (_a$6077 (keyword #f "bindings")) (_a$6078 (jolt-nth res 1)) (_a$6079 (keyword #f "body")) (_a$6080 (let* ((_a$6074 (jolt-get node (keyword #f "body"))) (_a$6075 (jolt-nth res 0))) (subst _a$6074 _a$6075)))) (jolt-assoc _a$6076 _a$6077 _a$6078 _a$6079 _a$6080))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec6081 ((c c)) (subst c env))) node) jolt-nil)))))))) subst) (let* ((_o$6082 (keyword #f "doc")) (_o$6083 "Substitute locals in node per env (a map name -> replacement IR node), and\n alpha-rename every inner :let binder to a globally fresh name (so the spliced\n body shares no name with the caller). env seeds the params: a trivial arg\n (local/const) maps a param straight to the arg node (copy propagation \x2014; this\n is what lets scalar-replace see a map-literal arg through the call boundary);\n a non-trivial arg maps the param to a fresh :local that a wrapping let binds.")) (jolt-hash-map _o$6082 _o$6083))))
(guard (e (#t #f))
(def-var! "jolt.passes.inline" "trivial-arg?" (letrec ((trivial-arg? (lambda (n) (let fnrec6084 ((n n)) (let* ((op (jolt-get n (keyword #f "op")))) (let* ((or__26__auto (jolt= op (keyword #f "local")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= op (keyword #f "const"))))))))) trivial-arg?)))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.inline" "body-closed?" (letrec ((body-closed? (lambda (node scope) (let fnrec6085 ((node node) (scope scope)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "local")) (jolt-contains? scope (jolt-get node (keyword #f "name"))) (if (jolt= op (keyword #f "let")) (let* ((res (let* ((_a$6091 (lambda (acc b) (let fnrec6086 ((acc acc) (b b)) (let* ((sc (jolt-nth acc 0)) (ok (jolt-nth acc 1))) (if (jolt-not ok) acc (let* ((_o$6087 (jolt-conj sc (jolt-nth b 0))) (_o$6088 (body-closed? (jolt-nth b 1) sc))) (jolt-vector _o$6087 _o$6088))))))) (_a$6092 (let* ((_o$6089 scope) (_o$6090 #t)) (jolt-vector _o$6089 _o$6090))) (_a$6093 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$6091 _a$6092 _a$6093)))) (let* ((and__25__auto (jolt-nth res 1))) (if (jolt-truthy? and__25__auto) (let* ((_a$6094 (jolt-get node (keyword #f "body"))) (_a$6095 (jolt-nth res 0))) (body-closed? _a$6094 _a$6095)) and__25__auto))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "safe-op?") op)) (jolt-invoke (var-deref "jolt.ir" "reduce-ir-children") (lambda (ok c) (let fnrec6096 ((ok ok) (c c)) (let* ((and__25__auto ok)) (if (jolt-truthy? and__25__auto) (body-closed? c scope) and__25__auto)))) #t node) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil))))))))) body-closed?) (let* ((_o$6097 (keyword #f "doc")) (_o$6098 "True if every :local in node is bound \x2014; by a param (in the initial scope set)\n or by an enclosing :let within the body. A self-recursive fn fails this: the\n analyzer binds the fn's own name as a local, so its body has a FREE local (the\n self-reference) that would dangle once the body is spliced elsewhere.")) (jolt-hash-map _o$6097 _o$6098))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.inline" "try-inline" (letrec ((try-inline (lambda (node ctx) (let fnrec6099 ((node node) (ctx ctx)) (let* ((f (jolt-get node (keyword #f "fn")))) (if (jolt= (keyword #f "var") (jolt-get f (keyword #f "op"))) (let* ((stash (let* ((_a$6100 (var-deref "jolt.host" "inline-ir")) (_a$6101 ctx) (_a$6102 (jolt-get f (keyword #f "ns"))) (_a$6103 (jolt-get f (keyword #f "name")))) (jolt-invoke _a$6100 _a$6101 _a$6102 _a$6103)))) (if (jolt-truthy? stash) (let* ((params (jolt-get stash (keyword #f "params"))) (body (jolt-get stash (keyword #f "body"))) (nh (let* ((_a$6108 (lambda (m pr) (let fnrec6104 ((m m) (pr pr)) (let* ((_a$6105 m) (_a$6106 (jolt-nth pr 0)) (_a$6107 (jolt-nth pr 1))) (jolt-assoc _a$6105 _a$6106 _a$6107))))) (_a$6109 (jolt-hash-map)) (_a$6110 (jolt-get stash (keyword #f "nhints")))) (jolt-reduce _a$6108 _a$6109 _a$6110))) (ret (jolt-get stash (keyword #f "ret"))) (args (jolt-get node (keyword #f "args")))) (if (jolt-truthy? (let* ((and__25__auto (let* ((_a$6111 (jolt-count params)) (_a$6112 (jolt-count args))) (jolt= _a$6111 _a$6112)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (<= (jolt-invoke (var-deref "jolt.passes.inline" "body-size") body) (var-deref "jolt.passes.inline" "inline-budget")))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.inline" "body-closed?") body (jolt-reduce jolt-conj (jolt-hash-set) params)) and__25__auto)) and__25__auto))) (let* ((n (jolt-count params)) (res (let* ((i 0) (env (jolt-hash-map)) (binds (jolt-vector))) (let loop6113 ((i i) (env env) (binds binds)) (if (< i n) (let* ((p (jolt-nth params i)) (a (jolt-nth args i)) (k (jolt-get nh p))) (if (jolt-truthy? k) (let* ((f (jolt-invoke (var-deref "jolt.passes.inline" "fresh") p))) (let* ((_a$6120 (jolt-inc i)) (_a$6121 (jolt-assoc env p (let* ((_o$6114 (keyword #f "op")) (_o$6115 (keyword #f "local")) (_o$6116 (keyword #f "name")) (_o$6117 f)) (jolt-hash-map _o$6114 _o$6115 _o$6116 _o$6117)))) (_a$6122 (jolt-conj binds (let* ((_o$6118 f) (_o$6119 (jolt-invoke (var-deref "jolt.ir" "coerce-node") k a))) (jolt-vector _o$6118 _o$6119))))) (loop6113 _a$6120 _a$6121 _a$6122))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "trivial-arg?") a)) (let* ((_a$6123 (jolt-inc i)) (_a$6124 (jolt-assoc env p a)) (_a$6125 binds)) (loop6113 _a$6123 _a$6124 _a$6125)) (if (jolt-truthy? (keyword #f "else")) (let* ((f (jolt-invoke (var-deref "jolt.passes.inline" "fresh") p))) (let* ((_a$6132 (jolt-inc i)) (_a$6133 (jolt-assoc env p (let* ((_o$6126 (keyword #f "op")) (_o$6127 (keyword #f "local")) (_o$6128 (keyword #f "name")) (_o$6129 f)) (jolt-hash-map _o$6126 _o$6127 _o$6128 _o$6129)))) (_a$6134 (jolt-conj binds (let* ((_o$6130 f) (_o$6131 a)) (jolt-vector _o$6130 _o$6131))))) (loop6113 _a$6132 _a$6133 _a$6134))) jolt-nil)))) (let* ((_o$6135 env) (_o$6136 binds)) (jolt-vector _o$6135 _o$6136)))))) (env (jolt-nth res 0)) (binds (jolt-nth res 1)) (rbody0 (jolt-invoke (var-deref "jolt.passes.inline" "subst") body env)) (rbody (if (jolt-truthy? ret) (jolt-invoke (var-deref "jolt.ir" "coerce-node") ret rbody0) rbody0))) (begin (jolt-invoke (var-deref "jolt.passes.inline" "mark!")) (if (jolt= 0 (jolt-count binds)) rbody (let* ((_o$6137 (keyword #f "op")) (_o$6138 (keyword #f "let")) (_o$6139 (keyword #f "bindings")) (_o$6140 binds) (_o$6141 (keyword #f "body")) (_o$6142 rbody)) (jolt-hash-map _o$6137 _o$6138 _o$6139 _o$6140 _o$6141 _o$6142))))) node)) node)) node)))))) try-inline) (let* ((_o$6143 (keyword #f "doc")) (_o$6144 "node is an :invoke whose children are already inlined. If its :fn is a var\n with a stashed, in-budget, arity-matching inline body, return the spliced\n let; else node.")) (jolt-hash-map _o$6143 _o$6144))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.inline" "inline-node" (letrec ((inline-node (lambda (node ctx) (let fnrec6145 ((node node) (ctx ctx)) (if (jolt= (keyword #f "invoke") (jolt-get node (keyword #f "op"))) (jolt-invoke (var-deref "jolt.passes.inline" "try-inline") (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec6146 ((c c)) (inline-node c ctx))) node) ctx) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec6147 ((c c)) (inline-node c ctx))) node)))))) inline-node) (let* ((_o$6148 (keyword #f "doc")) (_o$6149 "Bottom-up: inline children first, then attempt to inline this node.")) (jolt-hash-map _o$6148 _o$6149))))
(guard (e (#t #f))
(def-var! "jolt.passes.inline" "flatten-let-bindings" (letrec ((flatten-let-bindings (lambda (binds) (let fnrec6150 ((binds binds)) (let* ((_a$6156 (lambda (out b) (let fnrec6151 ((out out) (b b)) (let* ((nm (jolt-nth b 0)) (init (jolt-nth b 1))) (if (jolt= (keyword #f "let") (jolt-get init (keyword #f "op"))) (begin (jolt-invoke (var-deref "jolt.passes.inline" "mark!")) (let* ((_a$6154 (jolt-reduce jolt-conj out (jolt-get init (keyword #f "bindings")))) (_a$6155 (let* ((_o$6152 nm) (_o$6153 (jolt-get init (keyword #f "body")))) (jolt-vector _o$6152 _o$6153)))) (jolt-conj _a$6154 _a$6155))) (jolt-conj out b)))))) (_a$6157 (jolt-vector)) (_a$6158 binds)) (jolt-reduce _a$6156 _a$6157 _a$6158)))))) flatten-let-bindings)))
(guard (e (#t #f))
(def-var! "jolt.passes.inline" "flatten-lets" (letrec ((flatten-lets (lambda (node) (let fnrec6159 ((node node)) (if (jolt= (keyword #f "let") (jolt-get node (keyword #f "op"))) (let* ((n (jolt-invoke (var-deref "jolt.ir" "map-ir-children") flatten-lets node))) (jolt-assoc n (keyword #f "bindings") (jolt-invoke (var-deref "jolt.passes.inline" "flatten-let-bindings") (jolt-get n (keyword #f "bindings"))))) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") flatten-lets node)))))) flatten-lets)))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.inline" "pure-fns" (let* ((_o$6160 "+") (_o$6161 "-") (_o$6162 "*") (_o$6163 "/") (_o$6164 "<") (_o$6165 ">") (_o$6166 "<=") (_o$6167 ">=") (_o$6168 "=") (_o$6169 "not=") (_o$6170 "inc") (_o$6171 "dec") (_o$6172 "mod") (_o$6173 "rem") (_o$6174 "quot") (_o$6175 "min") (_o$6176 "max") (_o$6177 "abs") (_o$6178 "nil?") (_o$6179 "some?") (_o$6180 "not") (_o$6181 "get") (_o$6182 "zero?") (_o$6183 "pos?") (_o$6184 "neg?") (_o$6185 "even?") (_o$6186 "odd?") (_o$6187 "bit-and") (_o$6188 "bit-or") (_o$6189 "bit-xor")) (jolt-hash-set _o$6160 _o$6161 _o$6162 _o$6163 _o$6164 _o$6165 _o$6166 _o$6167 _o$6168 _o$6169 _o$6170 _o$6171 _o$6172 _o$6173 _o$6174 _o$6175 _o$6176 _o$6177 _o$6178 _o$6179 _o$6180 _o$6181 _o$6182 _o$6183 _o$6184 _o$6185 _o$6186 _o$6187 _o$6188 _o$6189)) (let* ((_o$6190 (keyword #f "private")) (_o$6191 #t)) (jolt-hash-map _o$6190 _o$6191))))
(guard (e (#t #f))
(def-var! "jolt.passes.inline" "pure-fn?" (letrec ((pure-fn? (lambda (f) (let fnrec6192 ((f f)) (let* ((op (jolt-get f (keyword #f "op")))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.fold" "kw-callee?") f)) #t (if (jolt= op (keyword #f "var")) (let* ((and__25__auto (jolt= "clojure.core" (jolt-get f (keyword #f "ns"))))) (if (jolt-truthy? and__25__auto) (jolt-contains? (var-deref "jolt.passes.inline" "pure-fns") (jolt-get f (keyword #f "name"))) and__25__auto)) (if (jolt= op (keyword #f "host")) (jolt-contains? (var-deref "jolt.passes.inline" "pure-fns") (jolt-get f (keyword #f "name"))) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil))))))))) pure-fn?)))
(guard (e (#t #f))
(declare-var! "jolt.passes.inline" "ctor-shape"))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.inline" "pure?" (letrec ((pure? (lambda (node) (let fnrec6193 ((node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "invoke")) (let* ((and__25__auto (let* ((or__26__auto (jolt-invoke (var-deref "jolt.passes.inline" "pure-fn?") (jolt-get node (keyword #f "fn"))))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-invoke (var-deref "jolt.passes.inline" "ctor-shape") node))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "every?") pure? (jolt-get node (keyword #f "args"))) and__25__auto)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "safe-op?") op)) (jolt-invoke (var-deref "jolt.ir" "reduce-ir-children") (lambda (ok c) (let fnrec6194 ((ok ok) (c c)) (let* ((and__25__auto ok)) (if (jolt-truthy? and__25__auto) (pure? c) and__25__auto)))) #t node) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil)))))))) pure?) (let* ((_o$6195 (keyword #f "doc")) (_o$6196 "Conservative: true only for expressions with no side effects that are safe to\n duplicate or discard. A var/host ref is a pure read; an invoke is pure for a\n known-pure fn (arithmetic, comparison, keyword lookup, get) or a record\n constructor (an immutable struct alloc) whose args are themselves pure.")) (jolt-hash-map _o$6195 _o$6196))))
(guard (e (#t #f))
(def-var! "jolt.passes.inline" "const-key-map?" (letrec ((const-key-map? (lambda (node) (let fnrec6197 ((node node)) (let* ((prs (jolt-get node (keyword #f "pairs")))) (let* ((and__25__auto (> (jolt-count prs) 0))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (pr) (let fnrec6198 ((pr pr)) (jolt-invoke (var-deref "jolt.passes.fold" "scalar-const?") (jolt-nth pr 0)))) prs) and__25__auto))))))) const-key-map?)))
(guard (e (#t #f))
(def-var! "jolt.passes.inline" "all-vals-pure?" (letrec ((all-vals-pure? (lambda (node) (let fnrec6199 ((node node)) (let* ((_a$6201 (var-deref "clojure.core" "every?")) (_a$6202 (lambda (pr) (let fnrec6200 ((pr pr)) (jolt-invoke (var-deref "jolt.passes.inline" "pure?") (jolt-nth pr 1))))) (_a$6203 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$6201 _a$6202 _a$6203)))))) all-vals-pure?)))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.inline" "map-val" (letrec ((map-val (lambda (mapnode k) (let fnrec6204 ((mapnode mapnode) (k k)) (let* ((prs (jolt-get mapnode (keyword #f "pairs"))) (n (jolt-count prs))) (let* ((i 0)) (let loop6205 ((i i)) (if (< i n) (let* ((pr (jolt-nth prs i))) (if (jolt= (jolt-get (jolt-nth pr 0) (keyword #f "val")) k) (jolt-nth pr 1) (loop6205 (jolt-inc i)))) (let* ((_o$6206 (keyword #f "op")) (_o$6207 (keyword #f "const")) (_o$6208 (keyword #f "val")) (_o$6209 jolt-nil)) (jolt-hash-map _o$6206 _o$6207 _o$6208 _o$6209)))))))))) map-val) (let* ((_o$6210 (keyword #f "doc")) (_o$6211 "The value IR at scalar key k in a const-key map node, or a nil constant when k\n is absent (struct-eligible literal: a missing key reads nil, like the back end).")) (jolt-hash-map _o$6210 _o$6211))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.inline" "lookup-key" (letrec ((lookup-key (lambda (node nm) (let fnrec6212 ((node node) (nm nm)) (if (jolt= (keyword #f "invoke") (jolt-get node (keyword #f "op"))) (let* ((f (jolt-get node (keyword #f "fn"))) (args (jolt-get node (keyword #f "args")))) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.fold" "kw-callee?") f))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= 1 (jolt-count args)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= (keyword #f "local") (jolt-get (jolt-nth args 0) (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt= nm (jolt-get (jolt-nth args 0) (keyword #f "name"))) and__25__auto)) and__25__auto)) and__25__auto))) (jolt-get f (keyword #f "val")) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.fold" "get-callee?") f))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= 2 (jolt-count args)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= (keyword #f "local") (jolt-get (jolt-nth args 0) (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= nm (jolt-get (jolt-nth args 0) (keyword #f "name"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.fold" "scalar-const?") (jolt-nth args 1)) and__25__auto)) and__25__auto)) and__25__auto)) and__25__auto))) (jolt-get (jolt-nth args 1) (keyword #f "val")) (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))) jolt-nil))))) lookup-key) (let* ((_o$6213 (keyword #f "doc")) (_o$6214 "If node is a constant-keyword lookup of (:local nm) \x2014; either (:k nm) or\n (get nm :k) \x2014; return the keyword k; else nil.")) (jolt-hash-map _o$6213 _o$6214))))
(guard (e (#t #f))
(def-var! "jolt.passes.inline" "any-binding-named?" (letrec ((any-binding-named? (lambda (binds nm) (let fnrec6215 ((binds binds) (nm nm)) (let* ((i 0)) (let loop6216 ((i i)) (if (< i (jolt-count binds)) (if (jolt= nm (jolt-nth (jolt-nth binds i) 0)) #t (loop6216 (jolt-inc i))) #f))))))) any-binding-named?)))
(guard (e (#t #f))
(def-var! "jolt.passes.inline" "any-name?" (letrec ((any-name? (lambda (names nm) (let fnrec6217 ((names names) (nm nm)) (let* ((i 0)) (let loop6218 ((i i)) (if (< i (jolt-count names)) (if (jolt= nm (jolt-nth names i)) #t (loop6218 (jolt-inc i))) #f))))))) any-name?)))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.inline" "local-escapes?" (letrec ((local-escapes? (lambda (node nm) (let fnrec6219 ((node node) (nm nm)) (let* ((op (jolt-get node (keyword #f "op"))) (k (jolt-invoke (var-deref "jolt.passes.inline" "lookup-key") node nm))) (if (jolt-truthy? k) (let* ((args (jolt-get node (keyword #f "args")))) (if (> (jolt-count args) 1) (let* ((i 1)) (let loop6220 ((i i)) (if (< i (jolt-count args)) (if (jolt-truthy? (local-escapes? (jolt-nth args i) nm)) #t (loop6220 (jolt-inc i))) #f))) #f)) (if (jolt= op (keyword #f "local")) (jolt= nm (jolt-get node (keyword #f "name"))) (if (jolt= op (keyword #f "const")) #f (if (jolt= op (keyword #f "var")) #f (if (jolt= op (keyword #f "host")) #f (if (jolt= op (keyword #f "the-var")) #f (if (jolt= op (keyword #f "quote")) #f (if (jolt= op (keyword #f "if")) (let* ((or__26__auto (local-escapes? (jolt-get node (keyword #f "test")) nm))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (local-escapes? (jolt-get node (keyword #f "then")) nm))) (if (jolt-truthy? or__26__auto) or__26__auto (local-escapes? (jolt-get node (keyword #f "else")) nm))))) (if (jolt= op (keyword #f "do")) (let* ((or__26__auto (let* ((i 0) (ss (jolt-get node (keyword #f "statements")))) (let loop6221 ((i i) (ss ss)) (if (< i (jolt-count ss)) (if (jolt-truthy? (local-escapes? (jolt-nth ss i) nm)) #t (loop6221 (jolt-inc i) ss)) #f))))) (if (jolt-truthy? or__26__auto) or__26__auto (local-escapes? (jolt-get node (keyword #f "ret")) nm))) (if (jolt= op (keyword #f "throw")) (local-escapes? (jolt-get node (keyword #f "expr")) nm) (if (jolt= op (keyword #f "invoke")) (let* ((or__26__auto (local-escapes? (jolt-get node (keyword #f "fn")) nm))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((i 0) (as (jolt-get node (keyword #f "args")))) (let loop6222 ((i i) (as as)) (if (< i (jolt-count as)) (if (jolt-truthy? (local-escapes? (jolt-nth as i) nm)) #t (loop6222 (jolt-inc i) as)) #f))))) (if (jolt= op (keyword #f "vector")) (let* ((i 0) (xs (jolt-get node (keyword #f "items")))) (let loop6223 ((i i) (xs xs)) (if (< i (jolt-count xs)) (if (jolt-truthy? (local-escapes? (jolt-nth xs i) nm)) #t (loop6223 (jolt-inc i) xs)) #f))) (if (jolt= op (keyword #f "set")) (let* ((i 0) (xs (jolt-get node (keyword #f "items")))) (let loop6224 ((i i) (xs xs)) (if (< i (jolt-count xs)) (if (jolt-truthy? (local-escapes? (jolt-nth xs i) nm)) #t (loop6224 (jolt-inc i) xs)) #f))) (if (jolt= op (keyword #f "map")) (let* ((i 0) (ps (jolt-get node (keyword #f "pairs")))) (let loop6225 ((i i) (ps ps)) (if (< i (jolt-count ps)) (if (jolt-truthy? (let* ((or__26__auto (local-escapes? (jolt-nth (jolt-nth ps i) 0) nm))) (if (jolt-truthy? or__26__auto) or__26__auto (local-escapes? (jolt-nth (jolt-nth ps i) 1) nm)))) #t (loop6225 (jolt-inc i) ps)) #f))) (if (jolt= op (keyword #f "let")) (let* ((binds (jolt-get node (keyword #f "bindings")))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "any-binding-named?") binds nm)) #t (let* ((or__26__auto (let* ((i 0)) (let loop6226 ((i i)) (if (< i (jolt-count binds)) (if (jolt-truthy? (local-escapes? (jolt-nth (jolt-nth binds i) 1) nm)) #t (loop6226 (jolt-inc i))) #f))))) (if (jolt-truthy? or__26__auto) or__26__auto (local-escapes? (jolt-get node (keyword #f "body")) nm))))) (if (jolt= op (keyword #f "recur")) (let* ((i 0) (as (jolt-get node (keyword #f "args")))) (let loop6227 ((i i) (as as)) (if (< i (jolt-count as)) (if (jolt-truthy? (local-escapes? (jolt-nth as i) nm)) #t (loop6227 (jolt-inc i) as)) #f))) (if (jolt= op (keyword #f "loop")) (let* ((binds (jolt-get node (keyword #f "bindings")))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "any-binding-named?") binds nm)) #t (let* ((or__26__auto (let* ((i 0)) (let loop6228 ((i i)) (if (< i (jolt-count binds)) (if (jolt-truthy? (local-escapes? (jolt-nth (jolt-nth binds i) 1) nm)) #t (loop6228 (jolt-inc i))) #f))))) (if (jolt-truthy? or__26__auto) or__26__auto (local-escapes? (jolt-get node (keyword #f "body")) nm))))) (if (jolt= op (keyword #f "fn")) (let* ((i 0) (ars (jolt-get node (keyword #f "arities")))) (let loop6229 ((i i) (ars ars)) (if (< i (jolt-count ars)) (let* ((ar (jolt-nth ars i)) (ps (jolt-get ar (keyword #f "params")))) (if (jolt-truthy? (let* ((or__26__auto (jolt-invoke (var-deref "jolt.passes.inline" "any-name?") ps nm))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= nm (jolt-get ar (keyword #f "rest")))))) #t (if (jolt-truthy? (local-escapes? (jolt-get ar (keyword #f "body")) nm)) #t (loop6229 (jolt-inc i) ars)))) #f))) (if (jolt= op (keyword #f "try")) (let* ((or__26__auto (local-escapes? (jolt-get node (keyword #f "body")) nm))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (let* ((cb (jolt-get node (keyword #f "catch-body")))) (let* ((and__25__auto cb)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt= nm (jolt-get node (keyword #f "catch-sym")))))) (if (jolt-truthy? and__25__auto) (local-escapes? cb nm) and__25__auto)) and__25__auto))))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((f (jolt-get node (keyword #f "finally")))) (let* ((and__25__auto f)) (if (jolt-truthy? and__25__auto) (local-escapes? f nm) and__25__auto))))))) (if (jolt= op (keyword #f "def")) (local-escapes? (jolt-get node (keyword #f "init")) nm) (if (jolt-truthy? (keyword #f "else")) #t jolt-nil)))))))))))))))))))))))))) local-escapes?) (let* ((_o$6230 (keyword #f "doc")) (_o$6231 "Does local nm escape in node \x2014; i.e. is it used anywhere other than as the\n subject of a constant-keyword lookup? Precise over straight-line expression\n ops; conservatively true for loop/fn/try/recur/def (and any rebinding of nm),\n so scalar replacement only fires where the whole use region is simple.\n\n Stays an explicit per-op walk (not the shared reduce-ir-children fold): its\n default is conservatively TRUE, and the lookup-subject and rebinding cases\n inspect node shape beyond child purity \x2014; folding an unhandled op over its\n children would under-report escape and is unsound for scalar replacement.")) (jolt-hash-map _o$6230 _o$6231))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.inline" "ctor-shape" (letrec ((ctor-shape (lambda (node) (let fnrec6232 ((node node)) (if (jolt= (keyword #f "invoke") (jolt-get node (keyword #f "op"))) (let* ((f (jolt-get node (keyword #f "fn")))) (if (jolt= (keyword #f "var") (jolt-get f (keyword #f "op"))) (let* ((rs (let* ((_a$6237 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.inline" "rec-shapes"))) (_a$6238 (let* ((_a$6233 (var-deref "clojure.core" "str")) (_a$6234 (jolt-get f (keyword #f "ns"))) (_a$6235 "/") (_a$6236 (jolt-get f (keyword #f "name")))) (jolt-invoke _a$6233 _a$6234 _a$6235 _a$6236)))) (jolt-get _a$6237 _a$6238)))) (if (jolt-truthy? (let* ((and__25__auto rs)) (if (jolt-truthy? and__25__auto) (let* ((_a$6239 (jolt-count (jolt-get rs (keyword #f "fields")))) (_a$6240 (jolt-count (jolt-get node (keyword #f "args"))))) (jolt= _a$6239 _a$6240)) and__25__auto))) rs jolt-nil)) jolt-nil)) jolt-nil))))) ctor-shape) (let* ((_o$6241 (keyword #f "doc")) (_o$6242 "If node is a record-constructor :invoke (its :fn a :var whose ns/name is a\n registered ctor key, with arg count matching the declared field count), return\n that record's shape entry; else nil.")) (jolt-hash-map _o$6241 _o$6242))))
(guard (e (#t #f))
(def-var! "jolt.passes.inline" "ctor-all-args-pure?" (letrec ((ctor-all-args-pure? (lambda (node) (let fnrec6243 ((node node)) (jolt-invoke (var-deref "clojure.core" "every?") (var-deref "jolt.passes.inline" "pure?") (jolt-get node (keyword #f "args"))))))) ctor-all-args-pure?)))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.inline" "field-index" (letrec ((field-index (lambda (fields k) (let fnrec6244 ((fields fields) (k k)) (let* ((n (jolt-count fields))) (let* ((i 0)) (let loop6245 ((i i)) (if (< i n) (if (jolt= (jolt-nth fields i) k) i (loop6245 (jolt-inc i))) jolt-nil)))))))) field-index) (let* ((_o$6246 (keyword #f "doc")) (_o$6247 "Index of scalar key k in the declared field tuple fields, or nil.")) (jolt-hash-map _o$6246 _o$6247))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.inline" "ctor-val" (letrec ((ctor-val (lambda (ctor rs k) (let fnrec6248 ((ctor ctor) (rs rs) (k k)) (let* ((_a$6249 (jolt-get ctor (keyword #f "args"))) (_a$6250 (jolt-invoke (var-deref "jolt.passes.inline" "field-index") (jolt-get rs (keyword #f "fields")) k))) (jolt-nth _a$6249 _a$6250)))))) ctor-val) (let* ((_o$6251 (keyword #f "doc")) (_o$6252 "The positional arg IR at declared field k of record ctor node (shape rs). Only\n called for a key known to be a field, so the index is always present.")) (jolt-hash-map _o$6251 _o$6252))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.inline" "collect-keys!" (letrec ((collect-keys! (lambda (node nm acc) (let fnrec6253 ((node node) (nm nm) (acc acc)) (let* ((k (jolt-invoke (var-deref "jolt.passes.inline" "lookup-key") node nm))) (if (jolt-truthy? k) (jolt-invoke (var-deref "clojure.core" "swap!") acc jolt-conj k) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec6254 ((c c)) (begin (collect-keys! c nm acc) c))) node))))))) collect-keys!) (let* ((_o$6255 (keyword #f "doc")) (_o$6256 "Accumulate (into atom acc) every constant-keyword lookup key applied to local\n nm in node. The caller has proven (via local-escapes?) that nm appears only as\n a lookup subject and is never rebound, so a uniform recursion suffices: at a\n lookup of nm we record the key and stop (its subject is nm itself); elsewhere\n we recurse into children.")) (jolt-hash-map _o$6255 _o$6256))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.inline" "lookups-all-fields?" (letrec ((lookups-all-fields? (lambda (nodes nm fields) (let fnrec6257 ((nodes nodes) (nm nm) (fields fields)) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (node) (let fnrec6258 ((node node)) (let* ((acc (jolt-invoke (var-deref "clojure.core" "atom") (jolt-hash-set)))) (begin (jolt-invoke (var-deref "jolt.passes.inline" "collect-keys!") node nm acc) (let* ((_a$6260 (var-deref "clojure.core" "every?")) (_a$6261 (lambda (k) (let fnrec6259 ((k k)) (jolt-invoke (var-deref "jolt.passes.inline" "field-index") fields k)))) (_a$6262 (jolt-invoke (var-deref "clojure.core" "deref") acc))) (jolt-invoke _a$6260 _a$6261 _a$6262)))))) nodes))))) lookups-all-fields?) (let* ((_o$6263 (keyword #f "doc")) (_o$6264 "True if every lookup of nm across nodes uses a declared field in fields \x2014; the\n record-only guard that keeps a :jolt/deftype/unknown-key read (not a positional\n arg) from being folded to the wrong value.")) (jolt-hash-map _o$6263 _o$6264))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.inline" "src-val" (letrec ((src-val (lambda (src k) (let fnrec6265 ((src src) (k k)) (if (jolt= (keyword #f "map") (jolt-get src (keyword #f "op"))) (jolt-invoke (var-deref "jolt.passes.inline" "map-val") src k) (jolt-invoke (var-deref "jolt.passes.inline" "ctor-val") src (jolt-invoke (var-deref "jolt.passes.inline" "ctor-shape") src) k)))))) src-val) (let* ((_o$6266 (keyword #f "doc")) (_o$6267 "Field value at k from a foldable struct source \x2014; a const-key map (absent key\n -> nil, struct-map semantics) or a record ctor (k is always a declared field\n here, guaranteed by lookups-all-fields?).")) (jolt-hash-map _o$6266 _o$6267))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.inline" "subst-lookup" (letrec ((subst-lookup (lambda (node nm src) (let fnrec6268 ((node node) (nm nm) (src src)) (let* ((k (jolt-invoke (var-deref "jolt.passes.inline" "lookup-key") node nm))) (if (jolt-truthy? k) (jolt-invoke (var-deref "jolt.passes.inline" "src-val") src k) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec6269 ((c c)) (subst-lookup c nm src))) node))))))) subst-lookup) (let* ((_o$6270 (keyword #f "doc")) (_o$6271 "Replace every (:k nm)/(get nm :k) in node with the source value at k. The\n caller guarantees (via local-escapes?) that nm is never rebound here and\n appears only as a lookup subject, so no shadowing logic is needed.")) (jolt-hash-map _o$6270 _o$6271))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.inline" "fold-kw-literal" (letrec ((fold-kw-literal (lambda (node) (let fnrec6272 ((node node)) (let* ((f (jolt-get node (keyword #f "fn"))) (args (jolt-get node (keyword #f "args")))) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.fold" "kw-callee?") f))) (if (jolt-truthy? and__25__auto) (jolt= 1 (jolt-count args)) and__25__auto))) (let* ((m (jolt-nth args 0)) (k (jolt-get f (keyword #f "val")))) (if (jolt-truthy? (let* ((and__25__auto (jolt= (keyword #f "map") (jolt-get m (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.inline" "const-key-map?") m))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.inline" "all-vals-pure?") m) and__25__auto)) and__25__auto))) (begin (jolt-invoke (var-deref "jolt.passes.inline" "mark!")) (jolt-invoke (var-deref "jolt.passes.inline" "map-val") m k)) (let* ((rs (jolt-invoke (var-deref "jolt.passes.inline" "ctor-shape") m))) (if (jolt-truthy? (let* ((and__25__auto rs)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.inline" "ctor-all-args-pure?") m))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.inline" "field-index") (jolt-get rs (keyword #f "fields")) k) and__25__auto)) and__25__auto))) (begin (jolt-invoke (var-deref "jolt.passes.inline" "mark!")) (jolt-invoke (var-deref "jolt.passes.inline" "ctor-val") m rs k)) node)))) node)))))) fold-kw-literal) (let* ((_o$6273 (keyword #f "doc")) (_o$6274 "(a) (:k <source>) -> the value at k. <source> is a const-key pure map\n ((:k {:k a ..}) -> a) or a pure record ctor ((:k (->Rec a ..)) -> the arg for\n field k). Siblings are duplicated/discarded, so all must be pure; a record\n lookup folds only for a declared field.")) (jolt-hash-map _o$6273 _o$6274))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.inline" "elim-let-structs" (letrec ((elim-let-structs (lambda (node) (let fnrec6275 ((node node)) (let* ((binds (jolt-get node (keyword #f "bindings"))) (n (jolt-count binds)) (body (jolt-get node (keyword #f "body")))) (let* ((i 0)) (let loop6276 ((i i)) (if (< i n) (let* ((b (jolt-nth binds i)) (nm (jolt-nth b 0)) (init (jolt-nth b 1)) (ismap (let* ((and__25__auto (jolt= (keyword #f "map") (jolt-get init (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.inline" "const-key-map?") init))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.inline" "all-vals-pure?") init) and__25__auto)) and__25__auto))) (rs (if (jolt-not ismap) (jolt-invoke (var-deref "jolt.passes.inline" "ctor-shape") init) jolt-nil)) (isrec (let* ((and__25__auto rs)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.inline" "ctor-all-args-pure?") init) and__25__auto)))) (if (jolt-truthy? (let* ((and__25__auto (let* ((or__26__auto ismap)) (if (jolt-truthy? or__26__auto) or__26__auto isrec)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-invoke (var-deref "jolt.passes.inline" "any-binding-named?") (jolt-invoke (var-deref "clojure.core" "subvec") binds (jolt-inc i) n) nm)))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (let* ((j (jolt-inc i))) (let loop6277 ((j j)) (if (< j n) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "local-escapes?") (jolt-nth (jolt-nth binds j) 1) nm)) #t (loop6277 (jolt-inc j))) #f)))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-invoke (var-deref "jolt.passes.inline" "local-escapes?") body nm)))) (if (jolt-truthy? and__25__auto) (let* ((or__26__auto ismap)) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((_a$6282 (var-deref "jolt.passes.inline" "lookups-all-fields?")) (_a$6283 (jolt-conj (let* ((_a$6279 (var-deref "clojure.core" "mapv")) (_a$6280 (lambda (bb) (let fnrec6278 ((bb bb)) (jolt-nth bb 1)))) (_a$6281 (jolt-invoke (var-deref "clojure.core" "subvec") binds (jolt-inc i) n))) (jolt-invoke _a$6279 _a$6280 _a$6281)) body)) (_a$6284 nm) (_a$6285 (jolt-get rs (keyword #f "fields")))) (jolt-invoke _a$6282 _a$6283 _a$6284 _a$6285)))) and__25__auto)) and__25__auto)) and__25__auto)) and__25__auto))) (let* ((head (jolt-invoke (var-deref "clojure.core" "subvec") binds 0 i)) (tail (let* ((_a$6289 (var-deref "clojure.core" "mapv")) (_a$6290 (lambda (bb) (let fnrec6286 ((bb bb)) (let* ((_o$6287 (jolt-nth bb 0)) (_o$6288 (jolt-invoke (var-deref "jolt.passes.inline" "subst-lookup") (jolt-nth bb 1) nm init))) (jolt-vector _o$6287 _o$6288))))) (_a$6291 (jolt-invoke (var-deref "clojure.core" "subvec") binds (jolt-inc i) n))) (jolt-invoke _a$6289 _a$6290 _a$6291))) (newbinds (jolt-reduce jolt-conj head tail)) (newbody (jolt-invoke (var-deref "jolt.passes.inline" "subst-lookup") body nm init))) (begin (jolt-invoke (var-deref "jolt.passes.inline" "mark!")) (if (jolt= 0 (jolt-count newbinds)) newbody (jolt-assoc node (keyword #f "bindings") newbinds (keyword #f "body") newbody)))) (loop6276 (jolt-inc i)))) node)))))))) elim-let-structs) (let* ((_o$6292 (keyword #f "doc")) (_o$6293 "(b) Drop the first non-escaping let binding whose init is a foldable struct\n source \x2014; a pure const-key map literal or a pure record ctor \x2014; substituting its\n field reads into the remaining bindings and body. Fixpoint re-runs us for the\n rest, so one elimination per call keeps it simple. For a record every lookup\n of the binding must hit a declared field, else we keep the allocation.")) (jolt-hash-map _o$6292 _o$6293))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.inline" "scalar-replace" (letrec ((scalar-replace (lambda (node) (let fnrec6294 ((node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "invoke")) (jolt-invoke (var-deref "jolt.passes.inline" "fold-kw-literal") (jolt-invoke (var-deref "jolt.ir" "map-ir-children") scalar-replace node)) (if (jolt= op (keyword #f "let")) (jolt-invoke (var-deref "jolt.passes.inline" "elim-let-structs") (jolt-invoke (var-deref "jolt.ir" "map-ir-children") scalar-replace node)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") scalar-replace node) jolt-nil)))))))) scalar-replace) (let* ((_o$6295 (keyword #f "doc")) (_o$6296 "Bottom-up: scalar-replace children, then apply (a) at invokes / (b) at lets.")) (jolt-hash-map _o$6295 _o$6296))))
(guard (e (#t #f))
(def-var! "jolt.passes.types.lattice" "velem" (letrec ((velem (lambda (t) (let fnrec5619 ((t t)) (jolt-get t (keyword #f "vec")))))) velem)))
(guard (e (#t #f))
(def-var! "jolt.passes.types.lattice" "selem" (letrec ((selem (lambda (t) (let fnrec5620 ((t t)) (jolt-get t (keyword #f "set")))))) selem)))
(guard (e (#t #f))
(def-var! "jolt.passes.types.lattice" "sfields" (letrec ((sfields (lambda (t) (let fnrec5621 ((t t)) (jolt-get t (keyword #f "struct")))))) sfields)))
(guard (e (#t #f))
(def-var! "jolt.passes.types.lattice" "vec-type?" (letrec ((vec-type? (lambda (t) (let fnrec5622 ((t t)) (jolt-invoke (var-deref "clojure.core" "some?") (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") t)))))) vec-type?)))
(guard (e (#t #f))
(def-var! "jolt.passes.types.lattice" "set-type?" (letrec ((set-type? (lambda (t) (let fnrec5623 ((t t)) (jolt-invoke (var-deref "clojure.core" "some?") (jolt-invoke (var-deref "jolt.passes.types.lattice" "selem") t)))))) set-type?)))
(guard (e (#t #f))
(def-var! "jolt.passes.types.lattice" "struct-type?" (letrec ((struct-type? (lambda (t) (let fnrec5624 ((t t)) (jolt-invoke (var-deref "clojure.core" "some?") (jolt-invoke (var-deref "jolt.passes.types.lattice" "sfields") t)))))) struct-type?)))
(guard (e (#t #f))
(def-var! "jolt.passes.types.lattice" "mk-vec" (letrec ((mk-vec (lambda (t) (let fnrec5625 ((t t)) (let* ((_o$5626 (keyword #f "vec")) (_o$5627 (if (jolt-truthy? t) t (keyword #f "any")))) (jolt-hash-map _o$5626 _o$5627)))))) mk-vec)))
(guard (e (#t #f))
(def-var! "jolt.passes.types.lattice" "mk-set" (letrec ((mk-set (lambda (t) (let fnrec5628 ((t t)) (let* ((_o$5629 (keyword #f "set")) (_o$5630 (if (jolt-truthy? t) t (keyword #f "any")))) (jolt-hash-map _o$5629 _o$5630)))))) mk-set)))
(guard (e (#t #f))
(def-var! "jolt.passes.types.lattice" "mk-struct" (letrec ((mk-struct (lambda (fs) (let fnrec5631 ((fs fs)) (let* ((_o$5632 (keyword #f "struct")) (_o$5633 fs)) (jolt-hash-map _o$5632 _o$5633)))))) mk-struct)))
(guard (e (#t #f))
(def-var! "jolt.passes.types.lattice" "union-cap" 4))
(guard (e (#t #f))
(def-var! "jolt.passes.types.lattice" "scalar-t?" (letrec ((scalar-t? (lambda (t) (let fnrec5634 ((t t)) (let* ((or__26__auto (jolt= t (keyword #f "num")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= t (keyword #f "str")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= t (keyword #f "kw")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= t (keyword #f "truthy")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= t (keyword #f "phm")))))))))))))) scalar-t?)))
(guard (e (#t #f))
(def-var! "jolt.passes.types.lattice" "union-type?" (letrec ((union-type? (lambda (t) (let fnrec5635 ((t t)) (jolt-invoke (var-deref "clojure.core" "some?") (jolt-get t (keyword #f "union"))))))) union-type?)))
(guard (e (#t #f))
(def-var! "jolt.passes.types.lattice" "umembers" (letrec ((umembers (lambda (t) (let fnrec5636 ((t t)) (jolt-get t (keyword #f "union")))))) umembers)))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types.lattice" "union-of" (letrec ((union-of (lambda (ts) (let fnrec5637 ((ts ts)) (let* ((flat (let* ((_a$5639 (lambda (acc t) (let fnrec5638 ((acc acc) (t t)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "union-type?") t)) (jolt-reduce jolt-conj acc (jolt-invoke (var-deref "jolt.passes.types.lattice" "umembers") t)) (jolt-conj acc t))))) (_a$5640 (jolt-hash-set)) (_a$5641 ts)) (jolt-reduce _a$5639 _a$5640 _a$5641)))) (if (jolt-not (jolt-invoke (var-deref "clojure.core" "every?") (var-deref "jolt.passes.types.lattice" "scalar-t?") flat)) (keyword #f "any") (if (jolt= 0 (jolt-count flat)) (keyword #f "any") (if (jolt= 1 (jolt-count flat)) (jolt-first flat) (if (> (jolt-count flat) (var-deref "jolt.passes.types.lattice" "union-cap")) (keyword #f "any") (if (jolt-truthy? (keyword #f "else")) (let* ((_o$5642 (keyword #f "union")) (_o$5643 flat)) (jolt-hash-map _o$5642 _o$5643)) jolt-nil)))))))))) union-of) (let* ((_o$5644 (keyword #f "doc")) (_o$5645 "Normalize a seq of member types into a lattice value: flatten nested unions,\n keep only scalars (any non-scalar member collapses the whole thing to :any,\n the conservative top), then return the lone member if one, {:union #{...}}\n for 2..cap distinct scalars, or :any past the cap.")) (jolt-hash-map _o$5644 _o$5645))))
(guard (e (#t #f))
(declare-var! "jolt.passes.types.lattice" "join-t"))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types.lattice" "merge-fields" (letrec ((merge-fields (lambda (fa fb) (let fnrec5646 ((fa fa) (fb fb)) (let* ((m1 (let* ((_a$5651 (lambda (m k) (let fnrec5647 ((m m) (k k)) (jolt-assoc m k (let* ((_a$5648 (var-deref "jolt.passes.types.lattice" "join-t")) (_a$5649 (jolt-get fa k (keyword #f "any"))) (_a$5650 (jolt-get fb k (keyword #f "any")))) (jolt-invoke _a$5648 _a$5649 _a$5650)))))) (_a$5652 (jolt-hash-map)) (_a$5653 (jolt-keys fa))) (jolt-reduce _a$5651 _a$5652 _a$5653)))) (let* ((_a$5658 (lambda (m k) (let fnrec5654 ((m m) (k k)) (if (jolt-truthy? (jolt-get m k)) m (jolt-assoc m k (let* ((_a$5655 (var-deref "jolt.passes.types.lattice" "join-t")) (_a$5656 (jolt-get fa k (keyword #f "any"))) (_a$5657 (jolt-get fb k (keyword #f "any")))) (jolt-invoke _a$5655 _a$5656 _a$5657))))))) (_a$5659 m1) (_a$5660 (jolt-keys fb))) (jolt-reduce _a$5658 _a$5659 _a$5660))))))) merge-fields) (let* ((_o$5661 (keyword #f "doc")) (_o$5662 "Per-field join of two field maps (a key in only one side joins with :any).")) (jolt-hash-map _o$5661 _o$5662))))
(guard (e (#t #f))
(def-var! "jolt.passes.types.lattice" "join-t" (letrec ((join-t (lambda (a b) (let fnrec5663 ((a a) (b b)) (if (jolt= a b) a (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") a)) b (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") b)) a (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") a))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") b) and__25__auto))) (let* ((merged (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-struct") (let* ((_a$5664 (var-deref "jolt.passes.types.lattice" "merge-fields")) (_a$5665 (jolt-invoke (var-deref "jolt.passes.types.lattice" "sfields") a)) (_a$5666 (jolt-invoke (var-deref "jolt.passes.types.lattice" "sfields") b))) (jolt-invoke _a$5664 _a$5665 _a$5666))))) (if (jolt-truthy? (let* ((and__25__auto (jolt-get a (keyword #f "shape")))) (if (jolt-truthy? and__25__auto) (let* ((_a$5667 (jolt-get a (keyword #f "shape"))) (_a$5668 (jolt-get b (keyword #f "shape")))) (jolt= _a$5667 _a$5668)) and__25__auto))) (jolt-assoc merged (keyword #f "shape") (jolt-get a (keyword #f "shape"))) merged)) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") a))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") b) and__25__auto))) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") (let* ((_a$5669 (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") a)) (_a$5670 (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") b))) (join-t _a$5669 _a$5670))) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "set-type?") a))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.types.lattice" "set-type?") b) and__25__auto))) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-set") (let* ((_a$5671 (jolt-invoke (var-deref "jolt.passes.types.lattice" "selem") a)) (_a$5672 (jolt-invoke (var-deref "jolt.passes.types.lattice" "selem") b))) (join-t _a$5671 _a$5672))) (if (jolt-truthy? (keyword #f "else")) (let* ((ma (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "union-type?") a)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "umembers") a) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "scalar-t?") a)) (jolt-hash-set a) (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))) (mb (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "union-type?") b)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "umembers") b) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "scalar-t?") b)) (jolt-hash-set b) (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))) (if (jolt-truthy? (let* ((and__25__auto ma)) (if (jolt-truthy? and__25__auto) mb and__25__auto))) (jolt-invoke (var-deref "jolt.passes.types.lattice" "union-of") (jolt-reduce jolt-conj ma mb)) (keyword #f "any"))) jolt-nil))))))))))) join-t)))
(guard (e (#t #f))
(def-var! "jolt.passes.types.lattice" "join" (letrec ((join (lambda (a b) (let fnrec5673 ((a a) (b b)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "join-t") a b))))) join)))
(guard (e (#t #f))
(def-var! "jolt.passes.types.lattice" "type-depth" 4))
(guard (e (#t #f))
(def-var! "jolt.passes.types.lattice" "cap" (letrec ((cap (lambda (t d) (let fnrec5674 ((t t) (d d)) (if (<= d 0) (if (jolt-truthy? (let* ((or__26__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") t))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") t))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "set-type?") t)))))) (keyword #f "any") t) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") t)) (let* ((capped (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-struct") (let* ((_a$5678 (lambda (m k) (let fnrec5675 ((m m) (k k)) (jolt-assoc m k (let* ((_a$5676 (jolt-get (jolt-invoke (var-deref "jolt.passes.types.lattice" "sfields") t) k)) (_a$5677 (jolt-dec d))) (cap _a$5676 _a$5677)))))) (_a$5679 (jolt-hash-map)) (_a$5680 (jolt-keys (jolt-invoke (var-deref "jolt.passes.types.lattice" "sfields") t)))) (jolt-reduce _a$5678 _a$5679 _a$5680)))) (capped (if (jolt-truthy? (jolt-get t (keyword #f "shape"))) (jolt-assoc capped (keyword #f "shape") (jolt-get t (keyword #f "shape"))) capped)) (capped (if (jolt-truthy? (jolt-get t (keyword #f "type"))) (jolt-assoc capped (keyword #f "type") (jolt-get t (keyword #f "type"))) capped))) capped) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") t)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") (let* ((_a$5681 (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") t)) (_a$5682 (jolt-dec d))) (cap _a$5681 _a$5682))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "set-type?") t)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-set") (let* ((_a$5683 (jolt-invoke (var-deref "jolt.passes.types.lattice" "selem") t)) (_a$5684 (jolt-dec d))) (cap _a$5683 _a$5684))) (if (jolt-truthy? (keyword #f "else")) t jolt-nil))))))))) cap)))
(guard (e (#t #f))
(def-var! "jolt.passes.types.lattice" "struct-safe?" (letrec ((struct-safe? (lambda (t) (let fnrec5685 ((t t)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") t))))) struct-safe?)))
(guard (e (#t #f))
(def-var! "jolt.passes.types.lattice" "field-type" (letrec ((field-type (lambda (t k) (let fnrec5686 ((t t) (k k)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") t)) (jolt-get (jolt-invoke (var-deref "jolt.passes.types.lattice" "sfields") t) k (keyword #f "any")) (keyword #f "any")))))) field-type)))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types.lattice" "shape-order" (letrec ((shape-order (lambda (ks) (let fnrec5687 ((ks ks)) (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "sort") (lambda (a b) (let fnrec5688 ((a a) (b b)) (let* ((_a$5689 (var-deref "clojure.core" "compare")) (_a$5690 (jolt-invoke (var-deref "clojure.core" "str") a)) (_a$5691 (jolt-invoke (var-deref "clojure.core" "str") b))) (jolt-invoke _a$5689 _a$5690 _a$5691)))) ks)))))) shape-order) (let* ((_o$5692 (keyword #f "doc")) (_o$5693 "Canonical key order for a shape: keys sorted by their string form, so two\n literals with the same keys in any order intern to the same shape.")) (jolt-hash-map _o$5692 _o$5693))))
(guard (e (#t #f))
(def-var! "jolt.passes.types.lattice" "type-shape" (letrec ((type-shape (lambda (t) (let fnrec5694 ((t t)) (jolt-get t (keyword #f "shape")))))) type-shape)))
(guard (e (#t #f))
(def-var! "jolt.passes.types.lattice" "mark-struct" (letrec ((mark-struct (lambda (node t) (let fnrec5695 ((node node) (t t)) (let* ((n (jolt-assoc node (keyword #f "hint") (keyword #f "struct")))) (if (jolt-truthy? (jolt-get t (keyword #f "shape"))) (jolt-assoc n (keyword #f "shape") (jolt-get t (keyword #f "shape"))) n)))))) mark-struct)))
(guard (e (#t #f))
(def-var! "jolt.passes.types.lattice" "truthy-type?" (letrec ((truthy-type? (lambda (t) (let fnrec5696 ((t t)) (let* ((or__26__auto (jolt= t (keyword #f "num")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= t (keyword #f "str")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= t (keyword #f "kw")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= t (keyword #f "truthy")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= t (keyword #f "phm")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") t))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") t))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "set-type?") t))))))))))))))))))) truthy-type?)))
(guard (e (#t #f))
(def-var! "jolt.passes.types.lattice" "num-ret-fns" (let* ((_o$5697 "+") (_o$5698 "-") (_o$5699 "*") (_o$5700 "/") (_o$5701 "inc") (_o$5702 "dec") (_o$5703 "mod") (_o$5704 "rem") (_o$5705 "quot") (_o$5706 "min") (_o$5707 "max") (_o$5708 "abs") (_o$5709 "bit-and") (_o$5710 "bit-or") (_o$5711 "bit-xor") (_o$5712 "count")) (jolt-hash-set _o$5697 _o$5698 _o$5699 _o$5700 _o$5701 _o$5702 _o$5703 _o$5704 _o$5705 _o$5706 _o$5707 _o$5708 _o$5709 _o$5710 _o$5711 _o$5712))))
(guard (e (#t #f))
(def-var! "jolt.passes.types.lattice" "vector-ret-fns" (let* ((_o$5713 "vec") (_o$5714 "vector") (_o$5715 "mapv") (_o$5716 "filterv") (_o$5717 "subvec")) (jolt-hash-set _o$5713 _o$5714 _o$5715 _o$5716 _o$5717))))
(guard (e (#t #f))
(def-var! "jolt.passes.types.check" "not-number?" (letrec ((not-number? (lambda (t) (let fnrec5718 ((t t)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "union-type?") t)) (jolt-invoke (var-deref "clojure.core" "every?") not-number? (jolt-invoke (var-deref "jolt.passes.types.lattice" "umembers") t)) (let* ((or__26__auto (jolt= t (keyword #f "str")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= t (keyword #f "kw")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= t (keyword #f "phm")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") t))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") t))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "set-type?") t)))))))))))))))) not-number?)))
(guard (e (#t #f))
(def-var! "jolt.passes.types.check" "not-seqable?" (letrec ((not-seqable? (lambda (t) (let fnrec5719 ((t t)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "union-type?") t)) (jolt-invoke (var-deref "clojure.core" "every?") not-seqable? (jolt-invoke (var-deref "jolt.passes.types.lattice" "umembers") t)) (let* ((or__26__auto (jolt= t (keyword #f "num")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= t (keyword #f "kw"))))))))) not-seqable?)))
(guard (e (#t #f))
(def-var! "jolt.passes.types.check" "not-callable?" (letrec ((not-callable? (lambda (t) (let fnrec5720 ((t t)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "union-type?") t)) (jolt-invoke (var-deref "clojure.core" "every?") not-callable? (jolt-invoke (var-deref "jolt.passes.types.lattice" "umembers") t)) (let* ((or__26__auto (jolt= t (keyword #f "num")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= t (keyword #f "str"))))))))) not-callable?)))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types.check" "num-ops" (let* ((_o$5721 "+") (_o$5722 "-") (_o$5723 "*") (_o$5724 "/") (_o$5725 "inc") (_o$5726 "dec") (_o$5727 "mod") (_o$5728 "rem") (_o$5729 "quot") (_o$5730 "min") (_o$5731 "max") (_o$5732 "abs") (_o$5733 "bit-and") (_o$5734 "bit-or") (_o$5735 "bit-xor") (_o$5736 "bit-not") (_o$5737 "bit-shift-left") (_o$5738 "bit-shift-right")) (jolt-hash-set _o$5721 _o$5722 _o$5723 _o$5724 _o$5725 _o$5726 _o$5727 _o$5728 _o$5729 _o$5730 _o$5731 _o$5732 _o$5733 _o$5734 _o$5735 _o$5736 _o$5737 _o$5738)) (let* ((_o$5739 (keyword #f "private")) (_o$5740 #t)) (jolt-hash-map _o$5739 _o$5740))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types.check" "seq-ops" (let* ((_o$5741 "count") (_o$5742 "first") (_o$5743 "rest") (_o$5744 "next") (_o$5745 "seq") (_o$5746 "nth")) (jolt-hash-set _o$5741 _o$5742 _o$5743 _o$5744 _o$5745 _o$5746)) (let* ((_o$5747 (keyword #f "private")) (_o$5748 #t)) (jolt-hash-map _o$5747 _o$5748))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types.check" "type-name" (letrec ((type-name (lambda (t) (let fnrec5749 ((t t)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "union-type?") t)) (let* ((_a$5751 (lambda (s m) (let fnrec5750 ((s s) (m m)) (if (jolt= s "") (type-name m) (jolt-invoke (var-deref "clojure.core" "str") s " or " (type-name m)))))) (_a$5752 "") (_a$5753 (jolt-invoke (var-deref "jolt.passes.types.lattice" "umembers") t))) (jolt-reduce _a$5751 _a$5752 _a$5753)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") t)) "a map" (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") t)) "a vector" (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "set-type?") t)) "a set" (if (jolt= t (keyword #f "str")) "a string" (if (jolt= t (keyword #f "kw")) "a keyword" (if (jolt= t (keyword #f "num")) "a number" (if (jolt= t (keyword #f "phm")) "a map" (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "clojure.core" "str") t) jolt-nil))))))))))))) type-name) (let* ((_o$5754 (keyword #f "doc")) (_o$5755 "Render an inferred type for an error message.")) (jolt-hash-map _o$5754 _o$5755))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types.check" "check-invoke" (letrec ((check-invoke (lambda (cn args arg-types pos env) (let fnrec5756 ((cn cn) (args args) (arg-types arg-types) (pos pos) (env env)) (if (jolt-contains? (var-deref "jolt.passes.types.check" "num-ops") cn) (let* ((_a$5779 (lambda (_ i) (let fnrec5757 ((_ _) (i i)) (begin (let* ((t (jolt-nth arg-types i))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.check" "not-number?") t)) (let* ((_a$5775 (var-deref "clojure.core" "swap!")) (_a$5776 (jolt-get env (keyword #f "diags"))) (_a$5777 jolt-conj) (_a$5778 (let* ((_o$5765 (keyword #f "op")) (_o$5766 cn) (_o$5767 (keyword #f "argpos")) (_o$5768 i) (_o$5769 (keyword #f "type")) (_o$5770 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") t)) (_o$5771 (keyword #f "pos")) (_o$5772 pos) (_o$5773 (keyword #f "msg")) (_o$5774 (let* ((_a$5758 (var-deref "clojure.core" "str")) (_a$5759 "`") (_a$5760 cn) (_a$5761 "` requires a number, but argument ") (_a$5762 (jolt-inc i)) (_a$5763 " is ") (_a$5764 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") t))) (jolt-invoke _a$5758 _a$5759 _a$5760 _a$5761 _a$5762 _a$5763 _a$5764)))) (jolt-hash-map _o$5765 _o$5766 _o$5767 _o$5768 _o$5769 _o$5770 _o$5771 _o$5772 _o$5773 _o$5774)))) (jolt-invoke _a$5775 _a$5776 _a$5777 _a$5778)) jolt-nil)) jolt-nil)))) (_a$5780 jolt-nil) (_a$5781 (jolt-range (jolt-count args)))) (jolt-reduce _a$5779 _a$5780 _a$5781)) (if (jolt-truthy? (let* ((and__25__auto (jolt-contains? (var-deref "jolt.passes.types.check" "seq-ops") cn))) (if (jolt-truthy? and__25__auto) (> (jolt-count args) 0) and__25__auto))) (let* ((t (jolt-nth arg-types 0))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.check" "not-seqable?") t)) (let* ((_a$5799 (var-deref "clojure.core" "swap!")) (_a$5800 (jolt-get env (keyword #f "diags"))) (_a$5801 jolt-conj) (_a$5802 (let* ((_o$5789 (keyword #f "op")) (_o$5790 cn) (_o$5791 (keyword #f "argpos")) (_o$5792 0) (_o$5793 (keyword #f "type")) (_o$5794 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") t)) (_o$5795 (keyword #f "pos")) (_o$5796 pos) (_o$5797 (keyword #f "msg")) (_o$5798 (let* ((_a$5782 (var-deref "clojure.core" "str")) (_a$5783 "`") (_a$5784 cn) (_a$5785 "` requires ") (_a$5786 (if (jolt= cn "count") "a countable collection" "a seqable")) (_a$5787 ", but argument 1 is ") (_a$5788 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") t))) (jolt-invoke _a$5782 _a$5783 _a$5784 _a$5785 _a$5786 _a$5787 _a$5788)))) (jolt-hash-map _o$5789 _o$5790 _o$5791 _o$5792 _o$5793 _o$5794 _o$5795 _o$5796 _o$5797 _o$5798)))) (jolt-invoke _a$5799 _a$5800 _a$5801 _a$5802)) jolt-nil)) (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))))) check-invoke) (let* ((_o$5803 (keyword #f "doc")) (_o$5804 "If node is a core-op call whose argument type is provably in the error domain,\n conj a diagnostic into env's diags cell. arg-types is the vector of inferred\n argument types; pos is the call form's source offset, carried into each\n diagnostic.")) (jolt-hash-map _o$5803 _o$5804))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types.check" "register-user-fn!" (letrec ((register-user-fn! (lambda (node env) (let fnrec5805 ((node node) (env env)) (let* ((init (jolt-get node (keyword #f "init"))) (m (jolt-get node (keyword #f "meta"))) (redefable (let* ((and__25__auto m)) (if (jolt-truthy? and__25__auto) (let* ((or__26__auto (jolt-get m (keyword #f "redef")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-get m (keyword #f "dynamic")))) and__25__auto)))) (if (jolt-truthy? (let* ((and__25__auto (jolt-not redefable))) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "fn") (jolt-get init (keyword #f "op"))) and__25__auto))) (let* ((arities (jolt-get init (keyword #f "arities")))) (if (jolt= 1 (jolt-count arities)) (let* ((ar (jolt-first arities))) (if (jolt-not (jolt-get ar (keyword #f "rest"))) (let* ((_a$5816 (var-deref "clojure.core" "swap!")) (_a$5817 (jolt-get env (keyword #f "user-sigs"))) (_a$5818 jolt-assoc) (_a$5819 (let* ((_a$5806 (var-deref "clojure.core" "str")) (_a$5807 (jolt-get node (keyword #f "ns"))) (_a$5808 "/") (_a$5809 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$5806 _a$5807 _a$5808 _a$5809))) (_a$5820 (let* ((_o$5810 (keyword #f "name")) (_o$5811 (jolt-get node (keyword #f "name"))) (_o$5812 (keyword #f "params")) (_o$5813 (jolt-get ar (keyword #f "params"))) (_o$5814 (keyword #f "body")) (_o$5815 (jolt-get ar (keyword #f "body")))) (jolt-hash-map _o$5810 _o$5811 _o$5812 _o$5813 _o$5814 _o$5815)))) (jolt-invoke _a$5816 _a$5817 _a$5818 _a$5819 _a$5820)) jolt-nil)) jolt-nil)) jolt-nil)))))) register-user-fn!) (let* ((_o$5821 (keyword #f "doc")) (_o$5822 "Record a (def name (fn [params] body)) \x2014; single fixed arity, not redefinable \x2014;\n for later user-fn call checking. Redefinable/dynamic and multi/variadic fns are\n skipped (their body is not a stable requirement).")) (jolt-hash-map _o$5821 _o$5822))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types" "config-box" (jolt-invoke (var-deref "clojure.core" "atom") (let* ((_o$5058 (keyword #f "rtenv")) (_o$5059 (jolt-hash-map)) (_o$5060 (keyword #f "vtypes")) (_o$5061 (jolt-hash-map)) (_o$5062 (keyword #f "record-shapes")) (_o$5063 (jolt-hash-map)) (_o$5064 (keyword #f "protocol-methods")) (_o$5065 (jolt-hash-map)) (_o$5066 (keyword #f "map-shapes?")) (_o$5067 #f)) (jolt-hash-map _o$5058 _o$5059 _o$5060 _o$5061 _o$5062 _o$5063 _o$5064 _o$5065 _o$5066 _o$5067))) (let* ((_o$5068 (keyword #f "private")) (_o$5069 #t)) (jolt-hash-map _o$5068 _o$5069))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types" "escapes-box" (jolt-invoke (var-deref "clojure.core" "atom") (jolt-hash-set)) (let* ((_o$5070 (keyword #f "private")) (_o$5071 #t)) (jolt-hash-map _o$5070 _o$5071))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types" "user-sig-box" (jolt-invoke (var-deref "clojure.core" "atom") (jolt-hash-map)) (let* ((_o$5072 (keyword #f "private")) (_o$5073 #t)) (jolt-hash-map _o$5072 _o$5073))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types" "last-diags-box" (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector)) (let* ((_o$5074 (keyword #f "private")) (_o$5075 #t)) (jolt-hash-map _o$5074 _o$5075))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types" "check-mode-box" (jolt-invoke (var-deref "clojure.core" "atom") (let* ((_o$5076 (keyword #f "on")) (_o$5077 #f) (_o$5078 (keyword #f "strict")) (_o$5079 #f)) (jolt-hash-map _o$5076 _o$5077 _o$5078 _o$5079))) (let* ((_o$5080 (keyword #f "private")) (_o$5081 #t)) (jolt-hash-map _o$5080 _o$5081))))
(guard (e (#t #f))
(def-var! "jolt.passes.types" "mk-env" (letrec ((mk-env (lambda (checking? strict?) (let fnrec5082 ((checking? checking?) (strict? strict?)) (let* ((c (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.types" "config-box")))) (let* ((_o$5083 (keyword #f "rtenv")) (_o$5084 (jolt-get c (keyword #f "rtenv"))) (_o$5085 (keyword #f "vtypes")) (_o$5086 (jolt-get c (keyword #f "vtypes"))) (_o$5087 (keyword #f "record-shapes")) (_o$5088 (jolt-get c (keyword #f "record-shapes"))) (_o$5089 (keyword #f "protocol-methods")) (_o$5090 (jolt-get c (keyword #f "protocol-methods"))) (_o$5091 (keyword #f "map-shapes?")) (_o$5092 (jolt-get c (keyword #f "map-shapes?"))) (_o$5093 (keyword #f "checking?")) (_o$5094 checking?) (_o$5095 (keyword #f "strict?")) (_o$5096 strict?) (_o$5097 (keyword #f "diags")) (_o$5098 (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))) (_o$5099 (keyword #f "calls")) (_o$5100 (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))) (_o$5101 (keyword #f "checking-set")) (_o$5102 (jolt-invoke (var-deref "clojure.core" "atom") (jolt-hash-set))) (_o$5103 (keyword #f "diag-memo")) (_o$5104 (jolt-invoke (var-deref "clojure.core" "atom") (jolt-hash-map))) (_o$5105 (keyword #f "escapes")) (_o$5106 (var-deref "jolt.passes.types" "escapes-box")) (_o$5107 (keyword #f "user-sigs")) (_o$5108 (var-deref "jolt.passes.types" "user-sig-box"))) (jolt-hash-map _o$5083 _o$5084 _o$5085 _o$5086 _o$5087 _o$5088 _o$5089 _o$5090 _o$5091 _o$5092 _o$5093 _o$5094 _o$5095 _o$5096 _o$5097 _o$5098 _o$5099 _o$5100 _o$5101 _o$5102 _o$5103 _o$5104 _o$5105 _o$5106 _o$5107 _o$5108))))))) mk-env)))
(guard (e (#t #f))
(declare-var! "jolt.passes.types" "record-type-from-entry"))
(guard (e (#t #f))
(def-var! "jolt.passes.types" "field-type-from-tag" (letrec ((field-type-from-tag (lambda (tag depth shapes) (let fnrec5109 ((tag tag) (depth depth) (shapes shapes)) (if (jolt-truthy? (let* ((or__26__auto (jolt-invoke (var-deref "clojure.core" "nil?") tag))) (if (jolt-truthy? or__26__auto) or__26__auto (<= depth 0)))) (keyword #f "any") (if (jolt= tag "num") (keyword #f "num") (if (jolt-truthy? (keyword #f "else")) (let* ((e (jolt-get shapes tag))) (if (jolt-truthy? e) (jolt-invoke (var-deref "jolt.passes.types" "record-type-from-entry") e depth shapes) (keyword #f "any"))) jolt-nil))))))) field-type-from-tag)))
(guard (e (#t #f))
(def-var! "jolt.passes.types" "record-type-from-entry" (letrec ((record-type-from-entry (lambda (rs depth shapes) (let fnrec5110 ((rs rs) (depth depth) (shapes shapes)) (let* ((fields (jolt-get rs (keyword #f "fields"))) (tags (jolt-get rs (keyword #f "tags"))) (fmap (let* ((_a$5119 (lambda (m i) (let fnrec5111 ((m m) (i i)) (let* ((_a$5116 m) (_a$5117 (jolt-nth fields i)) (_a$5118 (let* ((_a$5112 (var-deref "jolt.passes.types" "field-type-from-tag")) (_a$5113 (if (jolt-truthy? tags) (jolt-nth tags i) jolt-nil)) (_a$5114 (jolt-dec depth)) (_a$5115 shapes)) (jolt-invoke _a$5112 _a$5113 _a$5114 _a$5115)))) (jolt-assoc _a$5116 _a$5117 _a$5118))))) (_a$5120 (jolt-hash-map)) (_a$5121 (jolt-range (jolt-count fields)))) (jolt-reduce _a$5119 _a$5120 _a$5121)))) (let* ((_a$5122 (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-struct") fmap)) (_a$5123 (keyword #f "shape")) (_a$5124 (jolt-invoke (var-deref "clojure.core" "vec") fields)) (_a$5125 (keyword #f "type")) (_a$5126 (jolt-get rs (keyword #f "type")))) (jolt-assoc _a$5122 _a$5123 _a$5124 _a$5125 _a$5126))))))) record-type-from-entry)))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types" "elem-fns" (let* ((_o$5127 "rand-nth") (_o$5128 "first") (_o$5129 "peek") (_o$5130 "last") (_o$5131 "nth") (_o$5132 "fnext") (_o$5133 "second")) (jolt-hash-set _o$5127 _o$5128 _o$5129 _o$5130 _o$5131 _o$5132 _o$5133)) (let* ((_o$5134 (keyword #f "private")) (_o$5135 #t)) (jolt-hash-map _o$5134 _o$5135))))
(guard (e (#t #f))
(declare-var! "jolt.passes.types" "check-user-call"))
(guard (e (#t #f))
(def-var! "jolt.passes.types" "var-key" (letrec ((var-key (lambda (fnode) (let fnrec5136 ((fnode fnode)) (let* ((_a$5137 (var-deref "clojure.core" "str")) (_a$5138 (jolt-get fnode (keyword #f "ns"))) (_a$5139 "/") (_a$5140 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$5137 _a$5138 _a$5139 _a$5140)))))) var-key)))
(guard (e (#t #f))
(def-var! "jolt.passes.types" "call-ret-type" (letrec ((call-ret-type (lambda (fnode env) (let fnrec5141 ((fnode fnode) (env env)) (let* ((op (jolt-get fnode (keyword #f "op"))) (shapes (jolt-get env (keyword #f "record-shapes")))) (if (jolt= op (keyword #f "var")) (let* ((rs (jolt-get shapes (jolt-invoke (var-deref "jolt.passes.types" "var-key") fnode)))) (if (jolt-truthy? rs) (jolt-invoke (var-deref "jolt.passes.types" "record-type-from-entry") rs (var-deref "jolt.passes.types.lattice" "type-depth") shapes) (let* ((r (let* ((_a$5142 (jolt-get env (keyword #f "rtenv"))) (_a$5143 (jolt-invoke (var-deref "jolt.passes.types" "var-key") fnode))) (jolt-get _a$5142 _a$5143)))) (if (jolt-truthy? r) r (let* ((nm (let* ((and__25__auto (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))))) (if (jolt-truthy? and__25__auto) (jolt-get fnode (keyword #f "name")) and__25__auto)))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "nil?") nm)) (keyword #f "any") (if (jolt-contains? (var-deref "jolt.passes.types.lattice" "num-ret-fns") nm) (keyword #f "num") (if (jolt-contains? (var-deref "jolt.passes.types.lattice" "vector-ret-fns") nm) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") (keyword #f "any")) (if (jolt-truthy? (keyword #f "else")) (keyword #f "any") jolt-nil))))))))) (if (jolt= op (keyword #f "host")) (let* ((nm (jolt-get fnode (keyword #f "name")))) (if (jolt-contains? (var-deref "jolt.passes.types.lattice" "num-ret-fns") nm) (keyword #f "num") (if (jolt-contains? (var-deref "jolt.passes.types.lattice" "vector-ret-fns") nm) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") (keyword #f "any")) (if (jolt-truthy? (keyword #f "else")) (keyword #f "any") jolt-nil)))) (if (jolt-truthy? (keyword #f "else")) (keyword #f "any") jolt-nil)))))))) call-ret-type)))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types" "fold-preds" (let* ((_o$5144 "number?") (_o$5145 "string?") (_o$5146 "keyword?") (_o$5147 "record?") (_o$5148 "nil?") (_o$5149 "some?")) (jolt-hash-set _o$5144 _o$5145 _o$5146 _o$5147 _o$5148 _o$5149)) (let* ((_o$5150 (keyword #f "private")) (_o$5151 #t)) (jolt-hash-map _o$5150 _o$5151))))
(guard (e (#t #f))
(def-var! "jolt.passes.types" "record-t?" (letrec ((record-t? (lambda (t) (let fnrec5152 ((t t)) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") t))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "some?") (jolt-get t (keyword #f "type"))) and__25__auto)))))) record-t?)))
(guard (e (#t #f))
(def-var! "jolt.passes.types" "pred-on" (letrec ((pred-on (lambda (pname t) (let fnrec5153 ((pname pname) (t t)) (if (jolt-truthy? (let* ((or__26__auto (jolt= t (keyword #f "any")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= t (keyword #f "truthy"))))) jolt-nil (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "union-type?") t)) (let* ((vs (let* ((_a$5155 (lambda (m) (let fnrec5154 ((m m)) (pred-on pname m)))) (_a$5156 (jolt-invoke (var-deref "jolt.passes.types.lattice" "umembers") t))) (jolt-map _a$5155 _a$5156)))) (if (jolt-truthy? (let* ((and__25__auto (jolt-seq vs))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-not (jolt-invoke (var-deref "clojure.core" "nil?") (jolt-first vs))))) (if (jolt-truthy? and__25__auto) (jolt-apply jolt= vs) and__25__auto)) and__25__auto))) (jolt-first vs) jolt-nil)) (if (jolt-truthy? (keyword #f "else")) (let* ((G__122 pname)) (if (jolt= G__122 "number?") (jolt= t (keyword #f "num")) (if (jolt= G__122 "string?") (jolt= t (keyword #f "str")) (if (jolt= G__122 "keyword?") (jolt= t (keyword #f "kw")) (if (jolt= G__122 "record?") (jolt-invoke (var-deref "jolt.passes.types" "record-t?") t) (if (jolt= G__122 "nil?") #f (if (jolt= G__122 "some?") #t jolt-nil))))))) jolt-nil))))))) pred-on)))
(guard (e (#t #f))
(def-var! "jolt.passes.types" "pure-node?" (letrec ((pure-node? (lambda (n) (let fnrec5157 ((n n)) (let* ((op (jolt-get n (keyword #f "op")))) (let* ((or__26__auto (jolt= op (keyword #f "const")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= op (keyword #f "local"))))))))) pure-node?)))
(guard (e (#t #f))
(declare-var! "jolt.passes.types" "infer"))
(guard (e (#t #f))
(def-var! "jolt.passes.types" "ty" (letrec ((ty (lambda (r) (let fnrec5158 ((r r)) (jolt-nth r 0))))) ty)))
(guard (e (#t #f))
(def-var! "jolt.passes.types" "nd" (letrec ((nd (lambda (r) (let fnrec5159 ((r r)) (jolt-nth r 1))))) nd)))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types" "hof-table" (let* ((_o$5176 "map") (_o$5177 (let* ((_o$5160 (keyword #f "epos")) (_o$5161 0)) (jolt-hash-map _o$5160 _o$5161))) (_o$5178 "mapv") (_o$5179 (let* ((_o$5162 (keyword #f "epos")) (_o$5163 0)) (jolt-hash-map _o$5162 _o$5163))) (_o$5180 "filter") (_o$5181 (let* ((_o$5164 (keyword #f "epos")) (_o$5165 0)) (jolt-hash-map _o$5164 _o$5165))) (_o$5182 "filterv") (_o$5183 (let* ((_o$5166 (keyword #f "epos")) (_o$5167 0)) (jolt-hash-map _o$5166 _o$5167))) (_o$5184 "keep") (_o$5185 (let* ((_o$5168 (keyword #f "epos")) (_o$5169 0)) (jolt-hash-map _o$5168 _o$5169))) (_o$5186 "remove") (_o$5187 (let* ((_o$5170 (keyword #f "epos")) (_o$5171 0)) (jolt-hash-map _o$5170 _o$5171))) (_o$5188 "run!") (_o$5189 (let* ((_o$5172 (keyword #f "epos")) (_o$5173 0)) (jolt-hash-map _o$5172 _o$5173))) (_o$5190 "mapcat") (_o$5191 (let* ((_o$5174 (keyword #f "epos")) (_o$5175 0)) (jolt-hash-map _o$5174 _o$5175)))) (jolt-hash-map _o$5176 _o$5177 _o$5178 _o$5179 _o$5180 _o$5181 _o$5182 _o$5183 _o$5184 _o$5185 _o$5186 _o$5187 _o$5188 _o$5189 _o$5190 _o$5191)) (let* ((_o$5192 (keyword #f "private")) (_o$5193 #t)) (jolt-hash-map _o$5192 _o$5193))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types" "infer-fn-seeded" (letrec ((infer-fn-seeded (lambda (node seeds tenv env) (let fnrec5194 ((node node) (seeds seeds) (tenv tenv) (env env)) (let* ((res (let* ((_a$5205 (var-deref "clojure.core" "mapv")) (_a$5206 (lambda (a) (let fnrec5195 ((a a)) (let* ((params (jolt-get a (keyword #f "params"))) (pe (let* ((_a$5200 (lambda (e i) (let fnrec5196 ((e e) (i i)) (let* ((_a$5197 e) (_a$5198 (jolt-nth params i)) (_a$5199 (let* ((s (jolt-get seeds i))) (if (jolt-truthy? s) s (keyword #f "any"))))) (jolt-assoc _a$5197 _a$5198 _a$5199))))) (_a$5201 tenv) (_a$5202 (jolt-range (jolt-count params)))) (jolt-reduce _a$5200 _a$5201 _a$5202))) (pe (if (jolt-truthy? (jolt-get a (keyword #f "rest"))) (jolt-assoc pe (jolt-get a (keyword #f "rest")) (keyword #f "any")) pe)) (br (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-get a (keyword #f "body")) pe env))) (let* ((_o$5203 (jolt-invoke (var-deref "jolt.passes.types" "ty") br)) (_o$5204 (jolt-assoc a (keyword #f "body") (jolt-invoke (var-deref "jolt.passes.types" "nd") br)))) (jolt-vector _o$5203 _o$5204)))))) (_a$5207 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$5205 _a$5206 _a$5207))) (rets (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5208 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "ty") r))) res)) (ret (if (jolt-empty? rets) (keyword #f "any") (let* ((_a$5209 (var-deref "jolt.passes.types.lattice" "join")) (_a$5210 (jolt-first rets)) (_a$5211 (jolt-rest rets))) (jolt-reduce _a$5209 _a$5210 _a$5211))))) (let* ((_o$5213 ret) (_o$5214 (jolt-assoc node (keyword #f "arities") (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5212 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "nd") r))) res)))) (jolt-vector _o$5213 _o$5214))))))) infer-fn-seeded) (let* ((_o$5215 (keyword #f "doc")) (_o$5216 "Infer a fn-literal passed to a HOF, seeding the given params to element/accum\n types (seeds: param-index -> type), other params :any, captured locals from\n tenv. Returns [ret-type node'] \x2014; ret is the lub of arity tail types, used to\n type the HOF result (e.g. reduce's accumulator, mapv's element).")) (jolt-hash-map _o$5215 _o$5216))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types" "infer-pred-fold" (letrec ((infer-pred-fold (lambda (node fnode cn args tenv env) (let fnrec5217 ((node node) (fnode fnode) (cn cn) (args args) (tenv tenv) (env env)) (let* ((ar (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 0) tenv env)) (v (jolt-invoke (var-deref "jolt.passes.types" "pred-on") cn (jolt-invoke (var-deref "jolt.passes.types" "ty") ar)))) (if (jolt-truthy? (let* ((and__25__auto (jolt-not (jolt-invoke (var-deref "clojure.core" "nil?") v)))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.types" "pure-node?") (jolt-invoke (var-deref "jolt.passes.types" "nd") ar)) and__25__auto))) (let* ((_o$5222 (keyword #f "any")) (_o$5223 (let* ((_o$5218 (keyword #f "op")) (_o$5219 (keyword #f "const")) (_o$5220 (keyword #f "val")) (_o$5221 v)) (jolt-hash-map _o$5218 _o$5219 _o$5220 _o$5221)))) (jolt-vector _o$5222 _o$5223)) (let* ((_o$5224 (jolt-invoke (var-deref "jolt.passes.types" "call-ret-type") fnode env)) (_o$5225 (jolt-assoc node (keyword #f "args") (jolt-vector (jolt-invoke (var-deref "jolt.passes.types" "nd") ar))))) (jolt-vector _o$5224 _o$5225)))))))) infer-pred-fold) (let* ((_o$5226 (keyword #f "doc")) (_o$5227 "A type predicate over a single side-effect-free arg whose type PROVES the answer\n folds to a boolean constant \x2014; eliminating the call, and (once const-fold runs\n after inference) collapsing any `if` it gates. Falls back to the normal call path\n when the answer isn't provable or the arg is impure.")) (jolt-hash-map _o$5226 _o$5227))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types" "infer-kw-lookup" (letrec ((infer-kw-lookup (lambda (node fnode args n tenv env) (let fnrec5228 ((node node) (fnode fnode) (args args) (n n) (tenv tenv) (env env)) (let* ((mr (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 0) tenv env)) (mt (jolt-invoke (var-deref "jolt.passes.types" "ty") mr)) (msub (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-safe?") mt)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mark-struct") (jolt-invoke (var-deref "jolt.passes.types" "nd") mr) mt) (jolt-invoke (var-deref "jolt.passes.types" "nd") mr))) (ft (jolt-invoke (var-deref "jolt.passes.types.lattice" "field-type") mt (jolt-get fnode (keyword #f "val")))) (dr (if (jolt= n 2) (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 1) tenv env) jolt-nil))) (let* ((_o$5231 (if (jolt-truthy? dr) (jolt-invoke (var-deref "jolt.passes.types.lattice" "join") ft (jolt-invoke (var-deref "jolt.passes.types" "ty") dr)) ft)) (_o$5232 (jolt-assoc node (keyword #f "args") (if (jolt-truthy? dr) (let* ((_o$5229 msub) (_o$5230 (jolt-invoke (var-deref "jolt.passes.types" "nd") dr))) (jolt-vector _o$5229 _o$5230)) (jolt-vector msub))))) (jolt-vector _o$5231 _o$5232))))))) infer-kw-lookup) (let* ((_o$5233 (keyword #f "doc")) (_o$5234 "(:k m) / (:k m default): the result is m's field type, and if m is a struct the\n subject is tagged so the back end drops the guard \x2014; this types nested access end\n to end (RFC 0005).")) (jolt-hash-map _o$5233 _o$5234))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types" "infer-get-lookup" (letrec ((infer-get-lookup (lambda (node args n tenv env) (let fnrec5235 ((node node) (args args) (n n) (tenv tenv) (env env)) (let* ((mr (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 0) tenv env)) (mt (jolt-invoke (var-deref "jolt.passes.types" "ty") mr)) (msub (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-safe?") mt)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mark-struct") (jolt-invoke (var-deref "jolt.passes.types" "nd") mr) mt) (jolt-invoke (var-deref "jolt.passes.types" "nd") mr))) (kr (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 1) tenv env)) (ft (jolt-invoke (var-deref "jolt.passes.types.lattice" "field-type") mt (jolt-get (jolt-nth args 1) (keyword #f "val")))) (dr (if (jolt= n 3) (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 2) tenv env) jolt-nil))) (let* ((_o$5241 (if (jolt-truthy? dr) (jolt-invoke (var-deref "jolt.passes.types.lattice" "join") ft (jolt-invoke (var-deref "jolt.passes.types" "ty") dr)) ft)) (_o$5242 (jolt-assoc node (keyword #f "args") (if (jolt-truthy? dr) (let* ((_o$5236 msub) (_o$5237 (jolt-invoke (var-deref "jolt.passes.types" "nd") kr)) (_o$5238 (jolt-invoke (var-deref "jolt.passes.types" "nd") dr))) (jolt-vector _o$5236 _o$5237 _o$5238)) (let* ((_o$5239 msub) (_o$5240 (jolt-invoke (var-deref "jolt.passes.types" "nd") kr))) (jolt-vector _o$5239 _o$5240)))))) (jolt-vector _o$5241 _o$5242))))))) infer-get-lookup) (let* ((_o$5243 (keyword #f "doc")) (_o$5244 "(get m :k [default]): the keyword-lookup result type, when the key is a constant\n keyword.")) (jolt-hash-map _o$5243 _o$5244))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types" "infer-reduce-hof" (letrec ((infer-reduce-hof (lambda (node args n tenv env) (let fnrec5245 ((node node) (args args) (n n) (tenv tenv) (env env)) (let* ((three (>= n 3)) (coll-r (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args (if (jolt-truthy? three) 2 1)) tenv env)) (init-r (if (jolt-truthy? three) (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 1) tenv env) jolt-nil)) (et (let* ((ct (jolt-invoke (var-deref "jolt.passes.types" "ty") coll-r))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") ct)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") ct) (keyword #f "any")))) (init-t (if (jolt-truthy? init-r) (jolt-invoke (var-deref "jolt.passes.types" "ty") init-r) (keyword #f "any"))) (fn-r (let* ((_a$5250 (var-deref "jolt.passes.types" "infer-fn-seeded")) (_a$5251 (jolt-nth args 0)) (_a$5252 (let* ((_o$5246 0) (_o$5247 init-t) (_o$5248 1) (_o$5249 et)) (jolt-hash-map _o$5246 _o$5247 _o$5248 _o$5249))) (_a$5253 tenv) (_a$5254 env)) (jolt-invoke _a$5250 _a$5251 _a$5252 _a$5253 _a$5254)))) (let* ((_o$5260 (jolt-invoke (var-deref "jolt.passes.types.lattice" "join") init-t (jolt-invoke (var-deref "jolt.passes.types" "ty") fn-r))) (_o$5261 (jolt-assoc node (keyword #f "args") (if (jolt-truthy? three) (let* ((_o$5255 (jolt-invoke (var-deref "jolt.passes.types" "nd") fn-r)) (_o$5256 (jolt-invoke (var-deref "jolt.passes.types" "nd") init-r)) (_o$5257 (jolt-invoke (var-deref "jolt.passes.types" "nd") coll-r))) (jolt-vector _o$5255 _o$5256 _o$5257)) (let* ((_o$5258 (jolt-invoke (var-deref "jolt.passes.types" "nd") fn-r)) (_o$5259 (jolt-invoke (var-deref "jolt.passes.types" "nd") coll-r))) (jolt-vector _o$5258 _o$5259)))))) (jolt-vector _o$5260 _o$5261))))))) infer-reduce-hof) (let* ((_o$5262 (keyword #f "doc")) (_o$5263 "reduce over a typed vector with a fn-literal: seed the closure's accumulator\n (param 0) to the init type and its element (param 1) to the vector's element\n type, so its body \x2014; and any calls it makes \x2014; see those types.")) (jolt-hash-map _o$5262 _o$5263))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types" "infer-seq-hof" (letrec ((infer-seq-hof (lambda (node cn args tenv env) (let fnrec5264 ((node node) (cn cn) (args args) (tenv tenv) (env env)) (let* ((coll-r (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-nth args 1) tenv env)) (et (let* ((ct (jolt-invoke (var-deref "jolt.passes.types" "ty") coll-r))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") ct)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") ct) (keyword #f "any")))) (fn-r (let* ((_a$5267 (var-deref "jolt.passes.types" "infer-fn-seeded")) (_a$5268 (jolt-nth args 0)) (_a$5269 (let* ((_o$5265 (jolt-get (jolt-get (var-deref "jolt.passes.types" "hof-table") cn) (keyword #f "epos"))) (_o$5266 et)) (jolt-hash-map _o$5265 _o$5266))) (_a$5270 tenv) (_a$5271 env)) (jolt-invoke _a$5267 _a$5268 _a$5269 _a$5270 _a$5271))) (rt (if (jolt= cn "mapv") (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") (jolt-invoke (var-deref "jolt.passes.types" "ty") fn-r)) (if (jolt= cn "filterv") (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") et) (if (jolt-truthy? (keyword #f "else")) (keyword #f "any") jolt-nil))))) (let* ((_o$5274 rt) (_o$5275 (jolt-assoc node (keyword #f "args") (let* ((_o$5272 (jolt-invoke (var-deref "jolt.passes.types" "nd") fn-r)) (_o$5273 (jolt-invoke (var-deref "jolt.passes.types" "nd") coll-r))) (jolt-vector _o$5272 _o$5273))))) (jolt-vector _o$5274 _o$5275))))))) infer-seq-hof) (let* ((_o$5276 (keyword #f "doc")) (_o$5277 "map/mapv/filter/... over a typed vector with a fn-literal: seed the fn's element\n param; mapv/filterv produce a typed vector.")) (jolt-hash-map _o$5276 _o$5277))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types" "infer-conj-into" (letrec ((infer-conj-into (lambda (node fnode cn args n tenv env) (let fnrec5278 ((node node) (fnode fnode) (cn cn) (args args) (n n) (tenv tenv) (env env)) (let* ((ares (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (a) (let fnrec5279 ((a a)) (jolt-invoke (var-deref "jolt.passes.types" "infer") a tenv env))) args)) (base (jolt-invoke (var-deref "jolt.passes.types" "ty") (jolt-nth ares 0))) (rest-ts (let* ((_a$5281 (var-deref "clojure.core" "mapv")) (_a$5282 (lambda (r) (let fnrec5280 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "ty") r)))) (_a$5283 (jolt-rest ares))) (jolt-invoke _a$5281 _a$5282 _a$5283))) (rt (if (jolt-truthy? (let* ((and__25__auto (jolt= cn "conj"))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") base) and__25__auto))) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") (jolt-reduce (var-deref "jolt.passes.types.lattice" "join") (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") base) rest-ts)) (if (jolt-truthy? (let* ((and__25__auto (jolt= cn "into"))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") base))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= 2 n))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") (jolt-nth rest-ts 0)) and__25__auto)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") (let* ((_a$5284 (var-deref "jolt.passes.types.lattice" "join")) (_a$5285 (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") base)) (_a$5286 (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") (jolt-nth rest-ts 0)))) (jolt-invoke _a$5284 _a$5285 _a$5286))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.passes.types" "call-ret-type") fnode env) jolt-nil))))) (let* ((_o$5288 rt) (_o$5289 (jolt-assoc node (keyword #f "args") (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5287 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "nd") r))) ares)))) (jolt-vector _o$5288 _o$5289))))))) infer-conj-into) (let* ((_o$5290 (keyword #f "doc")) (_o$5291 "conj/into: track the element type of a vector being grown.")) (jolt-hash-map _o$5290 _o$5291))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types" "infer-call" (letrec ((infer-call (lambda (node fnode iscall-var cn args n tenv env) (let fnrec5292 ((node node) (fnode fnode) (iscall-var iscall-var) (cn cn) (args args) (n n) (tenv tenv) (env env)) (let* ((fr (if (jolt-not iscall-var) (jolt-invoke (var-deref "jolt.passes.types" "infer") fnode tenv env) jolt-nil)) (fnode_PRIME_ (if (jolt-truthy? iscall-var) fnode (jolt-invoke (var-deref "jolt.passes.types" "nd") fr))) (callee-t (if (jolt-truthy? iscall-var) (let* ((_a$5293 (jolt-get env (keyword #f "vtypes"))) (_a$5294 (jolt-invoke (var-deref "jolt.passes.types" "var-key") fnode))) (jolt-get _a$5293 _a$5294)) (jolt-invoke (var-deref "jolt.passes.types" "ty") fr))) (ares (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (a) (let fnrec5295 ((a a)) (jolt-invoke (var-deref "jolt.passes.types" "infer") a tenv env))) args))) (begin (if (jolt-truthy? iscall-var) (let* ((_a$5299 (var-deref "clojure.core" "swap!")) (_a$5300 (jolt-get env (keyword #f "calls"))) (_a$5301 jolt-conj) (_a$5302 (let* ((_o$5297 (jolt-invoke (var-deref "jolt.passes.types" "var-key") fnode)) (_o$5298 (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5296 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "ty") r))) ares))) (jolt-vector _o$5297 _o$5298)))) (jolt-invoke _a$5299 _a$5300 _a$5301 _a$5302)) jolt-nil) (if (jolt-truthy? (jolt-get env (keyword #f "checking?"))) (let* ((ats (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5303 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "ty") r))) ares)) (pos (jolt-get node (keyword #f "pos")))) (begin (if (jolt-truthy? cn) (jolt-invoke (var-deref "jolt.passes.types.check" "check-invoke") cn args ats pos env) jolt-nil) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.check" "not-callable?") callee-t)) (let* ((_a$5312 (var-deref "clojure.core" "swap!")) (_a$5313 (jolt-get env (keyword #f "diags"))) (_a$5314 jolt-conj) (_a$5315 (let* ((_o$5304 (keyword #f "op")) (_o$5305 (keyword #f "call")) (_o$5306 (keyword #f "type")) (_o$5307 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") callee-t)) (_o$5308 (keyword #f "pos")) (_o$5309 pos) (_o$5310 (keyword #f "msg")) (_o$5311 (jolt-invoke (var-deref "clojure.core" "str") "cannot call " (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") callee-t) " as a function"))) (jolt-hash-map _o$5304 _o$5305 _o$5306 _o$5307 _o$5308 _o$5309 _o$5310 _o$5311)))) (jolt-invoke _a$5312 _a$5313 _a$5314 _a$5315)) jolt-nil) (if (jolt-truthy? (let* ((and__25__auto (jolt-get env (keyword #f "strict?")))) (if (jolt-truthy? and__25__auto) iscall-var and__25__auto))) (let* ((k (jolt-invoke (var-deref "jolt.passes.types" "var-key") fnode)) (usig (jolt-get (jolt-invoke (var-deref "clojure.core" "deref") (jolt-get env (keyword #f "user-sigs"))) k))) (if (jolt-truthy? usig) (jolt-invoke (var-deref "jolt.passes.types" "check-user-call") k usig ats pos env) jolt-nil)) jolt-nil))) jolt-nil) (let* ((pm (let* ((and__25__auto iscall-var)) (if (jolt-truthy? and__25__auto) (let* ((_a$5316 (jolt-get env (keyword #f "protocol-methods"))) (_a$5317 (jolt-invoke (var-deref "jolt.passes.types" "var-key") fnode))) (jolt-get _a$5316 _a$5317)) and__25__auto))) (rtype (if (jolt-truthy? (let* ((and__25__auto pm)) (if (jolt-truthy? and__25__auto) (jolt-pos? n) and__25__auto))) (jolt-get (jolt-invoke (var-deref "jolt.passes.types" "ty") (jolt-nth ares 0)) (keyword #f "type")) jolt-nil)) (base (jolt-assoc node (keyword #f "fn") fnode_PRIME_ (keyword #f "args") (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5318 ((r r)) (jolt-invoke (var-deref "jolt.passes.types" "nd") r))) ares)))) (let* ((_o$5326 (if (jolt= cn "range") (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") (keyword #f "num")) (if (jolt-truthy? (let* ((and__25__auto cn)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-contains? (var-deref "jolt.passes.types" "elem-fns") cn))) (if (jolt-truthy? and__25__auto) (> n 0) and__25__auto)) and__25__auto))) (let* ((a0 (jolt-invoke (var-deref "jolt.passes.types" "ty") (jolt-nth ares 0)))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") a0)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") a0) (keyword #f "any"))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.passes.types" "call-ret-type") fnode env) jolt-nil)))) (_o$5327 (if (jolt-truthy? rtype) (let* ((_a$5319 base) (_a$5320 (keyword #f "devirt-type")) (_a$5321 rtype) (_a$5322 (keyword #f "devirt-proto")) (_a$5323 (jolt-nth pm 0)) (_a$5324 (keyword #f "devirt-method")) (_a$5325 (jolt-nth pm 1))) (jolt-assoc _a$5319 _a$5320 _a$5321 _a$5322 _a$5323 _a$5324 _a$5325)) base))) (jolt-vector _o$5326 _o$5327))))))))) infer-call) (let* ((_o$5328 (keyword #f "doc")) (_o$5329 "Everything else: type the args, collect the call (var callee) for whole-program\n inference, run the success-type check, and use the declared/estimated return type.\n range produces a numeric vector; an element-returning fn over a typed vector\n yields the element type. A protocol-method call whose receiver (arg 0) is a known\n record type is annotated [type-tag proto method] for devirtualization \x2014; the back\n end looks up the impl at emit time and calls it directly, skipping the registry\n dispatch (~19x cheaper).")) (jolt-hash-map _o$5328 _o$5329))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types" "infer-invoke" (letrec ((infer-invoke (lambda (node tenv env) (let fnrec5330 ((node node) (tenv tenv) (env env)) (let* ((fnode (jolt-get node (keyword #f "fn"))) (iscall-var (jolt= (keyword #f "var") (jolt-get fnode (keyword #f "op")))) (cn (if (jolt-truthy? (let* ((and__25__auto iscall-var)) (if (jolt-truthy? and__25__auto) (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) and__25__auto))) (jolt-get fnode (keyword #f "name")) jolt-nil)) (args (jolt-get node (keyword #f "args"))) (n (jolt-count args))) (if (jolt-truthy? (let* ((and__25__auto iscall-var)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-contains? (var-deref "jolt.passes.types" "fold-preds") cn))) (if (jolt-truthy? and__25__auto) (jolt= n 1) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.passes.types" "infer-pred-fold") node fnode cn args tenv env) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.fold" "kw-callee?") fnode))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (>= n 1))) (if (jolt-truthy? and__25__auto) (<= n 2) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.passes.types" "infer-kw-lookup") node fnode args n tenv env) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.passes.fold" "get-callee?") fnode))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (>= n 2))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= (keyword #f "const") (jolt-get (jolt-nth args 1) (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "keyword?") (jolt-get (jolt-nth args 1) (keyword #f "val"))) and__25__auto)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.passes.types" "infer-get-lookup") node args n tenv env) (if (jolt-truthy? (let* ((and__25__auto (jolt= cn "reduce"))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (>= n 2))) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "fn") (jolt-get (jolt-nth args 0) (keyword #f "op"))) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.passes.types" "infer-reduce-hof") node args n tenv env) (if (jolt-truthy? (let* ((and__25__auto cn)) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-get (var-deref "jolt.passes.types" "hof-table") cn))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (>= n 2))) (if (jolt-truthy? and__25__auto) (jolt= (keyword #f "fn") (jolt-get (jolt-nth args 0) (keyword #f "op"))) and__25__auto)) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.passes.types" "infer-seq-hof") node cn args tenv env) (if (jolt-truthy? (let* ((and__25__auto (let* ((or__26__auto (jolt= cn "conj"))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= cn "into"))))) (if (jolt-truthy? and__25__auto) (>= n 1) and__25__auto))) (jolt-invoke (var-deref "jolt.passes.types" "infer-conj-into") node fnode cn args n tenv env) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.passes.types" "infer-call") node fnode iscall-var cn args n tenv env) jolt-nil)))))))))))) infer-invoke) (let* ((_o$5331 (keyword #f "doc")) (_o$5332 "Split the callee/args once and dispatch by callee shape to a pattern helper.")) (jolt-hash-map _o$5331 _o$5332))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types" "infer" (letrec ((infer (lambda (node tenv env) (let fnrec5333 ((node node) (tenv tenv) (env env)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "const")) (let* ((_o$5334 (let* ((v (jolt-get node (keyword #f "val")))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "number?") v)) (keyword #f "num") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "string?") v)) (keyword #f "str") (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "keyword?") v)) (keyword #f "kw") (if (jolt-truthy? (let* ((or__26__auto (jolt-invoke (var-deref "clojure.core" "nil?") v))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= #f v)))) (keyword #f "any") (if (jolt-truthy? (keyword #f "else")) (keyword #f "truthy") jolt-nil))))))) (_o$5335 node)) (jolt-vector _o$5334 _o$5335)) (if (jolt= op (keyword #f "local")) (let* ((t (jolt-get tenv (jolt-get node (keyword #f "name"))))) (let* ((_o$5336 (if (jolt-truthy? t) t (keyword #f "any"))) (_o$5337 (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-safe?") t)) (let* ((n (jolt-assoc node (keyword #f "hint") (keyword #f "struct")))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "type-shape") t)) (jolt-assoc n (keyword #f "shape") (jolt-invoke (var-deref "jolt.passes.types.lattice" "type-shape") t)) n)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "vec-type?") t)) (jolt-assoc node (keyword #f "hint") (keyword #f "vector")) (if (jolt-truthy? (keyword #f "else")) node jolt-nil))))) (jolt-vector _o$5336 _o$5337))) (if (jolt= op (keyword #f "map")) (let* ((pairs (jolt-get node (keyword #f "pairs"))) (res (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (pr) (let fnrec5338 ((pr pr)) (let* ((kr (infer (jolt-nth pr 0) tenv env)) (vr (infer (jolt-nth pr 1) tenv env))) (let* ((_o$5339 (jolt-nth kr 1)) (_o$5340 (jolt-nth vr 1)) (_o$5341 (jolt-nth vr 0)) (_o$5342 (jolt-get (jolt-nth pr 0) (keyword #f "val")))) (jolt-vector _o$5339 _o$5340 _o$5341 _o$5342))))) pairs)) (struct? (let* ((and__25__auto (> (jolt-count res) 0))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "every?") (lambda (pr) (let fnrec5343 ((pr pr)) (jolt-invoke (var-deref "jolt.passes.fold" "scalar-const?") (jolt-nth pr 0)))) pairs))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (r) (let fnrec5344 ((r r)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "truthy-type?") (jolt-nth r 2)))) res) and__25__auto)) and__25__auto))) (base (if (jolt-truthy? struct?) (jolt-invoke (var-deref "jolt.passes.types.lattice" "cap") (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-struct") (let* ((_a$5349 (lambda (m r) (let fnrec5345 ((m m) (r r)) (let* ((_a$5346 m) (_a$5347 (jolt-nth r 3)) (_a$5348 (jolt-nth r 2))) (jolt-assoc _a$5346 _a$5347 _a$5348))))) (_a$5350 (jolt-hash-map)) (_a$5351 res)) (jolt-reduce _a$5349 _a$5350 _a$5351))) (var-deref "jolt.passes.types.lattice" "type-depth")) jolt-nil)) (shp (if (jolt-truthy? (let* ((and__25__auto (jolt-get env (keyword #f "map-shapes?")))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto base)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") base) and__25__auto)) and__25__auto))) (jolt-invoke (var-deref "jolt.passes.types.lattice" "shape-order") (jolt-keys (jolt-invoke (var-deref "jolt.passes.types.lattice" "sfields") base))) jolt-nil)) (t (if (jolt-truthy? base) (if (jolt-truthy? shp) (jolt-assoc base (keyword #f "shape") shp) base) (keyword #f "any"))) (node_PRIME_ (jolt-assoc node (keyword #f "pairs") (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5352 ((r r)) (let* ((_o$5353 (jolt-nth r 0)) (_o$5354 (jolt-nth r 1))) (jolt-vector _o$5353 _o$5354)))) res)))) (let* ((_o$5355 t) (_o$5356 (if (jolt-truthy? shp) (jolt-assoc node_PRIME_ (keyword #f "shape") shp) node_PRIME_))) (jolt-vector _o$5355 _o$5356))) (if (jolt= op (keyword #f "vector")) (let* ((irs (let* ((_a$5358 (var-deref "clojure.core" "mapv")) (_a$5359 (lambda (x) (let fnrec5357 ((x x)) (infer x tenv env)))) (_a$5360 (jolt-get node (keyword #f "items")))) (jolt-invoke _a$5358 _a$5359 _a$5360))) (ets (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5361 ((r r)) (jolt-nth r 0))) irs)) (el (if (jolt-empty? ets) (keyword #f "any") (let* ((_a$5362 (var-deref "jolt.passes.types.lattice" "join")) (_a$5363 (jolt-first ets)) (_a$5364 (jolt-rest ets))) (jolt-reduce _a$5362 _a$5363 _a$5364))))) (let* ((_o$5366 (jolt-invoke (var-deref "jolt.passes.types.lattice" "cap") (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-vec") el) (var-deref "jolt.passes.types.lattice" "type-depth"))) (_o$5367 (jolt-assoc node (keyword #f "items") (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5365 ((r r)) (jolt-nth r 1))) irs)))) (jolt-vector _o$5366 _o$5367))) (if (jolt= op (keyword #f "set")) (let* ((irs (let* ((_a$5369 (var-deref "clojure.core" "mapv")) (_a$5370 (lambda (x) (let fnrec5368 ((x x)) (infer x tenv env)))) (_a$5371 (jolt-get node (keyword #f "items")))) (jolt-invoke _a$5369 _a$5370 _a$5371))) (ets (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5372 ((r r)) (jolt-nth r 0))) irs)) (el (if (jolt-empty? ets) (keyword #f "any") (let* ((_a$5373 (var-deref "jolt.passes.types.lattice" "join")) (_a$5374 (jolt-first ets)) (_a$5375 (jolt-rest ets))) (jolt-reduce _a$5373 _a$5374 _a$5375))))) (let* ((_o$5377 (jolt-invoke (var-deref "jolt.passes.types.lattice" "cap") (jolt-invoke (var-deref "jolt.passes.types.lattice" "mk-set") el) (var-deref "jolt.passes.types.lattice" "type-depth"))) (_o$5378 (jolt-assoc node (keyword #f "items") (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec5376 ((r r)) (jolt-nth r 1))) irs)))) (jolt-vector _o$5377 _o$5378))) (if (jolt= op (keyword #f "if")) (let* ((tr (infer (jolt-get node (keyword #f "test")) tenv env)) (thn (infer (jolt-get node (keyword #f "then")) tenv env)) (els (infer (jolt-get node (keyword #f "else")) tenv env))) (let* ((_o$5389 (let* ((_a$5379 (var-deref "jolt.passes.types.lattice" "join")) (_a$5380 (jolt-nth thn 0)) (_a$5381 (jolt-nth els 0))) (jolt-invoke _a$5379 _a$5380 _a$5381))) (_o$5390 (let* ((_a$5382 node) (_a$5383 (keyword #f "test")) (_a$5384 (jolt-nth tr 1)) (_a$5385 (keyword #f "then")) (_a$5386 (jolt-nth thn 1)) (_a$5387 (keyword #f "else")) (_a$5388 (jolt-nth els 1))) (jolt-assoc _a$5382 _a$5383 _a$5384 _a$5385 _a$5386 _a$5387 _a$5388)))) (jolt-vector _o$5389 _o$5390))) (if (jolt= op (keyword #f "do")) (let* ((stmts (let* ((_a$5392 (var-deref "clojure.core" "mapv")) (_a$5393 (lambda (s) (let fnrec5391 ((s s)) (jolt-nth (infer s tenv env) 1)))) (_a$5394 (jolt-get node (keyword #f "statements")))) (jolt-invoke _a$5392 _a$5393 _a$5394))) (r (infer (jolt-get node (keyword #f "ret")) tenv env))) (let* ((_o$5395 (jolt-nth r 0)) (_o$5396 (jolt-assoc node (keyword #f "statements") stmts (keyword #f "ret") (jolt-nth r 1)))) (jolt-vector _o$5395 _o$5396))) (if (jolt= op (keyword #f "throw")) (let* ((_o$5397 (keyword #f "any")) (_o$5398 (jolt-assoc node (keyword #f "expr") (jolt-nth (infer (jolt-get node (keyword #f "expr")) tenv env) 1)))) (jolt-vector _o$5397 _o$5398)) (if (jolt= op (keyword #f "var")) (begin (let* ((_a$5399 (var-deref "clojure.core" "swap!")) (_a$5400 (jolt-get env (keyword #f "escapes"))) (_a$5401 jolt-conj) (_a$5402 (jolt-invoke (var-deref "jolt.passes.types" "var-key") node))) (jolt-invoke _a$5399 _a$5400 _a$5401 _a$5402)) (let* ((_o$5405 (let* ((vt (let* ((_a$5403 (jolt-get env (keyword #f "vtypes"))) (_a$5404 (jolt-invoke (var-deref "jolt.passes.types" "var-key") node))) (jolt-get _a$5403 _a$5404)))) (if (jolt-truthy? vt) vt (keyword #f "any")))) (_o$5406 node)) (jolt-vector _o$5405 _o$5406))) (if (jolt= op (keyword #f "invoke")) (jolt-invoke (var-deref "jolt.passes.types" "infer-invoke") node tenv env) (if (jolt= op (keyword #f "let")) (let* ((res (let* ((_a$5417 (lambda (acc b) (let fnrec5407 ((acc acc) (b b)) (let* ((te (jolt-nth acc 0)) (binds (jolt-nth acc 1)) (ir (infer (jolt-nth b 1) te env))) (let* ((_o$5413 (let* ((_a$5408 te) (_a$5409 (jolt-nth b 0)) (_a$5410 (jolt-nth ir 0))) (jolt-assoc _a$5408 _a$5409 _a$5410))) (_o$5414 (jolt-conj binds (let* ((_o$5411 (jolt-nth b 0)) (_o$5412 (jolt-nth ir 1))) (jolt-vector _o$5411 _o$5412))))) (jolt-vector _o$5413 _o$5414)))))) (_a$5418 (let* ((_o$5415 tenv) (_o$5416 (jolt-vector))) (jolt-vector _o$5415 _o$5416))) (_a$5419 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$5417 _a$5418 _a$5419))) (br (let* ((_a$5420 (jolt-get node (keyword #f "body"))) (_a$5421 (jolt-nth res 0)) (_a$5422 env)) (infer _a$5420 _a$5421 _a$5422)))) (let* ((_o$5428 (jolt-nth br 0)) (_o$5429 (let* ((_a$5423 node) (_a$5424 (keyword #f "bindings")) (_a$5425 (jolt-nth res 1)) (_a$5426 (keyword #f "body")) (_a$5427 (jolt-nth br 1))) (jolt-assoc _a$5423 _a$5424 _a$5425 _a$5426 _a$5427)))) (jolt-vector _o$5428 _o$5429))) (if (jolt= op (keyword #f "loop")) (let* ((_o$5441 (keyword #f "any")) (_o$5442 (let* ((_a$5436 node) (_a$5437 (keyword #f "bindings")) (_a$5438 (let* ((_a$5433 (var-deref "clojure.core" "mapv")) (_a$5434 (lambda (b) (let fnrec5430 ((b b)) (let* ((_o$5431 (jolt-nth b 0)) (_o$5432 (jolt-nth (infer (jolt-nth b 1) tenv env) 1))) (jolt-vector _o$5431 _o$5432))))) (_a$5435 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$5433 _a$5434 _a$5435))) (_a$5439 (keyword #f "body")) (_a$5440 (jolt-nth (infer (jolt-get node (keyword #f "body")) tenv env) 1))) (jolt-assoc _a$5436 _a$5437 _a$5438 _a$5439 _a$5440)))) (jolt-vector _o$5441 _o$5442)) (if (jolt= op (keyword #f "recur")) (let* ((_o$5447 (keyword #f "any")) (_o$5448 (jolt-assoc node (keyword #f "args") (let* ((_a$5444 (var-deref "clojure.core" "mapv")) (_a$5445 (lambda (a) (let fnrec5443 ((a a)) (jolt-nth (infer a tenv env) 1)))) (_a$5446 (jolt-get node (keyword #f "args")))) (jolt-invoke _a$5444 _a$5445 _a$5446))))) (jolt-vector _o$5447 _o$5448)) (if (jolt= op (keyword #f "fn")) (let* ((_o$5464 (keyword #f "any")) (_o$5465 (jolt-assoc node (keyword #f "arities") (let* ((_a$5461 (var-deref "clojure.core" "mapv")) (_a$5462 (lambda (a) (let fnrec5449 ((a a)) (let* ((shapes (jolt-get env (keyword #f "record-shapes"))) (phm (let* ((_a$5454 (lambda (m pr) (let fnrec5450 ((m m) (pr pr)) (let* ((_a$5451 m) (_a$5452 (jolt-nth pr 0)) (_a$5453 (jolt-nth pr 1))) (jolt-assoc _a$5451 _a$5452 _a$5453))))) (_a$5455 (jolt-hash-map)) (_a$5456 (jolt-get a (keyword #f "phints")))) (jolt-reduce _a$5454 _a$5455 _a$5456))) (pe (let* ((_a$5458 (lambda (e p) (let fnrec5457 ((e e) (p p)) (jolt-assoc e p (let* ((ent (jolt-get shapes (jolt-get phm p)))) (if (jolt-truthy? ent) (jolt-invoke (var-deref "jolt.passes.types" "record-type-from-entry") ent (var-deref "jolt.passes.types.lattice" "type-depth") shapes) (keyword #f "any"))))))) (_a$5459 tenv) (_a$5460 (jolt-get a (keyword #f "params")))) (jolt-reduce _a$5458 _a$5459 _a$5460))) (pe (if (jolt-truthy? (jolt-get a (keyword #f "rest"))) (jolt-assoc pe (jolt-get a (keyword #f "rest")) (keyword #f "any")) pe))) (jolt-assoc a (keyword #f "body") (jolt-nth (infer (jolt-get a (keyword #f "body")) pe env) 1)))))) (_a$5463 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$5461 _a$5462 _a$5463))))) (jolt-vector _o$5464 _o$5465)) (if (jolt= op (keyword #f "def")) (begin (if (jolt-truthy? (jolt-get env (keyword #f "checking?"))) (jolt-invoke (var-deref "jolt.passes.types.check" "register-user-fn!") node env) jolt-nil) (let* ((_o$5466 (keyword #f "any")) (_o$5467 (jolt-assoc node (keyword #f "init") (jolt-nth (infer (jolt-get node (keyword #f "init")) tenv env) 1)))) (jolt-vector _o$5466 _o$5467))) (if (jolt= op (keyword #f "try")) (let* ((_o$5475 (keyword #f "any")) (_o$5476 (let* ((_a$5468 node) (_a$5469 (keyword #f "body")) (_a$5470 (jolt-nth (infer (jolt-get node (keyword #f "body")) tenv env) 1)) (_a$5471 (keyword #f "catch-body")) (_a$5472 (if (jolt-truthy? (jolt-get node (keyword #f "catch-body"))) (jolt-nth (infer (jolt-get node (keyword #f "catch-body")) tenv env) 1) jolt-nil)) (_a$5473 (keyword #f "finally")) (_a$5474 (if (jolt-truthy? (jolt-get node (keyword #f "finally"))) (jolt-nth (infer (jolt-get node (keyword #f "finally")) tenv env) 1) jolt-nil))) (jolt-assoc _a$5468 _a$5469 _a$5470 _a$5471 _a$5472 _a$5473 _a$5474)))) (jolt-vector _o$5475 _o$5476)) (if (jolt-truthy? (keyword #f "else")) (let* ((_o$5477 (keyword #f "any")) (_o$5478 node)) (jolt-vector _o$5477 _o$5478)) jolt-nil)))))))))))))))))))))) infer) (let* ((_o$5479 (keyword #f "doc")) (_o$5480 "Returns [type node'] \x2014; the inferred type of node and node with struct-safe\n :local references annotated :hint :struct. tenv maps in-scope local names to\n inferred types; env carries the inference config and this run's accumulators.")) (jolt-hash-map _o$5479 _o$5480))))
(guard (e (#t #f))
(def-var! "jolt.passes.types" "infer-top" (letrec ((infer-top (lambda (node env) (let fnrec5481 ((node node) (env env)) (jolt-nth (jolt-invoke (var-deref "jolt.passes.types" "infer") node (jolt-hash-map) env) 1))))) infer-top)))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types" "all-any-env" (letrec ((all-any-env (lambda (params) (let fnrec5482 ((params params)) (let* ((_a$5484 (lambda (e p) (let fnrec5483 ((e e) (p p)) (jolt-assoc e p (keyword #f "any"))))) (_a$5485 (jolt-hash-map)) (_a$5486 params)) (jolt-reduce _a$5484 _a$5485 _a$5486)))))) all-any-env) (let* ((_o$5487 (keyword #f "doc")) (_o$5488 "tenv binding every param name to :any (the all-ambiguous baseline).")) (jolt-hash-map _o$5487 _o$5488))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types" "isolated-diag-count" (letrec ((isolated-diag-count (lambda (body tenv env) (let fnrec5489 ((body body) (tenv tenv) (env env)) (let* ((sub (jolt-assoc env (keyword #f "diags") (jolt-invoke (var-deref "clojure.core" "atom") (jolt-vector))))) (begin (jolt-invoke (var-deref "jolt.passes.types" "infer") body tenv sub) (jolt-count (jolt-invoke (var-deref "clojure.core" "deref") (jolt-get sub (keyword #f "diags")))))))))) isolated-diag-count) (let* ((_o$5490 (keyword #f "doc")) (_o$5491 "Count of diagnostics typing body under tenv produces. Runs under a SUB-ENV\n with its own diags cell, so this probe never leaks into the real report (the\n shared calls/escapes/guard cells are intentionally still threaded \x2014; they are\n not read here). Runs the same checking inference as check-form.")) (jolt-hash-map _o$5490 _o$5491))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types" "check-user-call" (letrec ((check-user-call (lambda (key sig arg-types pos env) (let fnrec5492 ((key key) (sig sig) (arg-types arg-types) (pos pos) (env env)) (let* ((cset (jolt-get env (keyword #f "checking-set")))) (if (jolt-not (jolt-contains? (jolt-invoke (var-deref "clojure.core" "deref") cset) key)) (let* ((prev (jolt-invoke (var-deref "clojure.core" "deref") cset))) (begin (jolt-invoke (var-deref "clojure.core" "reset!") cset (jolt-conj prev key)) (let* ((params (jolt-get sig (keyword #f "params"))) (body (jolt-get sig (keyword #f "body"))) (npar (jolt-count params)) (nargs (jolt-count arg-types)) (memo (jolt-get env (keyword #f "diag-memo")))) (if (jolt-truthy? (jolt-invoke (var-deref "clojure.core" "not=") npar nargs)) (let* ((_a$5501 (var-deref "clojure.core" "swap!")) (_a$5502 (jolt-get env (keyword #f "diags"))) (_a$5503 jolt-conj) (_a$5504 (let* ((_o$5493 (keyword #f "op")) (_o$5494 (keyword #f "user-call")) (_o$5495 (keyword #f "type")) (_o$5496 (keyword #f "arity")) (_o$5497 (keyword #f "pos")) (_o$5498 pos) (_o$5499 (keyword #f "msg")) (_o$5500 (jolt-invoke (var-deref "clojure.core" "str") "wrong number of args (" nargs ") passed to `" (jolt-get sig (keyword #f "name")) "` (expected " npar ")"))) (jolt-hash-map _o$5493 _o$5494 _o$5495 _o$5496 _o$5497 _o$5498 _o$5499 _o$5500)))) (jolt-invoke _a$5501 _a$5502 _a$5503 _a$5504)) (let* ((base-env (jolt-invoke (var-deref "jolt.passes.types" "all-any-env") params)) (base (let* ((bk (let* ((_o$5505 (keyword #f "base")) (_o$5506 key)) (jolt-vector _o$5505 _o$5506)))) (if (jolt-contains? (jolt-invoke (var-deref "clojure.core" "deref") memo) bk) (jolt-get (jolt-invoke (var-deref "clojure.core" "deref") memo) bk) (let* ((b (jolt-invoke (var-deref "jolt.passes.types" "isolated-diag-count") body base-env env))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") memo jolt-assoc bk b) b)))))) (let* ((_a$5534 (lambda (_ i) (let fnrec5507 ((_ _) (i i)) (begin (let* ((at (jolt-nth arg-types i))) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "not=") at (keyword #f "any")))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "not=") at (keyword #f "truthy")) and__25__auto))) (let* ((mk (let* ((_o$5508 (keyword #f "arg")) (_o$5509 key) (_o$5510 i) (_o$5511 at)) (jolt-vector _o$5508 _o$5509 _o$5510 _o$5511))) (rejects (if (jolt-contains? (jolt-invoke (var-deref "clojure.core" "deref") memo) mk) (jolt-get (jolt-invoke (var-deref "clojure.core" "deref") memo) mk) (let* ((r (> (jolt-invoke (var-deref "jolt.passes.types" "isolated-diag-count") body (jolt-assoc base-env (jolt-nth params i) at) env) base))) (begin (jolt-invoke (var-deref "clojure.core" "swap!") memo jolt-assoc mk r) r))))) (if (jolt-truthy? rejects) (let* ((_a$5530 (var-deref "clojure.core" "swap!")) (_a$5531 (jolt-get env (keyword #f "diags"))) (_a$5532 jolt-conj) (_a$5533 (let* ((_o$5520 (keyword #f "op")) (_o$5521 (keyword #f "user-call")) (_o$5522 (keyword #f "argpos")) (_o$5523 i) (_o$5524 (keyword #f "type")) (_o$5525 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") at)) (_o$5526 (keyword #f "pos")) (_o$5527 pos) (_o$5528 (keyword #f "msg")) (_o$5529 (let* ((_a$5512 (var-deref "clojure.core" "str")) (_a$5513 "argument ") (_a$5514 (jolt-inc i)) (_a$5515 " to `") (_a$5516 (jolt-get sig (keyword #f "name"))) (_a$5517 "` is ") (_a$5518 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") at)) (_a$5519 ", which its body provably rejects")) (jolt-invoke _a$5512 _a$5513 _a$5514 _a$5515 _a$5516 _a$5517 _a$5518 _a$5519)))) (jolt-hash-map _o$5520 _o$5521 _o$5522 _o$5523 _o$5524 _o$5525 _o$5526 _o$5527 _o$5528 _o$5529)))) (jolt-invoke _a$5530 _a$5531 _a$5532 _a$5533)) jolt-nil)) jolt-nil)) jolt-nil)))) (_a$5535 jolt-nil) (_a$5536 (jolt-range npar))) (jolt-reduce _a$5534 _a$5535 _a$5536))))) (jolt-invoke (var-deref "clojure.core" "reset!") cset prev))) jolt-nil)))))) check-user-call) (let* ((_o$5537 (keyword #f "doc")) (_o$5538 "Strict mode: report a call to a registered user fn that provably throws \x2014;\n either a WRONG ARITY (the registered fn has one fixed arity, so a different\n arg count always throws) or an argument whose concrete type the body\n rejects. For the latter, re-check the body with ONLY that parameter bound to\n its arg type (others :any); a diagnostic the all-:any body did not already\n have means the argument alone is provably wrong. Monotonic \x2014; binding a\n concrete type can only ADD error-domain hits \x2014; so no false positive.\n Cycle-guarded (env's checking-set) so mutually recursive fns terminate.")) (jolt-hash-map _o$5537 _o$5538))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types" "set-rtenv!" (letrec ((set-rtenv! (lambda (m) (let fnrec5539 ((m m)) (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.passes.types" "config-box") jolt-assoc (keyword #f "rtenv") (let* ((or__26__auto m)) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-hash-map)))))))) set-rtenv!) (let* ((_o$5540 (keyword #f "doc")) (_o$5541 "Install the current return-type estimates (a map \"ns/name\" -> type) used to\n type call results during the fixpoint.")) (jolt-hash-map _o$5540 _o$5541))))
(guard (e (#t #f))
(def-var! "jolt.passes.types" "set-record-shapes!" (letrec ((set-record-shapes! (lambda (m) (let fnrec5542 ((m m)) (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.passes.types" "config-box") jolt-assoc (keyword #f "record-shapes") (let* ((or__26__auto m)) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-hash-map)))))))) set-record-shapes!)))
(guard (e (#t #f))
(def-var! "jolt.passes.types" "set-protocol-methods!" (letrec ((set-protocol-methods! (lambda (m) (let fnrec5543 ((m m)) (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.passes.types" "config-box") jolt-assoc (keyword #f "protocol-methods") (let* ((or__26__auto m)) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-hash-map)))))))) set-protocol-methods!)))
(guard (e (#t #f))
(def-var! "jolt.passes.types" "set-map-shapes!" (letrec ((set-map-shapes! (lambda (b) (let fnrec5544 ((b b)) (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.passes.types" "config-box") jolt-assoc (keyword #f "map-shapes?") (jolt-invoke (var-deref "clojure.core" "boolean") b)))))) set-map-shapes!)))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types" "set-vtypes!" (letrec ((set-vtypes! (lambda (m) (let fnrec5545 ((m m)) (jolt-invoke (var-deref "clojure.core" "swap!") (var-deref "jolt.passes.types" "config-box") jolt-assoc (keyword #f "vtypes") (let* ((or__26__auto m)) (if (jolt-truthy? or__26__auto) or__26__auto (jolt-hash-map)))))))) set-vtypes!) (let* ((_o$5546 (keyword #f "doc")) (_o$5547 "Install var VALUE types (a map \"ns/name\" -> type): fn vars are :truthy\n (non-nil), def vars carry their inferred init type.")) (jolt-hash-map _o$5546 _o$5547))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types" "join-types" (letrec ((join-types (lambda (a b) (let fnrec5548 ((a a) (b b)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "join-t") a b))))) join-types) (let* ((_o$5549 (keyword #f "doc")) (_o$5550 "Public structural join (lub), used by the orchestrator's fixpoint so param/\n return types join field-wise/element-wise instead of collapsing to :any.")) (jolt-hash-map _o$5549 _o$5550))))
(guard (e (#t #f))
(def-var! "jolt.passes.types" "reset-escapes!" (letrec ((reset-escapes! (lambda () (let fnrec5551 () (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.passes.types" "escapes-box") (jolt-hash-set)))))) reset-escapes!)))
(guard (e (#t #f))
(def-var! "jolt.passes.types" "collected-escapes" (letrec ((collected-escapes (lambda () (let fnrec5552 () (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.types" "escapes-box"))))))) collected-escapes)))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types" "check-form" (letrec ((check-form (case-lambda ((node) (let fnrec5553 ((node node)) (check-form node #f))) ((node strict?) (let fnrec5554 ((node node) (strict? strict?)) (let* ((env (jolt-invoke (var-deref "jolt.passes.types" "mk-env") #t strict?))) (begin (jolt-invoke (var-deref "jolt.passes.types" "infer") node (jolt-hash-map) env) (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "deref") (jolt-get env (keyword #f "diags"))))))))))) check-form) (let* ((_o$5555 (keyword #f "doc")) (_o$5556 "Success-type check a single analyzed form (RFC 0006). Returns a vector of\n diagnostics [{:op :argpos :type :msg} ...] for provably-wrong calls; empty\n when nothing is provably wrong. Runs independently of specialization so it is\n usable in normal builds (the decoupled checking path).\n\n With strict? true, also reports calls to registered user functions whose\n concrete argument types provably make the body throw (opt-in,\n closed-world). user-sig-box accumulates registered defs across forms, so a\n def must precede its call \x2014; the same ordering RFC 0005 already assumes.")) (jolt-hash-map _o$5555 _o$5556))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types" "infer-body" (letrec ((infer-body (lambda (body tenv) (let fnrec5557 ((body body) (tenv tenv)) (let* ((env (jolt-invoke (var-deref "jolt.passes.types" "mk-env") #f #f)) (r (jolt-invoke (var-deref "jolt.passes.types" "infer") body tenv env))) (let* ((_o$5558 (jolt-nth r 0)) (_o$5559 (jolt-nth r 1)) (_o$5560 (jolt-invoke (var-deref "clojure.core" "deref") (jolt-get env (keyword #f "calls"))))) (jolt-vector _o$5558 _o$5559 _o$5560))))))) infer-body) (let* ((_o$5561 (keyword #f "doc")) (_o$5562 "Type `body` under tenv (local-name -> type). Returns [ret-type node' calls],\n where calls is the [[\"ns/name\" [arg-types...]] ...] this body invokes (for\n propagating into callee param types). Also accumulates escapes (read with\n collected-escapes after a full sweep).")) (jolt-hash-map _o$5561 _o$5562))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types" "reinfer-def" (letrec ((reinfer-def (lambda (def-node ptmap) (let fnrec5563 ((def-node def-node) (ptmap ptmap)) (let* ((fnode (jolt-get def-node (keyword #f "init"))) (env (jolt-invoke (var-deref "jolt.passes.types" "mk-env") #f #f)) (shapes (jolt-get env (keyword #f "record-shapes")))) (if (jolt= (keyword #f "fn") (jolt-get fnode (keyword #f "op"))) (jolt-assoc def-node (keyword #f "init") (jolt-assoc fnode (keyword #f "arities") (let* ((_a$5569 (var-deref "clojure.core" "mapv")) (_a$5570 (lambda (a) (let fnrec5564 ((a a)) (let* ((pt (let* ((_a$5566 (lambda (m pr) (let fnrec5565 ((m m) (pr pr)) (let* ((nm (jolt-nth pr 0)) (e (jolt-get shapes (jolt-nth pr 1)))) (if (jolt-truthy? (let* ((and__25__auto e)) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-contains? m nm)) and__25__auto))) (jolt-assoc m nm (jolt-invoke (var-deref "jolt.passes.types" "record-type-from-entry") e (var-deref "jolt.passes.types.lattice" "type-depth") shapes)) m))))) (_a$5567 ptmap) (_a$5568 (jolt-get a (keyword #f "phints")))) (jolt-reduce _a$5566 _a$5567 _a$5568)))) (jolt-assoc a (keyword #f "body") (jolt-nth (jolt-invoke (var-deref "jolt.passes.types" "infer") (jolt-get a (keyword #f "body")) pt env) 1)))))) (_a$5571 (jolt-get fnode (keyword #f "arities")))) (jolt-invoke _a$5569 _a$5570 _a$5571)))) def-node)))))) reinfer-def) (let* ((_o$5572 (keyword #f "doc")) (_o$5573 "Re-run inference on a stashed :def's fn arity bodies with param types seeded\n (ptmap: param-name -> type), returning the def with annotated bodies. The back\n end emits the result directly (no further passes), so the param-typed lookups\n keep their specialization. Used by the inter-procedural recompile.")) (jolt-hash-map _o$5572 _o$5573))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types" "phint-seed" (letrec ((phint-seed (lambda (params phints) (let fnrec5574 ((params params) (phints phints)) (let* ((shapes (jolt-get (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.types" "config-box")) (keyword #f "record-shapes"))) (m (let* ((_a$5579 (lambda (acc pr) (let fnrec5575 ((acc acc) (pr pr)) (let* ((_a$5576 acc) (_a$5577 (jolt-nth pr 0)) (_a$5578 (jolt-nth pr 1))) (jolt-assoc _a$5576 _a$5577 _a$5578))))) (_a$5580 (jolt-hash-map)) (_a$5581 phints)) (jolt-reduce _a$5579 _a$5580 _a$5581)))) (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (nm) (let fnrec5582 ((nm nm)) (let* ((ck (jolt-get m nm)) (e (let* ((and__25__auto ck)) (if (jolt-truthy? and__25__auto) (jolt-get shapes ck) and__25__auto)))) (if (jolt-truthy? e) (jolt-invoke (var-deref "jolt.passes.types" "record-type-from-entry") e (var-deref "jolt.passes.types.lattice" "type-depth") shapes) jolt-nil)))) params)))))) phint-seed) (let* ((_o$5583 (keyword #f "doc")) (_o$5584 "Positional declared-hint type seeds for a fn arity. Given the param-name\n vector and the arity's :phints (a seq of [name ctor-key] pairs), return a\n vector parallel to params whose slot i is the resolved record TYPE of that\n param's ^Record hint (via the record-shapes registry), or nil. The\n whole-program fixpoint seeds these as a param-type FLOOR so a declared hint\n propagates to a fn's callees DURING inference \x2014; not only at the final re-emit\n (reinfer-def). Without it a hinted param with no callers stays :any through the\n fixpoint, so a field read off it (e.g. (:origin ^Ray r)) never tells a shared\n callee its arg is a Vec3.")) (jolt-hash-map _o$5583 _o$5584))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types" "set-check-mode!" (letrec ((set-check-mode! (lambda (on strict?) (let fnrec5585 ((on on) (strict? strict?)) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.passes.types" "check-mode-box") (let* ((_o$5586 (keyword #f "on")) (_o$5587 (if (jolt-truthy? on) #t #f)) (_o$5588 (keyword #f "strict")) (_o$5589 (if (jolt-truthy? strict?) #t #f))) (jolt-hash-map _o$5586 _o$5587 _o$5588 _o$5589))))))) set-check-mode!) (let* ((_o$5590 (keyword #f "doc")) (_o$5591 "Enable/disable checking during the next run-passes inference (direct-link).")) (jolt-hash-map _o$5590 _o$5591))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types" "take-diags!" (letrec ((take-diags! (lambda () (let fnrec5592 () (let* ((d (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.types" "last-diags-box")))) (begin (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.passes.types" "last-diags-box") (jolt-vector)) d)))))) take-diags!) (let* ((_o$5593 (keyword #f "doc")) (_o$5594 "Diagnostics accumulated by the last checking run-passes; clears the buffer.")) (jolt-hash-map _o$5593 _o$5594))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes.types" "run-inference" (letrec ((run-inference (lambda (opt) (let fnrec5595 ((opt opt)) (if (jolt-truthy? (jolt-get (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.types" "check-mode-box")) (keyword #f "on"))) (let* ((env (jolt-invoke (var-deref "jolt.passes.types" "mk-env") #t (jolt-get (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.types" "check-mode-box")) (keyword #f "strict")))) (r (jolt-invoke (var-deref "jolt.passes.types" "infer-top") opt env))) (begin (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.passes.types" "last-diags-box") (jolt-invoke (var-deref "clojure.core" "deref") (jolt-get env (keyword #f "diags")))) r)) (jolt-invoke (var-deref "jolt.passes.types" "infer-top") opt (jolt-invoke (var-deref "jolt.passes.types" "mk-env") #f #f))))))) run-inference) (let* ((_o$5596 (keyword #f "doc")) (_o$5597 "Type-infer the optimized node (the inference walk specializes struct-safe\n lookups). When check mode is on (set-check-mode!), the same walk also emits\n success-type diagnostics, stashed for take-diags! to drain afterward. Pulled\n out of run-passes so the checking state stays private to this namespace.")) (jolt-hash-map _o$5596 _o$5597))))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes" "inline-fixpoint-cap" 8 (let* ((_o$5598 (keyword #f "private")) (_o$5599 #t)) (jolt-hash-map _o$5598 _o$5599))))
(guard (e (#t #f))
(def-var! "jolt.passes" "inline-eligible?" (letrec ((inline-eligible? (lambda (node) (let fnrec5600 ((node node)) (let* ((and__25__auto (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt-get node (keyword #f "init")))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= (keyword #f "fn") (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "op"))))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= 1 (jolt-count (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "arities")))))) (if (jolt-truthy? and__25__auto) (jolt-not (jolt-get (jolt-first (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "arities"))) (keyword #f "rest"))) and__25__auto)) and__25__auto)) and__25__auto)) and__25__auto)))))) inline-eligible?)))
(guard (e (#t #f))
(def-var! "jolt.passes" "stash-of" (letrec ((stash-of (lambda (node) (let fnrec5601 ((node node)) (let* ((a (jolt-first (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "arities"))))) (let* ((_o$5602 (keyword #f "params")) (_o$5603 (jolt-get a (keyword #f "params"))) (_o$5604 (keyword #f "body")) (_o$5605 (jolt-get a (keyword #f "body"))) (_o$5606 (keyword #f "nhints")) (_o$5607 (jolt-get a (keyword #f "nhints"))) (_o$5608 (keyword #f "ret")) (_o$5609 (jolt-get a (keyword #f "ret-nhint")))) (jolt-hash-map _o$5602 _o$5603 _o$5604 _o$5605 _o$5606 _o$5607 _o$5608 _o$5609))))))) stash-of)))
(guard (e (#t #f))
(def-var-with-meta! "jolt.passes" "run-passes" (letrec ((run-passes (lambda (node ctx) (let fnrec5610 ((node node) (ctx ctx)) (begin (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "jolt.host" "inline-enabled?") ctx))) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "jolt.passes" "inline-eligible?") node) and__25__auto))) (let* ((_a$5611 (var-deref "jolt.host" "stash-inline!")) (_a$5612 ctx) (_a$5613 (jolt-get node (keyword #f "ns"))) (_a$5614 (jolt-get node (keyword #f "name"))) (_a$5615 (jolt-invoke (var-deref "jolt.passes" "stash-of") node))) (jolt-invoke _a$5611 _a$5612 _a$5613 _a$5614 _a$5615)) jolt-nil) (jolt-invoke (var-deref "jolt.passes.numeric" "annotate") (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "inline-enabled?") ctx)) (let* ((_ (jolt-invoke (var-deref "jolt.passes.inline" "set-rec-shapes!") (jolt-invoke (var-deref "jolt.host" "record-shapes") ctx))) (_ (jolt-invoke (var-deref "jolt.passes.types" "set-record-shapes!") (jolt-invoke (var-deref "jolt.host" "record-shapes") ctx))) (opt (let* ((i 0) (n (jolt-invoke (var-deref "jolt.passes.fold" "const-fold") node))) (let loop5616 ((i i) (n n)) (begin (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.passes.inline" "dirty") #f) (let* ((n2 (jolt-invoke (var-deref "jolt.passes.fold" "const-fold") (jolt-invoke (var-deref "jolt.passes.inline" "scalar-replace") (jolt-invoke (var-deref "jolt.passes.inline" "flatten-lets") (jolt-invoke (var-deref "jolt.passes.inline" "inline-node") n ctx)))))) (if (jolt-truthy? (let* ((and__25__auto (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.inline" "dirty")))) (if (jolt-truthy? and__25__auto) (< i (var-deref "jolt.passes" "inline-fixpoint-cap")) and__25__auto))) (loop5616 (jolt-inc i) n2) n2))))))) (jolt-invoke (var-deref "jolt.passes.fold" "const-fold") (jolt-invoke (var-deref "jolt.passes.types" "run-inference") opt))) (jolt-invoke (var-deref "jolt.passes.fold" "const-fold") node)))))))) run-passes) (let* ((_o$5617 (keyword #f "doc")) (_o$5618 "All passes, in order. The back end applies this to every analyzed form. When\n inlining is enabled for the unit (user code under direct-linking),\n run inline + flatten + scalar-replace + const-fold to a capped fixpoint \x2014;\n inlining exposes map literals to lookups, scalar-replace collapses them, which\n may expose more \x2014; then a collection-type inference pass (optionally\n also emitting success diagnostics) that auto-drops the lookup guard where the\n type is proven. Otherwise (core + bootstrap) just const-fold, as before.\n\n numeric/annotate runs last in both branches (hint-directed fl*/fx* arithmetic);\n it benefits open builds too, so it is not gated on inlining.")) (jolt-hash-map _o$5617 _o$5618))))
Reference in a new issue View git blame Copy permalink