From e6e361233270f9df06c86fd10bb4746e7feb18fb Mon Sep 17 00:00:00 2001 From: Dmitri Sotnikov Date: Fri, 26 Jun 2026 13:58:23 +0000 Subject: [PATCH] Devirt: fall back to dispatch when the static tag has no direct impl (#229) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The devirtualized protocol call emitted find-protocol-method on the inferred record tag, but a record can satisfy a protocol via an Object/host-tag default rather than a direct impl — find-protocol-method on its own tag misses that, while protocol-resolve walks to the default. So a record relying on (extend-protocol P Object ...) resolved under ordinary dispatch but applied #f under devirt and crashed. Closed-world opt builds only; the gate previously covered just direct inline/extend-type impls so it shipped green. Emit devirt-resolve, which tries the static tag and falls back to protocol-resolve on a miss — same fast path, correct regardless of how the record satisfies the protocol. Mirrors jrec-field-at falling back to jolt-get. The receiver binds to one temp so it feeds the resolve and the application without double-evaluating a side-effecting arg 0. Also widen the whole-program fixpoint to :any on hitting the iteration cap: a non-converged pre-fixpoint is more specific than the least fixpoint, so seeding it would be unsound. Not reached in practice (~2 passes); a defensive floor. run-devirt.ss gains an Object-default case. make test / shakesmoke green, selfhost holds, 0 new divergences. Co-authored-by: Yogthos --- host/chez/records.ss | 10 + host/chez/run-devirt.ss | 15 +- host/chez/seed/image.ss | 436 +++++++++++++++--------------- jolt-core/jolt/backend_scheme.clj | 18 +- jolt-core/jolt/passes/types.clj | 32 ++- 5 files changed, 273 insertions(+), 238 deletions(-) diff --git a/host/chez/records.ss b/host/chez/records.ss index 05a090b..437f227 100644 --- a/host/chez/records.ss +++ b/host/chez/records.ss @@ -579,6 +579,16 @@ (let ((rest (if (jolt-nil? rest-args) '() (seq->list rest-args)))) (apply (protocol-resolve proto-name method-name obj) obj rest))) +;; devirt-resolve: the impl for a call the inference proved monomorphic. Try the +;; static type tag directly (the fast path that skips receiver-type computation), +;; and fall back to ordinary dispatch when it misses — a record can satisfy a +;; protocol via an Object/host-tag default rather than a direct impl, which +;; find-protocol-method on its own tag wouldn't see. Mirrors jrec-field-at falling +;; back to jolt-get: correct regardless of how precise the inference was. +(define (devirt-resolve type-tag proto-name method-name obj) + (or (find-protocol-method type-tag proto-name method-name) + (protocol-resolve proto-name method-name obj))) + ;; dot-dispatch fallback used by emit for (.method record args): find the method ;; in ANY protocol the record's type implements. ;; java.util.Iterator over a jolt seqable: (.iterator coll) returns a jiterator diff --git a/host/chez/run-devirt.ss b/host/chez/run-devirt.ss index 1a45190..e0a385e 100644 --- a/host/chez/run-devirt.ss +++ b/host/chez/run-devirt.ss @@ -54,7 +54,7 @@ (define (run-emit scm) (eval (read (open-input-string scm)) (interaction-environment))) (let ((e (devirt-emit "user.Circle" "c"))) - (check "emit uses find-protocol-method" (has-sub? e "find-protocol-method") #t) + (check "emit uses devirt-resolve" (has-sub? e "devirt-resolve") #t) (check "devirt inline impl == dispatch" (run-emit e) (evals "(area c)"))) ; 7 (let ((e (devirt-emit "user.Square" "sq"))) @@ -63,9 +63,20 @@ ;; a normal (no devirt) call still goes through dispatch and agrees — the path the ;; megamorphic / unknown-receiver site keeps. (let ((e (emit (analyze (make-analyze-ctx "user") (jolt-ce-read "(area c)"))))) - (check "non-devirt path no find-protocol-method" (has-sub? e "find-protocol-method") #f) + (check "non-devirt path no devirt-resolve" (has-sub? e "devirt-resolve") #f) (check "non-devirt still dispatches" (run-emit e) 7)) +;; a record that relies on the protocol's Object default (no direct impl): the +;; inference still types it as a concrete record and annotates devirt, so the +;; emitted call must resolve the same value dispatch would. find-protocol-method +;; on the record's own tag misses here, so the devirt path has to fall back to +;; ordinary dispatch (else it applies #f and crashes). +(evals "(extend-protocol Shape Object (area [s] :obj-default))") +(evals "(defrecord Plain [n])") +(evals "(def pl (->Plain 9))") +(let ((e (devirt-emit "user.Plain" "pl"))) + (check "devirt Object-default == dispatch" (run-emit e) (evals "(area pl)"))) ; :obj-default + (if (= fails 0) (begin (printf "devirt gate: ~a/~a passed\n" total total) (exit 0)) (begin (printf "devirt gate: ~a/~a passed (~a failed)\n" (- total fails) total fails) (exit 1))) diff --git a/host/chez/seed/image.ss b/host/chez/seed/image.ss index c3b0a20..ba253cd 100644 --- a/host/chez/seed/image.ss +++ b/host/chez/seed/image.ss @@ -1,449 +1,449 @@ (guard (e (#t #f)) - (def-var! "jolt.ir" "const" (letrec ((const (lambda (v) (let fnrec7454 ((v v)) (let* ((_o$7455 (keyword #f "op")) (_o$7456 (keyword #f "const")) (_o$7457 (keyword #f "val")) (_o$7458 v)) (jolt-hash-map _o$7455 _o$7456 _o$7457 _o$7458)))))) const))) + (def-var! "jolt.ir" "const" (letrec ((const (lambda (v) (let fnrec7462 ((v v)) (let* ((_o$7463 (keyword #f "op")) (_o$7464 (keyword #f "const")) (_o$7465 (keyword #f "val")) (_o$7466 v)) (jolt-hash-map _o$7463 _o$7464 _o$7465 _o$7466)))))) const))) (guard (e (#t #f)) - (def-var! "jolt.ir" "local" (letrec ((local (lambda (name) (let fnrec7459 ((name name)) (let* ((_o$7460 (keyword #f "op")) (_o$7461 (keyword #f "local")) (_o$7462 (keyword #f "name")) (_o$7463 name)) (jolt-hash-map _o$7460 _o$7461 _o$7462 _o$7463)))))) local))) + (def-var! "jolt.ir" "local" (letrec ((local (lambda (name) (let fnrec7467 ((name name)) (let* ((_o$7468 (keyword #f "op")) (_o$7469 (keyword #f "local")) (_o$7470 (keyword #f "name")) (_o$7471 name)) (jolt-hash-map _o$7468 _o$7469 _o$7470 _o$7471)))))) local))) (guard (e (#t #f)) - (def-var! "jolt.ir" "var-ref" (letrec ((var-ref (lambda (ns name) (let fnrec7464 ((ns ns) (name name)) (let* ((_o$7465 (keyword #f "op")) (_o$7466 (keyword #f "var")) (_o$7467 (keyword #f "ns")) (_o$7468 ns) (_o$7469 (keyword #f "name")) (_o$7470 name)) (jolt-hash-map _o$7465 _o$7466 _o$7467 _o$7468 _o$7469 _o$7470)))))) var-ref))) + (def-var! "jolt.ir" "var-ref" (letrec ((var-ref (lambda (ns name) (let fnrec7472 ((ns ns) (name name)) (let* ((_o$7473 (keyword #f "op")) (_o$7474 (keyword #f "var")) (_o$7475 (keyword #f "ns")) (_o$7476 ns) (_o$7477 (keyword #f "name")) (_o$7478 name)) (jolt-hash-map _o$7473 _o$7474 _o$7475 _o$7476 _o$7477 _o$7478)))))) var-ref))) (guard (e (#t #f)) - (def-var! "jolt.ir" "the-var" (letrec ((the-var (lambda (ns name) (let fnrec7471 ((ns ns) (name name)) (let* ((_o$7472 (keyword #f "op")) (_o$7473 (keyword #f "the-var")) (_o$7474 (keyword #f "ns")) (_o$7475 ns) (_o$7476 (keyword #f "name")) (_o$7477 name)) (jolt-hash-map _o$7472 _o$7473 _o$7474 _o$7475 _o$7476 _o$7477)))))) the-var))) + (def-var! "jolt.ir" "the-var" (letrec ((the-var (lambda (ns name) (let fnrec7479 ((ns ns) (name name)) (let* ((_o$7480 (keyword #f "op")) (_o$7481 (keyword #f "the-var")) (_o$7482 (keyword #f "ns")) (_o$7483 ns) (_o$7484 (keyword #f "name")) (_o$7485 name)) (jolt-hash-map _o$7480 _o$7481 _o$7482 _o$7483 _o$7484 _o$7485)))))) the-var))) (guard (e (#t #f)) - (def-var! "jolt.ir" "host-ref" (letrec ((host-ref (lambda (name) (let fnrec7478 ((name name)) (let* ((_o$7479 (keyword #f "op")) (_o$7480 (keyword #f "host")) (_o$7481 (keyword #f "name")) (_o$7482 name)) (jolt-hash-map _o$7479 _o$7480 _o$7481 _o$7482)))))) host-ref))) + (def-var! "jolt.ir" "host-ref" (letrec ((host-ref (lambda (name) (let fnrec7486 ((name name)) (let* ((_o$7487 (keyword #f "op")) (_o$7488 (keyword #f "host")) (_o$7489 (keyword #f "name")) (_o$7490 name)) (jolt-hash-map _o$7487 _o$7488 _o$7489 _o$7490)))))) host-ref))) (guard (e (#t #f)) - (def-var! "jolt.ir" "host-static" (letrec ((host-static (lambda (class member) (let fnrec7483 ((class class) (member member)) (let* ((_o$7484 (keyword #f "op")) (_o$7485 (keyword #f "host-static")) (_o$7486 (keyword #f "class")) (_o$7487 class) (_o$7488 (keyword #f "member")) (_o$7489 member)) (jolt-hash-map _o$7484 _o$7485 _o$7486 _o$7487 _o$7488 _o$7489)))))) host-static))) + (def-var! "jolt.ir" "host-static" (letrec ((host-static (lambda (class member) (let fnrec7491 ((class class) (member member)) (let* ((_o$7492 (keyword #f "op")) (_o$7493 (keyword #f "host-static")) (_o$7494 (keyword #f "class")) (_o$7495 class) (_o$7496 (keyword #f "member")) (_o$7497 member)) (jolt-hash-map _o$7492 _o$7493 _o$7494 _o$7495 _o$7496 _o$7497)))))) host-static))) (guard (e (#t #f)) - (def-var! "jolt.ir" "host-new" (letrec ((host-new (lambda (class args) (let fnrec7490 ((class class) (args args)) (let* ((_o$7491 (keyword #f "op")) (_o$7492 (keyword #f "host-new")) (_o$7493 (keyword #f "class")) (_o$7494 class) (_o$7495 (keyword #f "args")) (_o$7496 args)) (jolt-hash-map _o$7491 _o$7492 _o$7493 _o$7494 _o$7495 _o$7496)))))) host-new))) + (def-var! "jolt.ir" "host-new" (letrec ((host-new (lambda (class args) (let fnrec7498 ((class class) (args args)) (let* ((_o$7499 (keyword #f "op")) (_o$7500 (keyword #f "host-new")) (_o$7501 (keyword #f "class")) (_o$7502 class) (_o$7503 (keyword #f "args")) (_o$7504 args)) (jolt-hash-map _o$7499 _o$7500 _o$7501 _o$7502 _o$7503 _o$7504)))))) host-new))) (guard (e (#t #f)) - (def-var! "jolt.ir" "if-node" (letrec ((if-node (lambda (test then _else) (let fnrec7497 ((test test) (then then) (_else _else)) (let* ((_o$7498 (keyword #f "op")) (_o$7499 (keyword #f "if")) (_o$7500 (keyword #f "test")) (_o$7501 test) (_o$7502 (keyword #f "then")) (_o$7503 then) (_o$7504 (keyword #f "else")) (_o$7505 _else)) (jolt-hash-map _o$7498 _o$7499 _o$7500 _o$7501 _o$7502 _o$7503 _o$7504 _o$7505)))))) if-node))) + (def-var! "jolt.ir" "if-node" (letrec ((if-node (lambda (test then _else) (let fnrec7505 ((test test) (then then) (_else _else)) (let* ((_o$7506 (keyword #f "op")) (_o$7507 (keyword #f "if")) (_o$7508 (keyword #f "test")) (_o$7509 test) (_o$7510 (keyword #f "then")) (_o$7511 then) (_o$7512 (keyword #f "else")) (_o$7513 _else)) (jolt-hash-map _o$7506 _o$7507 _o$7508 _o$7509 _o$7510 _o$7511 _o$7512 _o$7513)))))) if-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "do-node" (letrec ((do-node (lambda (statements ret) (let fnrec7506 ((statements statements) (ret ret)) (let* ((_o$7507 (keyword #f "op")) (_o$7508 (keyword #f "do")) (_o$7509 (keyword #f "statements")) (_o$7510 statements) (_o$7511 (keyword #f "ret")) (_o$7512 ret)) (jolt-hash-map _o$7507 _o$7508 _o$7509 _o$7510 _o$7511 _o$7512)))))) do-node))) + (def-var! "jolt.ir" "do-node" (letrec ((do-node (lambda (statements ret) (let fnrec7514 ((statements statements) (ret ret)) (let* ((_o$7515 (keyword #f "op")) (_o$7516 (keyword #f "do")) (_o$7517 (keyword #f "statements")) (_o$7518 statements) (_o$7519 (keyword #f "ret")) (_o$7520 ret)) (jolt-hash-map _o$7515 _o$7516 _o$7517 _o$7518 _o$7519 _o$7520)))))) do-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "invoke" (letrec ((invoke (lambda (f args) (let fnrec7513 ((f f) (args args)) (let* ((_o$7514 (keyword #f "op")) (_o$7515 (keyword #f "invoke")) (_o$7516 (keyword #f "fn")) (_o$7517 f) (_o$7518 (keyword #f "args")) (_o$7519 args)) (jolt-hash-map _o$7514 _o$7515 _o$7516 _o$7517 _o$7518 _o$7519)))))) invoke))) + (def-var! "jolt.ir" "invoke" (letrec ((invoke (lambda (f args) (let fnrec7521 ((f f) (args args)) (let* ((_o$7522 (keyword #f "op")) (_o$7523 (keyword #f "invoke")) (_o$7524 (keyword #f "fn")) (_o$7525 f) (_o$7526 (keyword #f "args")) (_o$7527 args)) (jolt-hash-map _o$7522 _o$7523 _o$7524 _o$7525 _o$7526 _o$7527)))))) invoke))) (guard (e (#t #f)) - (def-var! "jolt.ir" "def-node" (letrec ((def-node (case-lambda ((ns name init) (let fnrec7520 ((ns ns) (name name) (init init)) (let* ((_o$7521 (keyword #f "op")) (_o$7522 (keyword #f "def")) (_o$7523 (keyword #f "ns")) (_o$7524 ns) (_o$7525 (keyword #f "name")) (_o$7526 name) (_o$7527 (keyword #f "init")) (_o$7528 init)) (jolt-hash-map _o$7521 _o$7522 _o$7523 _o$7524 _o$7525 _o$7526 _o$7527 _o$7528)))) ((ns name init meta) (let fnrec7529 ((ns ns) (name name) (init init) (meta meta)) (if (jolt-truthy? meta) (let* ((_o$7530 (keyword #f "op")) (_o$7531 (keyword #f "def")) (_o$7532 (keyword #f "ns")) (_o$7533 ns) (_o$7534 (keyword #f "name")) (_o$7535 name) (_o$7536 (keyword #f "init")) (_o$7537 init) (_o$7538 (keyword #f "meta")) (_o$7539 meta)) (jolt-hash-map _o$7530 _o$7531 _o$7532 _o$7533 _o$7534 _o$7535 _o$7536 _o$7537 _o$7538 _o$7539)) (let* ((_o$7540 (keyword #f "op")) (_o$7541 (keyword #f "def")) (_o$7542 (keyword #f "ns")) (_o$7543 ns) (_o$7544 (keyword #f "name")) (_o$7545 name) (_o$7546 (keyword #f "init")) (_o$7547 init)) (jolt-hash-map _o$7540 _o$7541 _o$7542 _o$7543 _o$7544 _o$7545 _o$7546 _o$7547)))))))) def-node))) + (def-var! "jolt.ir" "def-node" (letrec ((def-node (case-lambda ((ns name init) (let fnrec7528 ((ns ns) (name name) (init init)) (let* ((_o$7529 (keyword #f "op")) (_o$7530 (keyword #f "def")) (_o$7531 (keyword #f "ns")) (_o$7532 ns) (_o$7533 (keyword #f "name")) (_o$7534 name) (_o$7535 (keyword #f "init")) (_o$7536 init)) (jolt-hash-map _o$7529 _o$7530 _o$7531 _o$7532 _o$7533 _o$7534 _o$7535 _o$7536)))) ((ns name init meta) (let fnrec7537 ((ns ns) (name name) (init init) (meta meta)) (if (jolt-truthy? meta) (let* ((_o$7538 (keyword #f "op")) (_o$7539 (keyword #f "def")) (_o$7540 (keyword #f "ns")) (_o$7541 ns) (_o$7542 (keyword #f "name")) (_o$7543 name) (_o$7544 (keyword #f "init")) (_o$7545 init) (_o$7546 (keyword #f "meta")) (_o$7547 meta)) (jolt-hash-map _o$7538 _o$7539 _o$7540 _o$7541 _o$7542 _o$7543 _o$7544 _o$7545 _o$7546 _o$7547)) (let* ((_o$7548 (keyword #f "op")) (_o$7549 (keyword #f "def")) (_o$7550 (keyword #f "ns")) (_o$7551 ns) (_o$7552 (keyword #f "name")) (_o$7553 name) (_o$7554 (keyword #f "init")) (_o$7555 init)) (jolt-hash-map _o$7548 _o$7549 _o$7550 _o$7551 _o$7552 _o$7553 _o$7554 _o$7555)))))))) def-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "let-node" (letrec ((let-node (lambda (bindings body) (let fnrec7548 ((bindings bindings) (body body)) (let* ((_o$7549 (keyword #f "op")) (_o$7550 (keyword #f "let")) (_o$7551 (keyword #f "bindings")) (_o$7552 bindings) (_o$7553 (keyword #f "body")) (_o$7554 body)) (jolt-hash-map _o$7549 _o$7550 _o$7551 _o$7552 _o$7553 _o$7554)))))) let-node))) + (def-var! "jolt.ir" "let-node" (letrec ((let-node (lambda (bindings body) (let fnrec7556 ((bindings bindings) (body body)) (let* ((_o$7557 (keyword #f "op")) (_o$7558 (keyword #f "let")) (_o$7559 (keyword #f "bindings")) (_o$7560 bindings) (_o$7561 (keyword #f "body")) (_o$7562 body)) (jolt-hash-map _o$7557 _o$7558 _o$7559 _o$7560 _o$7561 _o$7562)))))) let-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "fn-node" (letrec ((fn-node (lambda (name arities) (let fnrec7555 ((name name) (arities arities)) (if (jolt-truthy? name) (let* ((_o$7556 (keyword #f "op")) (_o$7557 (keyword #f "fn")) (_o$7558 (keyword #f "name")) (_o$7559 name) (_o$7560 (keyword #f "arities")) (_o$7561 arities)) (jolt-hash-map _o$7556 _o$7557 _o$7558 _o$7559 _o$7560 _o$7561)) (let* ((_o$7562 (keyword #f "op")) (_o$7563 (keyword #f "fn")) (_o$7564 (keyword #f "arities")) (_o$7565 arities)) (jolt-hash-map _o$7562 _o$7563 _o$7564 _o$7565))))))) fn-node))) + (def-var! "jolt.ir" "fn-node" (letrec ((fn-node (lambda (name arities) (let fnrec7563 ((name name) (arities arities)) (if (jolt-truthy? name) (let* ((_o$7564 (keyword #f "op")) (_o$7565 (keyword #f "fn")) (_o$7566 (keyword #f "name")) (_o$7567 name) (_o$7568 (keyword #f "arities")) (_o$7569 arities)) (jolt-hash-map _o$7564 _o$7565 _o$7566 _o$7567 _o$7568 _o$7569)) (let* ((_o$7570 (keyword #f "op")) (_o$7571 (keyword #f "fn")) (_o$7572 (keyword #f "arities")) (_o$7573 arities)) (jolt-hash-map _o$7570 _o$7571 _o$7572 _o$7573))))))) fn-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "vector-node" (letrec ((vector-node (lambda (items) (let fnrec7566 ((items items)) (let* ((_o$7567 (keyword #f "op")) (_o$7568 (keyword #f "vector")) (_o$7569 (keyword #f "items")) (_o$7570 items)) (jolt-hash-map _o$7567 _o$7568 _o$7569 _o$7570)))))) vector-node))) + (def-var! "jolt.ir" "vector-node" (letrec ((vector-node (lambda (items) (let fnrec7574 ((items items)) (let* ((_o$7575 (keyword #f "op")) (_o$7576 (keyword #f "vector")) (_o$7577 (keyword #f "items")) (_o$7578 items)) (jolt-hash-map _o$7575 _o$7576 _o$7577 _o$7578)))))) vector-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "map-node" (letrec ((map-node (lambda (pairs) (let fnrec7571 ((pairs pairs)) (let* ((_o$7572 (keyword #f "op")) (_o$7573 (keyword #f "map")) (_o$7574 (keyword #f "pairs")) (_o$7575 pairs)) (jolt-hash-map _o$7572 _o$7573 _o$7574 _o$7575)))))) map-node))) + (def-var! "jolt.ir" "map-node" (letrec ((map-node (lambda (pairs) (let fnrec7579 ((pairs pairs)) (let* ((_o$7580 (keyword #f "op")) (_o$7581 (keyword #f "map")) (_o$7582 (keyword #f "pairs")) (_o$7583 pairs)) (jolt-hash-map _o$7580 _o$7581 _o$7582 _o$7583)))))) map-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "set-node" (letrec ((set-node (lambda (items) (let fnrec7576 ((items items)) (let* ((_o$7577 (keyword #f "op")) (_o$7578 (keyword #f "set")) (_o$7579 (keyword #f "items")) (_o$7580 items)) (jolt-hash-map _o$7577 _o$7578 _o$7579 _o$7580)))))) set-node))) + (def-var! "jolt.ir" "set-node" (letrec ((set-node (lambda (items) (let fnrec7584 ((items items)) (let* ((_o$7585 (keyword #f "op")) (_o$7586 (keyword #f "set")) (_o$7587 (keyword #f "items")) (_o$7588 items)) (jolt-hash-map _o$7585 _o$7586 _o$7587 _o$7588)))))) set-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "quote-node" (letrec ((quote-node (lambda (form) (let fnrec7581 ((form form)) (let* ((_o$7582 (keyword #f "op")) (_o$7583 (keyword #f "quote")) (_o$7584 (keyword #f "form")) (_o$7585 form)) (jolt-hash-map _o$7582 _o$7583 _o$7584 _o$7585)))))) quote-node))) + (def-var! "jolt.ir" "quote-node" (letrec ((quote-node (lambda (form) (let fnrec7589 ((form form)) (let* ((_o$7590 (keyword #f "op")) (_o$7591 (keyword #f "quote")) (_o$7592 (keyword #f "form")) (_o$7593 form)) (jolt-hash-map _o$7590 _o$7591 _o$7592 _o$7593)))))) quote-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "throw-node" (letrec ((throw-node (lambda (expr) (let fnrec7586 ((expr expr)) (let* ((_o$7587 (keyword #f "op")) (_o$7588 (keyword #f "throw")) (_o$7589 (keyword #f "expr")) (_o$7590 expr)) (jolt-hash-map _o$7587 _o$7588 _o$7589 _o$7590)))))) throw-node))) + (def-var! "jolt.ir" "throw-node" (letrec ((throw-node (lambda (expr) (let fnrec7594 ((expr expr)) (let* ((_o$7595 (keyword #f "op")) (_o$7596 (keyword #f "throw")) (_o$7597 (keyword #f "expr")) (_o$7598 expr)) (jolt-hash-map _o$7595 _o$7596 _o$7597 _o$7598)))))) throw-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "coerce-node" (letrec ((coerce-node (lambda (kind expr) (let fnrec7591 ((kind kind) (expr expr)) (let* ((_o$7592 (keyword #f "op")) (_o$7593 (keyword #f "coerce")) (_o$7594 (keyword #f "kind")) (_o$7595 kind) (_o$7596 (keyword #f "expr")) (_o$7597 expr)) (jolt-hash-map _o$7592 _o$7593 _o$7594 _o$7595 _o$7596 _o$7597)))))) coerce-node))) + (def-var! "jolt.ir" "coerce-node" (letrec ((coerce-node (lambda (kind expr) (let fnrec7599 ((kind kind) (expr expr)) (let* ((_o$7600 (keyword #f "op")) (_o$7601 (keyword #f "coerce")) (_o$7602 (keyword #f "kind")) (_o$7603 kind) (_o$7604 (keyword #f "expr")) (_o$7605 expr)) (jolt-hash-map _o$7600 _o$7601 _o$7602 _o$7603 _o$7604 _o$7605)))))) coerce-node))) (guard (e (#t #f)) - (def-var! "jolt.ir" "map-ir-children" (letrec ((map-ir-children (lambda (f node) (let fnrec7598 ((f f) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$7599 node) (_a$7600 (keyword #f "test")) (_a$7601 (jolt-invoke f (jolt-get node (keyword #f "test")))) (_a$7602 (keyword #f "then")) (_a$7603 (jolt-invoke f (jolt-get node (keyword #f "then")))) (_a$7604 (keyword #f "else")) (_a$7605 (jolt-invoke f (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$7599 _a$7600 _a$7601 _a$7602 _a$7603 _a$7604 _a$7605)) (if (jolt= op (keyword #f "do")) (let* ((_a$7606 node) (_a$7607 (keyword #f "statements")) (_a$7608 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "statements")))) (_a$7609 (keyword #f "ret")) (_a$7610 (jolt-invoke f (jolt-get node (keyword #f "ret"))))) (jolt-assoc _a$7606 _a$7607 _a$7608 _a$7609 _a$7610)) (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$7611 node) (_a$7612 (keyword #f "obj")) (_a$7613 (jolt-invoke f (jolt-get node (keyword #f "obj")))) (_a$7614 (keyword #f "val")) (_a$7615 (jolt-invoke f (jolt-get node (keyword #f "val"))))) (jolt-assoc _a$7611 _a$7612 _a$7613 _a$7614 _a$7615)) (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$7616 node) (_a$7617 (keyword #f "fn")) (_a$7618 (jolt-invoke f (jolt-get node (keyword #f "fn")))) (_a$7619 (keyword #f "args")) (_a$7620 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$7616 _a$7617 _a$7618 _a$7619 _a$7620)) (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$7624 (var-deref "clojure.core" "mapv")) (_a$7625 (lambda (pr) (let fnrec7621 ((pr pr)) (let* ((_o$7622 (jolt-invoke f (jolt-nth pr 0))) (_o$7623 (jolt-invoke f (jolt-nth pr 1)))) (jolt-vector _o$7622 _o$7623))))) (_a$7626 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$7624 _a$7625 _a$7626))) (if (jolt= op (keyword #f "let")) (let* ((_a$7633 node) (_a$7634 (keyword #f "bindings")) (_a$7635 (let* ((_a$7630 (var-deref "clojure.core" "mapv")) (_a$7631 (lambda (b) (let fnrec7627 ((b b)) (let* ((_o$7628 (jolt-nth b 0)) (_o$7629 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$7628 _o$7629))))) (_a$7632 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$7630 _a$7631 _a$7632))) (_a$7636 (keyword #f "body")) (_a$7637 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$7633 _a$7634 _a$7635 _a$7636 _a$7637)) (if (jolt= op (keyword #f "loop")) (let* ((_a$7644 node) (_a$7645 (keyword #f "bindings")) (_a$7646 (let* ((_a$7641 (var-deref "clojure.core" "mapv")) (_a$7642 (lambda (b) (let fnrec7638 ((b b)) (let* ((_o$7639 (jolt-nth b 0)) (_o$7640 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$7639 _o$7640))))) (_a$7643 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$7641 _a$7642 _a$7643))) (_a$7647 (keyword #f "body")) (_a$7648 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$7644 _a$7645 _a$7646 _a$7647 _a$7648)) (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$7650 (var-deref "clojure.core" "mapv")) (_a$7651 (lambda (a) (let fnrec7649 ((a a)) (jolt-assoc a (keyword #f "body") (jolt-invoke f (jolt-get a (keyword #f "body"))))))) (_a$7652 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$7650 _a$7651 _a$7652))) (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$7653 node) (_a$7654 (keyword #f "target")) (_a$7655 (jolt-invoke f (jolt-get node (keyword #f "target")))) (_a$7656 (keyword #f "args")) (_a$7657 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$7653 _a$7654 _a$7655 _a$7656 _a$7657)) (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))) + (def-var! "jolt.ir" "map-ir-children" (letrec ((map-ir-children (lambda (f node) (let fnrec7606 ((f f) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$7607 node) (_a$7608 (keyword #f "test")) (_a$7609 (jolt-invoke f (jolt-get node (keyword #f "test")))) (_a$7610 (keyword #f "then")) (_a$7611 (jolt-invoke f (jolt-get node (keyword #f "then")))) (_a$7612 (keyword #f "else")) (_a$7613 (jolt-invoke f (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$7607 _a$7608 _a$7609 _a$7610 _a$7611 _a$7612 _a$7613)) (if (jolt= op (keyword #f "do")) (let* ((_a$7614 node) (_a$7615 (keyword #f "statements")) (_a$7616 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "statements")))) (_a$7617 (keyword #f "ret")) (_a$7618 (jolt-invoke f (jolt-get node (keyword #f "ret"))))) (jolt-assoc _a$7614 _a$7615 _a$7616 _a$7617 _a$7618)) (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$7619 node) (_a$7620 (keyword #f "obj")) (_a$7621 (jolt-invoke f (jolt-get node (keyword #f "obj")))) (_a$7622 (keyword #f "val")) (_a$7623 (jolt-invoke f (jolt-get node (keyword #f "val"))))) (jolt-assoc _a$7619 _a$7620 _a$7621 _a$7622 _a$7623)) (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$7624 node) (_a$7625 (keyword #f "fn")) (_a$7626 (jolt-invoke f (jolt-get node (keyword #f "fn")))) (_a$7627 (keyword #f "args")) (_a$7628 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$7624 _a$7625 _a$7626 _a$7627 _a$7628)) (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$7632 (var-deref "clojure.core" "mapv")) (_a$7633 (lambda (pr) (let fnrec7629 ((pr pr)) (let* ((_o$7630 (jolt-invoke f (jolt-nth pr 0))) (_o$7631 (jolt-invoke f (jolt-nth pr 1)))) (jolt-vector _o$7630 _o$7631))))) (_a$7634 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$7632 _a$7633 _a$7634))) (if (jolt= op (keyword #f "let")) (let* ((_a$7641 node) (_a$7642 (keyword #f "bindings")) (_a$7643 (let* ((_a$7638 (var-deref "clojure.core" "mapv")) (_a$7639 (lambda (b) (let fnrec7635 ((b b)) (let* ((_o$7636 (jolt-nth b 0)) (_o$7637 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$7636 _o$7637))))) (_a$7640 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$7638 _a$7639 _a$7640))) (_a$7644 (keyword #f "body")) (_a$7645 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$7641 _a$7642 _a$7643 _a$7644 _a$7645)) (if (jolt= op (keyword #f "loop")) (let* ((_a$7652 node) (_a$7653 (keyword #f "bindings")) (_a$7654 (let* ((_a$7649 (var-deref "clojure.core" "mapv")) (_a$7650 (lambda (b) (let fnrec7646 ((b b)) (let* ((_o$7647 (jolt-nth b 0)) (_o$7648 (jolt-invoke f (jolt-nth b 1)))) (jolt-vector _o$7647 _o$7648))))) (_a$7651 (jolt-get node (keyword #f "bindings")))) (jolt-invoke _a$7649 _a$7650 _a$7651))) (_a$7655 (keyword #f "body")) (_a$7656 (jolt-invoke f (jolt-get node (keyword #f "body"))))) (jolt-assoc _a$7652 _a$7653 _a$7654 _a$7655 _a$7656)) (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$7658 (var-deref "clojure.core" "mapv")) (_a$7659 (lambda (a) (let fnrec7657 ((a a)) (jolt-assoc a (keyword #f "body") (jolt-invoke f (jolt-get a (keyword #f "body"))))))) (_a$7660 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$7658 _a$7659 _a$7660))) (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$7661 node) (_a$7662 (keyword #f "target")) (_a$7663 (jolt-invoke f (jolt-get node (keyword #f "target")))) (_a$7664 (keyword #f "args")) (_a$7665 (jolt-invoke (var-deref "clojure.core" "mapv") f (jolt-get node (keyword #f "args"))))) (jolt-assoc _a$7661 _a$7662 _a$7663 _a$7664 _a$7665)) (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 fnrec7658 ((f f) (acc acc) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$7662 f) (_a$7663 (let* ((_a$7659 f) (_a$7660 (jolt-invoke f acc (jolt-get node (keyword #f "test")))) (_a$7661 (jolt-get node (keyword #f "then")))) (jolt-invoke _a$7659 _a$7660 _a$7661))) (_a$7664 (jolt-get node (keyword #f "else")))) (jolt-invoke _a$7662 _a$7663 _a$7664)) (if (jolt= op (keyword #f "do")) (let* ((_a$7665 f) (_a$7666 (jolt-reduce f acc (jolt-get node (keyword #f "statements")))) (_a$7667 (jolt-get node (keyword #f "ret")))) (jolt-invoke _a$7665 _a$7666 _a$7667)) (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$7668 f) (_a$7669 (jolt-invoke f acc (jolt-get node (keyword #f "obj")))) (_a$7670 (jolt-get node (keyword #f "val")))) (jolt-invoke _a$7668 _a$7669 _a$7670)) (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$7671 f) (_a$7672 (jolt-invoke f acc (jolt-get node (keyword #f "fn")))) (_a$7673 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$7671 _a$7672 _a$7673)) (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$7678 (lambda (a pr) (let fnrec7674 ((a a) (pr pr)) (let* ((_a$7675 f) (_a$7676 (jolt-invoke f a (jolt-nth pr 0))) (_a$7677 (jolt-nth pr 1))) (jolt-invoke _a$7675 _a$7676 _a$7677))))) (_a$7679 acc) (_a$7680 (jolt-get node (keyword #f "pairs")))) (jolt-reduce _a$7678 _a$7679 _a$7680)) (if (jolt= op (keyword #f "let")) (let* ((_a$7685 f) (_a$7686 (let* ((_a$7682 (lambda (a b) (let fnrec7681 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$7683 acc) (_a$7684 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$7682 _a$7683 _a$7684))) (_a$7687 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$7685 _a$7686 _a$7687)) (if (jolt= op (keyword #f "loop")) (let* ((_a$7692 f) (_a$7693 (let* ((_a$7689 (lambda (a b) (let fnrec7688 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$7690 acc) (_a$7691 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$7689 _a$7690 _a$7691))) (_a$7694 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$7692 _a$7693 _a$7694)) (if (jolt= op (keyword #f "recur")) (jolt-reduce f acc (jolt-get node (keyword #f "args"))) (if (jolt= op (keyword #f "fn")) (let* ((_a$7696 (lambda (a ar) (let fnrec7695 ((a a) (ar ar)) (jolt-invoke f a (jolt-get ar (keyword #f "body")))))) (_a$7697 acc) (_a$7698 (jolt-get node (keyword #f "arities")))) (jolt-reduce _a$7696 _a$7697 _a$7698)) (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$7699 f) (_a$7700 (jolt-invoke f acc (jolt-get node (keyword #f "target")))) (_a$7701 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$7699 _a$7700 _a$7701)) (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))) + (def-var! "jolt.ir" "reduce-ir-children" (letrec ((reduce-ir-children (lambda (f acc node) (let fnrec7666 ((f f) (acc acc) (node node)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "if")) (let* ((_a$7670 f) (_a$7671 (let* ((_a$7667 f) (_a$7668 (jolt-invoke f acc (jolt-get node (keyword #f "test")))) (_a$7669 (jolt-get node (keyword #f "then")))) (jolt-invoke _a$7667 _a$7668 _a$7669))) (_a$7672 (jolt-get node (keyword #f "else")))) (jolt-invoke _a$7670 _a$7671 _a$7672)) (if (jolt= op (keyword #f "do")) (let* ((_a$7673 f) (_a$7674 (jolt-reduce f acc (jolt-get node (keyword #f "statements")))) (_a$7675 (jolt-get node (keyword #f "ret")))) (jolt-invoke _a$7673 _a$7674 _a$7675)) (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$7676 f) (_a$7677 (jolt-invoke f acc (jolt-get node (keyword #f "obj")))) (_a$7678 (jolt-get node (keyword #f "val")))) (jolt-invoke _a$7676 _a$7677 _a$7678)) (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$7679 f) (_a$7680 (jolt-invoke f acc (jolt-get node (keyword #f "fn")))) (_a$7681 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$7679 _a$7680 _a$7681)) (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$7686 (lambda (a pr) (let fnrec7682 ((a a) (pr pr)) (let* ((_a$7683 f) (_a$7684 (jolt-invoke f a (jolt-nth pr 0))) (_a$7685 (jolt-nth pr 1))) (jolt-invoke _a$7683 _a$7684 _a$7685))))) (_a$7687 acc) (_a$7688 (jolt-get node (keyword #f "pairs")))) (jolt-reduce _a$7686 _a$7687 _a$7688)) (if (jolt= op (keyword #f "let")) (let* ((_a$7693 f) (_a$7694 (let* ((_a$7690 (lambda (a b) (let fnrec7689 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$7691 acc) (_a$7692 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$7690 _a$7691 _a$7692))) (_a$7695 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$7693 _a$7694 _a$7695)) (if (jolt= op (keyword #f "loop")) (let* ((_a$7700 f) (_a$7701 (let* ((_a$7697 (lambda (a b) (let fnrec7696 ((a a) (b b)) (jolt-invoke f a (jolt-nth b 1))))) (_a$7698 acc) (_a$7699 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$7697 _a$7698 _a$7699))) (_a$7702 (jolt-get node (keyword #f "body")))) (jolt-invoke _a$7700 _a$7701 _a$7702)) (if (jolt= op (keyword #f "recur")) (jolt-reduce f acc (jolt-get node (keyword #f "args"))) (if (jolt= op (keyword #f "fn")) (let* ((_a$7704 (lambda (a ar) (let fnrec7703 ((a a) (ar ar)) (jolt-invoke f a (jolt-get ar (keyword #f "body")))))) (_a$7705 acc) (_a$7706 (jolt-get node (keyword #f "arities")))) (jolt-reduce _a$7704 _a$7705 _a$7706)) (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$7707 f) (_a$7708 (jolt-invoke f acc (jolt-get node (keyword #f "target")))) (_a$7709 (jolt-get node (keyword #f "args")))) (jolt-reduce _a$7707 _a$7708 _a$7709)) (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$7702 "quote") (_o$7703 "if") (_o$7704 "do") (_o$7705 "def") (_o$7706 "fn*") (_o$7707 "let*") (_o$7708 "loop*") (_o$7709 "recur") (_o$7710 "throw") (_o$7711 "try") (_o$7712 "syntax-quote") (_o$7713 "var") (_o$7714 "letfn") (_o$7715 "set!") (_o$7716 "defmacro")) (jolt-hash-set _o$7702 _o$7703 _o$7704 _o$7705 _o$7706 _o$7707 _o$7708 _o$7709 _o$7710 _o$7711 _o$7712 _o$7713 _o$7714 _o$7715 _o$7716)) (let* ((_o$7717 (keyword #f "private")) (_o$7718 #t)) (jolt-hash-map _o$7717 _o$7718)))) + (def-var-with-meta! "jolt.analyzer" "handled" (let* ((_o$7710 "quote") (_o$7711 "if") (_o$7712 "do") (_o$7713 "def") (_o$7714 "fn*") (_o$7715 "let*") (_o$7716 "loop*") (_o$7717 "recur") (_o$7718 "throw") (_o$7719 "try") (_o$7720 "syntax-quote") (_o$7721 "var") (_o$7722 "letfn") (_o$7723 "set!") (_o$7724 "defmacro")) (jolt-hash-set _o$7710 _o$7711 _o$7712 _o$7713 _o$7714 _o$7715 _o$7716 _o$7717 _o$7718 _o$7719 _o$7720 _o$7721 _o$7722 _o$7723 _o$7724)) (let* ((_o$7725 (keyword #f "private")) (_o$7726 #t)) (jolt-hash-map _o$7725 _o$7726)))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "uncompilable" (letrec ((uncompilable (lambda (why) (let fnrec7719 ((why why)) (jolt-throw (jolt-invoke (var-deref "clojure.core" "str") "jolt/uncompilable: " why)))))) uncompilable))) + (def-var! "jolt.analyzer" "uncompilable" (letrec ((uncompilable (lambda (why) (let fnrec7727 ((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$7720 (keyword #f "private")) (_o$7721 #t)) (jolt-hash-map _o$7720 _o$7721)))) + (def-var-with-meta! "jolt.analyzer" "gensym-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (let* ((_o$7728 (keyword #f "private")) (_o$7729 #t)) (jolt-hash-map _o$7728 _o$7729)))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "gen-name" (letrec ((gen-name (lambda (prefix) (let fnrec7722 ((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))) + (def-var! "jolt.analyzer" "gen-name" (letrec ((gen-name (lambda (prefix) (let fnrec7730 ((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 fnrec7723 () (let* ((_o$7724 (keyword #f "locals")) (_o$7725 (jolt-hash-set)) (_o$7726 (keyword #f "hints")) (_o$7727 (jolt-hash-map))) (jolt-hash-map _o$7724 _o$7725 _o$7726 _o$7727)))))) empty-env))) + (def-var! "jolt.analyzer" "empty-env" (letrec ((empty-env (lambda () (let fnrec7731 () (let* ((_o$7732 (keyword #f "locals")) (_o$7733 (jolt-hash-set)) (_o$7734 (keyword #f "hints")) (_o$7735 (jolt-hash-map))) (jolt-hash-map _o$7732 _o$7733 _o$7734 _o$7735)))))) empty-env))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "local?" (letrec ((local? (lambda (env nm) (let fnrec7728 ((env env) (nm nm)) (jolt-contains? (jolt-get env (keyword #f "locals")) nm))))) local?))) + (def-var! "jolt.analyzer" "local?" (letrec ((local? (lambda (env nm) (let fnrec7736 ((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 fnrec7729 ((env env) (names names)) (jolt-invoke (var-deref "clojure.core" "update") env (keyword #f "locals") (lambda (p__90_) (let fnrec7730 ((p__90_ p__90_)) (jolt-reduce jolt-conj p__90_ names)))))))) add-locals))) + (def-var! "jolt.analyzer" "add-locals" (letrec ((add-locals (lambda (env names) (let fnrec7737 ((env env) (names names)) (jolt-invoke (var-deref "clojure.core" "update") env (keyword #f "locals") (lambda (p__90_) (let fnrec7738 ((p__90_ p__90_)) (jolt-reduce jolt-conj p__90_ names)))))))) add-locals))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "with-recur" (letrec ((with-recur (lambda (env name) (let fnrec7731 ((env env) (name name)) (jolt-assoc env (keyword #f "recur") name))))) with-recur))) + (def-var! "jolt.analyzer" "with-recur" (letrec ((with-recur (lambda (env name) (let fnrec7739 ((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 fnrec7732 ((ctx ctx) (sym sym)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") sym))) (if (jolt-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))) + (def-var! "jolt.analyzer" "hint-of" (letrec ((hint-of (lambda (ctx sym) (let fnrec7740 ((ctx ctx) (sym sym)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-sym-meta") sym))) (if (jolt-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 fnrec7733 ((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))) + (def-var! "jolt.analyzer" "add-hint" (letrec ((add-hint (lambda (env nm h) (let fnrec7741 ((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 fnrec7734 ((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))) + (def-var! "jolt.analyzer" "phint-of" (letrec ((phint-of (lambda (ctx sym) (let fnrec7742 ((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 fnrec7735 ((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))) + (def-var! "jolt.analyzer" "tag->nkind" (letrec ((tag->nkind (lambda (t) (let fnrec7743 ((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 fnrec7736 ((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))) + (def-var! "jolt.analyzer" "nhint-of" (letrec ((nhint-of (lambda (ctx sym) (let fnrec7744 ((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 fnrec7737 ((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$7739 (var-deref "clojure.core" "mapv")) (_a$7740 (lambda (a) (let fnrec7738 ((a a)) (if (jolt-truthy? (jolt-get a (keyword #f "ret-nhint"))) a (jolt-assoc a (keyword #f "ret-nhint") kind))))) (_a$7741 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$7739 _a$7740 _a$7741))) node))))) with-ret-nhint))) + (def-var! "jolt.analyzer" "with-ret-nhint" (letrec ((with-ret-nhint (lambda (node kind) (let fnrec7745 ((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$7747 (var-deref "clojure.core" "mapv")) (_a$7748 (lambda (a) (let fnrec7746 ((a a)) (if (jolt-truthy? (jolt-get a (keyword #f "ret-nhint"))) a (jolt-assoc a (keyword #f "ret-nhint") kind))))) (_a$7749 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$7747 _a$7748 _a$7749))) node))))) with-ret-nhint))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "analyze-seq" (letrec ((analyze-seq (lambda (ctx forms env) (let fnrec7742 ((ctx ctx) (forms forms) (env env)) (let* ((v (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__91_) (let fnrec7743 ((p__91_ p__91_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__91_ 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$7744 (var-deref "jolt.ir" "do-node")) (_a$7745 (jolt-invoke (var-deref "clojure.core" "subvec") v 0 (jolt-dec n))) (_a$7746 (jolt-peek v))) (jolt-invoke _a$7744 _a$7745 _a$7746)) jolt-nil)))))))) analyze-seq))) + (def-var! "jolt.analyzer" "analyze-seq" (letrec ((analyze-seq (lambda (ctx forms env) (let fnrec7750 ((ctx ctx) (forms forms) (env env)) (let* ((v (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (p__91_) (let fnrec7751 ((p__91_ p__91_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__91_ 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$7752 (var-deref "jolt.ir" "do-node")) (_a$7753 (jolt-invoke (var-deref "clojure.core" "subvec") v 0 (jolt-dec n))) (_a$7754 (jolt-peek v))) (jolt-invoke _a$7752 _a$7753 _a$7754)) jolt-nil)))))))) analyze-seq))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "analyze-bindings" (letrec ((analyze-bindings (lambda (ctx bvec env) (let fnrec7747 ((ctx ctx) (bvec bvec) (env env)) (let* ((i 0) (env env) (pairs (jolt-vector))) (let loop7748 ((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$7755 (+ i 2)) (_a$7756 (let* ((_a$7749 (var-deref "jolt.analyzer" "add-hint")) (_a$7750 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector nm))) (_a$7751 nm) (_a$7752 (jolt-invoke (var-deref "jolt.analyzer" "hint-of") ctx bsym))) (jolt-invoke _a$7749 _a$7750 _a$7751 _a$7752))) (_a$7757 (jolt-conj pairs (let* ((_o$7753 nm) (_o$7754 init)) (jolt-vector _o$7753 _o$7754))))) (loop7748 _a$7755 _a$7756 _a$7757))))) (let* ((_o$7758 pairs) (_o$7759 env)) (jolt-vector _o$7758 _o$7759))))))))) analyze-bindings))) + (def-var! "jolt.analyzer" "analyze-bindings" (letrec ((analyze-bindings (lambda (ctx bvec env) (let fnrec7755 ((ctx ctx) (bvec bvec) (env env)) (let* ((i 0) (env env) (pairs (jolt-vector))) (let loop7756 ((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$7763 (+ i 2)) (_a$7764 (let* ((_a$7757 (var-deref "jolt.analyzer" "add-hint")) (_a$7758 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector nm))) (_a$7759 nm) (_a$7760 (jolt-invoke (var-deref "jolt.analyzer" "hint-of") ctx bsym))) (jolt-invoke _a$7757 _a$7758 _a$7759 _a$7760))) (_a$7765 (jolt-conj pairs (let* ((_o$7761 nm) (_o$7762 init)) (jolt-vector _o$7761 _o$7762))))) (loop7756 _a$7763 _a$7764 _a$7765))))) (let* ((_o$7766 pairs) (_o$7767 env)) (jolt-vector _o$7766 _o$7767))))))))) analyze-bindings))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "parse-params" (letrec ((parse-params (lambda (ctx pvec) (let fnrec7760 ((ctx ctx) (pvec pvec)) (let* ((i 0) (fixed (jolt-vector)) (rest-name jolt-nil) (hints (jolt-vector)) (phints (jolt-vector)) (nhints (jolt-vector))) (let loop7761 ((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$7762 (+ i 2)) (_a$7763 fixed) (_a$7764 (jolt-invoke (var-deref "jolt.host" "form-sym-name") r)) (_a$7765 hints) (_a$7766 phints) (_a$7767 nhints)) (loop7761 _a$7762 _a$7763 _a$7764 _a$7765 _a$7766 _a$7767)))) (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$7774 (jolt-inc i)) (_a$7775 (jolt-conj fixed nm)) (_a$7776 rest-name) (_a$7777 (if (jolt-truthy? h) (jolt-conj hints (let* ((_o$7768 nm) (_o$7769 h)) (jolt-vector _o$7768 _o$7769))) hints)) (_a$7778 (if (jolt-truthy? ph) (jolt-conj phints (let* ((_o$7770 nm) (_o$7771 ph)) (jolt-vector _o$7770 _o$7771))) phints)) (_a$7779 (if (jolt-truthy? nh) (jolt-conj nhints (let* ((_o$7772 nm) (_o$7773 nh)) (jolt-vector _o$7772 _o$7773))) nhints))) (loop7761 _a$7774 _a$7775 _a$7776 _a$7777 _a$7778 _a$7779)))))) (let* ((_o$7780 (keyword #f "fixed")) (_o$7781 fixed) (_o$7782 (keyword #f "rest")) (_o$7783 rest-name) (_o$7784 (keyword #f "hints")) (_o$7785 hints) (_o$7786 (keyword #f "phints")) (_o$7787 phints) (_o$7788 (keyword #f "nhints")) (_o$7789 nhints)) (jolt-hash-map _o$7780 _o$7781 _o$7782 _o$7783 _o$7784 _o$7785 _o$7786 _o$7787 _o$7788 _o$7789))))))))) parse-params))) + (def-var! "jolt.analyzer" "parse-params" (letrec ((parse-params (lambda (ctx pvec) (let fnrec7768 ((ctx ctx) (pvec pvec)) (let* ((i 0) (fixed (jolt-vector)) (rest-name jolt-nil) (hints (jolt-vector)) (phints (jolt-vector)) (nhints (jolt-vector))) (let loop7769 ((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$7770 (+ i 2)) (_a$7771 fixed) (_a$7772 (jolt-invoke (var-deref "jolt.host" "form-sym-name") r)) (_a$7773 hints) (_a$7774 phints) (_a$7775 nhints)) (loop7769 _a$7770 _a$7771 _a$7772 _a$7773 _a$7774 _a$7775)))) (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$7782 (jolt-inc i)) (_a$7783 (jolt-conj fixed nm)) (_a$7784 rest-name) (_a$7785 (if (jolt-truthy? h) (jolt-conj hints (let* ((_o$7776 nm) (_o$7777 h)) (jolt-vector _o$7776 _o$7777))) hints)) (_a$7786 (if (jolt-truthy? ph) (jolt-conj phints (let* ((_o$7778 nm) (_o$7779 ph)) (jolt-vector _o$7778 _o$7779))) phints)) (_a$7787 (if (jolt-truthy? nh) (jolt-conj nhints (let* ((_o$7780 nm) (_o$7781 nh)) (jolt-vector _o$7780 _o$7781))) nhints))) (loop7769 _a$7782 _a$7783 _a$7784 _a$7785 _a$7786 _a$7787)))))) (let* ((_o$7788 (keyword #f "fixed")) (_o$7789 fixed) (_o$7790 (keyword #f "rest")) (_o$7791 rest-name) (_o$7792 (keyword #f "hints")) (_o$7793 hints) (_o$7794 (keyword #f "phints")) (_o$7795 phints) (_o$7796 (keyword #f "nhints")) (_o$7797 nhints)) (jolt-hash-map _o$7788 _o$7789 _o$7790 _o$7791 _o$7792 _o$7793 _o$7794 _o$7795 _o$7796 _o$7797))))))))) parse-params))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "uniquify-params" (letrec ((uniquify-params (lambda (names) (let fnrec7790 ((names names)) (let* ((n (jolt-count names))) (let* ((i 0) (out (jolt-vector))) (let loop7791 ((i i) (out out)) (if (< i n) (let* ((nm (jolt-nth names i)) (dup? (let* ((j (jolt-inc i))) (let loop7792 ((j j)) (if (>= j n) #f (if (jolt= nm (jolt-nth names j)) #t (if (jolt-truthy? (keyword #f "else")) (loop7792 (jolt-inc j)) jolt-nil))))))) (let* ((_a$7793 (jolt-inc i)) (_a$7794 (jolt-conj out (if (jolt-truthy? dup?) (jolt-invoke (var-deref "jolt.analyzer" "gen-name") (jolt-invoke (var-deref "clojure.core" "str") nm "_")) nm)))) (loop7791 _a$7793 _a$7794))) out)))))))) uniquify-params))) + (def-var! "jolt.analyzer" "uniquify-params" (letrec ((uniquify-params (lambda (names) (let fnrec7798 ((names names)) (let* ((n (jolt-count names))) (let* ((i 0) (out (jolt-vector))) (let loop7799 ((i i) (out out)) (if (< i n) (let* ((nm (jolt-nth names i)) (dup? (let* ((j (jolt-inc i))) (let loop7800 ((j j)) (if (>= j n) #f (if (jolt= nm (jolt-nth names j)) #t (if (jolt-truthy? (keyword #f "else")) (loop7800 (jolt-inc j)) jolt-nil))))))) (let* ((_a$7801 (jolt-inc i)) (_a$7802 (jolt-conj out (if (jolt-truthy? dup?) (jolt-invoke (var-deref "jolt.analyzer" "gen-name") (jolt-invoke (var-deref "clojure.core" "str") nm "_")) nm)))) (loop7799 _a$7801 _a$7802))) out)))))))) uniquify-params))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "analyze-arity" (letrec ((analyze-arity (lambda (ctx pvec body env fn-name) (let fnrec7795 ((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$7796 (var-deref "clojure.core" "str")) (_a$7797 (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (_a$7798 "/") (_a$7799 (let* ((or__26__auto fn-name)) (if (jolt-truthy? or__26__auto) or__26__auto "fn"))) (_a$7800 "--")) (jolt-invoke _a$7796 _a$7797 _a$7798 _a$7799 _a$7800)))) (names (let* ((G__140 (jolt-invoke (var-deref "clojure.core" "vec") fixed))) (let* ((G__141 (if (jolt-truthy? rst) (jolt-conj G__140 rst) G__140))) (let* ((G__142 (if (jolt-truthy? fn-name) (jolt-conj G__141 fn-name) G__141))) G__142)))) (env0 (jolt-invoke (var-deref "jolt.analyzer" "with-recur") (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names) rname)) (env* (let* ((_a$7806 (lambda (e pr) (let fnrec7801 ((e e) (pr pr)) (let* ((_a$7802 (var-deref "jolt.analyzer" "add-hint")) (_a$7803 e) (_a$7804 (jolt-nth pr 0)) (_a$7805 (jolt-nth pr 1))) (jolt-invoke _a$7802 _a$7803 _a$7804 _a$7805))))) (_a$7807 env0) (_a$7808 (jolt-get pp (keyword #f "hints")))) (jolt-reduce _a$7806 _a$7807 _a$7808))) (arity (let* ((_o$7809 (keyword #f "params")) (_o$7810 fixed) (_o$7811 (keyword #f "recur-name")) (_o$7812 rname) (_o$7813 (keyword #f "body")) (_o$7814 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx body env*))) (jolt-hash-map _o$7809 _o$7810 _o$7811 _o$7812 _o$7813 _o$7814))) (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))) + (def-var! "jolt.analyzer" "analyze-arity" (letrec ((analyze-arity (lambda (ctx pvec body env fn-name) (let fnrec7803 ((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$7804 (var-deref "clojure.core" "str")) (_a$7805 (jolt-invoke (var-deref "jolt.host" "compile-ns") ctx)) (_a$7806 "/") (_a$7807 (let* ((or__26__auto fn-name)) (if (jolt-truthy? or__26__auto) or__26__auto "fn"))) (_a$7808 "--")) (jolt-invoke _a$7804 _a$7805 _a$7806 _a$7807 _a$7808)))) (names (let* ((G__140 (jolt-invoke (var-deref "clojure.core" "vec") fixed))) (let* ((G__141 (if (jolt-truthy? rst) (jolt-conj G__140 rst) G__140))) (let* ((G__142 (if (jolt-truthy? fn-name) (jolt-conj G__141 fn-name) G__141))) G__142)))) (env0 (jolt-invoke (var-deref "jolt.analyzer" "with-recur") (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names) rname)) (env* (let* ((_a$7814 (lambda (e pr) (let fnrec7809 ((e e) (pr pr)) (let* ((_a$7810 (var-deref "jolt.analyzer" "add-hint")) (_a$7811 e) (_a$7812 (jolt-nth pr 0)) (_a$7813 (jolt-nth pr 1))) (jolt-invoke _a$7810 _a$7811 _a$7812 _a$7813))))) (_a$7815 env0) (_a$7816 (jolt-get pp (keyword #f "hints")))) (jolt-reduce _a$7814 _a$7815 _a$7816))) (arity (let* ((_o$7817 (keyword #f "params")) (_o$7818 fixed) (_o$7819 (keyword #f "recur-name")) (_o$7820 rname) (_o$7821 (keyword #f "body")) (_o$7822 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx body env*))) (jolt-hash-map _o$7817 _o$7818 _o$7819 _o$7820 _o$7821 _o$7822))) (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 fnrec7815 ((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))) + (def-var! "jolt.analyzer" "strip-arglist-meta" (letrec ((strip-arglist-meta (lambda (form) (let fnrec7823 ((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 fnrec7816 ((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 fnrec7817 ((clause clause)) (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") clause)))) (let* ((_a$7818 (var-deref "jolt.analyzer" "analyze-arity")) (_a$7819 ctx) (_a$7820 (jolt-invoke (var-deref "jolt.analyzer" "strip-arglist-meta") (jolt-first cl))) (_a$7821 (jolt-rest cl)) (_a$7822 env) (_a$7823 fn-name)) (jolt-invoke _a$7818 _a$7819 _a$7820 _a$7821 _a$7822 _a$7823))))) rest-items)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "fn: bad params") jolt-nil)))))))) analyze-fn))) + (def-var! "jolt.analyzer" "analyze-fn" (letrec ((analyze-fn (lambda (ctx items env) (let fnrec7824 ((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 fnrec7825 ((clause clause)) (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") clause)))) (let* ((_a$7826 (var-deref "jolt.analyzer" "analyze-arity")) (_a$7827 ctx) (_a$7828 (jolt-invoke (var-deref "jolt.analyzer" "strip-arglist-meta") (jolt-first cl))) (_a$7829 (jolt-rest cl)) (_a$7830 env) (_a$7831 fn-name)) (jolt-invoke _a$7826 _a$7827 _a$7828 _a$7829 _a$7830 _a$7831))))) 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$7824 "Throwable") (_o$7825 "java.lang.Throwable") (_o$7826 "Object") (_o$7827 "java.lang.Object")) (jolt-hash-set _o$7824 _o$7825 _o$7826 _o$7827)) (let* ((_o$7828 (keyword #f "private")) (_o$7829 #t)) (jolt-hash-map _o$7828 _o$7829)))) + (def-var-with-meta! "jolt.analyzer" "catch-all-names" (let* ((_o$7832 "Throwable") (_o$7833 "java.lang.Throwable") (_o$7834 "Object") (_o$7835 "java.lang.Object")) (jolt-hash-set _o$7832 _o$7833 _o$7834 _o$7835)) (let* ((_o$7836 (keyword #f "private")) (_o$7837 #t)) (jolt-hash-map _o$7836 _o$7837)))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "analyze-try" (letrec ((analyze-try (lambda (ctx items env) (let fnrec7830 ((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 fnrec7831 ((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 (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$7832 (keyword #f "op")) (_o$7833 (keyword #f "try")) (_o$7834 (keyword #f "body")) (_o$7835 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-invoke (var-deref "clojure.core" "deref") body) env))) (jolt-hash-map _o$7832 _o$7833 _o$7834 _o$7835))) (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$7840 (lambda (_else cl) (let fnrec7836 ((_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$7837 (jolt-symbol #f "or")) (_a$7838 (jolt-list (jolt-symbol #f "instance?") cform evar)) (_a$7839 (jolt-list (jolt-symbol #f "__catch-broad?") fullname evar))) (jolt-list _a$7837 _a$7838 _a$7839)) letform _else)))))) (_a$7841 (jolt-list (jolt-symbol #f "throw") evar)) (_a$7842 (jolt-reverse (jolt-invoke (var-deref "clojure.core" "deref") catches)))) (jolt-reduce _a$7840 _a$7841 _a$7842)))) (jolt-assoc n (keyword #f "catch-sym") evar-name (keyword #f "catch-body") (let* ((_a$7843 (var-deref "jolt.analyzer" "analyze-seq")) (_a$7844 ctx) (_a$7845 (jolt-list dispatch)) (_a$7846 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector evar-name)))) (jolt-invoke _a$7843 _a$7844 _a$7845 _a$7846)))) 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))) + (def-var! "jolt.analyzer" "analyze-try" (letrec ((analyze-try (lambda (ctx items env) (let fnrec7838 ((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 fnrec7839 ((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 (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$7840 (keyword #f "op")) (_o$7841 (keyword #f "try")) (_o$7842 (keyword #f "body")) (_o$7843 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-invoke (var-deref "clojure.core" "deref") body) env))) (jolt-hash-map _o$7840 _o$7841 _o$7842 _o$7843))) (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$7848 (lambda (_else cl) (let fnrec7844 ((_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$7845 (jolt-symbol #f "or")) (_a$7846 (jolt-list (jolt-symbol #f "instance?") cform evar)) (_a$7847 (jolt-list (jolt-symbol #f "__catch-broad?") fullname evar))) (jolt-list _a$7845 _a$7846 _a$7847)) letform _else)))))) (_a$7849 (jolt-list (jolt-symbol #f "throw") evar)) (_a$7850 (jolt-reverse (jolt-invoke (var-deref "clojure.core" "deref") catches)))) (jolt-reduce _a$7848 _a$7849 _a$7850)))) (jolt-assoc n (keyword #f "catch-sym") evar-name (keyword #f "catch-body") (let* ((_a$7851 (var-deref "jolt.analyzer" "analyze-seq")) (_a$7852 ctx) (_a$7853 (jolt-list dispatch)) (_a$7854 (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env (jolt-vector evar-name)))) (jolt-invoke _a$7851 _a$7852 _a$7853 _a$7854)))) 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 fnrec7847 ((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__92_) (let fnrec7848 ((p__92_ p__92_)) (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__92_)))))) specs)) (env* (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names)) (binds (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (spec) (let fnrec7849 ((spec spec)) (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") spec)))) (let* ((_o$7850 (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first cl))) (_o$7851 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-cons (jolt-invoke (var-deref "clojure.core" "symbol") "fn") cl) env*))) (jolt-vector _o$7850 _o$7851))))) specs))) (let* ((_o$7852 (keyword #f "op")) (_o$7853 (keyword #f "let")) (_o$7854 (keyword #f "letrec")) (_o$7855 #t) (_o$7856 (keyword #f "bindings")) (_o$7857 binds) (_o$7858 (keyword #f "body")) (_o$7859 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env*))) (jolt-hash-map _o$7852 _o$7853 _o$7854 _o$7855 _o$7856 _o$7857 _o$7858 _o$7859))))))) analyze-letfn))) + (def-var! "jolt.analyzer" "analyze-letfn" (letrec ((analyze-letfn (lambda (ctx items env) (let fnrec7855 ((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__92_) (let fnrec7856 ((p__92_ p__92_)) (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__92_)))))) specs)) (env* (jolt-invoke (var-deref "jolt.analyzer" "add-locals") env names)) (binds (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (spec) (let fnrec7857 ((spec spec)) (let* ((cl (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "jolt.host" "form-elements") spec)))) (let* ((_o$7858 (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-first cl))) (_o$7859 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-cons (jolt-invoke (var-deref "clojure.core" "symbol") "fn") cl) env*))) (jolt-vector _o$7858 _o$7859))))) specs))) (let* ((_o$7860 (keyword #f "op")) (_o$7861 (keyword #f "let")) (_o$7862 (keyword #f "letrec")) (_o$7863 #t) (_o$7864 (keyword #f "bindings")) (_o$7865 binds) (_o$7866 (keyword #f "body")) (_o$7867 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env*))) (jolt-hash-map _o$7860 _o$7861 _o$7862 _o$7863 _o$7864 _o$7865 _o$7866 _o$7867))))))) analyze-letfn))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "field-head?" (letrec ((field-head? (lambda (nm) (let fnrec7860 ((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?))) + (def-var! "jolt.analyzer" "field-head?" (letrec ((field-head? (lambda (nm) (let fnrec7868 ((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 fnrec7861 ((ctx ctx) (base base) (env env)) (if (jolt-pos? (jolt-count base)) (jolt-invoke (var-deref "jolt.ir" "map-node") (let* ((_a$7865 (var-deref "clojure.core" "mapv")) (_a$7866 (lambda (p) (let fnrec7862 ((p p)) (let* ((k (jolt-first p)) (v (jolt-invoke (var-deref "clojure.core" "second") p))) (let* ((_o$7863 (jolt-invoke (var-deref "jolt.ir" "const") k)) (_o$7864 (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$7863 _o$7864)))))) (_a$7867 (jolt-seq base))) (jolt-invoke _a$7865 _a$7866 _a$7867))) jolt-nil))))) def-meta-expr))) + (def-var! "jolt.analyzer" "def-meta-expr" (letrec ((def-meta-expr (lambda (ctx base env) (let fnrec7869 ((ctx ctx) (base base) (env env)) (if (jolt-pos? (jolt-count base)) (jolt-invoke (var-deref "jolt.ir" "map-node") (let* ((_a$7873 (var-deref "clojure.core" "mapv")) (_a$7874 (lambda (p) (let fnrec7870 ((p p)) (let* ((k (jolt-first p)) (v (jolt-invoke (var-deref "clojure.core" "second") p))) (let* ((_o$7871 (jolt-invoke (var-deref "jolt.ir" "const") k)) (_o$7872 (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$7871 _o$7872)))))) (_a$7875 (jolt-seq base))) (jolt-invoke _a$7873 _a$7874 _a$7875))) jolt-nil))))) def-meta-expr))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "analyze-def" (letrec ((analyze-def (lambda (ctx items env) (let fnrec7868 ((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$7869 (keyword #f "op")) (_o$7870 (keyword #f "def")) (_o$7871 (keyword #f "ns")) (_o$7872 cur) (_o$7873 (keyword #f "name")) (_o$7874 nm) (_o$7875 (keyword #f "no-init")) (_o$7876 #t)) (jolt-hash-map _o$7869 _o$7870 _o$7871 _o$7872 _o$7873 _o$7874 _o$7875 _o$7876)))) (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$7877 (var-deref "jolt.analyzer" "with-ret-nhint")) (_a$7878 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx val-form env)) (_a$7879 (jolt-invoke (var-deref "jolt.analyzer" "tag->nkind") tag))) (jolt-invoke _a$7877 _a$7878 _a$7879)) 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))) + (def-var! "jolt.analyzer" "analyze-def" (letrec ((analyze-def (lambda (ctx items env) (let fnrec7876 ((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$7877 (keyword #f "op")) (_o$7878 (keyword #f "def")) (_o$7879 (keyword #f "ns")) (_o$7880 cur) (_o$7881 (keyword #f "name")) (_o$7882 nm) (_o$7883 (keyword #f "no-init")) (_o$7884 #t)) (jolt-hash-map _o$7877 _o$7878 _o$7879 _o$7880 _o$7881 _o$7882 _o$7883 _o$7884)))) (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$7885 (var-deref "jolt.analyzer" "with-ret-nhint")) (_a$7886 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx val-form env)) (_a$7887 (jolt-invoke (var-deref "jolt.analyzer" "tag->nkind") tag))) (jolt-invoke _a$7885 _a$7886 _a$7887)) 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 fnrec7880 ((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$7881 (keyword #f "op")) (_o$7882 (keyword #f "set-field")) (_o$7883 (keyword #f "obj")) (_o$7884 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth ti 1) env)) (_o$7885 (keyword #f "field")) (_o$7886 (jolt-invoke (var-deref "clojure.core" "subs") thead 2)) (_o$7887 (keyword #f "val")) (_o$7888 val-node)) (jolt-hash-map _o$7881 _o$7882 _o$7883 _o$7884 _o$7885 _o$7886 _o$7887 _o$7888)) (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$7892 (var-deref "jolt.ir" "invoke")) (_a$7893 (jolt-invoke (var-deref "jolt.ir" "var-ref") "jolt.host" "set-static-field!")) (_a$7894 (let* ((_o$7889 (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$7890 (jolt-invoke (var-deref "jolt.ir" "const") (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth ti 2)))) (_o$7891 val-node)) (jolt-vector _o$7889 _o$7890 _o$7891)))) (jolt-invoke _a$7892 _a$7893 _a$7894)) (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$7898 (keyword #f "op")) (_o$7899 (keyword #f "set-var")) (_o$7900 (keyword #f "the-var")) (_o$7901 (let* ((_a$7895 (var-deref "jolt.ir" "the-var")) (_a$7896 (jolt-get r (keyword #f "ns"))) (_a$7897 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$7895 _a$7896 _a$7897))) (_o$7902 (keyword #f "val")) (_o$7903 val-node)) (jolt-hash-map _o$7898 _o$7899 _o$7900 _o$7901 _o$7902 _o$7903))))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "set! of an unsupported target") jolt-nil))))))))) analyze-set!))) + (def-var! "jolt.analyzer" "analyze-set!" (letrec ((analyze-set! (lambda (ctx items env) (let fnrec7888 ((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$7889 (keyword #f "op")) (_o$7890 (keyword #f "set-field")) (_o$7891 (keyword #f "obj")) (_o$7892 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth ti 1) env)) (_o$7893 (keyword #f "field")) (_o$7894 (jolt-invoke (var-deref "clojure.core" "subs") thead 2)) (_o$7895 (keyword #f "val")) (_o$7896 val-node)) (jolt-hash-map _o$7889 _o$7890 _o$7891 _o$7892 _o$7893 _o$7894 _o$7895 _o$7896)) (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$7900 (var-deref "jolt.ir" "invoke")) (_a$7901 (jolt-invoke (var-deref "jolt.ir" "var-ref") "jolt.host" "set-static-field!")) (_a$7902 (let* ((_o$7897 (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$7898 (jolt-invoke (var-deref "jolt.ir" "const") (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth ti 2)))) (_o$7899 val-node)) (jolt-vector _o$7897 _o$7898 _o$7899)))) (jolt-invoke _a$7900 _a$7901 _a$7902)) (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$7906 (keyword #f "op")) (_o$7907 (keyword #f "set-var")) (_o$7908 (keyword #f "the-var")) (_o$7909 (let* ((_a$7903 (var-deref "jolt.ir" "the-var")) (_a$7904 (jolt-get r (keyword #f "ns"))) (_a$7905 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$7903 _a$7904 _a$7905))) (_o$7910 (keyword #f "val")) (_o$7911 val-node)) (jolt-hash-map _o$7906 _o$7907 _o$7908 _o$7909 _o$7910 _o$7911))))) (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 fnrec7904 ((ctx ctx) (op op) (items items) (env env)) (let* ((G__143 op)) (if (jolt= G__143 "quote") (jolt-invoke (var-deref "jolt.ir" "quote-node") (jolt-invoke (var-deref "clojure.core" "second") items)) (if (jolt= G__143 "if") (begin (if (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$7905 (var-deref "jolt.ir" "if-node")) (_a$7906 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_a$7907 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 2) env)) (_a$7908 (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$7905 _a$7906 _a$7907 _a$7908))) (if (jolt= G__143 "do") (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-rest items) env) (if (jolt= G__143 "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__143 "def") (jolt-invoke (var-deref "jolt.analyzer" "analyze-def") ctx items env) (if (jolt= G__143 "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$7913 (var-deref "jolt.ir" "let-node")) (_a$7914 (jolt-first r)) (_a$7915 (let* ((_a$7909 (var-deref "jolt.analyzer" "analyze-seq")) (_a$7910 ctx) (_a$7911 (jolt-drop 2 items)) (_a$7912 (jolt-invoke (var-deref "clojure.core" "second") r))) (jolt-invoke _a$7909 _a$7910 _a$7911 _a$7912)))) (jolt-invoke _a$7913 _a$7914 _a$7915))) (if (jolt= G__143 "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$7916 (keyword #f "op")) (_o$7917 (keyword #f "loop")) (_o$7918 (keyword #f "recur-name")) (_o$7919 rname) (_o$7920 (keyword #f "bindings")) (_o$7921 (jolt-first r)) (_o$7922 (keyword #f "body")) (_o$7923 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env**))) (jolt-hash-map _o$7916 _o$7917 _o$7918 _o$7919 _o$7920 _o$7921 _o$7922 _o$7923))) (if (jolt= G__143 "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$7928 (keyword #f "op")) (_o$7929 (keyword #f "recur")) (_o$7930 (keyword #f "recur-name")) (_o$7931 rt) (_o$7932 (keyword #f "args")) (_o$7933 (let* ((_a$7925 (var-deref "clojure.core" "mapv")) (_a$7926 (lambda (p__93_) (let fnrec7924 ((p__93_ p__93_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__93_ env)))) (_a$7927 (jolt-rest items))) (jolt-invoke _a$7925 _a$7926 _a$7927)))) (jolt-hash-map _o$7928 _o$7929 _o$7930 _o$7931 _o$7932 _o$7933)))) (if (jolt= G__143 "try") (jolt-invoke (var-deref "jolt.analyzer" "analyze-try") ctx items env) (if (jolt= G__143 "letfn") (jolt-invoke (var-deref "jolt.analyzer" "analyze-letfn") ctx items env) (if (jolt= G__143 "fn*") (jolt-invoke (var-deref "jolt.analyzer" "analyze-fn") ctx items env) (if (jolt= G__143 "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__143 "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$7934 (var-deref "jolt.ir" "the-var")) (_a$7935 (jolt-get r (keyword #f "ns"))) (_a$7936 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$7934 _a$7935 _a$7936)) (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__143 "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$7937 (keyword #f "op")) (_o$7938 (keyword #f "defmacro")) (_o$7939 (keyword #f "ns")) (_o$7940 cur) (_o$7941 (keyword #f "name")) (_o$7942 nm) (_o$7943 (keyword #f "fn")) (_o$7944 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx fn-form env))) (jolt-hash-map _o$7937 _o$7938 _o$7939 _o$7940 _o$7941 _o$7942 _o$7943 _o$7944)))) (if (jolt= G__143 "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))) + (def-var! "jolt.analyzer" "analyze-special" (letrec ((analyze-special (lambda (ctx op items env) (let fnrec7912 ((ctx ctx) (op op) (items items) (env env)) (let* ((G__143 op)) (if (jolt= G__143 "quote") (jolt-invoke (var-deref "jolt.ir" "quote-node") (jolt-invoke (var-deref "clojure.core" "second") items)) (if (jolt= G__143 "if") (begin (if (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$7913 (var-deref "jolt.ir" "if-node")) (_a$7914 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_a$7915 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 2) env)) (_a$7916 (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$7913 _a$7914 _a$7915 _a$7916))) (if (jolt= G__143 "do") (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-rest items) env) (if (jolt= G__143 "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__143 "def") (jolt-invoke (var-deref "jolt.analyzer" "analyze-def") ctx items env) (if (jolt= G__143 "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$7921 (var-deref "jolt.ir" "let-node")) (_a$7922 (jolt-first r)) (_a$7923 (let* ((_a$7917 (var-deref "jolt.analyzer" "analyze-seq")) (_a$7918 ctx) (_a$7919 (jolt-drop 2 items)) (_a$7920 (jolt-invoke (var-deref "clojure.core" "second") r))) (jolt-invoke _a$7917 _a$7918 _a$7919 _a$7920)))) (jolt-invoke _a$7921 _a$7922 _a$7923))) (if (jolt= G__143 "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$7924 (keyword #f "op")) (_o$7925 (keyword #f "loop")) (_o$7926 (keyword #f "recur-name")) (_o$7927 rname) (_o$7928 (keyword #f "bindings")) (_o$7929 (jolt-first r)) (_o$7930 (keyword #f "body")) (_o$7931 (jolt-invoke (var-deref "jolt.analyzer" "analyze-seq") ctx (jolt-drop 2 items) env**))) (jolt-hash-map _o$7924 _o$7925 _o$7926 _o$7927 _o$7928 _o$7929 _o$7930 _o$7931))) (if (jolt= G__143 "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$7936 (keyword #f "op")) (_o$7937 (keyword #f "recur")) (_o$7938 (keyword #f "recur-name")) (_o$7939 rt) (_o$7940 (keyword #f "args")) (_o$7941 (let* ((_a$7933 (var-deref "clojure.core" "mapv")) (_a$7934 (lambda (p__93_) (let fnrec7932 ((p__93_ p__93_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__93_ env)))) (_a$7935 (jolt-rest items))) (jolt-invoke _a$7933 _a$7934 _a$7935)))) (jolt-hash-map _o$7936 _o$7937 _o$7938 _o$7939 _o$7940 _o$7941)))) (if (jolt= G__143 "try") (jolt-invoke (var-deref "jolt.analyzer" "analyze-try") ctx items env) (if (jolt= G__143 "letfn") (jolt-invoke (var-deref "jolt.analyzer" "analyze-letfn") ctx items env) (if (jolt= G__143 "fn*") (jolt-invoke (var-deref "jolt.analyzer" "analyze-fn") ctx items env) (if (jolt= G__143 "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__143 "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$7942 (var-deref "jolt.ir" "the-var")) (_a$7943 (jolt-get r (keyword #f "ns"))) (_a$7944 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$7942 _a$7943 _a$7944)) (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__143 "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$7945 (keyword #f "op")) (_o$7946 (keyword #f "defmacro")) (_o$7947 (keyword #f "ns")) (_o$7948 cur) (_o$7949 (keyword #f "name")) (_o$7950 nm) (_o$7951 (keyword #f "fn")) (_o$7952 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx fn-form env))) (jolt-hash-map _o$7945 _o$7946 _o$7947 _o$7948 _o$7949 _o$7950 _o$7951 _o$7952)))) (if (jolt= G__143 "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 fnrec7945 ((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?))) + (def-var! "jolt.analyzer" "method-head?" (letrec ((method-head? (lambda (nm) (let fnrec7953 ((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 fnrec7946 ((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$7951 (keyword #f "op")) (_o$7952 (keyword #f "host-call")) (_o$7953 (keyword #f "method")) (_o$7954 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$7955 (keyword #f "target")) (_o$7956 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$7957 (keyword #f "args")) (_o$7958 (let* ((_a$7948 (var-deref "clojure.core" "mapv")) (_a$7949 (lambda (p__94_) (let fnrec7947 ((p__94_ p__94_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__94_ env)))) (_a$7950 (jolt-drop 2 items))) (jolt-invoke _a$7948 _a$7949 _a$7950)))) (jolt-hash-map _o$7951 _o$7952 _o$7953 _o$7954 _o$7955 _o$7956 _o$7957 _o$7958))))))) analyze-host-call))) + (def-var! "jolt.analyzer" "analyze-host-call" (letrec ((analyze-host-call (lambda (ctx hname items env) (let fnrec7954 ((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$7959 (keyword #f "op")) (_o$7960 (keyword #f "host-call")) (_o$7961 (keyword #f "method")) (_o$7962 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$7963 (keyword #f "target")) (_o$7964 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$7965 (keyword #f "args")) (_o$7966 (let* ((_a$7956 (var-deref "clojure.core" "mapv")) (_a$7957 (lambda (p__94_) (let fnrec7955 ((p__94_ p__94_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__94_ env)))) (_a$7958 (jolt-drop 2 items))) (jolt-invoke _a$7956 _a$7957 _a$7958)))) (jolt-hash-map _o$7959 _o$7960 _o$7961 _o$7962 _o$7963 _o$7964 _o$7965 _o$7966))))))) analyze-host-call))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "ctor-head?" (letrec ((ctor-head? (lambda (nm) (let fnrec7959 ((nm nm)) (let* ((and__25__auto (> (jolt-count nm) 1))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "." (let* ((_a$7960 (var-deref "clojure.core" "subs")) (_a$7961 nm) (_a$7962 (jolt-dec (jolt-count nm))) (_a$7963 (jolt-count nm))) (jolt-invoke _a$7960 _a$7961 _a$7962 _a$7963))))) (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?))) + (def-var! "jolt.analyzer" "ctor-head?" (letrec ((ctor-head? (lambda (nm) (let fnrec7967 ((nm nm)) (let* ((and__25__auto (> (jolt-count nm) 1))) (if (jolt-truthy? and__25__auto) (let* ((and__25__auto (jolt= "." (let* ((_a$7968 (var-deref "clojure.core" "subs")) (_a$7969 nm) (_a$7970 (jolt-dec (jolt-count nm))) (_a$7971 (jolt-count nm))) (jolt-invoke _a$7968 _a$7969 _a$7970 _a$7971))))) (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 fnrec7964 ((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__95_) (let fnrec7965 ((p__95_ p__95_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__95_ env))) args)))))) analyze-ctor))) + (def-var! "jolt.analyzer" "analyze-ctor" (letrec ((analyze-ctor (lambda (ctx class args env) (let fnrec7972 ((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__95_) (let fnrec7973 ((p__95_ p__95_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__95_ env))) args)))))) analyze-ctor))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "analyze-ffi-fn" (letrec ((analyze-ffi-fn (lambda (ctx items env) (let fnrec7966 ((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$7967 (keyword #f "op")) (_o$7968 (keyword #f "ffi-fn")) (_o$7969 (keyword #f "csym")) (_o$7970 (jolt-nth items 1)) (_o$7971 (keyword #f "argtypes")) (_o$7972 (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$7973 (keyword #f "rettype")) (_o$7974 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$7975 (keyword #f "blocking")) (_o$7976 (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$7967 _o$7968 _o$7969 _o$7970 _o$7971 _o$7972 _o$7973 _o$7974 _o$7975 _o$7976))))))) analyze-ffi-fn))) + (def-var! "jolt.analyzer" "analyze-ffi-fn" (letrec ((analyze-ffi-fn (lambda (ctx items env) (let fnrec7974 ((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$7975 (keyword #f "op")) (_o$7976 (keyword #f "ffi-fn")) (_o$7977 (keyword #f "csym")) (_o$7978 (jolt-nth items 1)) (_o$7979 (keyword #f "argtypes")) (_o$7980 (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$7981 (keyword #f "rettype")) (_o$7982 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$7983 (keyword #f "blocking")) (_o$7984 (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$7975 _o$7976 _o$7977 _o$7978 _o$7979 _o$7980 _o$7981 _o$7982 _o$7983 _o$7984))))))) analyze-ffi-fn))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "analyze-ffi-callable" (letrec ((analyze-ffi-callable (lambda (ctx items env) (let fnrec7977 ((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$7978 (keyword #f "op")) (_o$7979 (keyword #f "ffi-callable")) (_o$7980 (keyword #f "fn")) (_o$7981 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$7982 (keyword #f "argtypes")) (_o$7983 (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$7984 (keyword #f "rettype")) (_o$7985 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$7986 (keyword #f "collect-safe")) (_o$7987 (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$7978 _o$7979 _o$7980 _o$7981 _o$7982 _o$7983 _o$7984 _o$7985 _o$7986 _o$7987))))))) analyze-ffi-callable))) + (def-var! "jolt.analyzer" "analyze-ffi-callable" (letrec ((analyze-ffi-callable (lambda (ctx items env) (let fnrec7985 ((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$7986 (keyword #f "op")) (_o$7987 (keyword #f "ffi-callable")) (_o$7988 (keyword #f "fn")) (_o$7989 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$7990 (keyword #f "argtypes")) (_o$7991 (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$7992 (keyword #f "rettype")) (_o$7993 (jolt-invoke (var-deref "clojure.core" "name") (jolt-nth items 3))) (_o$7994 (keyword #f "collect-safe")) (_o$7995 (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$7986 _o$7987 _o$7988 _o$7989 _o$7990 _o$7991 _o$7992 _o$7993 _o$7994 _o$7995))))))) analyze-ffi-callable))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "analyze-dot" (letrec ((analyze-dot (lambda (ctx items env) (let fnrec7988 ((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$7993 (var-deref "jolt.ir" "invoke")) (_a$7994 (jolt-invoke (var-deref "jolt.ir" "host-static") class-target (jolt-invoke (var-deref "jolt.host" "form-sym-name") member))) (_a$7995 (let* ((_a$7990 (var-deref "clojure.core" "mapv")) (_a$7991 (lambda (p__96_) (let fnrec7989 ((p__96_ p__96_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__96_ env)))) (_a$7992 (jolt-drop 3 items))) (jolt-invoke _a$7990 _a$7991 _a$7992)))) (jolt-invoke _a$7993 _a$7994 _a$7995)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") member)) (let* ((_o$8000 (keyword #f "op")) (_o$8001 (keyword #f "host-call")) (_o$8002 (keyword #f "method")) (_o$8003 (jolt-invoke (var-deref "jolt.host" "form-sym-name") member)) (_o$8004 (keyword #f "target")) (_o$8005 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx target env)) (_o$8006 (keyword #f "args")) (_o$8007 (let* ((_a$7997 (var-deref "clojure.core" "mapv")) (_a$7998 (lambda (p__97_) (let fnrec7996 ((p__97_ p__97_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__97_ env)))) (_a$7999 (jolt-drop 3 items))) (jolt-invoke _a$7997 _a$7998 _a$7999)))) (jolt-hash-map _o$8000 _o$8001 _o$8002 _o$8003 _o$8004 _o$8005 _o$8006 _o$8007)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-keyword?") member)) (let* ((_a$8008 (var-deref "jolt.ir" "invoke")) (_a$8009 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx member env)) (_a$8010 (jolt-vector (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)))) (jolt-invoke _a$8008 _a$8009 _a$8010)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "special form . (non-symbol member)") jolt-nil)))))))))) analyze-dot))) + (def-var! "jolt.analyzer" "analyze-dot" (letrec ((analyze-dot (lambda (ctx items env) (let fnrec7996 ((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$8001 (var-deref "jolt.ir" "invoke")) (_a$8002 (jolt-invoke (var-deref "jolt.ir" "host-static") class-target (jolt-invoke (var-deref "jolt.host" "form-sym-name") member))) (_a$8003 (let* ((_a$7998 (var-deref "clojure.core" "mapv")) (_a$7999 (lambda (p__96_) (let fnrec7997 ((p__96_ p__96_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__96_ env)))) (_a$8000 (jolt-drop 3 items))) (jolt-invoke _a$7998 _a$7999 _a$8000)))) (jolt-invoke _a$8001 _a$8002 _a$8003)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-sym?") member)) (let* ((_o$8008 (keyword #f "op")) (_o$8009 (keyword #f "host-call")) (_o$8010 (keyword #f "method")) (_o$8011 (jolt-invoke (var-deref "jolt.host" "form-sym-name") member)) (_o$8012 (keyword #f "target")) (_o$8013 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx target env)) (_o$8014 (keyword #f "args")) (_o$8015 (let* ((_a$8005 (var-deref "clojure.core" "mapv")) (_a$8006 (lambda (p__97_) (let fnrec8004 ((p__97_ p__97_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__97_ env)))) (_a$8007 (jolt-drop 3 items))) (jolt-invoke _a$8005 _a$8006 _a$8007)))) (jolt-hash-map _o$8008 _o$8009 _o$8010 _o$8011 _o$8012 _o$8013 _o$8014 _o$8015)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-keyword?") member)) (let* ((_a$8016 (var-deref "jolt.ir" "invoke")) (_a$8017 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx member env)) (_a$8018 (jolt-vector (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)))) (jolt-invoke _a$8016 _a$8017 _a$8018)) (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 fnrec8011 ((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$8012 (keyword #f "op")) (_o$8013 (keyword #f "host-call")) (_o$8014 (keyword #f "method")) (_o$8015 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$8016 (keyword #f "target")) (_o$8017 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$8018 (keyword #f "args")) (_o$8019 (jolt-vector))) (jolt-hash-map _o$8012 _o$8013 _o$8014 _o$8015 _o$8016 _o$8017 _o$8018 _o$8019))))))) analyze-field))) + (def-var! "jolt.analyzer" "analyze-field" (letrec ((analyze-field (lambda (ctx hname items env) (let fnrec8019 ((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$8020 (keyword #f "op")) (_o$8021 (keyword #f "host-call")) (_o$8022 (keyword #f "method")) (_o$8023 (jolt-invoke (var-deref "clojure.core" "subs") hname 1)) (_o$8024 (keyword #f "target")) (_o$8025 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx (jolt-nth items 1) env)) (_o$8026 (keyword #f "args")) (_o$8027 (jolt-vector))) (jolt-hash-map _o$8020 _o$8021 _o$8022 _o$8023 _o$8024 _o$8025 _o$8026 _o$8027))))))) analyze-field))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "analyze-symbol" (letrec ((analyze-symbol (lambda (ctx form env) (let fnrec8020 ((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-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__144 (let* ((_a$8021 (var-deref "jolt.ir" "var-ref")) (_a$8022 (jolt-get r (keyword #f "ns"))) (_a$8023 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8021 _a$8022 _a$8023)))) (let* ((G__145 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__144 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__144))) G__145)) (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__146 (jolt-get r (keyword #f "kind")))) (if (jolt= G__146 (keyword #f "var")) (let* ((G__147 (let* ((_a$8024 (var-deref "jolt.ir" "var-ref")) (_a$8025 (jolt-get r (keyword #f "ns"))) (_a$8026 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8024 _a$8025 _a$8026)))) (let* ((G__148 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__147 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__147))) G__148)) (if (jolt= G__146 (keyword #f "host")) (jolt-invoke (var-deref "jolt.ir" "host-ref") (jolt-get r (keyword #f "name"))) (if (jolt= G__146 (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))) + (def-var! "jolt.analyzer" "analyze-symbol" (letrec ((analyze-symbol (lambda (ctx form env) (let fnrec8028 ((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-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__144 (let* ((_a$8029 (var-deref "jolt.ir" "var-ref")) (_a$8030 (jolt-get r (keyword #f "ns"))) (_a$8031 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8029 _a$8030 _a$8031)))) (let* ((G__145 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__144 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__144))) G__145)) (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__146 (jolt-get r (keyword #f "kind")))) (if (jolt= G__146 (keyword #f "var")) (let* ((G__147 (let* ((_a$8032 (var-deref "jolt.ir" "var-ref")) (_a$8033 (jolt-get r (keyword #f "ns"))) (_a$8034 (jolt-get r (keyword #f "name")))) (jolt-invoke _a$8032 _a$8033 _a$8034)))) (let* ((G__148 (if (jolt-truthy? (jolt-get r (keyword #f "num-ret"))) (jolt-assoc G__147 (keyword #f "num-ret") (jolt-get r (keyword #f "num-ret"))) G__147))) G__148)) (if (jolt= G__146 (keyword #f "host")) (jolt-invoke (var-deref "jolt.ir" "host-ref") (jolt-get r (keyword #f "name"))) (if (jolt= G__146 (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 fnrec8027 ((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-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$8028 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$8029 ctx) (_a$8030 (jolt-invoke (var-deref "clojure.core" "subs") hname 0 (jolt-dec (jolt-count hname)))) (_a$8031 (jolt-rest items)) (_a$8032 env)) (jolt-invoke _a$8028 _a$8029 _a$8030 _a$8031 _a$8032)) (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$8033 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$8034 ctx) (_a$8035 (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth items 1))) (_a$8036 (jolt-drop 2 items)) (_a$8037 env)) (jolt-invoke _a$8033 _a$8034 _a$8035 _a$8036 _a$8037)) (if (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$8042 (var-deref "jolt.ir" "invoke")) (_a$8043 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx head env)) (_a$8044 (let* ((_a$8039 (var-deref "clojure.core" "mapv")) (_a$8040 (lambda (p__98_) (let fnrec8038 ((p__98_ p__98_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__98_ env)))) (_a$8041 (jolt-rest items))) (jolt-invoke _a$8039 _a$8040 _a$8041)))) (jolt-invoke _a$8042 _a$8043 _a$8044))) (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))) + (def-var! "jolt.analyzer" "analyze-list" (letrec ((analyze-list (lambda (ctx form env) (let fnrec8035 ((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-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$8036 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$8037 ctx) (_a$8038 (jolt-invoke (var-deref "clojure.core" "subs") hname 0 (jolt-dec (jolt-count hname)))) (_a$8039 (jolt-rest items)) (_a$8040 env)) (jolt-invoke _a$8036 _a$8037 _a$8038 _a$8039 _a$8040)) (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$8041 (var-deref "jolt.analyzer" "analyze-ctor")) (_a$8042 ctx) (_a$8043 (jolt-invoke (var-deref "jolt.host" "form-sym-name") (jolt-nth items 1))) (_a$8044 (jolt-drop 2 items)) (_a$8045 env)) (jolt-invoke _a$8041 _a$8042 _a$8043 _a$8044 _a$8045)) (if (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$8050 (var-deref "jolt.ir" "invoke")) (_a$8051 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx head env)) (_a$8052 (let* ((_a$8047 (var-deref "clojure.core" "mapv")) (_a$8048 (lambda (p__98_) (let fnrec8046 ((p__98_ p__98_)) (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx p__98_ env)))) (_a$8049 (jolt-rest items))) (jolt-invoke _a$8047 _a$8048 _a$8049)))) (jolt-invoke _a$8050 _a$8051 _a$8052))) (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 fnrec8045 ((ctx ctx) (form form) (env env) (node node)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-coll-meta") form))) (if (jolt-nil? m) node (let* ((_a$8048 (var-deref "jolt.ir" "invoke")) (_a$8049 (jolt-invoke (var-deref "jolt.ir" "var-ref") "clojure.core" "with-meta")) (_a$8050 (let* ((_o$8046 node) (_o$8047 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx m env))) (jolt-vector _o$8046 _o$8047)))) (jolt-invoke _a$8048 _a$8049 _a$8050)))))))) with-coll-meta))) + (def-var! "jolt.analyzer" "with-coll-meta" (letrec ((with-coll-meta (lambda (ctx form env node) (let fnrec8053 ((ctx ctx) (form form) (env env) (node node)) (let* ((m (jolt-invoke (var-deref "jolt.host" "form-coll-meta") form))) (if (jolt-nil? m) node (let* ((_a$8056 (var-deref "jolt.ir" "invoke")) (_a$8057 (jolt-invoke (var-deref "jolt.ir" "var-ref") "clojure.core" "with-meta")) (_a$8058 (let* ((_o$8054 node) (_o$8055 (jolt-invoke (var-deref "jolt.analyzer" "analyze") ctx m env))) (jolt-vector _o$8054 _o$8055)))) (jolt-invoke _a$8056 _a$8057 _a$8058)))))))) with-coll-meta))) (guard (e (#t #f)) - (def-var! "jolt.analyzer" "analyze" (letrec ((analyze (case-lambda ((ctx form) (let fnrec8051 ((ctx ctx) (form form)) (analyze ctx form (jolt-invoke (var-deref "jolt.analyzer" "empty-env"))))) ((ctx form env) (let fnrec8052 ((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$8054 (var-deref "clojure.core" "mapv")) (_a$8055 (lambda (p__99_) (let fnrec8053 ((p__99_ p__99_)) (analyze ctx p__99_ env)))) (_a$8056 (jolt-invoke (var-deref "jolt.host" "form-vec-items") form))) (jolt-invoke _a$8054 _a$8055 _a$8056)))) (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$8060 (var-deref "clojure.core" "mapv")) (_a$8061 (lambda (p) (let fnrec8057 ((p p)) (let* ((_o$8058 (analyze ctx (jolt-first p) env)) (_o$8059 (analyze ctx (jolt-invoke (var-deref "clojure.core" "second") p) env))) (jolt-vector _o$8058 _o$8059))))) (_a$8062 (jolt-invoke (var-deref "jolt.host" "form-map-pairs") form))) (jolt-invoke _a$8060 _a$8061 _a$8062)))) (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$8064 (var-deref "clojure.core" "mapv")) (_a$8065 (lambda (p__100_) (let fnrec8063 ((p__100_ p__100_)) (analyze ctx p__100_ env)))) (_a$8066 (jolt-invoke (var-deref "jolt.host" "form-set-items") form))) (jolt-invoke _a$8064 _a$8065 _a$8066)))) (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$8067 (keyword #f "op")) (_o$8068 (keyword #f "regex")) (_o$8069 (keyword #f "source")) (_o$8070 (jolt-invoke (var-deref "jolt.host" "form-regex-source") form))) (jolt-hash-map _o$8067 _o$8068 _o$8069 _o$8070)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-inst?") form)) (let* ((_o$8071 (keyword #f "op")) (_o$8072 (keyword #f "inst")) (_o$8073 (keyword #f "source")) (_o$8074 (jolt-invoke (var-deref "jolt.host" "form-inst-source") form))) (jolt-hash-map _o$8071 _o$8072 _o$8073 _o$8074)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-uuid?") form)) (let* ((_o$8075 (keyword #f "op")) (_o$8076 (keyword #f "uuid")) (_o$8077 (keyword #f "source")) (_o$8078 (jolt-invoke (var-deref "jolt.host" "form-uuid-source") form))) (jolt-hash-map _o$8075 _o$8076 _o$8077 _o$8078)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-bigdec?") form)) (let* ((_o$8079 (keyword #f "op")) (_o$8080 (keyword #f "bigdec")) (_o$8081 (keyword #f "source")) (_o$8082 (jolt-invoke (var-deref "jolt.host" "form-bigdec-source") form))) (jolt-hash-map _o$8079 _o$8080 _o$8081 _o$8082)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-ns-value?") form)) (let* ((_o$8083 (keyword #f "op")) (_o$8084 (keyword #f "the-ns")) (_o$8085 (keyword #f "name")) (_o$8086 (jolt-invoke (var-deref "jolt.host" "form-ns-value-name") form))) (jolt-hash-map _o$8083 _o$8084 _o$8085 _o$8086)) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.analyzer" "uncompilable") "unsupported form") jolt-nil))))))))))))))))) analyze))) + (def-var! "jolt.analyzer" "analyze" (letrec ((analyze (case-lambda ((ctx form) (let fnrec8059 ((ctx ctx) (form form)) (analyze ctx form (jolt-invoke (var-deref "jolt.analyzer" "empty-env"))))) ((ctx form env) (let fnrec8060 ((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$8062 (var-deref "clojure.core" "mapv")) (_a$8063 (lambda (p__99_) (let fnrec8061 ((p__99_ p__99_)) (analyze ctx p__99_ env)))) (_a$8064 (jolt-invoke (var-deref "jolt.host" "form-vec-items") form))) (jolt-invoke _a$8062 _a$8063 _a$8064)))) (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$8068 (var-deref "clojure.core" "mapv")) (_a$8069 (lambda (p) (let fnrec8065 ((p p)) (let* ((_o$8066 (analyze ctx (jolt-first p) env)) (_o$8067 (analyze ctx (jolt-invoke (var-deref "clojure.core" "second") p) env))) (jolt-vector _o$8066 _o$8067))))) (_a$8070 (jolt-invoke (var-deref "jolt.host" "form-map-pairs") form))) (jolt-invoke _a$8068 _a$8069 _a$8070)))) (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$8072 (var-deref "clojure.core" "mapv")) (_a$8073 (lambda (p__100_) (let fnrec8071 ((p__100_ p__100_)) (analyze ctx p__100_ env)))) (_a$8074 (jolt-invoke (var-deref "jolt.host" "form-set-items") form))) (jolt-invoke _a$8072 _a$8073 _a$8074)))) (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$8075 (keyword #f "op")) (_o$8076 (keyword #f "regex")) (_o$8077 (keyword #f "source")) (_o$8078 (jolt-invoke (var-deref "jolt.host" "form-regex-source") form))) (jolt-hash-map _o$8075 _o$8076 _o$8077 _o$8078)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-inst?") form)) (let* ((_o$8079 (keyword #f "op")) (_o$8080 (keyword #f "inst")) (_o$8081 (keyword #f "source")) (_o$8082 (jolt-invoke (var-deref "jolt.host" "form-inst-source") form))) (jolt-hash-map _o$8079 _o$8080 _o$8081 _o$8082)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-uuid?") form)) (let* ((_o$8083 (keyword #f "op")) (_o$8084 (keyword #f "uuid")) (_o$8085 (keyword #f "source")) (_o$8086 (jolt-invoke (var-deref "jolt.host" "form-uuid-source") form))) (jolt-hash-map _o$8083 _o$8084 _o$8085 _o$8086)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-bigdec?") form)) (let* ((_o$8087 (keyword #f "op")) (_o$8088 (keyword #f "bigdec")) (_o$8089 (keyword #f "source")) (_o$8090 (jolt-invoke (var-deref "jolt.host" "form-bigdec-source") form))) (jolt-hash-map _o$8087 _o$8088 _o$8089 _o$8090)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.host" "form-ns-value?") form)) (let* ((_o$8091 (keyword #f "op")) (_o$8092 (keyword #f "the-ns")) (_o$8093 (keyword #f "name")) (_o$8094 (jolt-invoke (var-deref "jolt.host" "form-ns-value-name") form))) (jolt-hash-map _o$8091 _o$8092 _o$8093 _o$8094)) (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$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 "jolt=") (_o$6493 "inc") (_o$6494 "jolt-inc") (_o$6495 "dec") (_o$6496 "jolt-dec") (_o$6497 "not") (_o$6498 "jolt-not") (_o$6499 "min") (_o$6500 "min") (_o$6501 "max") (_o$6502 "max") (_o$6503 "mod") (_o$6504 "modulo") (_o$6505 "rem") (_o$6506 "remainder") (_o$6507 "quot") (_o$6508 "quotient") (_o$6509 "vector") (_o$6510 "jolt-vector") (_o$6511 "hash-map") (_o$6512 "jolt-hash-map") (_o$6513 "hash-set") (_o$6514 "jolt-hash-set") (_o$6515 "conj") (_o$6516 "jolt-conj") (_o$6517 "get") (_o$6518 "jolt-get") (_o$6519 "nth") (_o$6520 "jolt-nth") (_o$6521 "count") (_o$6522 "jolt-count") (_o$6523 "assoc") (_o$6524 "jolt-assoc") (_o$6525 "dissoc") (_o$6526 "jolt-dissoc") (_o$6527 "contains?") (_o$6528 "jolt-contains?") (_o$6529 "empty?") (_o$6530 "jolt-empty?") (_o$6531 "peek") (_o$6532 "jolt-peek") (_o$6533 "pop") (_o$6534 "jolt-pop") (_o$6535 "first") (_o$6536 "jolt-first") (_o$6537 "rest") (_o$6538 "jolt-rest") (_o$6539 "next") (_o$6540 "jolt-next") (_o$6541 "seq") (_o$6542 "jolt-seq") (_o$6543 "cons") (_o$6544 "jolt-cons") (_o$6545 "list") (_o$6546 "jolt-list") (_o$6547 "reverse") (_o$6548 "jolt-reverse") (_o$6549 "last") (_o$6550 "jolt-last") (_o$6551 "map") (_o$6552 "jolt-map") (_o$6553 "filter") (_o$6554 "jolt-filter") (_o$6555 "remove") (_o$6556 "jolt-remove") (_o$6557 "reduce") (_o$6558 "jolt-reduce") (_o$6559 "into") (_o$6560 "jolt-into") (_o$6561 "concat") (_o$6562 "jolt-concat") (_o$6563 "apply") (_o$6564 "jolt-apply") (_o$6565 "range") (_o$6566 "jolt-range") (_o$6567 "take") (_o$6568 "jolt-take") (_o$6569 "drop") (_o$6570 "jolt-drop") (_o$6571 "keys") (_o$6572 "jolt-keys") (_o$6573 "vals") (_o$6574 "jolt-vals") (_o$6575 "even?") (_o$6576 "jolt-even?") (_o$6577 "odd?") (_o$6578 "jolt-odd?") (_o$6579 "pos?") (_o$6580 "jolt-pos?") (_o$6581 "neg?") (_o$6582 "jolt-neg?") (_o$6583 "zero?") (_o$6584 "jolt-zero?") (_o$6585 "identity") (_o$6586 "jolt-identity") (_o$6587 "nil?") (_o$6588 "jolt-nil?") (_o$6589 "some?") (_o$6590 "jolt-some?") (_o$6591 "ex-info") (_o$6592 "jolt-ex-info") (_o$6593 "protocol-dispatch1") (_o$6594 "protocol-dispatch1") (_o$6595 "protocol-dispatch2") (_o$6596 "protocol-dispatch2") (_o$6597 "protocol-dispatch3") (_o$6598 "protocol-dispatch3")) (jolt-hash-map _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 _o$6550 _o$6551 _o$6552 _o$6553 _o$6554 _o$6555 _o$6556 _o$6557 _o$6558 _o$6559 _o$6560 _o$6561 _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 _o$6575 _o$6576 _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)) (let* ((_o$6599 (keyword #f "private")) (_o$6600 #t)) (jolt-hash-map _o$6599 _o$6600)))) + (def-var-with-meta! "jolt.backend-scheme" "native-ops" (let* ((_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 "jolt=") (_o$6494 "inc") (_o$6495 "jolt-inc") (_o$6496 "dec") (_o$6497 "jolt-dec") (_o$6498 "not") (_o$6499 "jolt-not") (_o$6500 "min") (_o$6501 "min") (_o$6502 "max") (_o$6503 "max") (_o$6504 "mod") (_o$6505 "modulo") (_o$6506 "rem") (_o$6507 "remainder") (_o$6508 "quot") (_o$6509 "quotient") (_o$6510 "vector") (_o$6511 "jolt-vector") (_o$6512 "hash-map") (_o$6513 "jolt-hash-map") (_o$6514 "hash-set") (_o$6515 "jolt-hash-set") (_o$6516 "conj") (_o$6517 "jolt-conj") (_o$6518 "get") (_o$6519 "jolt-get") (_o$6520 "nth") (_o$6521 "jolt-nth") (_o$6522 "count") (_o$6523 "jolt-count") (_o$6524 "assoc") (_o$6525 "jolt-assoc") (_o$6526 "dissoc") (_o$6527 "jolt-dissoc") (_o$6528 "contains?") (_o$6529 "jolt-contains?") (_o$6530 "empty?") (_o$6531 "jolt-empty?") (_o$6532 "peek") (_o$6533 "jolt-peek") (_o$6534 "pop") (_o$6535 "jolt-pop") (_o$6536 "first") (_o$6537 "jolt-first") (_o$6538 "rest") (_o$6539 "jolt-rest") (_o$6540 "next") (_o$6541 "jolt-next") (_o$6542 "seq") (_o$6543 "jolt-seq") (_o$6544 "cons") (_o$6545 "jolt-cons") (_o$6546 "list") (_o$6547 "jolt-list") (_o$6548 "reverse") (_o$6549 "jolt-reverse") (_o$6550 "last") (_o$6551 "jolt-last") (_o$6552 "map") (_o$6553 "jolt-map") (_o$6554 "filter") (_o$6555 "jolt-filter") (_o$6556 "remove") (_o$6557 "jolt-remove") (_o$6558 "reduce") (_o$6559 "jolt-reduce") (_o$6560 "into") (_o$6561 "jolt-into") (_o$6562 "concat") (_o$6563 "jolt-concat") (_o$6564 "apply") (_o$6565 "jolt-apply") (_o$6566 "range") (_o$6567 "jolt-range") (_o$6568 "take") (_o$6569 "jolt-take") (_o$6570 "drop") (_o$6571 "jolt-drop") (_o$6572 "keys") (_o$6573 "jolt-keys") (_o$6574 "vals") (_o$6575 "jolt-vals") (_o$6576 "even?") (_o$6577 "jolt-even?") (_o$6578 "odd?") (_o$6579 "jolt-odd?") (_o$6580 "pos?") (_o$6581 "jolt-pos?") (_o$6582 "neg?") (_o$6583 "jolt-neg?") (_o$6584 "zero?") (_o$6585 "jolt-zero?") (_o$6586 "identity") (_o$6587 "jolt-identity") (_o$6588 "nil?") (_o$6589 "jolt-nil?") (_o$6590 "some?") (_o$6591 "jolt-some?") (_o$6592 "ex-info") (_o$6593 "jolt-ex-info") (_o$6594 "protocol-dispatch1") (_o$6595 "protocol-dispatch1") (_o$6596 "protocol-dispatch2") (_o$6597 "protocol-dispatch2") (_o$6598 "protocol-dispatch3") (_o$6599 "protocol-dispatch3")) (jolt-hash-map _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 _o$6550 _o$6551 _o$6552 _o$6553 _o$6554 _o$6555 _o$6556 _o$6557 _o$6558 _o$6559 _o$6560 _o$6561 _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 _o$6575 _o$6576 _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)) (let* ((_o$6600 (keyword #f "private")) (_o$6601 #t)) (jolt-hash-map _o$6600 _o$6601)))) (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$6601 "+") (_o$6602 "jolt-add") (_o$6603 "-") (_o$6604 "jolt-sub") (_o$6605 "*") (_o$6606 "jolt-mul") (_o$6607 "/") (_o$6608 "jolt-div") (_o$6609 "min") (_o$6610 "jolt-min") (_o$6611 "max") (_o$6612 "jolt-max")) (jolt-hash-map _o$6601 _o$6602 _o$6603 _o$6604 _o$6605 _o$6606 _o$6607 _o$6608 _o$6609 _o$6610 _o$6611 _o$6612))) (let* ((_o$6613 (keyword #f "private")) (_o$6614 #t)) (jolt-hash-map _o$6613 _o$6614)))) + (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$6602 "+") (_o$6603 "jolt-add") (_o$6604 "-") (_o$6605 "jolt-sub") (_o$6606 "*") (_o$6607 "jolt-mul") (_o$6608 "/") (_o$6609 "jolt-div") (_o$6610 "min") (_o$6611 "jolt-min") (_o$6612 "max") (_o$6613 "jolt-max")) (jolt-hash-map _o$6602 _o$6603 _o$6604 _o$6605 _o$6606 _o$6607 _o$6608 _o$6609 _o$6610 _o$6611 _o$6612 _o$6613))) (let* ((_o$6614 (keyword #f "private")) (_o$6615 #t)) (jolt-hash-map _o$6614 _o$6615)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "op-arity" (let* ((_o$6661 "inc") (_o$6662 (lambda (p__42_) (let fnrec6615 ((p__42_ p__42_)) (jolt= p__42_ 1)))) (_o$6663 "dec") (_o$6664 (lambda (p__43_) (let fnrec6616 ((p__43_ p__43_)) (jolt= p__43_ 1)))) (_o$6665 "not") (_o$6666 (lambda (p__44_) (let fnrec6617 ((p__44_ p__44_)) (jolt= p__44_ 1)))) (_o$6667 "count") (_o$6668 (lambda (p__45_) (let fnrec6618 ((p__45_ p__45_)) (jolt= p__45_ 1)))) (_o$6669 "empty?") (_o$6670 (lambda (p__46_) (let fnrec6619 ((p__46_ p__46_)) (jolt= p__46_ 1)))) (_o$6671 "peek") (_o$6672 (lambda (p__47_) (let fnrec6620 ((p__47_ p__47_)) (jolt= p__47_ 1)))) (_o$6673 "pop") (_o$6674 (lambda (p__48_) (let fnrec6621 ((p__48_ p__48_)) (jolt= p__48_ 1)))) (_o$6675 "mod") (_o$6676 (lambda (p__49_) (let fnrec6622 ((p__49_ p__49_)) (jolt= p__49_ 2)))) (_o$6677 "rem") (_o$6678 (lambda (p__50_) (let fnrec6623 ((p__50_ p__50_)) (jolt= p__50_ 2)))) (_o$6679 "quot") (_o$6680 (lambda (p__51_) (let fnrec6624 ((p__51_ p__51_)) (jolt= p__51_ 2)))) (_o$6681 "contains?") (_o$6682 (lambda (p__52_) (let fnrec6625 ((p__52_ p__52_)) (jolt= p__52_ 2)))) (_o$6683 "get") (_o$6684 (lambda (p__53_) (let fnrec6626 ((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$6685 "nth") (_o$6686 (lambda (p__54_) (let fnrec6627 ((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$6687 "assoc") (_o$6688 (lambda (p__55_) (let fnrec6628 ((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$6689 "dissoc") (_o$6690 (lambda (p__56_) (let fnrec6629 ((p__56_ p__56_)) (>= p__56_ 1)))) (_o$6691 "conj") (_o$6692 (lambda (p__57_) (let fnrec6630 ((p__57_ p__57_)) (>= p__57_ 1)))) (_o$6693 "first") (_o$6694 (lambda (p__58_) (let fnrec6631 ((p__58_ p__58_)) (jolt= p__58_ 1)))) (_o$6695 "rest") (_o$6696 (lambda (p__59_) (let fnrec6632 ((p__59_ p__59_)) (jolt= p__59_ 1)))) (_o$6697 "next") (_o$6698 (lambda (p__60_) (let fnrec6633 ((p__60_ p__60_)) (jolt= p__60_ 1)))) (_o$6699 "seq") (_o$6700 (lambda (p__61_) (let fnrec6634 ((p__61_ p__61_)) (jolt= p__61_ 1)))) (_o$6701 "reverse") (_o$6702 (lambda (p__62_) (let fnrec6635 ((p__62_ p__62_)) (jolt= p__62_ 1)))) (_o$6703 "last") (_o$6704 (lambda (p__63_) (let fnrec6636 ((p__63_ p__63_)) (jolt= p__63_ 1)))) (_o$6705 "keys") (_o$6706 (lambda (p__64_) (let fnrec6637 ((p__64_ p__64_)) (jolt= p__64_ 1)))) (_o$6707 "vals") (_o$6708 (lambda (p__65_) (let fnrec6638 ((p__65_ p__65_)) (jolt= p__65_ 1)))) (_o$6709 "even?") (_o$6710 (lambda (p__66_) (let fnrec6639 ((p__66_ p__66_)) (jolt= p__66_ 1)))) (_o$6711 "odd?") (_o$6712 (lambda (p__67_) (let fnrec6640 ((p__67_ p__67_)) (jolt= p__67_ 1)))) (_o$6713 "pos?") (_o$6714 (lambda (p__68_) (let fnrec6641 ((p__68_ p__68_)) (jolt= p__68_ 1)))) (_o$6715 "neg?") (_o$6716 (lambda (p__69_) (let fnrec6642 ((p__69_ p__69_)) (jolt= p__69_ 1)))) (_o$6717 "zero?") (_o$6718 (lambda (p__70_) (let fnrec6643 ((p__70_ p__70_)) (jolt= p__70_ 1)))) (_o$6719 "identity") (_o$6720 (lambda (p__71_) (let fnrec6644 ((p__71_ p__71_)) (jolt= p__71_ 1)))) (_o$6721 "nil?") (_o$6722 (lambda (p__72_) (let fnrec6645 ((p__72_ p__72_)) (jolt= p__72_ 1)))) (_o$6723 "some?") (_o$6724 (lambda (p__73_) (let fnrec6646 ((p__73_ p__73_)) (jolt= p__73_ 1)))) (_o$6725 "protocol-dispatch1") (_o$6726 (lambda (p__74_) (let fnrec6647 ((p__74_ p__74_)) (jolt= p__74_ 3)))) (_o$6727 "protocol-dispatch2") (_o$6728 (lambda (p__75_) (let fnrec6648 ((p__75_ p__75_)) (jolt= p__75_ 4)))) (_o$6729 "protocol-dispatch3") (_o$6730 (lambda (p__76_) (let fnrec6649 ((p__76_ p__76_)) (jolt= p__76_ 5)))) (_o$6731 "cons") (_o$6732 (lambda (p__77_) (let fnrec6650 ((p__77_ p__77_)) (jolt= p__77_ 2)))) (_o$6733 "filter") (_o$6734 (lambda (p__78_) (let fnrec6651 ((p__78_ p__78_)) (jolt= p__78_ 2)))) (_o$6735 "remove") (_o$6736 (lambda (p__79_) (let fnrec6652 ((p__79_ p__79_)) (jolt= p__79_ 2)))) (_o$6737 "into") (_o$6738 (lambda (p__80_) (let fnrec6653 ((p__80_ p__80_)) (jolt= p__80_ 2)))) (_o$6739 "take") (_o$6740 (lambda (p__81_) (let fnrec6654 ((p__81_ p__81_)) (jolt= p__81_ 2)))) (_o$6741 "drop") (_o$6742 (lambda (p__82_) (let fnrec6655 ((p__82_ p__82_)) (jolt= p__82_ 2)))) (_o$6743 "map") (_o$6744 (lambda (p__83_) (let fnrec6656 ((p__83_ p__83_)) (>= p__83_ 2)))) (_o$6745 "apply") (_o$6746 (lambda (p__84_) (let fnrec6657 ((p__84_ p__84_)) (>= p__84_ 2)))) (_o$6747 "reduce") (_o$6748 (lambda (p__85_) (let fnrec6658 ((p__85_ p__85_)) (let* ((or__26__auto (jolt= p__85_ 2))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= p__85_ 3)))))) (_o$6749 "range") (_o$6750 (lambda (p__86_) (let fnrec6659 ((p__86_ p__86_)) (let* ((and__25__auto (>= p__86_ 0))) (if (jolt-truthy? and__25__auto) (<= p__86_ 3) and__25__auto))))) (_o$6751 "ex-info") (_o$6752 (lambda (p__87_) (let fnrec6660 ((p__87_ p__87_)) (let* ((or__26__auto (jolt= p__87_ 2))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= p__87_ 3))))))) (jolt-hash-map _o$6661 _o$6662 _o$6663 _o$6664 _o$6665 _o$6666 _o$6667 _o$6668 _o$6669 _o$6670 _o$6671 _o$6672 _o$6673 _o$6674 _o$6675 _o$6676 _o$6677 _o$6678 _o$6679 _o$6680 _o$6681 _o$6682 _o$6683 _o$6684 _o$6685 _o$6686 _o$6687 _o$6688 _o$6689 _o$6690 _o$6691 _o$6692 _o$6693 _o$6694 _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 _o$6720 _o$6721 _o$6722 _o$6723 _o$6724 _o$6725 _o$6726 _o$6727 _o$6728 _o$6729 _o$6730 _o$6731 _o$6732 _o$6733 _o$6734 _o$6735 _o$6736 _o$6737 _o$6738 _o$6739 _o$6740 _o$6741 _o$6742 _o$6743 _o$6744 _o$6745 _o$6746 _o$6747 _o$6748 _o$6749 _o$6750 _o$6751 _o$6752)) (let* ((_o$6753 (keyword #f "private")) (_o$6754 #t)) (jolt-hash-map _o$6753 _o$6754)))) + (def-var-with-meta! "jolt.backend-scheme" "op-arity" (let* ((_o$6662 "inc") (_o$6663 (lambda (p__42_) (let fnrec6616 ((p__42_ p__42_)) (jolt= p__42_ 1)))) (_o$6664 "dec") (_o$6665 (lambda (p__43_) (let fnrec6617 ((p__43_ p__43_)) (jolt= p__43_ 1)))) (_o$6666 "not") (_o$6667 (lambda (p__44_) (let fnrec6618 ((p__44_ p__44_)) (jolt= p__44_ 1)))) (_o$6668 "count") (_o$6669 (lambda (p__45_) (let fnrec6619 ((p__45_ p__45_)) (jolt= p__45_ 1)))) (_o$6670 "empty?") (_o$6671 (lambda (p__46_) (let fnrec6620 ((p__46_ p__46_)) (jolt= p__46_ 1)))) (_o$6672 "peek") (_o$6673 (lambda (p__47_) (let fnrec6621 ((p__47_ p__47_)) (jolt= p__47_ 1)))) (_o$6674 "pop") (_o$6675 (lambda (p__48_) (let fnrec6622 ((p__48_ p__48_)) (jolt= p__48_ 1)))) (_o$6676 "mod") (_o$6677 (lambda (p__49_) (let fnrec6623 ((p__49_ p__49_)) (jolt= p__49_ 2)))) (_o$6678 "rem") (_o$6679 (lambda (p__50_) (let fnrec6624 ((p__50_ p__50_)) (jolt= p__50_ 2)))) (_o$6680 "quot") (_o$6681 (lambda (p__51_) (let fnrec6625 ((p__51_ p__51_)) (jolt= p__51_ 2)))) (_o$6682 "contains?") (_o$6683 (lambda (p__52_) (let fnrec6626 ((p__52_ p__52_)) (jolt= p__52_ 2)))) (_o$6684 "get") (_o$6685 (lambda (p__53_) (let fnrec6627 ((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$6686 "nth") (_o$6687 (lambda (p__54_) (let fnrec6628 ((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$6688 "assoc") (_o$6689 (lambda (p__55_) (let fnrec6629 ((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$6690 "dissoc") (_o$6691 (lambda (p__56_) (let fnrec6630 ((p__56_ p__56_)) (>= p__56_ 1)))) (_o$6692 "conj") (_o$6693 (lambda (p__57_) (let fnrec6631 ((p__57_ p__57_)) (>= p__57_ 1)))) (_o$6694 "first") (_o$6695 (lambda (p__58_) (let fnrec6632 ((p__58_ p__58_)) (jolt= p__58_ 1)))) (_o$6696 "rest") (_o$6697 (lambda (p__59_) (let fnrec6633 ((p__59_ p__59_)) (jolt= p__59_ 1)))) (_o$6698 "next") (_o$6699 (lambda (p__60_) (let fnrec6634 ((p__60_ p__60_)) (jolt= p__60_ 1)))) (_o$6700 "seq") (_o$6701 (lambda (p__61_) (let fnrec6635 ((p__61_ p__61_)) (jolt= p__61_ 1)))) (_o$6702 "reverse") (_o$6703 (lambda (p__62_) (let fnrec6636 ((p__62_ p__62_)) (jolt= p__62_ 1)))) (_o$6704 "last") (_o$6705 (lambda (p__63_) (let fnrec6637 ((p__63_ p__63_)) (jolt= p__63_ 1)))) (_o$6706 "keys") (_o$6707 (lambda (p__64_) (let fnrec6638 ((p__64_ p__64_)) (jolt= p__64_ 1)))) (_o$6708 "vals") (_o$6709 (lambda (p__65_) (let fnrec6639 ((p__65_ p__65_)) (jolt= p__65_ 1)))) (_o$6710 "even?") (_o$6711 (lambda (p__66_) (let fnrec6640 ((p__66_ p__66_)) (jolt= p__66_ 1)))) (_o$6712 "odd?") (_o$6713 (lambda (p__67_) (let fnrec6641 ((p__67_ p__67_)) (jolt= p__67_ 1)))) (_o$6714 "pos?") (_o$6715 (lambda (p__68_) (let fnrec6642 ((p__68_ p__68_)) (jolt= p__68_ 1)))) (_o$6716 "neg?") (_o$6717 (lambda (p__69_) (let fnrec6643 ((p__69_ p__69_)) (jolt= p__69_ 1)))) (_o$6718 "zero?") (_o$6719 (lambda (p__70_) (let fnrec6644 ((p__70_ p__70_)) (jolt= p__70_ 1)))) (_o$6720 "identity") (_o$6721 (lambda (p__71_) (let fnrec6645 ((p__71_ p__71_)) (jolt= p__71_ 1)))) (_o$6722 "nil?") (_o$6723 (lambda (p__72_) (let fnrec6646 ((p__72_ p__72_)) (jolt= p__72_ 1)))) (_o$6724 "some?") (_o$6725 (lambda (p__73_) (let fnrec6647 ((p__73_ p__73_)) (jolt= p__73_ 1)))) (_o$6726 "protocol-dispatch1") (_o$6727 (lambda (p__74_) (let fnrec6648 ((p__74_ p__74_)) (jolt= p__74_ 3)))) (_o$6728 "protocol-dispatch2") (_o$6729 (lambda (p__75_) (let fnrec6649 ((p__75_ p__75_)) (jolt= p__75_ 4)))) (_o$6730 "protocol-dispatch3") (_o$6731 (lambda (p__76_) (let fnrec6650 ((p__76_ p__76_)) (jolt= p__76_ 5)))) (_o$6732 "cons") (_o$6733 (lambda (p__77_) (let fnrec6651 ((p__77_ p__77_)) (jolt= p__77_ 2)))) (_o$6734 "filter") (_o$6735 (lambda (p__78_) (let fnrec6652 ((p__78_ p__78_)) (jolt= p__78_ 2)))) (_o$6736 "remove") (_o$6737 (lambda (p__79_) (let fnrec6653 ((p__79_ p__79_)) (jolt= p__79_ 2)))) (_o$6738 "into") (_o$6739 (lambda (p__80_) (let fnrec6654 ((p__80_ p__80_)) (jolt= p__80_ 2)))) (_o$6740 "take") (_o$6741 (lambda (p__81_) (let fnrec6655 ((p__81_ p__81_)) (jolt= p__81_ 2)))) (_o$6742 "drop") (_o$6743 (lambda (p__82_) (let fnrec6656 ((p__82_ p__82_)) (jolt= p__82_ 2)))) (_o$6744 "map") (_o$6745 (lambda (p__83_) (let fnrec6657 ((p__83_ p__83_)) (>= p__83_ 2)))) (_o$6746 "apply") (_o$6747 (lambda (p__84_) (let fnrec6658 ((p__84_ p__84_)) (>= p__84_ 2)))) (_o$6748 "reduce") (_o$6749 (lambda (p__85_) (let fnrec6659 ((p__85_ p__85_)) (let* ((or__26__auto (jolt= p__85_ 2))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= p__85_ 3)))))) (_o$6750 "range") (_o$6751 (lambda (p__86_) (let fnrec6660 ((p__86_ p__86_)) (let* ((and__25__auto (>= p__86_ 0))) (if (jolt-truthy? and__25__auto) (<= p__86_ 3) and__25__auto))))) (_o$6752 "ex-info") (_o$6753 (lambda (p__87_) (let fnrec6661 ((p__87_ p__87_)) (let* ((or__26__auto (jolt= p__87_ 2))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= p__87_ 3))))))) (jolt-hash-map _o$6662 _o$6663 _o$6664 _o$6665 _o$6666 _o$6667 _o$6668 _o$6669 _o$6670 _o$6671 _o$6672 _o$6673 _o$6674 _o$6675 _o$6676 _o$6677 _o$6678 _o$6679 _o$6680 _o$6681 _o$6682 _o$6683 _o$6684 _o$6685 _o$6686 _o$6687 _o$6688 _o$6689 _o$6690 _o$6691 _o$6692 _o$6693 _o$6694 _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 _o$6720 _o$6721 _o$6722 _o$6723 _o$6724 _o$6725 _o$6726 _o$6727 _o$6728 _o$6729 _o$6730 _o$6731 _o$6732 _o$6733 _o$6734 _o$6735 _o$6736 _o$6737 _o$6738 _o$6739 _o$6740 _o$6741 _o$6742 _o$6743 _o$6744 _o$6745 _o$6746 _o$6747 _o$6748 _o$6749 _o$6750 _o$6751 _o$6752 _o$6753)) (let* ((_o$6754 (keyword #f "private")) (_o$6755 #t)) (jolt-hash-map _o$6754 _o$6755)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "cmp1-ops" (let* ((_o$6755 "<") (_o$6756 ">") (_o$6757 "<=") (_o$6758 ">=")) (jolt-hash-set _o$6755 _o$6756 _o$6757 _o$6758)) (let* ((_o$6759 (keyword #f "private")) (_o$6760 #t)) (jolt-hash-map _o$6759 _o$6760)))) + (def-var-with-meta! "jolt.backend-scheme" "cmp1-ops" (let* ((_o$6756 "<") (_o$6757 ">") (_o$6758 "<=") (_o$6759 ">=")) (jolt-hash-set _o$6756 _o$6757 _o$6758 _o$6759)) (let* ((_o$6760 (keyword #f "private")) (_o$6761 #t)) (jolt-hash-map _o$6760 _o$6761)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "supported-host-methods" (let* ((_o$6761 "isDirectory") (_o$6762 "listFiles")) (jolt-hash-set _o$6761 _o$6762)) (let* ((_o$6763 (keyword #f "private")) (_o$6764 #t)) (jolt-hash-map _o$6763 _o$6764)))) + (def-var-with-meta! "jolt.backend-scheme" "supported-host-methods" (let* ((_o$6762 "isDirectory") (_o$6763 "listFiles")) (jolt-hash-set _o$6762 _o$6763)) (let* ((_o$6764 (keyword #f "private")) (_o$6765 #t)) (jolt-hash-map _o$6764 _o$6765)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "bool-returning-ops" (let* ((_o$6765 "<") (_o$6766 "<=") (_o$6767 ">") (_o$6768 ">=") (_o$6769 "jolt=") (_o$6770 "jolt-not") (_o$6771 "jolt-even?") (_o$6772 "jolt-odd?") (_o$6773 "jolt-pos?") (_o$6774 "jolt-neg?") (_o$6775 "jolt-zero?") (_o$6776 "jolt-empty?") (_o$6777 "jolt-contains?") (_o$6778 "jolt-nil?") (_o$6779 "jolt-some?")) (jolt-hash-set _o$6765 _o$6766 _o$6767 _o$6768 _o$6769 _o$6770 _o$6771 _o$6772 _o$6773 _o$6774 _o$6775 _o$6776 _o$6777 _o$6778 _o$6779)) (let* ((_o$6780 (keyword #f "private")) (_o$6781 #t)) (jolt-hash-map _o$6780 _o$6781)))) + (def-var-with-meta! "jolt.backend-scheme" "bool-returning-ops" (let* ((_o$6766 "<") (_o$6767 "<=") (_o$6768 ">") (_o$6769 ">=") (_o$6770 "jolt=") (_o$6771 "jolt-not") (_o$6772 "jolt-even?") (_o$6773 "jolt-odd?") (_o$6774 "jolt-pos?") (_o$6775 "jolt-neg?") (_o$6776 "jolt-zero?") (_o$6777 "jolt-empty?") (_o$6778 "jolt-contains?") (_o$6779 "jolt-nil?") (_o$6780 "jolt-some?")) (jolt-hash-set _o$6766 _o$6767 _o$6768 _o$6769 _o$6770 _o$6771 _o$6772 _o$6773 _o$6774 _o$6775 _o$6776 _o$6777 _o$6778 _o$6779 _o$6780)) (let* ((_o$6781 (keyword #f "private")) (_o$6782 #t)) (jolt-hash-map _o$6781 _o$6782)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "dbl-ops" (let* ((_o$6782 "+") (_o$6783 "fl+") (_o$6784 "-") (_o$6785 "fl-") (_o$6786 "*") (_o$6787 "fl*") (_o$6788 "/") (_o$6789 "fl/") (_o$6790 "min") (_o$6791 "flmin") (_o$6792 "max") (_o$6793 "flmax") (_o$6794 "<") (_o$6795 "fl") (_o$6797 "fl>?") (_o$6798 "<=") (_o$6799 "fl<=?") (_o$6800 ">=") (_o$6801 "fl>=?") (_o$6802 "=") (_o$6803 "fl=?") (_o$6804 "==") (_o$6805 "fl=?")) (jolt-hash-map _o$6782 _o$6783 _o$6784 _o$6785 _o$6786 _o$6787 _o$6788 _o$6789 _o$6790 _o$6791 _o$6792 _o$6793 _o$6794 _o$6795 _o$6796 _o$6797 _o$6798 _o$6799 _o$6800 _o$6801 _o$6802 _o$6803 _o$6804 _o$6805)) (let* ((_o$6806 (keyword #f "private")) (_o$6807 #t)) (jolt-hash-map _o$6806 _o$6807)))) + (def-var-with-meta! "jolt.backend-scheme" "dbl-ops" (let* ((_o$6783 "+") (_o$6784 "fl+") (_o$6785 "-") (_o$6786 "fl-") (_o$6787 "*") (_o$6788 "fl*") (_o$6789 "/") (_o$6790 "fl/") (_o$6791 "min") (_o$6792 "flmin") (_o$6793 "max") (_o$6794 "flmax") (_o$6795 "<") (_o$6796 "fl") (_o$6798 "fl>?") (_o$6799 "<=") (_o$6800 "fl<=?") (_o$6801 ">=") (_o$6802 "fl>=?") (_o$6803 "=") (_o$6804 "fl=?") (_o$6805 "==") (_o$6806 "fl=?")) (jolt-hash-map _o$6783 _o$6784 _o$6785 _o$6786 _o$6787 _o$6788 _o$6789 _o$6790 _o$6791 _o$6792 _o$6793 _o$6794 _o$6795 _o$6796 _o$6797 _o$6798 _o$6799 _o$6800 _o$6801 _o$6802 _o$6803 _o$6804 _o$6805 _o$6806)) (let* ((_o$6807 (keyword #f "private")) (_o$6808 #t)) (jolt-hash-map _o$6807 _o$6808)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "lng-ops" (let* ((_o$6808 "+") (_o$6809 "fx+") (_o$6810 "-") (_o$6811 "fx-") (_o$6812 "*") (_o$6813 "fx*") (_o$6814 "min") (_o$6815 "fxmin") (_o$6816 "max") (_o$6817 "fxmax") (_o$6818 "unchecked-add") (_o$6819 "fx+") (_o$6820 "unchecked-subtract") (_o$6821 "fx-") (_o$6822 "unchecked-multiply") (_o$6823 "fx*") (_o$6824 "quot") (_o$6825 "fxquotient") (_o$6826 "rem") (_o$6827 "fxremainder") (_o$6828 "mod") (_o$6829 "fxmodulo") (_o$6830 "<") (_o$6831 "fx") (_o$6833 "fx>?") (_o$6834 "<=") (_o$6835 "fx<=?") (_o$6836 ">=") (_o$6837 "fx>=?") (_o$6838 "=") (_o$6839 "fx=?") (_o$6840 "==") (_o$6841 "fx=?")) (jolt-hash-map _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)))) + (def-var-with-meta! "jolt.backend-scheme" "lng-ops" (let* ((_o$6809 "+") (_o$6810 "fx+") (_o$6811 "-") (_o$6812 "fx-") (_o$6813 "*") (_o$6814 "fx*") (_o$6815 "min") (_o$6816 "fxmin") (_o$6817 "max") (_o$6818 "fxmax") (_o$6819 "unchecked-add") (_o$6820 "fx+") (_o$6821 "unchecked-subtract") (_o$6822 "fx-") (_o$6823 "unchecked-multiply") (_o$6824 "fx*") (_o$6825 "quot") (_o$6826 "fxquotient") (_o$6827 "rem") (_o$6828 "fxremainder") (_o$6829 "mod") (_o$6830 "fxmodulo") (_o$6831 "<") (_o$6832 "fx") (_o$6834 "fx>?") (_o$6835 "<=") (_o$6836 "fx<=?") (_o$6837 ">=") (_o$6838 "fx>=?") (_o$6839 "=") (_o$6840 "fx=?") (_o$6841 "==") (_o$6842 "fx=?")) (jolt-hash-map _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 _o$6842)) (let* ((_o$6843 (keyword #f "private")) (_o$6844 #t)) (jolt-hash-map _o$6843 _o$6844)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "bd-ops" (let* ((_o$6844 "+") (_o$6845 "jbd-add") (_o$6846 "-") (_o$6847 "jbd-sub") (_o$6848 "*") (_o$6849 "jbd-mul") (_o$6850 "/") (_o$6851 "jbd-div") (_o$6852 "min") (_o$6853 "jbd-min") (_o$6854 "max") (_o$6855 "jbd-max") (_o$6856 "quot") (_o$6857 "jbd-quot") (_o$6858 "rem") (_o$6859 "jbd-rem") (_o$6860 "<") (_o$6861 "jbd-lt?") (_o$6862 ">") (_o$6863 "jbd-gt?") (_o$6864 "<=") (_o$6865 "jbd-le?") (_o$6866 ">=") (_o$6867 "jbd-ge?") (_o$6868 "zero?") (_o$6869 "jbd-zero?") (_o$6870 "pos?") (_o$6871 "jbd-pos?") (_o$6872 "neg?") (_o$6873 "jbd-neg?")) (jolt-hash-map _o$6844 _o$6845 _o$6846 _o$6847 _o$6848 _o$6849 _o$6850 _o$6851 _o$6852 _o$6853 _o$6854 _o$6855 _o$6856 _o$6857 _o$6858 _o$6859 _o$6860 _o$6861 _o$6862 _o$6863 _o$6864 _o$6865 _o$6866 _o$6867 _o$6868 _o$6869 _o$6870 _o$6871 _o$6872 _o$6873)) (let* ((_o$6874 (keyword #f "private")) (_o$6875 #t)) (jolt-hash-map _o$6874 _o$6875)))) + (def-var-with-meta! "jolt.backend-scheme" "bd-ops" (let* ((_o$6845 "+") (_o$6846 "jbd-add") (_o$6847 "-") (_o$6848 "jbd-sub") (_o$6849 "*") (_o$6850 "jbd-mul") (_o$6851 "/") (_o$6852 "jbd-div") (_o$6853 "min") (_o$6854 "jbd-min") (_o$6855 "max") (_o$6856 "jbd-max") (_o$6857 "quot") (_o$6858 "jbd-quot") (_o$6859 "rem") (_o$6860 "jbd-rem") (_o$6861 "<") (_o$6862 "jbd-lt?") (_o$6863 ">") (_o$6864 "jbd-gt?") (_o$6865 "<=") (_o$6866 "jbd-le?") (_o$6867 ">=") (_o$6868 "jbd-ge?") (_o$6869 "zero?") (_o$6870 "jbd-zero?") (_o$6871 "pos?") (_o$6872 "jbd-pos?") (_o$6873 "neg?") (_o$6874 "jbd-neg?")) (jolt-hash-map _o$6845 _o$6846 _o$6847 _o$6848 _o$6849 _o$6850 _o$6851 _o$6852 _o$6853 _o$6854 _o$6855 _o$6856 _o$6857 _o$6858 _o$6859 _o$6860 _o$6861 _o$6862 _o$6863 _o$6864 _o$6865 _o$6866 _o$6867 _o$6868 _o$6869 _o$6870 _o$6871 _o$6872 _o$6873 _o$6874)) (let* ((_o$6875 (keyword #f "private")) (_o$6876 #t)) (jolt-hash-map _o$6875 _o$6876)))) (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 fnrec6876 ((on on)) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "prelude-mode?") on))))) set-prelude-mode!))) + (def-var! "jolt.backend-scheme" "set-prelude-mode!" (letrec ((set-prelude-mode! (lambda (on) (let fnrec6877 ((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 fnrec6877 ((on on)) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.backend-scheme" "direct-link?") on))))) set-direct-link!))) + (def-var! "jolt.backend-scheme" "set-direct-link!" (letrec ((set-direct-link! (lambda (on) (let fnrec6878 ((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 fnrec6878 () (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!))) + (def-var! "jolt.backend-scheme" "direct-link-reset!" (letrec ((direct-link-reset! (lambda () (let fnrec6879 () (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 fnrec6879 ((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))) + (def-var! "jolt.backend-scheme" "dl-munge" (letrec ((dl-munge (lambda (s) (let fnrec6880 ((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 fnrec6880 ((ns ns) (nm nm)) (let* ((_a$6881 (var-deref "clojure.core" "str")) (_a$6882 "jv$") (_a$6883 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-munge") ns)) (_a$6884 "$") (_a$6885 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-munge") nm))) (jolt-invoke _a$6881 _a$6882 _a$6883 _a$6884 _a$6885)))))) dl-name))) + (def-var! "jolt.backend-scheme" "dl-name" (letrec ((dl-name (lambda (ns nm) (let fnrec6881 ((ns ns) (nm nm)) (let* ((_a$6882 (var-deref "clojure.core" "str")) (_a$6883 "jv$") (_a$6884 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-munge") ns)) (_a$6885 "$") (_a$6886 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-munge") nm))) (jolt-invoke _a$6882 _a$6883 _a$6884 _a$6885 _a$6886)))))) dl-name))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "dl-fqn" (letrec ((dl-fqn (lambda (ns nm) (let fnrec6886 ((ns ns) (nm nm)) (jolt-invoke (var-deref "clojure.core" "str") ns "/" nm))))) dl-fqn))) + (def-var! "jolt.backend-scheme" "dl-fqn" (letrec ((dl-fqn (lambda (ns nm) (let fnrec6887 ((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 fnrec6887 ((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$6888 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link-defined"))) (_a$6889 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm))) (jolt-contains? _a$6888 _a$6889)) and__25__auto)))))) direct-linkable?))) + (def-var! "jolt.backend-scheme" "direct-linkable?" (letrec ((direct-linkable? (lambda (ns nm) (let fnrec6888 ((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$6889 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link-defined"))) (_a$6890 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm))) (jolt-contains? _a$6889 _a$6890)) 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 fnrec6890 ((ns ns) (nm nm)) (let* ((_a$6891 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link-fns"))) (_a$6892 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm))) (jolt-contains? _a$6891 _a$6892)))))) direct-link-fn?))) + (def-var! "jolt.backend-scheme" "direct-link-fn?" (letrec ((direct-link-fn? (lambda (ns nm) (let fnrec6891 ((ns ns) (nm nm)) (let* ((_a$6892 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.backend-scheme" "direct-link-fns"))) (_a$6893 (jolt-invoke (var-deref "jolt.backend-scheme" "dl-fqn") ns nm))) (jolt-contains? _a$6892 _a$6893)))))) direct-link-fn?))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "*recur-target*" jolt-nil (let* ((_o$6893 (keyword #f "dynamic")) (_o$6894 #t)) (jolt-hash-map _o$6893 _o$6894)))) + (def-var-with-meta! "jolt.backend-scheme" "*recur-target*" jolt-nil (let* ((_o$6894 (keyword #f "dynamic")) (_o$6895 #t)) (jolt-hash-map _o$6894 _o$6895)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "*known-procs*" (jolt-hash-set) (let* ((_o$6895 (keyword #f "dynamic")) (_o$6896 #t)) (jolt-hash-map _o$6895 _o$6896)))) + (def-var-with-meta! "jolt.backend-scheme" "*known-procs*" (jolt-hash-set) (let* ((_o$6896 (keyword #f "dynamic")) (_o$6897 #t)) (jolt-hash-map _o$6896 _o$6897)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.backend-scheme" "gensym-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (let* ((_o$6897 (keyword #f "private")) (_o$6898 #t)) (jolt-hash-map _o$6897 _o$6898)))) + (def-var-with-meta! "jolt.backend-scheme" "gensym-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (let* ((_o$6898 (keyword #f "private")) (_o$6899 #t)) (jolt-hash-map _o$6898 _o$6899)))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "fresh-label" (letrec ((fresh-label (lambda (prefix) (let fnrec6899 ((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))) + (def-var! "jolt.backend-scheme" "fresh-label" (letrec ((fresh-label (lambda (prefix) (let fnrec6900 ((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$6900 "if") (_o$6901 "begin") (_o$6902 "lambda") (_o$6903 "let") (_o$6904 "let*") (_o$6905 "letrec") (_o$6906 "letrec*") (_o$6907 "quote") (_o$6908 "quasiquote") (_o$6909 "unquote") (_o$6910 "set!") (_o$6911 "define") (_o$6912 "define-syntax") (_o$6913 "cond") (_o$6914 "case") (_o$6915 "when") (_o$6916 "unless") (_o$6917 "and") (_o$6918 "or") (_o$6919 "do") (_o$6920 "else") (_o$6921 "guard") (_o$6922 "parameterize") (_o$6923 "delay") (_o$6924 "values")) (jolt-hash-set _o$6900 _o$6901 _o$6902 _o$6903 _o$6904 _o$6905 _o$6906 _o$6907 _o$6908 _o$6909 _o$6910 _o$6911 _o$6912 _o$6913 _o$6914 _o$6915 _o$6916 _o$6917 _o$6918 _o$6919 _o$6920 _o$6921 _o$6922 _o$6923 _o$6924)) (let* ((_o$6925 (keyword #f "private")) (_o$6926 #t)) (jolt-hash-map _o$6925 _o$6926)))) + (def-var-with-meta! "jolt.backend-scheme" "scheme-reserved" (let* ((_o$6901 "if") (_o$6902 "begin") (_o$6903 "lambda") (_o$6904 "let") (_o$6905 "let*") (_o$6906 "letrec") (_o$6907 "letrec*") (_o$6908 "quote") (_o$6909 "quasiquote") (_o$6910 "unquote") (_o$6911 "set!") (_o$6912 "define") (_o$6913 "define-syntax") (_o$6914 "cond") (_o$6915 "case") (_o$6916 "when") (_o$6917 "unless") (_o$6918 "and") (_o$6919 "or") (_o$6920 "do") (_o$6921 "else") (_o$6922 "guard") (_o$6923 "parameterize") (_o$6924 "delay") (_o$6925 "values")) (jolt-hash-set _o$6901 _o$6902 _o$6903 _o$6904 _o$6905 _o$6906 _o$6907 _o$6908 _o$6909 _o$6910 _o$6911 _o$6912 _o$6913 _o$6914 _o$6915 _o$6916 _o$6917 _o$6918 _o$6919 _o$6920 _o$6921 _o$6922 _o$6923 _o$6924 _o$6925)) (let* ((_o$6926 (keyword #f "private")) (_o$6927 #t)) (jolt-hash-map _o$6926 _o$6927)))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "munge-name" (letrec ((munge-name (lambda (s) (let fnrec6927 ((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))) + (def-var! "jolt.backend-scheme" "munge-name" (letrec ((munge-name (lambda (s) (let fnrec6928 ((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 fnrec6928 ((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 (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))) + (def-var! "jolt.backend-scheme" "char-escape" (letrec ((char-escape (lambda (cp) (let fnrec6929 ((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 (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 fnrec6929 ((s s)) (jolt-invoke (var-deref "clojure.core" "str") "\"" (jolt-apply (var-deref "clojure.core" "str") (jolt-map (lambda (c) (let fnrec6930 ((c c)) (jolt-invoke (var-deref "jolt.backend-scheme" "char-escape") (jolt-invoke (var-deref "clojure.core" "int") c)))) s)) "\""))))) chez-str-lit))) + (def-var! "jolt.backend-scheme" "chez-str-lit" (letrec ((chez-str-lit (lambda (s) (let fnrec6930 ((s s)) (jolt-invoke (var-deref "clojure.core" "str") "\"" (jolt-apply (var-deref "clojure.core" "str") (jolt-map (lambda (c) (let fnrec6931 ((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 fnrec6931 ((v v)) (if (jolt-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$6932 (var-deref "clojure.core" "str")) (_a$6933 "(keyword ") (_a$6934 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") kns)) (_a$6935 " ") (_a$6936 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "clojure.core" "name") v))) (_a$6937 ")")) (jolt-invoke _a$6932 _a$6933 _a$6934 _a$6935 _a$6936 _a$6937))) (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$6938 (jolt-invoke (var-deref "clojure.core" "str") "emit-const: unsupported literal " (jolt-invoke (var-deref "clojure.core" "pr-str") v))) (_a$6939 (jolt-hash-map))) (jolt-ex-info _a$6938 _a$6939))) jolt-nil))))))))))) emit-const))) + (def-var! "jolt.backend-scheme" "emit-const" (letrec ((emit-const (lambda (v) (let fnrec6932 ((v v)) (if (jolt-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$6933 (var-deref "clojure.core" "str")) (_a$6934 "(keyword ") (_a$6935 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") kns)) (_a$6936 " ") (_a$6937 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-invoke (var-deref "clojure.core" "name") v))) (_a$6938 ")")) (jolt-invoke _a$6933 _a$6934 _a$6935 _a$6936 _a$6937 _a$6938))) (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$6939 (jolt-invoke (var-deref "clojure.core" "str") "emit-const: unsupported literal " (jolt-invoke (var-deref "clojure.core" "pr-str") v))) (_a$6940 (jolt-hash-map))) (jolt-ex-info _a$6939 _a$6940))) jolt-nil))))))))))) emit-const))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "emit-ordered" (letrec ((emit-ordered (lambda (ctor arg-strs) (let fnrec6940 ((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 fnrec6941 ((_ _)) (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 fnrec6942 ((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))) + (def-var! "jolt.backend-scheme" "emit-ordered" (letrec ((emit-ordered (lambda (ctor arg-strs) (let fnrec6941 ((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 fnrec6942 ((_ _)) (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 fnrec6943 ((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 fnrec6943 ((n n)) (let* ((_a$6949 (let* ((_o$6944 (keyword #f "const")) (_o$6945 (keyword #f "local")) (_o$6946 (keyword #f "var")) (_o$6947 (keyword #f "the-var")) (_o$6948 (keyword #f "quote"))) (jolt-hash-set _o$6944 _o$6945 _o$6946 _o$6947 _o$6948))) (_a$6950 (jolt-get n (keyword #f "op")))) (jolt-contains? _a$6949 _a$6950)))))) side-effect-free?))) + (def-var! "jolt.backend-scheme" "side-effect-free?" (letrec ((side-effect-free? (lambda (n) (let fnrec6944 ((n n)) (let* ((_a$6950 (let* ((_o$6945 (keyword #f "const")) (_o$6946 (keyword #f "local")) (_o$6947 (keyword #f "var")) (_o$6948 (keyword #f "the-var")) (_o$6949 (keyword #f "quote"))) (jolt-hash-set _o$6945 _o$6946 _o$6947 _o$6948 _o$6949))) (_a$6951 (jolt-get n (keyword #f "op")))) (jolt-contains? _a$6950 _a$6951)))))) side-effect-free?))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "needs-order?" (letrec ((needs-order? (lambda (nodes) (let fnrec6951 ((nodes nodes)) (> (jolt-count (jolt-remove (var-deref "jolt.backend-scheme" "side-effect-free?") nodes)) 1))))) needs-order?))) + (def-var! "jolt.backend-scheme" "needs-order?" (letrec ((needs-order? (lambda (nodes) (let fnrec6952 ((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 fnrec6952 ((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 fnrec6953 ((_ _)) (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 fnrec6954 ((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))) + (def-var! "jolt.backend-scheme" "ordered-call" (letrec ((ordered-call (lambda (nodes strs build) (let fnrec6953 ((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 fnrec6954 ((_ _)) (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 fnrec6955 ((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 fnrec6955 ((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 fnrec6956 ((p p)) (let* ((_o$6957 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-nth p 0))) (_o$6958 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-nth p 1)))) (jolt-vector _o$6957 _o$6958)))) pairs)) ")"))))) emit-quoted-map))) + (def-var! "jolt.backend-scheme" "emit-quoted-map" (letrec ((emit-quoted-map (lambda (pairs) (let fnrec6956 ((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 fnrec6957 ((p p)) (let* ((_o$6958 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-nth p 0))) (_o$6959 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-nth p 1)))) (jolt-vector _o$6958 _o$6959)))) 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 fnrec6959 ((m m)) (let* ((pairs (jolt-invoke (var-deref "clojure.core" "sort") (let* ((_a$6965 (lambda (k) (let fnrec6960 ((k k)) (let* ((_a$6961 (var-deref "clojure.core" "str")) (_a$6962 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") k)) (_a$6963 " ") (_a$6964 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get m k)))) (jolt-invoke _a$6961 _a$6962 _a$6963 _a$6964))))) (_a$6966 (jolt-keys m))) (jolt-map _a$6965 _a$6966))))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-hash-map " (jolt-invoke (var-deref "clojure.string" "join") " " pairs) ")")))))) emit-quoted-map-value))) + (def-var! "jolt.backend-scheme" "emit-quoted-map-value" (letrec ((emit-quoted-map-value (lambda (m) (let fnrec6960 ((m m)) (let* ((pairs (jolt-invoke (var-deref "clojure.core" "sort") (let* ((_a$6966 (lambda (k) (let fnrec6961 ((k k)) (let* ((_a$6962 (var-deref "clojure.core" "str")) (_a$6963 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") k)) (_a$6964 " ") (_a$6965 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get m k)))) (jolt-invoke _a$6962 _a$6963 _a$6964 _a$6965))))) (_a$6967 (jolt-keys m))) (jolt-map _a$6966 _a$6967))))) (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 fnrec6967 ((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$6968 (var-deref "clojure.core" "str")) (_a$6969 "(jolt-symbol/meta ") (_a$6970 (if (jolt-truthy? sns) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") sns) "#f")) (_a$6971 " ") (_a$6972 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$6973 " ") (_a$6974 (emit-quoted m)) (_a$6975 ")")) (jolt-invoke _a$6968 _a$6969 _a$6970 _a$6971 _a$6972 _a$6973 _a$6974 _a$6975)) (let* ((_a$6976 (var-deref "clojure.core" "str")) (_a$6977 "(jolt-symbol ") (_a$6978 (if (jolt-truthy? sns) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") sns) "#f")) (_a$6979 " ") (_a$6980 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$6981 ")")) (jolt-invoke _a$6976 _a$6977 _a$6978 _a$6979 _a$6980 _a$6981)))) (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$6982 (jolt-invoke (var-deref "clojure.core" "str") "emit-quoted: unsupported quoted form " (jolt-invoke (var-deref "clojure.core" "pr-str") form))) (_a$6983 (jolt-hash-map))) (jolt-ex-info _a$6982 _a$6983))) jolt-nil))))))))))))))))) emit-quoted))) + (def-var! "jolt.backend-scheme" "emit-quoted" (letrec ((emit-quoted (lambda (form) (let fnrec6968 ((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$6969 (var-deref "clojure.core" "str")) (_a$6970 "(jolt-symbol/meta ") (_a$6971 (if (jolt-truthy? sns) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") sns) "#f")) (_a$6972 " ") (_a$6973 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$6974 " ") (_a$6975 (emit-quoted m)) (_a$6976 ")")) (jolt-invoke _a$6969 _a$6970 _a$6971 _a$6972 _a$6973 _a$6974 _a$6975 _a$6976)) (let* ((_a$6977 (var-deref "clojure.core" "str")) (_a$6978 "(jolt-symbol ") (_a$6979 (if (jolt-truthy? sns) (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") sns) "#f")) (_a$6980 " ") (_a$6981 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$6982 ")")) (jolt-invoke _a$6977 _a$6978 _a$6979 _a$6980 _a$6981 _a$6982)))) (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$6983 (jolt-invoke (var-deref "clojure.core" "str") "emit-quoted: unsupported quoted form " (jolt-invoke (var-deref "clojure.core" "pr-str") form))) (_a$6984 (jolt-hash-map))) (jolt-ex-info _a$6983 _a$6984))) jolt-nil))))))))))))))))) emit-quoted))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "jmeta-nonempty?" (letrec ((jmeta-nonempty? (lambda (m) (let fnrec6984 ((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?))) + (def-var! "jolt.backend-scheme" "jmeta-nonempty?" (letrec ((jmeta-nonempty? (lambda (m) (let fnrec6985 ((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 fnrec6985 ((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))) + (def-var! "jolt.backend-scheme" "emit-def-meta" (letrec ((emit-def-meta (lambda (node) (let fnrec6986 ((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 fnrec6986 ((b b)) (let* ((_a$6987 (var-deref "clojure.core" "str")) (_a$6988 "(") (_a$6989 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-nth b 0))) (_a$6990 " ") (_a$6991 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-nth b 1))) (_a$6992 ")")) (jolt-invoke _a$6987 _a$6988 _a$6989 _a$6990 _a$6991 _a$6992)))))) emit-binding))) + (def-var! "jolt.backend-scheme" "emit-binding" (letrec ((emit-binding (lambda (b) (let fnrec6987 ((b b)) (let* ((_a$6988 (var-deref "clojure.core" "str")) (_a$6989 "(") (_a$6990 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-nth b 0))) (_a$6991 " ") (_a$6992 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-nth b 1))) (_a$6993 ")")) (jolt-invoke _a$6988 _a$6989 _a$6990 _a$6991 _a$6992 _a$6993)))))) emit-binding))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "emit-let" (letrec ((emit-let (lambda (node) (let fnrec6993 ((node node)) (let* ((kw (if (jolt-truthy? (jolt-get node (keyword #f "letrec"))) "letrec*" "let*"))) (let* ((_a$6994 (var-deref "clojure.core" "str")) (_a$6995 "(") (_a$6996 kw) (_a$6997 " (") (_a$6998 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "emit-binding") (jolt-get node (keyword #f "bindings"))))) (_a$6999 ") ") (_a$7000 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (_a$7001 ")")) (jolt-invoke _a$6994 _a$6995 _a$6996 _a$6997 _a$6998 _a$6999 _a$7000 _a$7001))))))) emit-let))) + (def-var! "jolt.backend-scheme" "emit-let" (letrec ((emit-let (lambda (node) (let fnrec6994 ((node node)) (let* ((kw (if (jolt-truthy? (jolt-get node (keyword #f "letrec"))) "letrec*" "let*"))) (let* ((_a$6995 (var-deref "clojure.core" "str")) (_a$6996 "(") (_a$6997 kw) (_a$6998 " (") (_a$6999 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "emit-binding") (jolt-get node (keyword #f "bindings"))))) (_a$7000 ") ") (_a$7001 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (_a$7002 ")")) (jolt-invoke _a$6995 _a$6996 _a$6997 _a$6998 _a$6999 _a$7000 _a$7001 _a$7002))))))) emit-let))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "emit-loop" (letrec ((emit-loop (lambda (node) (let fnrec7002 ((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__88_) (let fnrec7003 ((p__88_ p__88_)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-nth p__88_ 0)))) pairs)) (inits (jolt-map (lambda (p__89_) (let fnrec7004 ((p__89_ p__89_)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-nth p__89_ 1)))) pairs)) (seq-bs (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (n i) (let fnrec7005 ((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 fnrec7006 ((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))) + (def-var! "jolt.backend-scheme" "emit-loop" (letrec ((emit-loop (lambda (node) (let fnrec7003 ((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__88_) (let fnrec7004 ((p__88_ p__88_)) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-nth p__88_ 0)))) pairs)) (inits (jolt-map (lambda (p__89_) (let fnrec7005 ((p__89_ p__89_)) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-nth p__89_ 1)))) pairs)) (seq-bs (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (n i) (let fnrec7006 ((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 fnrec7007 ((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$7007 "int") (_o$7008 "int") (_o$7009 "uint") (_o$7010 "unsigned-int") (_o$7011 "long") (_o$7012 "long") (_o$7013 "ulong") (_o$7014 "unsigned-long") (_o$7015 "int64") (_o$7016 "integer-64") (_o$7017 "uint64") (_o$7018 "unsigned-64") (_o$7019 "size_t") (_o$7020 "size_t") (_o$7021 "ssize_t") (_o$7022 "ssize_t") (_o$7023 "iptr") (_o$7024 "iptr") (_o$7025 "uptr") (_o$7026 "uptr") (_o$7027 "double") (_o$7028 "double") (_o$7029 "float") (_o$7030 "float") (_o$7031 "pointer") (_o$7032 "void*") (_o$7033 "void*") (_o$7034 "void*") (_o$7035 "string") (_o$7036 "string") (_o$7037 "void") (_o$7038 "void") (_o$7039 "uint8") (_o$7040 "unsigned-8") (_o$7041 "u8") (_o$7042 "unsigned-8") (_o$7043 "byte") (_o$7044 "unsigned-8") (_o$7045 "char") (_o$7046 "char")) (jolt-hash-map _o$7007 _o$7008 _o$7009 _o$7010 _o$7011 _o$7012 _o$7013 _o$7014 _o$7015 _o$7016 _o$7017 _o$7018 _o$7019 _o$7020 _o$7021 _o$7022 _o$7023 _o$7024 _o$7025 _o$7026 _o$7027 _o$7028 _o$7029 _o$7030 _o$7031 _o$7032 _o$7033 _o$7034 _o$7035 _o$7036 _o$7037 _o$7038 _o$7039 _o$7040 _o$7041 _o$7042 _o$7043 _o$7044 _o$7045 _o$7046)) (let* ((_o$7047 (keyword #f "private")) (_o$7048 #t)) (jolt-hash-map _o$7047 _o$7048)))) + (def-var-with-meta! "jolt.backend-scheme" "ffi-types" (let* ((_o$7008 "int") (_o$7009 "int") (_o$7010 "uint") (_o$7011 "unsigned-int") (_o$7012 "long") (_o$7013 "long") (_o$7014 "ulong") (_o$7015 "unsigned-long") (_o$7016 "int64") (_o$7017 "integer-64") (_o$7018 "uint64") (_o$7019 "unsigned-64") (_o$7020 "size_t") (_o$7021 "size_t") (_o$7022 "ssize_t") (_o$7023 "ssize_t") (_o$7024 "iptr") (_o$7025 "iptr") (_o$7026 "uptr") (_o$7027 "uptr") (_o$7028 "double") (_o$7029 "double") (_o$7030 "float") (_o$7031 "float") (_o$7032 "pointer") (_o$7033 "void*") (_o$7034 "void*") (_o$7035 "void*") (_o$7036 "string") (_o$7037 "string") (_o$7038 "void") (_o$7039 "void") (_o$7040 "uint8") (_o$7041 "unsigned-8") (_o$7042 "u8") (_o$7043 "unsigned-8") (_o$7044 "byte") (_o$7045 "unsigned-8") (_o$7046 "char") (_o$7047 "char")) (jolt-hash-map _o$7008 _o$7009 _o$7010 _o$7011 _o$7012 _o$7013 _o$7014 _o$7015 _o$7016 _o$7017 _o$7018 _o$7019 _o$7020 _o$7021 _o$7022 _o$7023 _o$7024 _o$7025 _o$7026 _o$7027 _o$7028 _o$7029 _o$7030 _o$7031 _o$7032 _o$7033 _o$7034 _o$7035 _o$7036 _o$7037 _o$7038 _o$7039 _o$7040 _o$7041 _o$7042 _o$7043 _o$7044 _o$7045 _o$7046 _o$7047)) (let* ((_o$7048 (keyword #f "private")) (_o$7049 #t)) (jolt-hash-map _o$7048 _o$7049)))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "ffi-type->chez" (letrec ((ffi-type->chez (lambda (t) (let fnrec7049 ((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$7050 (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi: unknown foreign type :" t)) (_a$7051 (jolt-hash-map))) (jolt-ex-info _a$7050 _a$7051))))))))) ffi-type->chez))) + (def-var! "jolt.backend-scheme" "ffi-type->chez" (letrec ((ffi-type->chez (lambda (t) (let fnrec7050 ((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$7051 (jolt-invoke (var-deref "clojure.core" "str") "jolt.ffi: unknown foreign type :" t)) (_a$7052 (jolt-hash-map))) (jolt-ex-info _a$7051 _a$7052))))))))) ffi-type->chez))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "emit-ffi-fn" (letrec ((emit-ffi-fn (lambda (node) (let fnrec7052 ((node node)) (let* ((_a$7053 (var-deref "clojure.core" "str")) (_a$7054 "(foreign-procedure ") (_a$7055 (if (jolt-truthy? (jolt-get node (keyword #f "blocking"))) "__collect_safe " jolt-nil)) (_a$7056 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "csym")))) (_a$7057 " (") (_a$7058 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "argtypes"))))) (_a$7059 ") ") (_a$7060 (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "rettype")))) (_a$7061 ")")) (jolt-invoke _a$7053 _a$7054 _a$7055 _a$7056 _a$7057 _a$7058 _a$7059 _a$7060 _a$7061)))))) emit-ffi-fn))) + (def-var! "jolt.backend-scheme" "emit-ffi-fn" (letrec ((emit-ffi-fn (lambda (node) (let fnrec7053 ((node node)) (let* ((_a$7054 (var-deref "clojure.core" "str")) (_a$7055 "(foreign-procedure ") (_a$7056 (if (jolt-truthy? (jolt-get node (keyword #f "blocking"))) "__collect_safe " jolt-nil)) (_a$7057 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "csym")))) (_a$7058 " (") (_a$7059 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "argtypes"))))) (_a$7060 ") ") (_a$7061 (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "rettype")))) (_a$7062 ")")) (jolt-invoke _a$7054 _a$7055 _a$7056 _a$7057 _a$7058 _a$7059 _a$7060 _a$7061 _a$7062)))))) emit-ffi-fn))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "emit-ffi-callable" (letrec ((emit-ffi-callable (lambda (node) (let fnrec7062 ((node node)) (let* ((_a$7063 (var-deref "clojure.core" "str")) (_a$7064 "(jolt-ffi-register-callable! (foreign-callable ") (_a$7065 (if (jolt-truthy? (jolt-get node (keyword #f "collect-safe"))) "__collect_safe " jolt-nil)) (_a$7066 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "fn")))) (_a$7067 " (") (_a$7068 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "argtypes"))))) (_a$7069 ") ") (_a$7070 (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "rettype")))) (_a$7071 "))")) (jolt-invoke _a$7063 _a$7064 _a$7065 _a$7066 _a$7067 _a$7068 _a$7069 _a$7070 _a$7071)))))) emit-ffi-callable))) + (def-var! "jolt.backend-scheme" "emit-ffi-callable" (letrec ((emit-ffi-callable (lambda (node) (let fnrec7063 ((node node)) (let* ((_a$7064 (var-deref "clojure.core" "str")) (_a$7065 "(jolt-ffi-register-callable! (foreign-callable ") (_a$7066 (if (jolt-truthy? (jolt-get node (keyword #f "collect-safe"))) "__collect_safe " jolt-nil)) (_a$7067 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "fn")))) (_a$7068 " (") (_a$7069 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "argtypes"))))) (_a$7070 ") ") (_a$7071 (jolt-invoke (var-deref "jolt.backend-scheme" "ffi-type->chez") (jolt-get node (keyword #f "rettype")))) (_a$7072 "))")) (jolt-invoke _a$7064 _a$7065 _a$7066 _a$7067 _a$7068 _a$7069 _a$7070 _a$7071 _a$7072)))))) emit-ffi-callable))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "emit-recur" (letrec ((emit-recur (lambda (node) (let fnrec7072 ((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$7074 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7075 arg-nodes) (_a$7076 (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "jolt.backend-scheme" "emit") arg-nodes)) (_a$7077 (lambda (as) (let fnrec7073 ((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$7074 _a$7075 _a$7076 _a$7077)))))))) emit-recur))) + (def-var! "jolt.backend-scheme" "emit-recur" (letrec ((emit-recur (lambda (node) (let fnrec7073 ((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$7075 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7076 arg-nodes) (_a$7077 (jolt-invoke (var-deref "clojure.core" "mapv") (var-deref "jolt.backend-scheme" "emit") arg-nodes)) (_a$7078 (lambda (as) (let fnrec7074 ((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$7075 _a$7076 _a$7077 _a$7078)))))))) emit-recur))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "nhint-init" (letrec ((nhint-init (lambda (nh orig munged) (let fnrec7078 ((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))) + (def-var! "jolt.backend-scheme" "nhint-init" (letrec ((nhint-init (lambda (nh orig munged) (let fnrec7079 ((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 fnrec7079 ((a a)) (let* ((orig (jolt-get a (keyword #f "params"))) (nh (let* ((_a$7080 (jolt-hash-map)) (_a$7081 (jolt-get a (keyword #f "nhints")))) (jolt-into _a$7080 _a$7081))) (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 fnrec7082 ((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$7083 paramlist) (_o$7084 (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$7083 _o$7084))))))) emit-arity-clause))) + (def-var! "jolt.backend-scheme" "emit-arity-clause" (letrec ((emit-arity-clause (lambda (a) (let fnrec7080 ((a a)) (let* ((orig (jolt-get a (keyword #f "params"))) (nh (let* ((_a$7081 (jolt-hash-map)) (_a$7082 (jolt-get a (keyword #f "nhints")))) (jolt-into _a$7081 _a$7082))) (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 fnrec7083 ((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$7084 paramlist) (_o$7085 (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$7084 _o$7085))))))) emit-arity-clause))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "emit-fn" (letrec ((emit-fn (lambda (node) (let fnrec7085 ((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$7086 (var-deref "clojure.core" "str")) (_a$7087 "(lambda ") (_a$7088 (jolt-nth c 0)) (_a$7089 " ") (_a$7090 (jolt-nth c 1)) (_a$7091 ")")) (jolt-invoke _a$7086 _a$7087 _a$7088 _a$7089 _a$7090 _a$7091))) (jolt-invoke (var-deref "clojure.core" "str") "(case-lambda " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (c) (let fnrec7092 ((c c)) (let* ((_a$7093 (var-deref "clojure.core" "str")) (_a$7094 "(") (_a$7095 (jolt-nth c 0)) (_a$7096 " ") (_a$7097 (jolt-nth c 1)) (_a$7098 ")")) (jolt-invoke _a$7093 _a$7094 _a$7095 _a$7096 _a$7097 _a$7098)))) 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))) + (def-var! "jolt.backend-scheme" "emit-fn" (letrec ((emit-fn (lambda (node) (let fnrec7086 ((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$7087 (var-deref "clojure.core" "str")) (_a$7088 "(lambda ") (_a$7089 (jolt-nth c 0)) (_a$7090 " ") (_a$7091 (jolt-nth c 1)) (_a$7092 ")")) (jolt-invoke _a$7087 _a$7088 _a$7089 _a$7090 _a$7091 _a$7092))) (jolt-invoke (var-deref "clojure.core" "str") "(case-lambda " (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map (lambda (c) (let fnrec7093 ((c c)) (let* ((_a$7094 (var-deref "clojure.core" "str")) (_a$7095 "(") (_a$7096 (jolt-nth c 0)) (_a$7097 " ") (_a$7098 (jolt-nth c 1)) (_a$7099 ")")) (jolt-invoke _a$7094 _a$7095 _a$7096 _a$7097 _a$7098 _a$7099)))) 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 fnrec7099 ((fnode fnode) (nargs nargs)) (let* ((nm (let* ((G__132 (jolt-get fnode (keyword #f "op")))) (if (jolt= G__132 (keyword #f "var")) (if (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) (jolt-get fnode (keyword #f "name")) jolt-nil) (if (jolt= G__132 (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-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))) + (def-var! "jolt.backend-scheme" "native-op" (letrec ((native-op (lambda (fnode nargs) (let fnrec7100 ((fnode fnode) (nargs nargs)) (let* ((nm (let* ((G__132 (jolt-get fnode (keyword #f "op")))) (if (jolt= G__132 (keyword #f "var")) (if (jolt= "clojure.core" (jolt-get fnode (keyword #f "ns"))) (jolt-get fnode (keyword #f "name")) jolt-nil) (if (jolt= G__132 (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-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 fnrec7100 ((fnode fnode)) (let* ((G__133 (jolt-get fnode (keyword #f "op")))) (if (jolt= G__133 (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 (let* ((or__26__auto (jolt= G__133 (keyword #f "map")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= G__133 (keyword #f "set")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= G__133 (keyword #f "vector")))))) (keyword #f "coll") jolt-nil))))))) ifn-kind))) + (def-var! "jolt.backend-scheme" "ifn-kind" (letrec ((ifn-kind (lambda (fnode) (let fnrec7101 ((fnode fnode)) (let* ((G__133 (jolt-get fnode (keyword #f "op")))) (if (jolt= G__133 (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 (let* ((or__26__auto (jolt= G__133 (keyword #f "map")))) (if (jolt-truthy? or__26__auto) or__26__auto (let* ((or__26__auto (jolt= G__133 (keyword #f "set")))) (if (jolt-truthy? or__26__auto) or__26__auto (jolt= G__133 (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 fnrec7101 ((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?))) + (def-var! "jolt.backend-scheme" "stdlib-var?" (letrec ((stdlib-var? (lambda (n) (let fnrec7102 ((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 fnrec7102 ((kind kind) (nm nm) (args args) (order-args order-args)) (if (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 (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 (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 (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__134 kind)) (if (jolt= G__134 (keyword #f "double")) (jolt-invoke (var-deref "jolt.backend-scheme" "dbl-ops") nm) (if (jolt= G__134 (keyword #f "long")) (jolt-invoke (var-deref "jolt.backend-scheme" "lng-ops") nm) (if (jolt= G__134 (keyword #f "bigdec")) (jolt-invoke (var-deref "jolt.backend-scheme" "bd-ops") nm) (jolt-throw (let* ((_a$7103 (jolt-invoke (var-deref "clojure.core" "str") "No matching clause: " G__134)) (_a$7104 (jolt-hash-map))) (jolt-ex-info _a$7103 _a$7104))))))))) (jolt-invoke order-args (lambda (as) (let fnrec7105 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" op " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")"))))) jolt-nil))))))))) emit-numeric))) + (def-var! "jolt.backend-scheme" "emit-numeric" (letrec ((emit-numeric (lambda (kind nm args order-args) (let fnrec7103 ((kind kind) (nm nm) (args args) (order-args order-args)) (if (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 (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 (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 (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__134 kind)) (if (jolt= G__134 (keyword #f "double")) (jolt-invoke (var-deref "jolt.backend-scheme" "dbl-ops") nm) (if (jolt= G__134 (keyword #f "long")) (jolt-invoke (var-deref "jolt.backend-scheme" "lng-ops") nm) (if (jolt= G__134 (keyword #f "bigdec")) (jolt-invoke (var-deref "jolt.backend-scheme" "bd-ops") nm) (jolt-throw (let* ((_a$7104 (jolt-invoke (var-deref "clojure.core" "str") "No matching clause: " G__134)) (_a$7105 (jolt-hash-map))) (jolt-ex-info _a$7104 _a$7105))))))))) (jolt-invoke order-args (lambda (as) (let fnrec7106 ((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" "struct-field-index" (letrec ((struct-field-index (lambda (shape kw) (let fnrec7106 ((shape shape) (kw kw)) (if (jolt-truthy? shape) (let* ((i 0)) (let loop7107 ((i i)) (if (>= i (jolt-count shape)) jolt-nil (if (jolt= (jolt-nth shape i) kw) i (if (jolt-truthy? (keyword #f "else")) (loop7107 (jolt-inc i)) jolt-nil))))) jolt-nil))))) struct-field-index))) + (def-var! "jolt.backend-scheme" "struct-field-index" (letrec ((struct-field-index (lambda (shape kw) (let fnrec7107 ((shape shape) (kw kw)) (if (jolt-truthy? shape) (let* ((i 0)) (let loop7108 ((i i)) (if (>= i (jolt-count shape)) jolt-nil (if (jolt= (jolt-nth shape i) kw) i (if (jolt-truthy? (keyword #f "else")) (loop7108 (jolt-inc i)) jolt-nil))))) jolt-nil))))) struct-field-index))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "emit-invoke" (letrec ((emit-invoke (lambda (node) (let fnrec7108 ((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 fnrec7109 ((build build)) (jolt-invoke (var-deref "jolt.backend-scheme" "ordered-call") arg-nodes args build)))) (defstr (lambda (as) (let fnrec7110 ((as as)) (if (> (jolt-count as) 1) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-nth as 1)) "")))) (invoke (lambda () (let fnrec7111 () (let* ((_a$7113 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7114 (jolt-cons fnode arg-nodes)) (_a$7115 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$7116 (lambda (G__135) (let fnrec7112 ((G__135 G__135)) (let* ((G__136 G__135) (f (jolt-nth G__136 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__136 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$7113 _a$7114 _a$7115 _a$7116)))))) (if (jolt-truthy? (jolt-get node (keyword #f "devirt-type"))) (jolt-invoke order-args (lambda (as) (let fnrec7117 ((as as)) (let* ((_a$7118 (var-deref "clojure.core" "str")) (_a$7119 "((find-protocol-method ") (_a$7120 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-type")))) (_a$7121 " ") (_a$7122 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-proto")))) (_a$7123 " ") (_a$7124 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-method")))) (_a$7125 ") ") (_a$7126 (jolt-invoke (var-deref "clojure.string" "join") " " as)) (_a$7127 ")")) (jolt-invoke _a$7118 _a$7119 _a$7120 _a$7121 _a$7122 _a$7123 _a$7124 _a$7125 _a$7126 _a$7127))))) (if (jolt-truthy? (jolt-get node (keyword #f "num-kind"))) (let* ((_a$7128 (var-deref "jolt.backend-scheme" "emit-numeric")) (_a$7129 (jolt-get node (keyword #f "num-kind"))) (_a$7130 (jolt-get fnode (keyword #f "name"))) (_a$7131 args) (_a$7132 order-args)) (jolt-invoke _a$7128 _a$7129 _a$7130 _a$7131 _a$7132)) (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 fnrec7133 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" nop " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")")))) (if (jolt= kind (keyword #f "keyword")) (let* ((recv (jolt-first arg-nodes)) (idx (if (let* ((and__25__auto (jolt= (keyword #f "struct") (jolt-get recv (keyword #f "hint"))))) (if (jolt-truthy? and__25__auto) (jolt= 1 (jolt-count arg-nodes)) and__25__auto)) (let* ((_a$7134 (var-deref "jolt.backend-scheme" "struct-field-index")) (_a$7135 (jolt-get recv (keyword #f "shape"))) (_a$7136 (jolt-get fnode (keyword #f "val")))) (jolt-invoke _a$7134 _a$7135 _a$7136)) jolt-nil))) (if (jolt-truthy? idx) (jolt-invoke order-args (lambda (as) (let fnrec7137 ((as as)) (let* ((_a$7138 (var-deref "clojure.core" "str")) (_a$7139 "(jrec-field-at ") (_a$7140 (jolt-first as)) (_a$7141 " ") (_a$7142 idx) (_a$7143 " ") (_a$7144 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode)) (_a$7145 ")")) (jolt-invoke _a$7138 _a$7139 _a$7140 _a$7141 _a$7142 _a$7143 _a$7144 _a$7145))))) (jolt-invoke order-args (lambda (as) (let fnrec7146 ((as as)) (let* ((_a$7147 (var-deref "clojure.core" "str")) (_a$7148 "(jolt-get ") (_a$7149 (jolt-first as)) (_a$7150 " ") (_a$7151 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode)) (_a$7152 (jolt-invoke defstr as)) (_a$7153 ")")) (jolt-invoke _a$7147 _a$7148 _a$7149 _a$7150 _a$7151 _a$7152 _a$7153))))))) (if (jolt= kind (keyword #f "coll")) (let* ((_a$7155 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7156 (jolt-cons fnode arg-nodes)) (_a$7157 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$7158 (lambda (G__137) (let fnrec7154 ((G__137 G__137)) (let* ((G__138 G__137) (c (jolt-nth G__138 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__138 1))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-get " c " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")")))))) (jolt-invoke _a$7155 _a$7156 _a$7157 _a$7158)) (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$7165 (let* ((_a$7159 (var-deref "clojure.core" "str")) (_a$7160 "emit: unsupported stdlib fn `") (_a$7161 (jolt-get fnode (keyword #f "ns"))) (_a$7162 "/") (_a$7163 (jolt-get fnode (keyword #f "name"))) (_a$7164 "` (no core on Chez yet)")) (jolt-invoke _a$7159 _a$7160 _a$7161 _a$7162 _a$7163 _a$7164))) (_a$7166 (jolt-hash-map))) (jolt-ex-info _a$7165 _a$7166))) (if (jolt= (keyword #f "host-static") (jolt-get fnode (keyword #f "op"))) (jolt-invoke order-args (lambda (as) (let fnrec7167 ((as as)) (let* ((_a$7168 (var-deref "clojure.core" "str")) (_a$7169 "(host-static-call ") (_a$7170 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "class")))) (_a$7171 " ") (_a$7172 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "member")))) (_a$7173 (if (jolt-empty? as) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)))) (_a$7174 ")")) (jolt-invoke _a$7168 _a$7169 _a$7170 _a$7171 _a$7172 _a$7173 _a$7174))))) (if (jolt= (keyword #f "host") (jolt-get fnode (keyword #f "op"))) (jolt-throw (let* ((_a$7175 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host call `" (jolt-get fnode (keyword #f "name")) "`")) (_a$7176 (jolt-hash-map))) (jolt-ex-info _a$7175 _a$7176))) (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 fnrec7177 ((as as)) (let* ((_a$7178 (var-deref "clojure.core" "str")) (_a$7179 "(") (_a$7180 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get fnode (keyword #f "name")))) (_a$7181 (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "")) (_a$7182 ")")) (jolt-invoke _a$7178 _a$7179 _a$7180 _a$7181 _a$7182))))) (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$7183 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$7184 (jolt-get fnode (keyword #f "ns"))) (_a$7185 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7183 _a$7184 _a$7185)))) (if (jolt-truthy? and__25__auto) (let* ((_a$7186 (var-deref "jolt.backend-scheme" "direct-link-fn?")) (_a$7187 (jolt-get fnode (keyword #f "ns"))) (_a$7188 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7186 _a$7187 _a$7188)) and__25__auto)) and__25__auto))) (jolt-invoke order-args (lambda (as) (let fnrec7189 ((as as)) (let* ((_a$7193 (var-deref "clojure.core" "str")) (_a$7194 "(") (_a$7195 (let* ((_a$7190 (var-deref "jolt.backend-scheme" "dl-name")) (_a$7191 (jolt-get fnode (keyword #f "ns"))) (_a$7192 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7190 _a$7191 _a$7192))) (_a$7196 (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "")) (_a$7197 ")")) (jolt-invoke _a$7193 _a$7194 _a$7195 _a$7196 _a$7197))))) (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))) + (def-var! "jolt.backend-scheme" "emit-invoke" (letrec ((emit-invoke (lambda (node) (let fnrec7109 ((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 fnrec7110 ((build build)) (jolt-invoke (var-deref "jolt.backend-scheme" "ordered-call") arg-nodes args build)))) (defstr (lambda (as) (let fnrec7111 ((as as)) (if (> (jolt-count as) 1) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-nth as 1)) "")))) (invoke (lambda () (let fnrec7112 () (let* ((_a$7114 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7115 (jolt-cons fnode arg-nodes)) (_a$7116 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$7117 (lambda (G__135) (let fnrec7113 ((G__135 G__135)) (let* ((G__136 G__135) (f (jolt-nth G__136 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__136 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$7114 _a$7115 _a$7116 _a$7117)))))) (if (jolt-truthy? (jolt-get node (keyword #f "devirt-type"))) (jolt-invoke order-args (lambda (as) (let fnrec7118 ((as as)) (let* ((r (jolt-invoke (var-deref "jolt.backend-scheme" "fresh-label") "_r$"))) (let* ((_a$7119 (var-deref "clojure.core" "str")) (_a$7120 "(let* ((") (_a$7121 r) (_a$7122 " ") (_a$7123 (jolt-first as)) (_a$7124 ")) ") (_a$7125 "((devirt-resolve ") (_a$7126 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-type")))) (_a$7127 " ") (_a$7128 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-proto")))) (_a$7129 " ") (_a$7130 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "devirt-method")))) (_a$7131 " ") (_a$7132 r) (_a$7133 ") ") (_a$7134 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-cons r (jolt-rest as)))) (_a$7135 "))")) (jolt-invoke _a$7119 _a$7120 _a$7121 _a$7122 _a$7123 _a$7124 _a$7125 _a$7126 _a$7127 _a$7128 _a$7129 _a$7130 _a$7131 _a$7132 _a$7133 _a$7134 _a$7135)))))) (if (jolt-truthy? (jolt-get node (keyword #f "num-kind"))) (let* ((_a$7136 (var-deref "jolt.backend-scheme" "emit-numeric")) (_a$7137 (jolt-get node (keyword #f "num-kind"))) (_a$7138 (jolt-get fnode (keyword #f "name"))) (_a$7139 args) (_a$7140 order-args)) (jolt-invoke _a$7136 _a$7137 _a$7138 _a$7139 _a$7140)) (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 fnrec7141 ((as as)) (jolt-invoke (var-deref "clojure.core" "str") "(" nop " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")")))) (if (jolt= kind (keyword #f "keyword")) (let* ((recv (jolt-first arg-nodes)) (idx (if (let* ((and__25__auto (jolt= (keyword #f "struct") (jolt-get recv (keyword #f "hint"))))) (if (jolt-truthy? and__25__auto) (jolt= 1 (jolt-count arg-nodes)) and__25__auto)) (let* ((_a$7142 (var-deref "jolt.backend-scheme" "struct-field-index")) (_a$7143 (jolt-get recv (keyword #f "shape"))) (_a$7144 (jolt-get fnode (keyword #f "val")))) (jolt-invoke _a$7142 _a$7143 _a$7144)) jolt-nil))) (if (jolt-truthy? idx) (jolt-invoke order-args (lambda (as) (let fnrec7145 ((as as)) (let* ((_a$7146 (var-deref "clojure.core" "str")) (_a$7147 "(jrec-field-at ") (_a$7148 (jolt-first as)) (_a$7149 " ") (_a$7150 idx) (_a$7151 " ") (_a$7152 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode)) (_a$7153 ")")) (jolt-invoke _a$7146 _a$7147 _a$7148 _a$7149 _a$7150 _a$7151 _a$7152 _a$7153))))) (jolt-invoke order-args (lambda (as) (let fnrec7154 ((as as)) (let* ((_a$7155 (var-deref "clojure.core" "str")) (_a$7156 "(jolt-get ") (_a$7157 (jolt-first as)) (_a$7158 " ") (_a$7159 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode)) (_a$7160 (jolt-invoke defstr as)) (_a$7161 ")")) (jolt-invoke _a$7155 _a$7156 _a$7157 _a$7158 _a$7159 _a$7160 _a$7161))))))) (if (jolt= kind (keyword #f "coll")) (let* ((_a$7163 (var-deref "jolt.backend-scheme" "ordered-call")) (_a$7164 (jolt-cons fnode arg-nodes)) (_a$7165 (jolt-cons (jolt-invoke (var-deref "jolt.backend-scheme" "emit") fnode) args)) (_a$7166 (lambda (G__137) (let fnrec7162 ((G__137 G__137)) (let* ((G__138 G__137) (c (jolt-nth G__138 0 jolt-nil)) (as (jolt-invoke (var-deref "clojure.core" "nthnext") G__138 1))) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-get " c " " (jolt-invoke (var-deref "clojure.string" "join") " " as) ")")))))) (jolt-invoke _a$7163 _a$7164 _a$7165 _a$7166)) (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$7173 (let* ((_a$7167 (var-deref "clojure.core" "str")) (_a$7168 "emit: unsupported stdlib fn `") (_a$7169 (jolt-get fnode (keyword #f "ns"))) (_a$7170 "/") (_a$7171 (jolt-get fnode (keyword #f "name"))) (_a$7172 "` (no core on Chez yet)")) (jolt-invoke _a$7167 _a$7168 _a$7169 _a$7170 _a$7171 _a$7172))) (_a$7174 (jolt-hash-map))) (jolt-ex-info _a$7173 _a$7174))) (if (jolt= (keyword #f "host-static") (jolt-get fnode (keyword #f "op"))) (jolt-invoke order-args (lambda (as) (let fnrec7175 ((as as)) (let* ((_a$7176 (var-deref "clojure.core" "str")) (_a$7177 "(host-static-call ") (_a$7178 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "class")))) (_a$7179 " ") (_a$7180 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get fnode (keyword #f "member")))) (_a$7181 (if (jolt-empty? as) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)))) (_a$7182 ")")) (jolt-invoke _a$7176 _a$7177 _a$7178 _a$7179 _a$7180 _a$7181 _a$7182))))) (if (jolt= (keyword #f "host") (jolt-get fnode (keyword #f "op"))) (jolt-throw (let* ((_a$7183 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host call `" (jolt-get fnode (keyword #f "name")) "`")) (_a$7184 (jolt-hash-map))) (jolt-ex-info _a$7183 _a$7184))) (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 fnrec7185 ((as as)) (let* ((_a$7186 (var-deref "clojure.core" "str")) (_a$7187 "(") (_a$7188 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get fnode (keyword #f "name")))) (_a$7189 (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "")) (_a$7190 ")")) (jolt-invoke _a$7186 _a$7187 _a$7188 _a$7189 _a$7190))))) (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$7191 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$7192 (jolt-get fnode (keyword #f "ns"))) (_a$7193 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7191 _a$7192 _a$7193)))) (if (jolt-truthy? and__25__auto) (let* ((_a$7194 (var-deref "jolt.backend-scheme" "direct-link-fn?")) (_a$7195 (jolt-get fnode (keyword #f "ns"))) (_a$7196 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7194 _a$7195 _a$7196)) and__25__auto)) and__25__auto))) (jolt-invoke order-args (lambda (as) (let fnrec7197 ((as as)) (let* ((_a$7201 (var-deref "clojure.core" "str")) (_a$7202 "(") (_a$7203 (let* ((_a$7198 (var-deref "jolt.backend-scheme" "dl-name")) (_a$7199 (jolt-get fnode (keyword #f "ns"))) (_a$7200 (jolt-get fnode (keyword #f "name")))) (jolt-invoke _a$7198 _a$7199 _a$7200))) (_a$7204 (if (jolt-truthy? (jolt-seq as)) (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " as)) "")) (_a$7205 ")")) (jolt-invoke _a$7201 _a$7202 _a$7203 _a$7204 _a$7205))))) (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 fnrec7198 ((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$7199 (var-deref "clojure.core" "str")) (_a$7200 "(guard (") (_a$7201 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") cs)) (_a$7202 " (else ") (_a$7203 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "catch-body")))) (_a$7204 ")) ") (_a$7205 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (_a$7206 ")")) (jolt-invoke _a$7199 _a$7200 _a$7201 _a$7202 _a$7203 _a$7204 _a$7205 _a$7206))) (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))) + (def-var! "jolt.backend-scheme" "emit-try" (letrec ((emit-try (lambda (node) (let fnrec7206 ((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$7207 (var-deref "clojure.core" "str")) (_a$7208 "(guard (") (_a$7209 (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") cs)) (_a$7210 " (else ") (_a$7211 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "catch-body")))) (_a$7212 ")) ") (_a$7213 (jolt-invoke (var-deref "jolt.backend-scheme" "emit") (jolt-get node (keyword #f "body")))) (_a$7214 ")")) (jolt-invoke _a$7207 _a$7208 _a$7209 _a$7210 _a$7211 _a$7212 _a$7213 _a$7214))) (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? (case-lambda ((node) (let fnrec7207 ((node node)) (returns-scheme-bool? node (jolt-hash-set)))) ((node bools) (let fnrec7208 ((node node) (bools bools)) (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$7209 (var-deref "jolt.backend-scheme" "native-op")) (_a$7210 (jolt-get node (keyword #f "fn"))) (_a$7211 (jolt-count (jolt-get node (keyword #f "args"))))) (jolt-invoke _a$7209 _a$7210 _a$7211)))) (jolt-invoke (var-deref "clojure.core" "boolean") (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)))) (if (jolt= (keyword #f "local") (jolt-get node (keyword #f "op"))) (jolt-contains? bools (jolt-get node (keyword #f "name"))) (if (jolt= (keyword #f "if") (jolt-get node (keyword #f "op"))) (let* ((and__25__auto (returns-scheme-bool? (jolt-get node (keyword #f "then")) bools))) (if (jolt-truthy? and__25__auto) (returns-scheme-bool? (jolt-get node (keyword #f "else")) bools) and__25__auto)) (if (jolt= (keyword #f "let") (jolt-get node (keyword #f "op"))) (let* ((bools_PRIME_ (let* ((_a$7213 (lambda (s b) (let fnrec7212 ((s s) (b b)) (if (jolt-truthy? (returns-scheme-bool? (jolt-nth b 1) s)) (jolt-conj s (jolt-nth b 0)) (jolt-invoke (var-deref "clojure.core" "disj") s (jolt-nth b 0)))))) (_a$7214 bools) (_a$7215 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$7213 _a$7214 _a$7215)))) (returns-scheme-bool? (jolt-get node (keyword #f "body")) bools_PRIME_)) (if (jolt-truthy? (keyword #f "else")) #f jolt-nil))))))))))) returns-scheme-bool?))) + (def-var! "jolt.backend-scheme" "returns-scheme-bool?" (letrec ((returns-scheme-bool? (case-lambda ((node) (let fnrec7215 ((node node)) (returns-scheme-bool? node (jolt-hash-set)))) ((node bools) (let fnrec7216 ((node node) (bools bools)) (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$7217 (var-deref "jolt.backend-scheme" "native-op")) (_a$7218 (jolt-get node (keyword #f "fn"))) (_a$7219 (jolt-count (jolt-get node (keyword #f "args"))))) (jolt-invoke _a$7217 _a$7218 _a$7219)))) (jolt-invoke (var-deref "clojure.core" "boolean") (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)))) (if (jolt= (keyword #f "local") (jolt-get node (keyword #f "op"))) (jolt-contains? bools (jolt-get node (keyword #f "name"))) (if (jolt= (keyword #f "if") (jolt-get node (keyword #f "op"))) (let* ((and__25__auto (returns-scheme-bool? (jolt-get node (keyword #f "then")) bools))) (if (jolt-truthy? and__25__auto) (returns-scheme-bool? (jolt-get node (keyword #f "else")) bools) and__25__auto)) (if (jolt= (keyword #f "let") (jolt-get node (keyword #f "op"))) (let* ((bools_PRIME_ (let* ((_a$7221 (lambda (s b) (let fnrec7220 ((s s) (b b)) (if (jolt-truthy? (returns-scheme-bool? (jolt-nth b 1) s)) (jolt-conj s (jolt-nth b 0)) (jolt-invoke (var-deref "clojure.core" "disj") s (jolt-nth b 0)))))) (_a$7222 bools) (_a$7223 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$7221 _a$7222 _a$7223)))) (returns-scheme-bool? (jolt-get node (keyword #f "body")) bools_PRIME_)) (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 fnrec7216 ((node node)) (let* ((G__139 (jolt-get node (keyword #f "op")))) (if (jolt= G__139 (keyword #f "const")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-const") (jolt-get node (keyword #f "val"))) (if (jolt= G__139 (keyword #f "local")) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get node (keyword #f "name"))) (if (jolt= G__139 (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$7217 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$7218 (jolt-get node (keyword #f "ns"))) (_a$7219 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$7217 _a$7218 _a$7219))) (let* ((_a$7220 (var-deref "jolt.backend-scheme" "dl-name")) (_a$7221 (jolt-get node (keyword #f "ns"))) (_a$7222 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$7220 _a$7221 _a$7222)) (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$7229 (let* ((_a$7223 (var-deref "clojure.core" "str")) (_a$7224 "emit: unsupported stdlib ref `") (_a$7225 (jolt-get node (keyword #f "ns"))) (_a$7226 "/") (_a$7227 (jolt-get node (keyword #f "name"))) (_a$7228 "` (no core on Chez yet)")) (jolt-invoke _a$7223 _a$7224 _a$7225 _a$7226 _a$7227 _a$7228))) (_a$7230 (jolt-hash-map))) (jolt-ex-info _a$7229 _a$7230))) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$7231 (var-deref "clojure.core" "str")) (_a$7232 "(var-deref ") (_a$7233 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7234 " ") (_a$7235 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7236 ")")) (jolt-invoke _a$7231 _a$7232 _a$7233 _a$7234 _a$7235 _a$7236)) jolt-nil))))) (if (jolt= G__139 (keyword #f "the-var")) (let* ((_a$7237 (var-deref "clojure.core" "str")) (_a$7238 "(jolt-var ") (_a$7239 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7240 " ") (_a$7241 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7242 ")")) (jolt-invoke _a$7237 _a$7238 _a$7239 _a$7240 _a$7241 _a$7242)) (if (jolt= G__139 (keyword #f "set-var")) (let* ((_a$7243 (var-deref "clojure.core" "str")) (_a$7244 "(jolt-var-set ") (_a$7245 (emit (jolt-get node (keyword #f "the-var")))) (_a$7246 " ") (_a$7247 (emit (jolt-get node (keyword #f "val")))) (_a$7248 ")")) (jolt-invoke _a$7243 _a$7244 _a$7245 _a$7246 _a$7247 _a$7248)) (if (jolt= G__139 (keyword #f "set-field")) (let* ((_a$7249 (var-deref "clojure.core" "str")) (_a$7250 "(jolt-set-field! ") (_a$7251 (emit (jolt-get node (keyword #f "obj")))) (_a$7252 " (keyword #f ") (_a$7253 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "field")))) (_a$7254 ") ") (_a$7255 (emit (jolt-get node (keyword #f "val")))) (_a$7256 ")")) (jolt-invoke _a$7249 _a$7250 _a$7251 _a$7252 _a$7253 _a$7254 _a$7255 _a$7256)) (if (jolt= G__139 (keyword #f "defmacro")) (let* ((_a$7257 (var-deref "clojure.core" "str")) (_a$7258 "(begin (def-var! ") (_a$7259 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7260 " ") (_a$7261 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7262 " ") (_a$7263 (emit (jolt-get node (keyword #f "fn")))) (_a$7264 ") (mark-macro! ") (_a$7265 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7266 " ") (_a$7267 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7268 ") jolt-nil)")) (jolt-invoke _a$7257 _a$7258 _a$7259 _a$7260 _a$7261 _a$7262 _a$7263 _a$7264 _a$7265 _a$7266 _a$7267 _a$7268)) (if (jolt= G__139 (keyword #f "host")) (jolt-throw (let* ((_a$7269 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host ref `" (jolt-get node (keyword #f "name")) "`")) (_a$7270 (jolt-hash-map))) (jolt-ex-info _a$7269 _a$7270))) (if (jolt= G__139 (keyword #f "host-static")) (let* ((_a$7271 (var-deref "clojure.core" "str")) (_a$7272 "(host-static-ref ") (_a$7273 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$7274 " ") (_a$7275 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "member")))) (_a$7276 ")")) (jolt-invoke _a$7271 _a$7272 _a$7273 _a$7274 _a$7275 _a$7276)) (if (jolt= G__139 (keyword #f "host-new")) (let* ((_a$7277 (var-deref "clojure.core" "str")) (_a$7278 "(host-new ") (_a$7279 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$7280 (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$7281 ")")) (jolt-invoke _a$7277 _a$7278 _a$7279 _a$7280 _a$7281)) (if (jolt= G__139 (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$7282 (var-deref "clojure.core" "str")) (_a$7283 "(if ") (_a$7284 t) (_a$7285 " ") (_a$7286 (emit (jolt-get node (keyword #f "then")))) (_a$7287 " ") (_a$7288 (emit (jolt-get node (keyword #f "else")))) (_a$7289 ")")) (jolt-invoke _a$7282 _a$7283 _a$7284 _a$7285 _a$7286 _a$7287 _a$7288 _a$7289))) (if (jolt= G__139 (keyword #f "do")) (let* ((_a$7290 (var-deref "clojure.core" "str")) (_a$7291 "(begin ") (_a$7292 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit (jolt-get node (keyword #f "statements"))))) (_a$7293 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$7294 (emit (jolt-get node (keyword #f "ret")))) (_a$7295 ")")) (jolt-invoke _a$7290 _a$7291 _a$7292 _a$7293 _a$7294 _a$7295)) (if (jolt= G__139 (keyword #f "invoke")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-invoke") node) (if (jolt= G__139 (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__139 (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__139 (keyword #f "map")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-hash-map" (let* ((_a$7299 (var-deref "clojure.core" "mapcat")) (_a$7300 (lambda (p) (let fnrec7296 ((p p)) (let* ((_o$7297 (emit (jolt-nth p 0))) (_o$7298 (emit (jolt-nth p 1)))) (jolt-vector _o$7297 _o$7298))))) (_a$7301 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$7299 _a$7300 _a$7301))) (if (jolt= G__139 (keyword #f "quote")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get node (keyword #f "form"))) (if (jolt= G__139 (keyword #f "throw")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-throw " (emit (jolt-get node (keyword #f "expr"))) ")") (if (jolt= G__139 (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__139 (keyword #f "try")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-try") node) (if (jolt= G__139 (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__139 (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__139 (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__139 (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__139 (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__139 (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$7302 (var-deref "clojure.core" "str")) (_a$7303 "(jolt-host-call ") (_a$7304 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$7305 " ") (_a$7306 target) (_a$7307 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$7308 ")")) (jolt-invoke _a$7302 _a$7303 _a$7304 _a$7305 _a$7306 _a$7307 _a$7308)) (let* ((_a$7309 (var-deref "clojure.core" "str")) (_a$7310 "(record-method-dispatch ") (_a$7311 target) (_a$7312 " ") (_a$7313 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$7314 " (jolt-vector") (_a$7315 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$7316 "))")) (jolt-invoke _a$7309 _a$7310 _a$7311 _a$7312 _a$7313 _a$7314 _a$7315 _a$7316)))) (if (jolt= G__139 (keyword #f "let")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-let") node) (if (jolt= G__139 (keyword #f "loop")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-loop") node) (if (jolt= G__139 (keyword #f "recur")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-recur") node) (if (jolt= G__139 (keyword #f "ffi-fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-fn") node) (if (jolt= G__139 (keyword #f "ffi-callable")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-callable") node) (if (jolt= G__139 (keyword #f "fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-fn") node) (if (jolt= G__139 (keyword #f "def")) (if (jolt-truthy? (jolt-get node (keyword #f "no-init"))) (let* ((_a$7317 (var-deref "clojure.core" "str")) (_a$7318 "(declare-var! ") (_a$7319 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7320 " ") (_a$7321 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7322 ")")) (jolt-invoke _a$7317 _a$7318 _a$7319 _a$7320 _a$7321 _a$7322)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$7323 (var-deref "clojure.core" "str")) (_a$7324 "(def-var-with-meta! ") (_a$7325 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7326 " ") (_a$7327 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7328 " ") (_a$7329 (emit (jolt-get node (keyword #f "init")))) (_a$7330 " ") (_a$7331 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$7332 ")")) (jolt-invoke _a$7323 _a$7324 _a$7325 _a$7326 _a$7327 _a$7328 _a$7329 _a$7330 _a$7331 _a$7332)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$7333 (var-deref "clojure.core" "str")) (_a$7334 "(def-var! ") (_a$7335 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7336 " ") (_a$7337 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7338 " ") (_a$7339 (emit (jolt-get node (keyword #f "init")))) (_a$7340 ")")) (jolt-invoke _a$7333 _a$7334 _a$7335 _a$7336 _a$7337 _a$7338 _a$7339 _a$7340)) jolt-nil))) (jolt-throw (let* ((_a$7341 (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$7342 (jolt-hash-map))) (jolt-ex-info _a$7341 _a$7342))))))))))))))))))))))))))))))))))))))))) emit))) + (def-var! "jolt.backend-scheme" "emit" (letrec ((emit (lambda (node) (let fnrec7224 ((node node)) (let* ((G__139 (jolt-get node (keyword #f "op")))) (if (jolt= G__139 (keyword #f "const")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-const") (jolt-get node (keyword #f "val"))) (if (jolt= G__139 (keyword #f "local")) (jolt-invoke (var-deref "jolt.backend-scheme" "munge-name") (jolt-get node (keyword #f "name"))) (if (jolt= G__139 (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$7225 (var-deref "jolt.backend-scheme" "direct-linkable?")) (_a$7226 (jolt-get node (keyword #f "ns"))) (_a$7227 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$7225 _a$7226 _a$7227))) (let* ((_a$7228 (var-deref "jolt.backend-scheme" "dl-name")) (_a$7229 (jolt-get node (keyword #f "ns"))) (_a$7230 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$7228 _a$7229 _a$7230)) (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$7237 (let* ((_a$7231 (var-deref "clojure.core" "str")) (_a$7232 "emit: unsupported stdlib ref `") (_a$7233 (jolt-get node (keyword #f "ns"))) (_a$7234 "/") (_a$7235 (jolt-get node (keyword #f "name"))) (_a$7236 "` (no core on Chez yet)")) (jolt-invoke _a$7231 _a$7232 _a$7233 _a$7234 _a$7235 _a$7236))) (_a$7238 (jolt-hash-map))) (jolt-ex-info _a$7237 _a$7238))) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$7239 (var-deref "clojure.core" "str")) (_a$7240 "(var-deref ") (_a$7241 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7242 " ") (_a$7243 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7244 ")")) (jolt-invoke _a$7239 _a$7240 _a$7241 _a$7242 _a$7243 _a$7244)) jolt-nil))))) (if (jolt= G__139 (keyword #f "the-var")) (let* ((_a$7245 (var-deref "clojure.core" "str")) (_a$7246 "(jolt-var ") (_a$7247 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7248 " ") (_a$7249 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7250 ")")) (jolt-invoke _a$7245 _a$7246 _a$7247 _a$7248 _a$7249 _a$7250)) (if (jolt= G__139 (keyword #f "set-var")) (let* ((_a$7251 (var-deref "clojure.core" "str")) (_a$7252 "(jolt-var-set ") (_a$7253 (emit (jolt-get node (keyword #f "the-var")))) (_a$7254 " ") (_a$7255 (emit (jolt-get node (keyword #f "val")))) (_a$7256 ")")) (jolt-invoke _a$7251 _a$7252 _a$7253 _a$7254 _a$7255 _a$7256)) (if (jolt= G__139 (keyword #f "set-field")) (let* ((_a$7257 (var-deref "clojure.core" "str")) (_a$7258 "(jolt-set-field! ") (_a$7259 (emit (jolt-get node (keyword #f "obj")))) (_a$7260 " (keyword #f ") (_a$7261 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "field")))) (_a$7262 ") ") (_a$7263 (emit (jolt-get node (keyword #f "val")))) (_a$7264 ")")) (jolt-invoke _a$7257 _a$7258 _a$7259 _a$7260 _a$7261 _a$7262 _a$7263 _a$7264)) (if (jolt= G__139 (keyword #f "defmacro")) (let* ((_a$7265 (var-deref "clojure.core" "str")) (_a$7266 "(begin (def-var! ") (_a$7267 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7268 " ") (_a$7269 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7270 " ") (_a$7271 (emit (jolt-get node (keyword #f "fn")))) (_a$7272 ") (mark-macro! ") (_a$7273 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7274 " ") (_a$7275 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7276 ") jolt-nil)")) (jolt-invoke _a$7265 _a$7266 _a$7267 _a$7268 _a$7269 _a$7270 _a$7271 _a$7272 _a$7273 _a$7274 _a$7275 _a$7276)) (if (jolt= G__139 (keyword #f "host")) (jolt-throw (let* ((_a$7277 (jolt-invoke (var-deref "clojure.core" "str") "emit: unsupported host ref `" (jolt-get node (keyword #f "name")) "`")) (_a$7278 (jolt-hash-map))) (jolt-ex-info _a$7277 _a$7278))) (if (jolt= G__139 (keyword #f "host-static")) (let* ((_a$7279 (var-deref "clojure.core" "str")) (_a$7280 "(host-static-ref ") (_a$7281 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$7282 " ") (_a$7283 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "member")))) (_a$7284 ")")) (jolt-invoke _a$7279 _a$7280 _a$7281 _a$7282 _a$7283 _a$7284)) (if (jolt= G__139 (keyword #f "host-new")) (let* ((_a$7285 (var-deref "clojure.core" "str")) (_a$7286 "(host-new ") (_a$7287 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "class")))) (_a$7288 (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$7289 ")")) (jolt-invoke _a$7285 _a$7286 _a$7287 _a$7288 _a$7289)) (if (jolt= G__139 (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$7290 (var-deref "clojure.core" "str")) (_a$7291 "(if ") (_a$7292 t) (_a$7293 " ") (_a$7294 (emit (jolt-get node (keyword #f "then")))) (_a$7295 " ") (_a$7296 (emit (jolt-get node (keyword #f "else")))) (_a$7297 ")")) (jolt-invoke _a$7290 _a$7291 _a$7292 _a$7293 _a$7294 _a$7295 _a$7296 _a$7297))) (if (jolt= G__139 (keyword #f "do")) (let* ((_a$7298 (var-deref "clojure.core" "str")) (_a$7299 "(begin ") (_a$7300 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit (jolt-get node (keyword #f "statements"))))) (_a$7301 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$7302 (emit (jolt-get node (keyword #f "ret")))) (_a$7303 ")")) (jolt-invoke _a$7298 _a$7299 _a$7300 _a$7301 _a$7302 _a$7303)) (if (jolt= G__139 (keyword #f "invoke")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-invoke") node) (if (jolt= G__139 (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__139 (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__139 (keyword #f "map")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ordered") "jolt-hash-map" (let* ((_a$7307 (var-deref "clojure.core" "mapcat")) (_a$7308 (lambda (p) (let fnrec7304 ((p p)) (let* ((_o$7305 (emit (jolt-nth p 0))) (_o$7306 (emit (jolt-nth p 1)))) (jolt-vector _o$7305 _o$7306))))) (_a$7309 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$7307 _a$7308 _a$7309))) (if (jolt= G__139 (keyword #f "quote")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-quoted") (jolt-get node (keyword #f "form"))) (if (jolt= G__139 (keyword #f "throw")) (jolt-invoke (var-deref "clojure.core" "str") "(jolt-throw " (emit (jolt-get node (keyword #f "expr"))) ")") (if (jolt= G__139 (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__139 (keyword #f "try")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-try") node) (if (jolt= G__139 (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__139 (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__139 (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__139 (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__139 (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__139 (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$7310 (var-deref "clojure.core" "str")) (_a$7311 "(jolt-host-call ") (_a$7312 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$7313 " ") (_a$7314 target) (_a$7315 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$7316 ")")) (jolt-invoke _a$7310 _a$7311 _a$7312 _a$7313 _a$7314 _a$7315 _a$7316)) (let* ((_a$7317 (var-deref "clojure.core" "str")) (_a$7318 "(record-method-dispatch ") (_a$7319 target) (_a$7320 " ") (_a$7321 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") m)) (_a$7322 " (jolt-vector") (_a$7323 (if (jolt-empty? args) "" (jolt-invoke (var-deref "clojure.core" "str") " " (jolt-invoke (var-deref "clojure.string" "join") " " args)))) (_a$7324 "))")) (jolt-invoke _a$7317 _a$7318 _a$7319 _a$7320 _a$7321 _a$7322 _a$7323 _a$7324)))) (if (jolt= G__139 (keyword #f "let")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-let") node) (if (jolt= G__139 (keyword #f "loop")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-loop") node) (if (jolt= G__139 (keyword #f "recur")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-recur") node) (if (jolt= G__139 (keyword #f "ffi-fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-fn") node) (if (jolt= G__139 (keyword #f "ffi-callable")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-ffi-callable") node) (if (jolt= G__139 (keyword #f "fn")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit-fn") node) (if (jolt= G__139 (keyword #f "def")) (if (jolt-truthy? (jolt-get node (keyword #f "no-init"))) (let* ((_a$7325 (var-deref "clojure.core" "str")) (_a$7326 "(declare-var! ") (_a$7327 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7328 " ") (_a$7329 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7330 ")")) (jolt-invoke _a$7325 _a$7326 _a$7327 _a$7328 _a$7329 _a$7330)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.backend-scheme" "jmeta-nonempty?") (jolt-get node (keyword #f "meta")))) (let* ((_a$7331 (var-deref "clojure.core" "str")) (_a$7332 "(def-var-with-meta! ") (_a$7333 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7334 " ") (_a$7335 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7336 " ") (_a$7337 (emit (jolt-get node (keyword #f "init")))) (_a$7338 " ") (_a$7339 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$7340 ")")) (jolt-invoke _a$7331 _a$7332 _a$7333 _a$7334 _a$7335 _a$7336 _a$7337 _a$7338 _a$7339 _a$7340)) (if (jolt-truthy? (keyword #f "else")) (let* ((_a$7341 (var-deref "clojure.core" "str")) (_a$7342 "(def-var! ") (_a$7343 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "ns")))) (_a$7344 " ") (_a$7345 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") (jolt-get node (keyword #f "name")))) (_a$7346 " ") (_a$7347 (emit (jolt-get node (keyword #f "init")))) (_a$7348 ")")) (jolt-invoke _a$7341 _a$7342 _a$7343 _a$7344 _a$7345 _a$7346 _a$7347 _a$7348)) jolt-nil))) (jolt-throw (let* ((_a$7349 (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$7350 (jolt-hash-map))) (jolt-ex-info _a$7349 _a$7350))))))))))))))))))))))))))))))))))))))))) emit))) (guard (e (#t #f)) - (def-var! "jolt.backend-scheme" "dl-opt-out?" (letrec ((dl-opt-out? (lambda (m) (let fnrec7343 ((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?))) + (def-var! "jolt.backend-scheme" "dl-opt-out?" (letrec ((dl-opt-out? (lambda (m) (let fnrec7351 ((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 fnrec7344 ((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$7345 (var-deref "clojure.core" "str")) (_a$7346 "(begin ") (_a$7347 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-top-form (jolt-get node (keyword #f "statements"))))) (_a$7348 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$7349 (emit-top-form (jolt-get node (keyword #f "ret")))) (_a$7350 ")")) (jolt-invoke _a$7345 _a$7346 _a$7347 _a$7348 _a$7349 _a$7350)) (if (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$7351 (var-deref "clojure.core" "str")) (_a$7352 " (jolt-register-source! ") (_a$7353 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") frame-name)) (_a$7354 " ") (_a$7355 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$7356 " ") (_a$7357 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7358 " ") (_a$7359 (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$7360 " ") (_a$7361 (let* ((or__26__auto (jolt-get pos (keyword #f "line")))) (if (jolt-truthy? or__26__auto) or__26__auto 0))) (_a$7362 ")")) (jolt-invoke _a$7351 _a$7352 _a$7353 _a$7354 _a$7355 _a$7356 _a$7357 _a$7358 _a$7359 _a$7360 _a$7361 _a$7362)) 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$7363 (var-deref "clojure.core" "str")) (_a$7364 "(begin (define ") (_a$7365 b) (_a$7366 " ") (_a$7367 init) (_a$7368 ") (def-var-with-meta! ") (_a$7369 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$7370 " ") (_a$7371 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7372 " ") (_a$7373 b) (_a$7374 " ") (_a$7375 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$7376 ")") (_a$7377 (let* ((or__26__auto reg)) (if (jolt-truthy? or__26__auto) or__26__auto ""))) (_a$7378 ")")) (jolt-invoke _a$7363 _a$7364 _a$7365 _a$7366 _a$7367 _a$7368 _a$7369 _a$7370 _a$7371 _a$7372 _a$7373 _a$7374 _a$7375 _a$7376 _a$7377 _a$7378)) (let* ((_a$7379 (var-deref "clojure.core" "str")) (_a$7380 "(begin (define ") (_a$7381 b) (_a$7382 " ") (_a$7383 init) (_a$7384 ") (def-var! ") (_a$7385 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$7386 " ") (_a$7387 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7388 " ") (_a$7389 b) (_a$7390 ")") (_a$7391 (let* ((or__26__auto reg)) (if (jolt-truthy? or__26__auto) or__26__auto ""))) (_a$7392 ")")) (jolt-invoke _a$7379 _a$7380 _a$7381 _a$7382 _a$7383 _a$7384 _a$7385 _a$7386 _a$7387 _a$7388 _a$7389 _a$7390 _a$7391 _a$7392)))))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.backend-scheme" "emit") node) jolt-nil)))))))) emit-top-form))) + (def-var! "jolt.backend-scheme" "emit-top-form" (letrec ((emit-top-form (lambda (node) (let fnrec7352 ((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$7353 (var-deref "clojure.core" "str")) (_a$7354 "(begin ") (_a$7355 (jolt-invoke (var-deref "clojure.string" "join") " " (jolt-map emit-top-form (jolt-get node (keyword #f "statements"))))) (_a$7356 (if (jolt-empty? (jolt-get node (keyword #f "statements"))) "" " ")) (_a$7357 (emit-top-form (jolt-get node (keyword #f "ret")))) (_a$7358 ")")) (jolt-invoke _a$7353 _a$7354 _a$7355 _a$7356 _a$7357 _a$7358)) (if (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$7359 (var-deref "clojure.core" "str")) (_a$7360 " (jolt-register-source! ") (_a$7361 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") frame-name)) (_a$7362 " ") (_a$7363 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$7364 " ") (_a$7365 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7366 " ") (_a$7367 (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$7368 " ") (_a$7369 (let* ((or__26__auto (jolt-get pos (keyword #f "line")))) (if (jolt-truthy? or__26__auto) or__26__auto 0))) (_a$7370 ")")) (jolt-invoke _a$7359 _a$7360 _a$7361 _a$7362 _a$7363 _a$7364 _a$7365 _a$7366 _a$7367 _a$7368 _a$7369 _a$7370)) 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$7371 (var-deref "clojure.core" "str")) (_a$7372 "(begin (define ") (_a$7373 b) (_a$7374 " ") (_a$7375 init) (_a$7376 ") (def-var-with-meta! ") (_a$7377 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$7378 " ") (_a$7379 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7380 " ") (_a$7381 b) (_a$7382 " ") (_a$7383 (jolt-invoke (var-deref "jolt.backend-scheme" "emit-def-meta") node)) (_a$7384 ")") (_a$7385 (let* ((or__26__auto reg)) (if (jolt-truthy? or__26__auto) or__26__auto ""))) (_a$7386 ")")) (jolt-invoke _a$7371 _a$7372 _a$7373 _a$7374 _a$7375 _a$7376 _a$7377 _a$7378 _a$7379 _a$7380 _a$7381 _a$7382 _a$7383 _a$7384 _a$7385 _a$7386)) (let* ((_a$7387 (var-deref "clojure.core" "str")) (_a$7388 "(begin (define ") (_a$7389 b) (_a$7390 " ") (_a$7391 init) (_a$7392 ") (def-var! ") (_a$7393 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") ns)) (_a$7394 " ") (_a$7395 (jolt-invoke (var-deref "jolt.backend-scheme" "chez-str-lit") nm)) (_a$7396 " ") (_a$7397 b) (_a$7398 ")") (_a$7399 (let* ((or__26__auto reg)) (if (jolt-truthy? or__26__auto) or__26__auto ""))) (_a$7400 ")")) (jolt-invoke _a$7387 _a$7388 _a$7389 _a$7390 _a$7391 _a$7392 _a$7393 _a$7394 _a$7395 _a$7396 _a$7397 _a$7398 _a$7399 _a$7400)))))) (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$7393 "+") (_o$7394 jolt-add) (_o$7395 "-") (_o$7396 jolt-sub) (_o$7397 "*") (_o$7398 jolt-mul) (_o$7399 "/") (_o$7400 jolt-div) (_o$7401 "<") (_o$7402 <) (_o$7403 ">") (_o$7404 >) (_o$7405 "<=") (_o$7406 <=) (_o$7407 ">=") (_o$7408 >=) (_o$7409 "=") (_o$7410 jolt=) (_o$7411 "inc") (_o$7412 jolt-inc) (_o$7413 "dec") (_o$7414 jolt-dec) (_o$7415 "mod") (_o$7416 modulo) (_o$7417 "rem") (_o$7418 remainder) (_o$7419 "quot") (_o$7420 quotient) (_o$7421 "bit-and") (_o$7422 (var-deref "clojure.core" "__bit-and")) (_o$7423 "bit-or") (_o$7424 (var-deref "clojure.core" "__bit-or")) (_o$7425 "bit-xor") (_o$7426 (var-deref "clojure.core" "__bit-xor"))) (jolt-hash-map _o$7393 _o$7394 _o$7395 _o$7396 _o$7397 _o$7398 _o$7399 _o$7400 _o$7401 _o$7402 _o$7403 _o$7404 _o$7405 _o$7406 _o$7407 _o$7408 _o$7409 _o$7410 _o$7411 _o$7412 _o$7413 _o$7414 _o$7415 _o$7416 _o$7417 _o$7418 _o$7419 _o$7420 _o$7421 _o$7422 _o$7423 _o$7424 _o$7425 _o$7426)) (let* ((_o$7427 (keyword #f "private")) (_o$7428 #t)) (jolt-hash-map _o$7427 _o$7428)))) + (def-var-with-meta! "jolt.passes.fold" "foldable" (let* ((_o$7401 "+") (_o$7402 jolt-add) (_o$7403 "-") (_o$7404 jolt-sub) (_o$7405 "*") (_o$7406 jolt-mul) (_o$7407 "/") (_o$7408 jolt-div) (_o$7409 "<") (_o$7410 <) (_o$7411 ">") (_o$7412 >) (_o$7413 "<=") (_o$7414 <=) (_o$7415 ">=") (_o$7416 >=) (_o$7417 "=") (_o$7418 jolt=) (_o$7419 "inc") (_o$7420 jolt-inc) (_o$7421 "dec") (_o$7422 jolt-dec) (_o$7423 "mod") (_o$7424 modulo) (_o$7425 "rem") (_o$7426 remainder) (_o$7427 "quot") (_o$7428 quotient) (_o$7429 "bit-and") (_o$7430 (var-deref "clojure.core" "__bit-and")) (_o$7431 "bit-or") (_o$7432 (var-deref "clojure.core" "__bit-or")) (_o$7433 "bit-xor") (_o$7434 (var-deref "clojure.core" "__bit-xor"))) (jolt-hash-map _o$7401 _o$7402 _o$7403 _o$7404 _o$7405 _o$7406 _o$7407 _o$7408 _o$7409 _o$7410 _o$7411 _o$7412 _o$7413 _o$7414 _o$7415 _o$7416 _o$7417 _o$7418 _o$7419 _o$7420 _o$7421 _o$7422 _o$7423 _o$7424 _o$7425 _o$7426 _o$7427 _o$7428 _o$7429 _o$7430 _o$7431 _o$7432 _o$7433 _o$7434)) (let* ((_o$7435 (keyword #f "private")) (_o$7436 #t)) (jolt-hash-map _o$7435 _o$7436)))) (guard (e (#t #f)) - (def-var! "jolt.passes.fold" "const?" (letrec ((const? (lambda (n) (let fnrec7429 ((n n)) (jolt= (keyword #f "const") (jolt-get n (keyword #f "op"))))))) const?))) + (def-var! "jolt.passes.fold" "const?" (letrec ((const? (lambda (n) (let fnrec7437 ((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 fnrec7430 ((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?))) + (def-var! "jolt.passes.fold" "const-num?" (letrec ((const-num? (lambda (n) (let fnrec7438 ((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 fnrec7431 ((fnode fnode)) (let* ((op (jolt-get fnode (keyword #f "op")))) (if (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))) + (def-var! "jolt.passes.fold" "fold-fn" (letrec ((fold-fn (lambda (fnode) (let fnrec7439 ((fnode fnode)) (let* ((op (jolt-get fnode (keyword #f "op")))) (if (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 fnrec7432 ((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$catch1536 (else (let* ((e _r$catch1536)) jolt-nil))) (let* ((_o$7434 (keyword #f "op")) (_o$7435 (keyword #f "const")) (_o$7436 (keyword #f "val")) (_o$7437 (jolt-apply ff (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (a) (let fnrec7433 ((a a)) (jolt-get a (keyword #f "val")))) args)))) (jolt-hash-map _o$7434 _o$7435 _o$7436 _o$7437))) 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 (let* ((or__26__auto (jolt-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$7438 node) (_a$7439 (keyword #f "test")) (_a$7440 t) (_a$7441 (keyword #f "then")) (_a$7442 (const-fold (jolt-get node (keyword #f "then")))) (_a$7443 (keyword #f "else")) (_a$7444 (const-fold (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$7438 _a$7439 _a$7440 _a$7441 _a$7442 _a$7443 _a$7444)))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") const-fold node) jolt-nil)))))))) const-fold) (let* ((_o$7445 (keyword #f "doc")) (_o$7446 "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$7445 _o$7446)))) + (def-var-with-meta! "jolt.passes.fold" "const-fold" (letrec ((const-fold (lambda (node) (let fnrec7440 ((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$catch1537 (else (let* ((e _r$catch1537)) jolt-nil))) (let* ((_o$7442 (keyword #f "op")) (_o$7443 (keyword #f "const")) (_o$7444 (keyword #f "val")) (_o$7445 (jolt-apply ff (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (a) (let fnrec7441 ((a a)) (jolt-get a (keyword #f "val")))) args)))) (jolt-hash-map _o$7442 _o$7443 _o$7444 _o$7445))) 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 (let* ((or__26__auto (jolt-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$7446 node) (_a$7447 (keyword #f "test")) (_a$7448 t) (_a$7449 (keyword #f "then")) (_a$7450 (const-fold (jolt-get node (keyword #f "then")))) (_a$7451 (keyword #f "else")) (_a$7452 (const-fold (jolt-get node (keyword #f "else"))))) (jolt-assoc _a$7446 _a$7447 _a$7448 _a$7449 _a$7450 _a$7451 _a$7452)))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") const-fold node) jolt-nil)))))))) const-fold) (let* ((_o$7453 (keyword #f "doc")) (_o$7454 "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$7453 _o$7454)))) (guard (e (#t #f)) - (def-var! "jolt.passes.fold" "scalar-const?" (letrec ((scalar-const? (lambda (n) (let fnrec7447 ((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?))) + (def-var! "jolt.passes.fold" "scalar-const?" (letrec ((scalar-const? (lambda (n) (let fnrec7455 ((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 fnrec7448 ((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$7449 (keyword #f "doc")) (_o$7450 "True if fnode is a constant keyword used as a function head \x2014; the (:k m) form.")) (jolt-hash-map _o$7449 _o$7450)))) + (def-var-with-meta! "jolt.passes.fold" "kw-callee?" (letrec ((kw-callee? (lambda (fnode) (let fnrec7456 ((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$7457 (keyword #f "doc")) (_o$7458 "True if fnode is a constant keyword used as a function head \x2014; the (:k m) form.")) (jolt-hash-map _o$7457 _o$7458)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.fold" "get-callee?" (letrec ((get-callee? (lambda (fnode) (let fnrec7451 ((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$7452 (keyword #f "doc")) (_o$7453 "True if fnode is the clojure.core/get (or host get) callee \x2014; the (get m k) form.")) (jolt-hash-map _o$7452 _o$7453)))) + (def-var-with-meta! "jolt.passes.fold" "get-callee?" (letrec ((get-callee? (lambda (fnode) (let fnrec7459 ((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$7460 (keyword #f "doc")) (_o$7461 "True if fnode is the clojure.core/get (or host get) callee \x2014; the (get m k) form.")) (jolt-hash-map _o$7460 _o$7461)))) (guard (e (#t #f)) - (def-var! "jolt.passes.numeric" "int-lit?" (letrec ((int-lit? (lambda (n) (let fnrec6001 ((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?))) + (def-var! "jolt.passes.numeric" "int-lit?" (letrec ((int-lit? (lambda (n) (let fnrec6002 ((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 fnrec6002 ((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?))) + (def-var! "jolt.passes.numeric" "float-lit?" (letrec ((float-lit? (lambda (n) (let fnrec6003 ((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 fnrec6003 ((nm nm) (n n)) (if (let* ((and__25__auto (>= n 1))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$6004 "+") (_o$6005 "-") (_o$6006 "*") (_o$6007 "/") (_o$6008 "min") (_o$6009 "max")) (jolt-hash-set _o$6004 _o$6005 _o$6006 _o$6007 _o$6008 _o$6009)) nm) and__25__auto)) (keyword #f "double") (if (let* ((and__25__auto (jolt= n 1))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$6010 "inc") (_o$6011 "dec")) (jolt-hash-set _o$6010 _o$6011)) nm) and__25__auto)) (keyword #f "double") (if (let* ((and__25__auto (>= n 2))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$6012 "<") (_o$6013 ">") (_o$6014 "<=") (_o$6015 ">=") (_o$6016 "=") (_o$6017 "==")) (jolt-hash-set _o$6012 _o$6013 _o$6014 _o$6015 _o$6016 _o$6017)) nm) and__25__auto)) (keyword #f "bool") (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil)))))))) dbl-spec))) + (def-var! "jolt.passes.numeric" "dbl-spec" (letrec ((dbl-spec (lambda (nm n) (let fnrec6004 ((nm nm) (n n)) (if (let* ((and__25__auto (>= n 1))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$6005 "+") (_o$6006 "-") (_o$6007 "*") (_o$6008 "/") (_o$6009 "min") (_o$6010 "max")) (jolt-hash-set _o$6005 _o$6006 _o$6007 _o$6008 _o$6009 _o$6010)) nm) and__25__auto)) (keyword #f "double") (if (let* ((and__25__auto (jolt= n 1))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$6011 "inc") (_o$6012 "dec")) (jolt-hash-set _o$6011 _o$6012)) nm) and__25__auto)) (keyword #f "double") (if (let* ((and__25__auto (>= n 2))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$6013 "<") (_o$6014 ">") (_o$6015 "<=") (_o$6016 ">=") (_o$6017 "=") (_o$6018 "==")) (jolt-hash-set _o$6013 _o$6014 _o$6015 _o$6016 _o$6017 _o$6018)) 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 fnrec6018 ((nm nm) (n n)) (if (let* ((and__25__auto (>= n 1))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$6019 "+") (_o$6020 "-") (_o$6021 "*") (_o$6022 "min") (_o$6023 "max") (_o$6024 "unchecked-add") (_o$6025 "unchecked-subtract") (_o$6026 "unchecked-multiply")) (jolt-hash-set _o$6019 _o$6020 _o$6021 _o$6022 _o$6023 _o$6024 _o$6025 _o$6026)) nm) and__25__auto)) (keyword #f "long") (if (let* ((and__25__auto (jolt= n 1))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$6027 "inc") (_o$6028 "dec") (_o$6029 "unchecked-inc") (_o$6030 "unchecked-dec")) (jolt-hash-set _o$6027 _o$6028 _o$6029 _o$6030)) nm) and__25__auto)) (keyword #f "long") (if (let* ((and__25__auto (jolt= n 2))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$6031 "quot") (_o$6032 "rem") (_o$6033 "mod")) (jolt-hash-set _o$6031 _o$6032 _o$6033)) nm) and__25__auto)) (keyword #f "long") (if (let* ((and__25__auto (>= n 2))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$6034 "<") (_o$6035 ">") (_o$6036 "<=") (_o$6037 ">=") (_o$6038 "=") (_o$6039 "==")) (jolt-hash-set _o$6034 _o$6035 _o$6036 _o$6037 _o$6038 _o$6039)) nm) and__25__auto)) (keyword #f "bool") (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))))))) lng-spec))) + (def-var! "jolt.passes.numeric" "lng-spec" (letrec ((lng-spec (lambda (nm n) (let fnrec6019 ((nm nm) (n n)) (if (let* ((and__25__auto (>= n 1))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$6020 "+") (_o$6021 "-") (_o$6022 "*") (_o$6023 "min") (_o$6024 "max") (_o$6025 "unchecked-add") (_o$6026 "unchecked-subtract") (_o$6027 "unchecked-multiply")) (jolt-hash-set _o$6020 _o$6021 _o$6022 _o$6023 _o$6024 _o$6025 _o$6026 _o$6027)) nm) and__25__auto)) (keyword #f "long") (if (let* ((and__25__auto (jolt= n 1))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$6028 "inc") (_o$6029 "dec") (_o$6030 "unchecked-inc") (_o$6031 "unchecked-dec")) (jolt-hash-set _o$6028 _o$6029 _o$6030 _o$6031)) nm) and__25__auto)) (keyword #f "long") (if (let* ((and__25__auto (jolt= n 2))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$6032 "quot") (_o$6033 "rem") (_o$6034 "mod")) (jolt-hash-set _o$6032 _o$6033 _o$6034)) nm) and__25__auto)) (keyword #f "long") (if (let* ((and__25__auto (>= n 2))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$6035 "<") (_o$6036 ">") (_o$6037 "<=") (_o$6038 ">=") (_o$6039 "=") (_o$6040 "==")) (jolt-hash-set _o$6035 _o$6036 _o$6037 _o$6038 _o$6039 _o$6040)) 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 fnrec6040 ((nm nm) (n n)) (if (let* ((and__25__auto (>= n 1))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$6041 "+") (_o$6042 "-") (_o$6043 "*") (_o$6044 "/") (_o$6045 "min") (_o$6046 "max")) (jolt-hash-set _o$6041 _o$6042 _o$6043 _o$6044 _o$6045 _o$6046)) nm) and__25__auto)) (keyword #f "bigdec") (if (let* ((and__25__auto (jolt= n 2))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$6047 "quot") (_o$6048 "rem")) (jolt-hash-set _o$6047 _o$6048)) nm) and__25__auto)) (keyword #f "bigdec") (if (let* ((and__25__auto (jolt= n 1))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$6049 "zero?") (_o$6050 "pos?") (_o$6051 "neg?")) (jolt-hash-set _o$6049 _o$6050 _o$6051)) nm) and__25__auto)) (keyword #f "bool") (if (let* ((and__25__auto (>= n 2))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$6052 "<") (_o$6053 ">") (_o$6054 "<=") (_o$6055 ">=")) (jolt-hash-set _o$6052 _o$6053 _o$6054 _o$6055)) nm) and__25__auto)) (keyword #f "bool") (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))))))) bd-spec))) + (def-var! "jolt.passes.numeric" "bd-spec" (letrec ((bd-spec (lambda (nm n) (let fnrec6041 ((nm nm) (n n)) (if (let* ((and__25__auto (>= n 1))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$6042 "+") (_o$6043 "-") (_o$6044 "*") (_o$6045 "/") (_o$6046 "min") (_o$6047 "max")) (jolt-hash-set _o$6042 _o$6043 _o$6044 _o$6045 _o$6046 _o$6047)) nm) and__25__auto)) (keyword #f "bigdec") (if (let* ((and__25__auto (jolt= n 2))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$6048 "quot") (_o$6049 "rem")) (jolt-hash-set _o$6048 _o$6049)) nm) and__25__auto)) (keyword #f "bigdec") (if (let* ((and__25__auto (jolt= n 1))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$6050 "zero?") (_o$6051 "pos?") (_o$6052 "neg?")) (jolt-hash-set _o$6050 _o$6051 _o$6052)) nm) and__25__auto)) (keyword #f "bool") (if (let* ((and__25__auto (>= n 2))) (if (jolt-truthy? and__25__auto) (jolt-contains? (let* ((_o$6053 "<") (_o$6054 ">") (_o$6055 "<=") (_o$6056 ">=")) (jolt-hash-set _o$6053 _o$6054 _o$6055 _o$6056)) 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 fnrec6056 ((spec spec)) (if (jolt= spec (keyword #f "bool")) jolt-nil spec))))) propagate))) + (def-var! "jolt.passes.numeric" "propagate" (letrec ((propagate (lambda (spec) (let fnrec6057 ((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 fnrec6057 ((node node) (tenv tenv)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "recur")) (jolt-vector (let* ((_a$6059 (var-deref "clojure.core" "mapv")) (_a$6060 (lambda (a) (let fnrec6058 ((a a)) (jolt-nth (jolt-invoke (var-deref "jolt.passes.numeric" "an") a tenv) 0)))) (_a$6061 (jolt-get node (keyword #f "args")))) (jolt-invoke _a$6059 _a$6060 _a$6061))) (if (jolt= op (keyword #f "let")) (let* ((_a$6069 (jolt-get node (keyword #f "body"))) (_a$6070 (let* ((_a$6066 (lambda (te b) (let fnrec6062 ((te te) (b b)) (let* ((_a$6063 te) (_a$6064 (jolt-nth b 0)) (_a$6065 (jolt-nth (jolt-invoke (var-deref "jolt.passes.numeric" "an") (jolt-nth b 1) te) 0))) (jolt-assoc _a$6063 _a$6064 _a$6065))))) (_a$6067 tenv) (_a$6068 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$6066 _a$6067 _a$6068)))) (recur-kinds _a$6069 _a$6070)) (if (jolt= op (keyword #f "if")) (let* ((_a$6071 (recur-kinds (jolt-get node (keyword #f "then")) tenv)) (_a$6072 (recur-kinds (jolt-get node (keyword #f "else")) tenv))) (jolt-concat _a$6071 _a$6072)) (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))) + (def-var! "jolt.passes.numeric" "recur-kinds" (letrec ((recur-kinds (lambda (node tenv) (let fnrec6058 ((node node) (tenv tenv)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "recur")) (jolt-vector (let* ((_a$6060 (var-deref "clojure.core" "mapv")) (_a$6061 (lambda (a) (let fnrec6059 ((a a)) (jolt-nth (jolt-invoke (var-deref "jolt.passes.numeric" "an") a tenv) 0)))) (_a$6062 (jolt-get node (keyword #f "args")))) (jolt-invoke _a$6060 _a$6061 _a$6062))) (if (jolt= op (keyword #f "let")) (let* ((_a$6070 (jolt-get node (keyword #f "body"))) (_a$6071 (let* ((_a$6067 (lambda (te b) (let fnrec6063 ((te te) (b b)) (let* ((_a$6064 te) (_a$6065 (jolt-nth b 0)) (_a$6066 (jolt-nth (jolt-invoke (var-deref "jolt.passes.numeric" "an") (jolt-nth b 1) te) 0))) (jolt-assoc _a$6064 _a$6065 _a$6066))))) (_a$6068 tenv) (_a$6069 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$6067 _a$6068 _a$6069)))) (recur-kinds _a$6070 _a$6071)) (if (jolt= op (keyword #f "if")) (let* ((_a$6072 (recur-kinds (jolt-get node (keyword #f "then")) tenv)) (_a$6073 (recur-kinds (jolt-get node (keyword #f "else")) tenv))) (jolt-concat _a$6072 _a$6073)) (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 fnrec6073 ((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$6074 (recur-arg-lists (jolt-get node (keyword #f "then")))) (_a$6075 (recur-arg-lists (jolt-get node (keyword #f "else"))))) (jolt-concat _a$6074 _a$6075)) (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))) + (def-var! "jolt.passes.numeric" "recur-arg-lists" (letrec ((recur-arg-lists (lambda (node) (let fnrec6074 ((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$6075 (recur-arg-lists (jolt-get node (keyword #f "then")))) (_a$6076 (recur-arg-lists (jolt-get node (keyword #f "else"))))) (jolt-concat _a$6075 _a$6076)) (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 fnrec6076 ((arg arg) (vname vname)) (if (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 fnrec6077 ((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 (let* ((and__25__auto (jolt-contains? (let* ((_o$6078 "inc") (_o$6079 "dec") (_o$6080 "unchecked-inc") (_o$6081 "unchecked-dec")) (jolt-hash-set _o$6078 _o$6079 _o$6080 _o$6081)) nm))) (if (jolt-truthy? and__25__auto) (jolt= 1 (jolt-count as)) and__25__auto)) (jolt-invoke v? (jolt-nth as 0)) (if (let* ((and__25__auto (jolt-contains? (let* ((_o$6082 "+") (_o$6083 "unchecked-add")) (jolt-hash-set _o$6082 _o$6083)) 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 (let* ((and__25__auto (jolt-contains? (let* ((_o$6084 "-") (_o$6085 "unchecked-subtract")) (jolt-hash-set _o$6084 _o$6085)) 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?))) + (def-var! "jolt.passes.numeric" "counter-step?" (letrec ((counter-step? (lambda (arg vname) (let fnrec6077 ((arg arg) (vname vname)) (if (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 fnrec6078 ((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 (let* ((and__25__auto (jolt-contains? (let* ((_o$6079 "inc") (_o$6080 "dec") (_o$6081 "unchecked-inc") (_o$6082 "unchecked-dec")) (jolt-hash-set _o$6079 _o$6080 _o$6081 _o$6082)) nm))) (if (jolt-truthy? and__25__auto) (jolt= 1 (jolt-count as)) and__25__auto)) (jolt-invoke v? (jolt-nth as 0)) (if (let* ((and__25__auto (jolt-contains? (let* ((_o$6083 "+") (_o$6084 "unchecked-add")) (jolt-hash-set _o$6083 _o$6084)) 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 (let* ((and__25__auto (jolt-contains? (let* ((_o$6085 "-") (_o$6086 "unchecked-subtract")) (jolt-hash-set _o$6085 _o$6086)) 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 fnrec6086 ((names names) (seed seed) (body body) (tenv tenv)) (let* ((cur seed) (iter 0)) (let loop6087 ((cur cur) (iter iter)) (if (> iter (jolt-count names)) cur (let* ((te (let* ((_a$6092 (lambda (t i) (let fnrec6088 ((t t) (i i)) (let* ((_a$6089 t) (_a$6090 (jolt-nth names i)) (_a$6091 (jolt-nth cur i))) (jolt-assoc _a$6089 _a$6090 _a$6091))))) (_a$6093 tenv) (_a$6094 (jolt-range (jolt-count names)))) (jolt-reduce _a$6092 _a$6093 _a$6094))) (rks (jolt-invoke (var-deref "jolt.passes.numeric" "recur-kinds") body te)) (nxt (let* ((_a$6097 (var-deref "clojure.core" "mapv")) (_a$6098 (lambda (j) (let fnrec6095 ((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 fnrec6096 ((rk rk)) (jolt= k (jolt-nth rk j)))) rks) and__25__auto))) k jolt-nil))))) (_a$6099 (jolt-range (jolt-count names)))) (jolt-invoke _a$6097 _a$6098 _a$6099)))) (if (jolt= nxt cur) cur (loop6087 nxt (jolt-inc iter))))))))))) loop-kinds))) + (def-var! "jolt.passes.numeric" "loop-kinds" (letrec ((loop-kinds (lambda (names seed body tenv) (let fnrec6087 ((names names) (seed seed) (body body) (tenv tenv)) (let* ((cur seed) (iter 0)) (let loop6088 ((cur cur) (iter iter)) (if (> iter (jolt-count names)) cur (let* ((te (let* ((_a$6093 (lambda (t i) (let fnrec6089 ((t t) (i i)) (let* ((_a$6090 t) (_a$6091 (jolt-nth names i)) (_a$6092 (jolt-nth cur i))) (jolt-assoc _a$6090 _a$6091 _a$6092))))) (_a$6094 tenv) (_a$6095 (jolt-range (jolt-count names)))) (jolt-reduce _a$6093 _a$6094 _a$6095))) (rks (jolt-invoke (var-deref "jolt.passes.numeric" "recur-kinds") body te)) (nxt (let* ((_a$6098 (var-deref "clojure.core" "mapv")) (_a$6099 (lambda (j) (let fnrec6096 ((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 fnrec6097 ((rk rk)) (jolt= k (jolt-nth rk j)))) rks) and__25__auto))) k jolt-nil))))) (_a$6100 (jolt-range (jolt-count names)))) (jolt-invoke _a$6098 _a$6099 _a$6100)))) (if (jolt= nxt cur) cur (loop6088 nxt (jolt-inc iter))))))))))) loop-kinds))) (guard (e (#t #f)) - (def-var! "jolt.passes.numeric" "arity-env" (letrec ((arity-env (lambda (tenv a) (let fnrec6100 ((tenv tenv) (a a)) (let* ((nh (let* ((_a$6101 (jolt-hash-map)) (_a$6102 (jolt-get a (keyword #f "nhints")))) (jolt-into _a$6101 _a$6102))) (pe (let* ((_a$6104 (lambda (e p) (let fnrec6103 ((e e) (p p)) (jolt-assoc e p (jolt-get nh p))))) (_a$6105 tenv) (_a$6106 (jolt-get a (keyword #f "params")))) (jolt-reduce _a$6104 _a$6105 _a$6106)))) (if (jolt-truthy? (jolt-get a (keyword #f "rest"))) (jolt-assoc pe (jolt-get a (keyword #f "rest")) jolt-nil) pe)))))) arity-env))) + (def-var! "jolt.passes.numeric" "arity-env" (letrec ((arity-env (lambda (tenv a) (let fnrec6101 ((tenv tenv) (a a)) (let* ((nh (let* ((_a$6102 (jolt-hash-map)) (_a$6103 (jolt-get a (keyword #f "nhints")))) (jolt-into _a$6102 _a$6103))) (pe (let* ((_a$6105 (lambda (e p) (let fnrec6104 ((e e) (p p)) (jolt-assoc e p (jolt-get nh p))))) (_a$6106 tenv) (_a$6107 (jolt-get a (keyword #f "params")))) (jolt-reduce _a$6105 _a$6106 _a$6107)))) (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 fnrec6107 ((node node) (tenv tenv)) (let* ((fnode (jolt-get node (keyword #f "fn"))) (nm (if (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$6109 (var-deref "clojure.core" "mapv")) (_a$6110 (lambda (a) (let fnrec6108 ((a a)) (jolt-invoke (var-deref "jolt.passes.numeric" "an") a tenv)))) (_a$6111 (jolt-get node (keyword #f "args")))) (jolt-invoke _a$6109 _a$6110 _a$6111))) (argnodes (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec6112 ((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$6113 (jolt-get fnode (keyword #f "num-ret"))) (_o$6114 node1)) (jolt-vector _o$6113 _o$6114)) (if (jolt-nil? nm) (let* ((_o$6115 jolt-nil) (_o$6116 node1)) (jolt-vector _o$6115 _o$6116)) (if (jolt-truthy? (keyword #f "else")) (let* ((cls (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec6117 ((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 fnrec6118 ((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 fnrec6119 ((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 fnrec6120 ((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 fnrec6121 ((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$6122 (jolt-invoke (var-deref "jolt.passes.numeric" "propagate") ds)) (_o$6123 (jolt-assoc node1 (keyword #f "args") args_PRIME_ (keyword #f "num-kind") (keyword #f "double")))) (jolt-vector _o$6122 _o$6123))) (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$6124 (jolt-invoke (var-deref "jolt.passes.numeric" "propagate") ls)) (_o$6125 (jolt-assoc node1 (keyword #f "num-kind") (keyword #f "long")))) (jolt-vector _o$6124 _o$6125)) (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$6126 (jolt-invoke (var-deref "jolt.passes.numeric" "propagate") bs)) (_o$6127 (jolt-assoc node1 (keyword #f "num-kind") (keyword #f "bigdec")))) (jolt-vector _o$6126 _o$6127)) (if (jolt-truthy? (keyword #f "else")) (let* ((_o$6128 jolt-nil) (_o$6129 node1)) (jolt-vector _o$6128 _o$6129)) jolt-nil))))) jolt-nil)))))))) an-invoke) (let* ((_o$6130 (keyword #f "doc")) (_o$6131 "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$6130 _o$6131)))) + (def-var-with-meta! "jolt.passes.numeric" "an-invoke" (letrec ((an-invoke (lambda (node tenv) (let fnrec6108 ((node node) (tenv tenv)) (let* ((fnode (jolt-get node (keyword #f "fn"))) (nm (if (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$6110 (var-deref "clojure.core" "mapv")) (_a$6111 (lambda (a) (let fnrec6109 ((a a)) (jolt-invoke (var-deref "jolt.passes.numeric" "an") a tenv)))) (_a$6112 (jolt-get node (keyword #f "args")))) (jolt-invoke _a$6110 _a$6111 _a$6112))) (argnodes (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec6113 ((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$6114 (jolt-get fnode (keyword #f "num-ret"))) (_o$6115 node1)) (jolt-vector _o$6114 _o$6115)) (if (jolt-nil? nm) (let* ((_o$6116 jolt-nil) (_o$6117 node1)) (jolt-vector _o$6116 _o$6117)) (if (jolt-truthy? (keyword #f "else")) (let* ((cls (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (r) (let fnrec6118 ((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 fnrec6119 ((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 fnrec6120 ((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 fnrec6121 ((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 fnrec6122 ((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$6123 (jolt-invoke (var-deref "jolt.passes.numeric" "propagate") ds)) (_o$6124 (jolt-assoc node1 (keyword #f "args") args_PRIME_ (keyword #f "num-kind") (keyword #f "double")))) (jolt-vector _o$6123 _o$6124))) (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$6125 (jolt-invoke (var-deref "jolt.passes.numeric" "propagate") ls)) (_o$6126 (jolt-assoc node1 (keyword #f "num-kind") (keyword #f "long")))) (jolt-vector _o$6125 _o$6126)) (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$6127 (jolt-invoke (var-deref "jolt.passes.numeric" "propagate") bs)) (_o$6128 (jolt-assoc node1 (keyword #f "num-kind") (keyword #f "bigdec")))) (jolt-vector _o$6127 _o$6128)) (if (jolt-truthy? (keyword #f "else")) (let* ((_o$6129 jolt-nil) (_o$6130 node1)) (jolt-vector _o$6129 _o$6130)) jolt-nil))))) jolt-nil)))))))) an-invoke) (let* ((_o$6131 (keyword #f "doc")) (_o$6132 "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$6131 _o$6132)))) (guard (e (#t #f)) - (def-var! "jolt.passes.numeric" "an" (letrec ((an (lambda (node tenv) (let fnrec6132 ((node node) (tenv tenv)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "const")) (let* ((_o$6133 (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.numeric" "float-lit?") node)) (keyword #f "double") jolt-nil)) (_o$6134 node)) (jolt-vector _o$6133 _o$6134)) (if (jolt= op (keyword #f "bigdec")) (let* ((_o$6135 (keyword #f "bigdec")) (_o$6136 node)) (jolt-vector _o$6135 _o$6136)) (if (jolt= op (keyword #f "local")) (let* ((_o$6137 (jolt-get tenv (jolt-get node (keyword #f "name")))) (_o$6138 node)) (jolt-vector _o$6137 _o$6138)) (if (jolt= op (keyword #f "coerce")) (let* ((_o$6139 (jolt-get node (keyword #f "kind"))) (_o$6140 (jolt-assoc node (keyword #f "expr") (jolt-nth (an (jolt-get node (keyword #f "expr")) tenv) 1)))) (jolt-vector _o$6139 _o$6140)) (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$6151 (lambda (acc b) (let fnrec6141 ((acc acc) (b b)) (let* ((te (jolt-nth acc 0)) (binds (jolt-nth acc 1)) (ir (an (jolt-nth b 1) te))) (let* ((_o$6147 (let* ((_a$6142 te) (_a$6143 (jolt-nth b 0)) (_a$6144 (jolt-nth ir 0))) (jolt-assoc _a$6142 _a$6143 _a$6144))) (_o$6148 (jolt-conj binds (let* ((_o$6145 (jolt-nth b 0)) (_o$6146 (jolt-nth ir 1))) (jolt-vector _o$6145 _o$6146))))) (jolt-vector _o$6147 _o$6148)))))) (_a$6152 (let* ((_o$6149 tenv) (_o$6150 (jolt-vector))) (jolt-vector _o$6149 _o$6150))) (_a$6153 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$6151 _a$6152 _a$6153))) (br (let* ((_a$6154 (jolt-get node (keyword #f "body"))) (_a$6155 (jolt-nth res 0))) (an _a$6154 _a$6155)))) (let* ((_o$6161 (jolt-nth br 0)) (_o$6162 (let* ((_a$6156 node) (_a$6157 (keyword #f "bindings")) (_a$6158 (jolt-nth res 1)) (_a$6159 (keyword #f "body")) (_a$6160 (jolt-nth br 1))) (jolt-assoc _a$6156 _a$6157 _a$6158 _a$6159 _a$6160)))) (jolt-vector _o$6161 _o$6162))) (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 fnrec6163 ((b b)) (jolt-nth b 0))) binds)) (ik (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (b) (let fnrec6164 ((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$6170 (var-deref "clojure.core" "mapv")) (_a$6171 (lambda (j) (let fnrec6165 ((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 fnrec6166 ((args args)) (let* ((_a$6167 (var-deref "jolt.passes.numeric" "counter-step?")) (_a$6168 (jolt-nth args j)) (_a$6169 (jolt-nth b 0))) (jolt-invoke _a$6167 _a$6168 _a$6169)))) rlists) and__25__auto)) and__25__auto))) (keyword #f "long") (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))))) (_a$6172 (jolt-range (jolt-count names)))) (jolt-invoke _a$6170 _a$6171 _a$6172))) (lk (jolt-invoke (var-deref "jolt.passes.numeric" "loop-kinds") names seed (jolt-get node (keyword #f "body")) tenv)) (te (let* ((_a$6177 (lambda (t i) (let fnrec6173 ((t t) (i i)) (let* ((_a$6174 t) (_a$6175 (jolt-nth names i)) (_a$6176 (jolt-nth lk i))) (jolt-assoc _a$6174 _a$6175 _a$6176))))) (_a$6178 tenv) (_a$6179 (jolt-range (jolt-count names)))) (jolt-reduce _a$6177 _a$6178 _a$6179)))) (let* ((_o$6188 jolt-nil) (_o$6189 (let* ((_a$6183 node) (_a$6184 (keyword #f "bindings")) (_a$6185 (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (b) (let fnrec6180 ((b b)) (let* ((_o$6181 (jolt-nth b 0)) (_o$6182 (jolt-nth (an (jolt-nth b 1) tenv) 1))) (jolt-vector _o$6181 _o$6182)))) binds)) (_a$6186 (keyword #f "body")) (_a$6187 (jolt-nth (an (jolt-get node (keyword #f "body")) te) 1))) (jolt-assoc _a$6183 _a$6184 _a$6185 _a$6186 _a$6187)))) (jolt-vector _o$6188 _o$6189))) (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$6197 (if (jolt= tk ek) tk jolt-nil)) (_o$6198 (let* ((_a$6190 node) (_a$6191 (keyword #f "test")) (_a$6192 (jolt-nth tr 1)) (_a$6193 (keyword #f "then")) (_a$6194 (jolt-nth thn 1)) (_a$6195 (keyword #f "else")) (_a$6196 (jolt-nth els 1))) (jolt-assoc _a$6190 _a$6191 _a$6192 _a$6193 _a$6194 _a$6195 _a$6196)))) (jolt-vector _o$6197 _o$6198))) (if (jolt= op (keyword #f "do")) (let* ((stmts (let* ((_a$6200 (var-deref "clojure.core" "mapv")) (_a$6201 (lambda (s) (let fnrec6199 ((s s)) (jolt-nth (an s tenv) 1)))) (_a$6202 (jolt-get node (keyword #f "statements")))) (jolt-invoke _a$6200 _a$6201 _a$6202))) (r (an (jolt-get node (keyword #f "ret")) tenv))) (let* ((_o$6203 (jolt-nth r 0)) (_o$6204 (jolt-assoc node (keyword #f "statements") stmts (keyword #f "ret") (jolt-nth r 1)))) (jolt-vector _o$6203 _o$6204))) (if (jolt= op (keyword #f "fn")) (let* ((_o$6211 jolt-nil) (_o$6212 (jolt-assoc node (keyword #f "arities") (let* ((_a$6208 (var-deref "clojure.core" "mapv")) (_a$6209 (lambda (a) (let fnrec6205 ((a a)) (jolt-assoc a (keyword #f "body") (jolt-nth (let* ((_a$6206 (jolt-get a (keyword #f "body"))) (_a$6207 (jolt-invoke (var-deref "jolt.passes.numeric" "arity-env") tenv a))) (an _a$6206 _a$6207)) 1))))) (_a$6210 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$6208 _a$6209 _a$6210))))) (jolt-vector _o$6211 _o$6212)) (if (jolt= op (keyword #f "def")) (let* ((_o$6213 jolt-nil) (_o$6214 (jolt-assoc node (keyword #f "init") (jolt-nth (an (jolt-get node (keyword #f "init")) tenv) 1)))) (jolt-vector _o$6213 _o$6214)) (if (jolt-truthy? (keyword #f "else")) (let* ((_o$6216 jolt-nil) (_o$6217 (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec6215 ((c c)) (jolt-nth (an c tenv) 1))) node))) (jolt-vector _o$6216 _o$6217)) jolt-nil))))))))))))))))) an))) + (def-var! "jolt.passes.numeric" "an" (letrec ((an (lambda (node tenv) (let fnrec6133 ((node node) (tenv tenv)) (let* ((op (jolt-get node (keyword #f "op")))) (if (jolt= op (keyword #f "const")) (let* ((_o$6134 (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.numeric" "float-lit?") node)) (keyword #f "double") jolt-nil)) (_o$6135 node)) (jolt-vector _o$6134 _o$6135)) (if (jolt= op (keyword #f "bigdec")) (let* ((_o$6136 (keyword #f "bigdec")) (_o$6137 node)) (jolt-vector _o$6136 _o$6137)) (if (jolt= op (keyword #f "local")) (let* ((_o$6138 (jolt-get tenv (jolt-get node (keyword #f "name")))) (_o$6139 node)) (jolt-vector _o$6138 _o$6139)) (if (jolt= op (keyword #f "coerce")) (let* ((_o$6140 (jolt-get node (keyword #f "kind"))) (_o$6141 (jolt-assoc node (keyword #f "expr") (jolt-nth (an (jolt-get node (keyword #f "expr")) tenv) 1)))) (jolt-vector _o$6140 _o$6141)) (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$6152 (lambda (acc b) (let fnrec6142 ((acc acc) (b b)) (let* ((te (jolt-nth acc 0)) (binds (jolt-nth acc 1)) (ir (an (jolt-nth b 1) te))) (let* ((_o$6148 (let* ((_a$6143 te) (_a$6144 (jolt-nth b 0)) (_a$6145 (jolt-nth ir 0))) (jolt-assoc _a$6143 _a$6144 _a$6145))) (_o$6149 (jolt-conj binds (let* ((_o$6146 (jolt-nth b 0)) (_o$6147 (jolt-nth ir 1))) (jolt-vector _o$6146 _o$6147))))) (jolt-vector _o$6148 _o$6149)))))) (_a$6153 (let* ((_o$6150 tenv) (_o$6151 (jolt-vector))) (jolt-vector _o$6150 _o$6151))) (_a$6154 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$6152 _a$6153 _a$6154))) (br (let* ((_a$6155 (jolt-get node (keyword #f "body"))) (_a$6156 (jolt-nth res 0))) (an _a$6155 _a$6156)))) (let* ((_o$6162 (jolt-nth br 0)) (_o$6163 (let* ((_a$6157 node) (_a$6158 (keyword #f "bindings")) (_a$6159 (jolt-nth res 1)) (_a$6160 (keyword #f "body")) (_a$6161 (jolt-nth br 1))) (jolt-assoc _a$6157 _a$6158 _a$6159 _a$6160 _a$6161)))) (jolt-vector _o$6162 _o$6163))) (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 fnrec6164 ((b b)) (jolt-nth b 0))) binds)) (ik (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (b) (let fnrec6165 ((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$6171 (var-deref "clojure.core" "mapv")) (_a$6172 (lambda (j) (let fnrec6166 ((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 fnrec6167 ((args args)) (let* ((_a$6168 (var-deref "jolt.passes.numeric" "counter-step?")) (_a$6169 (jolt-nth args j)) (_a$6170 (jolt-nth b 0))) (jolt-invoke _a$6168 _a$6169 _a$6170)))) rlists) and__25__auto)) and__25__auto))) (keyword #f "long") (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))))) (_a$6173 (jolt-range (jolt-count names)))) (jolt-invoke _a$6171 _a$6172 _a$6173))) (lk (jolt-invoke (var-deref "jolt.passes.numeric" "loop-kinds") names seed (jolt-get node (keyword #f "body")) tenv)) (te (let* ((_a$6178 (lambda (t i) (let fnrec6174 ((t t) (i i)) (let* ((_a$6175 t) (_a$6176 (jolt-nth names i)) (_a$6177 (jolt-nth lk i))) (jolt-assoc _a$6175 _a$6176 _a$6177))))) (_a$6179 tenv) (_a$6180 (jolt-range (jolt-count names)))) (jolt-reduce _a$6178 _a$6179 _a$6180)))) (let* ((_o$6189 jolt-nil) (_o$6190 (let* ((_a$6184 node) (_a$6185 (keyword #f "bindings")) (_a$6186 (jolt-invoke (var-deref "clojure.core" "mapv") (lambda (b) (let fnrec6181 ((b b)) (let* ((_o$6182 (jolt-nth b 0)) (_o$6183 (jolt-nth (an (jolt-nth b 1) tenv) 1))) (jolt-vector _o$6182 _o$6183)))) binds)) (_a$6187 (keyword #f "body")) (_a$6188 (jolt-nth (an (jolt-get node (keyword #f "body")) te) 1))) (jolt-assoc _a$6184 _a$6185 _a$6186 _a$6187 _a$6188)))) (jolt-vector _o$6189 _o$6190))) (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$6198 (if (jolt= tk ek) tk jolt-nil)) (_o$6199 (let* ((_a$6191 node) (_a$6192 (keyword #f "test")) (_a$6193 (jolt-nth tr 1)) (_a$6194 (keyword #f "then")) (_a$6195 (jolt-nth thn 1)) (_a$6196 (keyword #f "else")) (_a$6197 (jolt-nth els 1))) (jolt-assoc _a$6191 _a$6192 _a$6193 _a$6194 _a$6195 _a$6196 _a$6197)))) (jolt-vector _o$6198 _o$6199))) (if (jolt= op (keyword #f "do")) (let* ((stmts (let* ((_a$6201 (var-deref "clojure.core" "mapv")) (_a$6202 (lambda (s) (let fnrec6200 ((s s)) (jolt-nth (an s tenv) 1)))) (_a$6203 (jolt-get node (keyword #f "statements")))) (jolt-invoke _a$6201 _a$6202 _a$6203))) (r (an (jolt-get node (keyword #f "ret")) tenv))) (let* ((_o$6204 (jolt-nth r 0)) (_o$6205 (jolt-assoc node (keyword #f "statements") stmts (keyword #f "ret") (jolt-nth r 1)))) (jolt-vector _o$6204 _o$6205))) (if (jolt= op (keyword #f "fn")) (let* ((_o$6212 jolt-nil) (_o$6213 (jolt-assoc node (keyword #f "arities") (let* ((_a$6209 (var-deref "clojure.core" "mapv")) (_a$6210 (lambda (a) (let fnrec6206 ((a a)) (jolt-assoc a (keyword #f "body") (jolt-nth (let* ((_a$6207 (jolt-get a (keyword #f "body"))) (_a$6208 (jolt-invoke (var-deref "jolt.passes.numeric" "arity-env") tenv a))) (an _a$6207 _a$6208)) 1))))) (_a$6211 (jolt-get node (keyword #f "arities")))) (jolt-invoke _a$6209 _a$6210 _a$6211))))) (jolt-vector _o$6212 _o$6213)) (if (jolt= op (keyword #f "def")) (let* ((_o$6214 jolt-nil) (_o$6215 (jolt-assoc node (keyword #f "init") (jolt-nth (an (jolt-get node (keyword #f "init")) tenv) 1)))) (jolt-vector _o$6214 _o$6215)) (if (jolt-truthy? (keyword #f "else")) (let* ((_o$6217 jolt-nil) (_o$6218 (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec6216 ((c c)) (jolt-nth (an c tenv) 1))) node))) (jolt-vector _o$6217 _o$6218)) jolt-nil))))))))))))))))) an))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.numeric" "annotate" (letrec ((annotate (lambda (node) (let fnrec6218 ((node node)) (jolt-nth (jolt-invoke (var-deref "jolt.passes.numeric" "an") node (jolt-hash-map)) 1))))) annotate) (let* ((_o$6219 (keyword #f "doc")) (_o$6220 "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$6219 _o$6220)))) + (def-var-with-meta! "jolt.passes.numeric" "annotate" (letrec ((annotate (lambda (node) (let fnrec6219 ((node node)) (jolt-nth (jolt-invoke (var-deref "jolt.passes.numeric" "an") node (jolt-hash-map)) 1))))) annotate) (let* ((_o$6220 (keyword #f "doc")) (_o$6221 "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$6220 _o$6221)))) (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 fnrec6221 () (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.passes.inline" "dirty") #t))))) mark!))) + (def-var! "jolt.passes.inline" "mark!" (letrec ((mark! (lambda () (let fnrec6222 () (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$6222 (keyword #f "private")) (_o$6223 #t)) (jolt-hash-map _o$6222 _o$6223)))) + (def-var-with-meta! "jolt.passes.inline" "rec-shapes" (jolt-invoke (var-deref "clojure.core" "atom") (jolt-hash-map)) (let* ((_o$6223 (keyword #f "private")) (_o$6224 #t)) (jolt-hash-map _o$6223 _o$6224)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "set-rec-shapes!" (letrec ((set-rec-shapes! (lambda (m) (let fnrec6224 ((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$6225 (keyword #f "doc")) (_o$6226 "Install the record-ctor shape registry the record fold consults.")) (jolt-hash-map _o$6225 _o$6226)))) + (def-var-with-meta! "jolt.passes.inline" "set-rec-shapes!" (letrec ((set-rec-shapes! (lambda (m) (let fnrec6225 ((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$6226 (keyword #f "doc")) (_o$6227 "Install the record-ctor shape registry the record fold consults.")) (jolt-hash-map _o$6226 _o$6227)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "fresh-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (let* ((_o$6227 (keyword #f "private")) (_o$6228 #t)) (jolt-hash-map _o$6227 _o$6228)))) + (def-var-with-meta! "jolt.passes.inline" "fresh-counter" (jolt-invoke (var-deref "clojure.core" "atom") 0) (let* ((_o$6228 (keyword #f "private")) (_o$6229 #t)) (jolt-hash-map _o$6228 _o$6229)))) (guard (e (#t #f)) - (def-var! "jolt.passes.inline" "fresh" (letrec ((fresh (lambda (base) (let fnrec6229 ((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))) + (def-var! "jolt.passes.inline" "fresh" (letrec ((fresh (lambda (base) (let fnrec6230 ((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 fnrec6230 ((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?))) + (def-var! "jolt.passes.inline" "safe-op?" (letrec ((safe-op? (lambda (op) (let fnrec6231 ((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$6231 (keyword #f "private")) (_o$6232 #t)) (jolt-hash-map _o$6231 _o$6232)))) + (def-var-with-meta! "jolt.passes.inline" "inline-budget" 120 (let* ((_o$6232 (keyword #f "private")) (_o$6233 #t)) (jolt-hash-map _o$6232 _o$6233)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "body-size" (letrec ((body-size (lambda (node) (let fnrec6233 ((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 fnrec6234 ((acc acc) (c c)) (+ acc (body-size c)))) 1 node)))))) body-size) (let* ((_o$6235 (keyword #f "doc")) (_o$6236 "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$6235 _o$6236)))) + (def-var-with-meta! "jolt.passes.inline" "body-size" (letrec ((body-size (lambda (node) (let fnrec6234 ((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 fnrec6235 ((acc acc) (c c)) (+ acc (body-size c)))) 1 node)))))) body-size) (let* ((_o$6236 (keyword #f "doc")) (_o$6237 "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$6236 _o$6237)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "subst" (letrec ((subst (lambda (node env) (let fnrec6237 ((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$6249 (lambda (acc b) (let fnrec6238 ((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$6245 (jolt-assoc e nm (let* ((_o$6239 (keyword #f "op")) (_o$6240 (keyword #f "local")) (_o$6241 (keyword #f "name")) (_o$6242 f)) (jolt-hash-map _o$6239 _o$6240 _o$6241 _o$6242)))) (_o$6246 (jolt-conj binds (let* ((_o$6243 f) (_o$6244 init)) (jolt-vector _o$6243 _o$6244))))) (jolt-vector _o$6245 _o$6246)))))) (_a$6250 (let* ((_o$6247 env) (_o$6248 (jolt-vector))) (jolt-vector _o$6247 _o$6248))) (_a$6251 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$6249 _a$6250 _a$6251)))) (let* ((_a$6254 node) (_a$6255 (keyword #f "bindings")) (_a$6256 (jolt-nth res 1)) (_a$6257 (keyword #f "body")) (_a$6258 (let* ((_a$6252 (jolt-get node (keyword #f "body"))) (_a$6253 (jolt-nth res 0))) (subst _a$6252 _a$6253)))) (jolt-assoc _a$6254 _a$6255 _a$6256 _a$6257 _a$6258))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec6259 ((c c)) (subst c env))) node) jolt-nil)))))))) subst) (let* ((_o$6260 (keyword #f "doc")) (_o$6261 "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$6260 _o$6261)))) + (def-var-with-meta! "jolt.passes.inline" "subst" (letrec ((subst (lambda (node env) (let fnrec6238 ((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$6250 (lambda (acc b) (let fnrec6239 ((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$6246 (jolt-assoc e nm (let* ((_o$6240 (keyword #f "op")) (_o$6241 (keyword #f "local")) (_o$6242 (keyword #f "name")) (_o$6243 f)) (jolt-hash-map _o$6240 _o$6241 _o$6242 _o$6243)))) (_o$6247 (jolt-conj binds (let* ((_o$6244 f) (_o$6245 init)) (jolt-vector _o$6244 _o$6245))))) (jolt-vector _o$6246 _o$6247)))))) (_a$6251 (let* ((_o$6248 env) (_o$6249 (jolt-vector))) (jolt-vector _o$6248 _o$6249))) (_a$6252 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$6250 _a$6251 _a$6252)))) (let* ((_a$6255 node) (_a$6256 (keyword #f "bindings")) (_a$6257 (jolt-nth res 1)) (_a$6258 (keyword #f "body")) (_a$6259 (let* ((_a$6253 (jolt-get node (keyword #f "body"))) (_a$6254 (jolt-nth res 0))) (subst _a$6253 _a$6254)))) (jolt-assoc _a$6255 _a$6256 _a$6257 _a$6258 _a$6259))) (if (jolt-truthy? (keyword #f "else")) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec6260 ((c c)) (subst c env))) node) jolt-nil)))))))) subst) (let* ((_o$6261 (keyword #f "doc")) (_o$6262 "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$6261 _o$6262)))) (guard (e (#t #f)) - (def-var! "jolt.passes.inline" "trivial-arg?" (letrec ((trivial-arg? (lambda (n) (let fnrec6262 ((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?))) + (def-var! "jolt.passes.inline" "trivial-arg?" (letrec ((trivial-arg? (lambda (n) (let fnrec6263 ((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 fnrec6263 ((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$6269 (lambda (acc b) (let fnrec6264 ((acc acc) (b b)) (let* ((sc (jolt-nth acc 0)) (ok (jolt-nth acc 1))) (if (jolt-not ok) acc (let* ((_o$6265 (jolt-conj sc (jolt-nth b 0))) (_o$6266 (body-closed? (jolt-nth b 1) sc))) (jolt-vector _o$6265 _o$6266))))))) (_a$6270 (let* ((_o$6267 scope) (_o$6268 #t)) (jolt-vector _o$6267 _o$6268))) (_a$6271 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$6269 _a$6270 _a$6271)))) (let* ((and__25__auto (jolt-nth res 1))) (if (jolt-truthy? and__25__auto) (let* ((_a$6272 (jolt-get node (keyword #f "body"))) (_a$6273 (jolt-nth res 0))) (body-closed? _a$6272 _a$6273)) 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 fnrec6274 ((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$6275 (keyword #f "doc")) (_o$6276 "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$6275 _o$6276)))) + (def-var-with-meta! "jolt.passes.inline" "body-closed?" (letrec ((body-closed? (lambda (node scope) (let fnrec6264 ((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$6270 (lambda (acc b) (let fnrec6265 ((acc acc) (b b)) (let* ((sc (jolt-nth acc 0)) (ok (jolt-nth acc 1))) (if (jolt-not ok) acc (let* ((_o$6266 (jolt-conj sc (jolt-nth b 0))) (_o$6267 (body-closed? (jolt-nth b 1) sc))) (jolt-vector _o$6266 _o$6267))))))) (_a$6271 (let* ((_o$6268 scope) (_o$6269 #t)) (jolt-vector _o$6268 _o$6269))) (_a$6272 (jolt-get node (keyword #f "bindings")))) (jolt-reduce _a$6270 _a$6271 _a$6272)))) (let* ((and__25__auto (jolt-nth res 1))) (if (jolt-truthy? and__25__auto) (let* ((_a$6273 (jolt-get node (keyword #f "body"))) (_a$6274 (jolt-nth res 0))) (body-closed? _a$6273 _a$6274)) 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 fnrec6275 ((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$6276 (keyword #f "doc")) (_o$6277 "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$6276 _o$6277)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "try-inline" (letrec ((try-inline (lambda (node ctx) (let fnrec6277 ((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$6278 (var-deref "jolt.host" "inline-ir")) (_a$6279 ctx) (_a$6280 (jolt-get f (keyword #f "ns"))) (_a$6281 (jolt-get f (keyword #f "name")))) (jolt-invoke _a$6278 _a$6279 _a$6280 _a$6281)))) (if (jolt-truthy? stash) (let* ((params (jolt-get stash (keyword #f "params"))) (body (jolt-get stash (keyword #f "body"))) (nh (let* ((_a$6286 (lambda (m pr) (let fnrec6282 ((m m) (pr pr)) (let* ((_a$6283 m) (_a$6284 (jolt-nth pr 0)) (_a$6285 (jolt-nth pr 1))) (jolt-assoc _a$6283 _a$6284 _a$6285))))) (_a$6287 (jolt-hash-map)) (_a$6288 (jolt-get stash (keyword #f "nhints")))) (jolt-reduce _a$6286 _a$6287 _a$6288))) (ret (jolt-get stash (keyword #f "ret"))) (args (jolt-get node (keyword #f "args")))) (if (jolt-truthy? (let* ((and__25__auto (let* ((_a$6289 (jolt-count params)) (_a$6290 (jolt-count args))) (jolt= _a$6289 _a$6290)))) (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 loop6291 ((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$6298 (jolt-inc i)) (_a$6299 (jolt-assoc env p (let* ((_o$6292 (keyword #f "op")) (_o$6293 (keyword #f "local")) (_o$6294 (keyword #f "name")) (_o$6295 f)) (jolt-hash-map _o$6292 _o$6293 _o$6294 _o$6295)))) (_a$6300 (jolt-conj binds (let* ((_o$6296 f) (_o$6297 (jolt-invoke (var-deref "jolt.ir" "coerce-node") k a))) (jolt-vector _o$6296 _o$6297))))) (loop6291 _a$6298 _a$6299 _a$6300))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "trivial-arg?") a)) (let* ((_a$6301 (jolt-inc i)) (_a$6302 (jolt-assoc env p a)) (_a$6303 binds)) (loop6291 _a$6301 _a$6302 _a$6303)) (if (jolt-truthy? (keyword #f "else")) (let* ((f (jolt-invoke (var-deref "jolt.passes.inline" "fresh") p))) (let* ((_a$6310 (jolt-inc i)) (_a$6311 (jolt-assoc env p (let* ((_o$6304 (keyword #f "op")) (_o$6305 (keyword #f "local")) (_o$6306 (keyword #f "name")) (_o$6307 f)) (jolt-hash-map _o$6304 _o$6305 _o$6306 _o$6307)))) (_a$6312 (jolt-conj binds (let* ((_o$6308 f) (_o$6309 a)) (jolt-vector _o$6308 _o$6309))))) (loop6291 _a$6310 _a$6311 _a$6312))) jolt-nil)))) (let* ((_o$6313 env) (_o$6314 binds)) (jolt-vector _o$6313 _o$6314)))))) (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$6315 (keyword #f "op")) (_o$6316 (keyword #f "let")) (_o$6317 (keyword #f "bindings")) (_o$6318 binds) (_o$6319 (keyword #f "body")) (_o$6320 rbody)) (jolt-hash-map _o$6315 _o$6316 _o$6317 _o$6318 _o$6319 _o$6320))))) node)) node)) node)))))) try-inline) (let* ((_o$6321 (keyword #f "doc")) (_o$6322 "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$6321 _o$6322)))) + (def-var-with-meta! "jolt.passes.inline" "try-inline" (letrec ((try-inline (lambda (node ctx) (let fnrec6278 ((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$6279 (var-deref "jolt.host" "inline-ir")) (_a$6280 ctx) (_a$6281 (jolt-get f (keyword #f "ns"))) (_a$6282 (jolt-get f (keyword #f "name")))) (jolt-invoke _a$6279 _a$6280 _a$6281 _a$6282)))) (if (jolt-truthy? stash) (let* ((params (jolt-get stash (keyword #f "params"))) (body (jolt-get stash (keyword #f "body"))) (nh (let* ((_a$6287 (lambda (m pr) (let fnrec6283 ((m m) (pr pr)) (let* ((_a$6284 m) (_a$6285 (jolt-nth pr 0)) (_a$6286 (jolt-nth pr 1))) (jolt-assoc _a$6284 _a$6285 _a$6286))))) (_a$6288 (jolt-hash-map)) (_a$6289 (jolt-get stash (keyword #f "nhints")))) (jolt-reduce _a$6287 _a$6288 _a$6289))) (ret (jolt-get stash (keyword #f "ret"))) (args (jolt-get node (keyword #f "args")))) (if (jolt-truthy? (let* ((and__25__auto (let* ((_a$6290 (jolt-count params)) (_a$6291 (jolt-count args))) (jolt= _a$6290 _a$6291)))) (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 loop6292 ((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$6299 (jolt-inc i)) (_a$6300 (jolt-assoc env p (let* ((_o$6293 (keyword #f "op")) (_o$6294 (keyword #f "local")) (_o$6295 (keyword #f "name")) (_o$6296 f)) (jolt-hash-map _o$6293 _o$6294 _o$6295 _o$6296)))) (_a$6301 (jolt-conj binds (let* ((_o$6297 f) (_o$6298 (jolt-invoke (var-deref "jolt.ir" "coerce-node") k a))) (jolt-vector _o$6297 _o$6298))))) (loop6292 _a$6299 _a$6300 _a$6301))) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.inline" "trivial-arg?") a)) (let* ((_a$6302 (jolt-inc i)) (_a$6303 (jolt-assoc env p a)) (_a$6304 binds)) (loop6292 _a$6302 _a$6303 _a$6304)) (if (jolt-truthy? (keyword #f "else")) (let* ((f (jolt-invoke (var-deref "jolt.passes.inline" "fresh") p))) (let* ((_a$6311 (jolt-inc i)) (_a$6312 (jolt-assoc env p (let* ((_o$6305 (keyword #f "op")) (_o$6306 (keyword #f "local")) (_o$6307 (keyword #f "name")) (_o$6308 f)) (jolt-hash-map _o$6305 _o$6306 _o$6307 _o$6308)))) (_a$6313 (jolt-conj binds (let* ((_o$6309 f) (_o$6310 a)) (jolt-vector _o$6309 _o$6310))))) (loop6292 _a$6311 _a$6312 _a$6313))) jolt-nil)))) (let* ((_o$6314 env) (_o$6315 binds)) (jolt-vector _o$6314 _o$6315)))))) (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$6316 (keyword #f "op")) (_o$6317 (keyword #f "let")) (_o$6318 (keyword #f "bindings")) (_o$6319 binds) (_o$6320 (keyword #f "body")) (_o$6321 rbody)) (jolt-hash-map _o$6316 _o$6317 _o$6318 _o$6319 _o$6320 _o$6321))))) node)) node)) node)))))) try-inline) (let* ((_o$6322 (keyword #f "doc")) (_o$6323 "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$6322 _o$6323)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "inline-node" (letrec ((inline-node (lambda (node ctx) (let fnrec6323 ((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 fnrec6324 ((c c)) (inline-node c ctx))) node) ctx) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec6325 ((c c)) (inline-node c ctx))) node)))))) inline-node) (let* ((_o$6326 (keyword #f "doc")) (_o$6327 "Bottom-up: inline children first, then attempt to inline this node.")) (jolt-hash-map _o$6326 _o$6327)))) + (def-var-with-meta! "jolt.passes.inline" "inline-node" (letrec ((inline-node (lambda (node ctx) (let fnrec6324 ((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 fnrec6325 ((c c)) (inline-node c ctx))) node) ctx) (jolt-invoke (var-deref "jolt.ir" "map-ir-children") (lambda (c) (let fnrec6326 ((c c)) (inline-node c ctx))) node)))))) inline-node) (let* ((_o$6327 (keyword #f "doc")) (_o$6328 "Bottom-up: inline children first, then attempt to inline this node.")) (jolt-hash-map _o$6327 _o$6328)))) (guard (e (#t #f)) - (def-var! "jolt.passes.inline" "flatten-let-bindings" (letrec ((flatten-let-bindings (lambda (binds) (let fnrec6328 ((binds binds)) (let* ((_a$6334 (lambda (out b) (let fnrec6329 ((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$6332 (jolt-reduce jolt-conj out (jolt-get init (keyword #f "bindings")))) (_a$6333 (let* ((_o$6330 nm) (_o$6331 (jolt-get init (keyword #f "body")))) (jolt-vector _o$6330 _o$6331)))) (jolt-conj _a$6332 _a$6333))) (jolt-conj out b)))))) (_a$6335 (jolt-vector)) (_a$6336 binds)) (jolt-reduce _a$6334 _a$6335 _a$6336)))))) flatten-let-bindings))) + (def-var! "jolt.passes.inline" "flatten-let-bindings" (letrec ((flatten-let-bindings (lambda (binds) (let fnrec6329 ((binds binds)) (let* ((_a$6335 (lambda (out b) (let fnrec6330 ((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$6333 (jolt-reduce jolt-conj out (jolt-get init (keyword #f "bindings")))) (_a$6334 (let* ((_o$6331 nm) (_o$6332 (jolt-get init (keyword #f "body")))) (jolt-vector _o$6331 _o$6332)))) (jolt-conj _a$6333 _a$6334))) (jolt-conj out b)))))) (_a$6336 (jolt-vector)) (_a$6337 binds)) (jolt-reduce _a$6335 _a$6336 _a$6337)))))) flatten-let-bindings))) (guard (e (#t #f)) - (def-var! "jolt.passes.inline" "flatten-lets" (letrec ((flatten-lets (lambda (node) (let fnrec6337 ((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))) + (def-var! "jolt.passes.inline" "flatten-lets" (letrec ((flatten-lets (lambda (node) (let fnrec6338 ((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$6338 "+") (_o$6339 "-") (_o$6340 "*") (_o$6341 "/") (_o$6342 "<") (_o$6343 ">") (_o$6344 "<=") (_o$6345 ">=") (_o$6346 "=") (_o$6347 "not=") (_o$6348 "inc") (_o$6349 "dec") (_o$6350 "mod") (_o$6351 "rem") (_o$6352 "quot") (_o$6353 "min") (_o$6354 "max") (_o$6355 "abs") (_o$6356 "nil?") (_o$6357 "some?") (_o$6358 "not") (_o$6359 "get") (_o$6360 "zero?") (_o$6361 "pos?") (_o$6362 "neg?") (_o$6363 "even?") (_o$6364 "odd?") (_o$6365 "bit-and") (_o$6366 "bit-or") (_o$6367 "bit-xor")) (jolt-hash-set _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)) (let* ((_o$6368 (keyword #f "private")) (_o$6369 #t)) (jolt-hash-map _o$6368 _o$6369)))) + (def-var-with-meta! "jolt.passes.inline" "pure-fns" (let* ((_o$6339 "+") (_o$6340 "-") (_o$6341 "*") (_o$6342 "/") (_o$6343 "<") (_o$6344 ">") (_o$6345 "<=") (_o$6346 ">=") (_o$6347 "=") (_o$6348 "not=") (_o$6349 "inc") (_o$6350 "dec") (_o$6351 "mod") (_o$6352 "rem") (_o$6353 "quot") (_o$6354 "min") (_o$6355 "max") (_o$6356 "abs") (_o$6357 "nil?") (_o$6358 "some?") (_o$6359 "not") (_o$6360 "get") (_o$6361 "zero?") (_o$6362 "pos?") (_o$6363 "neg?") (_o$6364 "even?") (_o$6365 "odd?") (_o$6366 "bit-and") (_o$6367 "bit-or") (_o$6368 "bit-xor")) (jolt-hash-set _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)) (let* ((_o$6369 (keyword #f "private")) (_o$6370 #t)) (jolt-hash-map _o$6369 _o$6370)))) (guard (e (#t #f)) - (def-var! "jolt.passes.inline" "pure-fn?" (letrec ((pure-fn? (lambda (f) (let fnrec6370 ((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?))) + (def-var! "jolt.passes.inline" "pure-fn?" (letrec ((pure-fn? (lambda (f) (let fnrec6371 ((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 fnrec6371 ((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 fnrec6372 ((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$6373 (keyword #f "doc")) (_o$6374 "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$6373 _o$6374)))) + (def-var-with-meta! "jolt.passes.inline" "pure?" (letrec ((pure? (lambda (node) (let fnrec6372 ((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 fnrec6373 ((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$6374 (keyword #f "doc")) (_o$6375 "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$6374 _o$6375)))) (guard (e (#t #f)) - (def-var! "jolt.passes.inline" "const-key-map?" (letrec ((const-key-map? (lambda (node) (let fnrec6375 ((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 fnrec6376 ((pr pr)) (jolt-invoke (var-deref "jolt.passes.fold" "scalar-const?") (jolt-nth pr 0)))) prs) and__25__auto))))))) const-key-map?))) + (def-var! "jolt.passes.inline" "const-key-map?" (letrec ((const-key-map? (lambda (node) (let fnrec6376 ((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 fnrec6377 ((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 fnrec6377 ((node node)) (let* ((_a$6379 (var-deref "clojure.core" "every?")) (_a$6380 (lambda (pr) (let fnrec6378 ((pr pr)) (jolt-invoke (var-deref "jolt.passes.inline" "pure?") (jolt-nth pr 1))))) (_a$6381 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$6379 _a$6380 _a$6381)))))) all-vals-pure?))) + (def-var! "jolt.passes.inline" "all-vals-pure?" (letrec ((all-vals-pure? (lambda (node) (let fnrec6378 ((node node)) (let* ((_a$6380 (var-deref "clojure.core" "every?")) (_a$6381 (lambda (pr) (let fnrec6379 ((pr pr)) (jolt-invoke (var-deref "jolt.passes.inline" "pure?") (jolt-nth pr 1))))) (_a$6382 (jolt-get node (keyword #f "pairs")))) (jolt-invoke _a$6380 _a$6381 _a$6382)))))) all-vals-pure?))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "map-val" (letrec ((map-val (lambda (mapnode k) (let fnrec6382 ((mapnode mapnode) (k k)) (let* ((prs (jolt-get mapnode (keyword #f "pairs"))) (n (jolt-count prs))) (let* ((i 0)) (let loop6383 ((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) (loop6383 (jolt-inc i)))) (let* ((_o$6384 (keyword #f "op")) (_o$6385 (keyword #f "const")) (_o$6386 (keyword #f "val")) (_o$6387 jolt-nil)) (jolt-hash-map _o$6384 _o$6385 _o$6386 _o$6387)))))))))) map-val) (let* ((_o$6388 (keyword #f "doc")) (_o$6389 "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$6388 _o$6389)))) + (def-var-with-meta! "jolt.passes.inline" "map-val" (letrec ((map-val (lambda (mapnode k) (let fnrec6383 ((mapnode mapnode) (k k)) (let* ((prs (jolt-get mapnode (keyword #f "pairs"))) (n (jolt-count prs))) (let* ((i 0)) (let loop6384 ((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) (loop6384 (jolt-inc i)))) (let* ((_o$6385 (keyword #f "op")) (_o$6386 (keyword #f "const")) (_o$6387 (keyword #f "val")) (_o$6388 jolt-nil)) (jolt-hash-map _o$6385 _o$6386 _o$6387 _o$6388)))))))))) map-val) (let* ((_o$6389 (keyword #f "doc")) (_o$6390 "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$6389 _o$6390)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "lookup-key" (letrec ((lookup-key (lambda (node nm) (let fnrec6390 ((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$6391 (keyword #f "doc")) (_o$6392 "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$6391 _o$6392)))) + (def-var-with-meta! "jolt.passes.inline" "lookup-key" (letrec ((lookup-key (lambda (node nm) (let fnrec6391 ((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$6392 (keyword #f "doc")) (_o$6393 "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$6392 _o$6393)))) (guard (e (#t #f)) - (def-var! "jolt.passes.inline" "any-binding-named?" (letrec ((any-binding-named? (lambda (binds nm) (let fnrec6393 ((binds binds) (nm nm)) (let* ((i 0)) (let loop6394 ((i i)) (if (< i (jolt-count binds)) (if (jolt= nm (jolt-nth (jolt-nth binds i) 0)) #t (loop6394 (jolt-inc i))) #f))))))) any-binding-named?))) + (def-var! "jolt.passes.inline" "any-binding-named?" (letrec ((any-binding-named? (lambda (binds nm) (let fnrec6394 ((binds binds) (nm nm)) (let* ((i 0)) (let loop6395 ((i i)) (if (< i (jolt-count binds)) (if (jolt= nm (jolt-nth (jolt-nth binds i) 0)) #t (loop6395 (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 fnrec6395 ((names names) (nm nm)) (let* ((i 0)) (let loop6396 ((i i)) (if (< i (jolt-count names)) (if (jolt= nm (jolt-nth names i)) #t (loop6396 (jolt-inc i))) #f))))))) any-name?))) + (def-var! "jolt.passes.inline" "any-name?" (letrec ((any-name? (lambda (names nm) (let fnrec6396 ((names names) (nm nm)) (let* ((i 0)) (let loop6397 ((i i)) (if (< i (jolt-count names)) (if (jolt= nm (jolt-nth names i)) #t (loop6397 (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 fnrec6397 ((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 loop6398 ((i i)) (if (< i (jolt-count args)) (if (jolt-truthy? (local-escapes? (jolt-nth args i) nm)) #t (loop6398 (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 loop6399 ((i i) (ss ss)) (if (< i (jolt-count ss)) (if (jolt-truthy? (local-escapes? (jolt-nth ss i) nm)) #t (loop6399 (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 loop6400 ((i i) (as as)) (if (< i (jolt-count as)) (if (jolt-truthy? (local-escapes? (jolt-nth as i) nm)) #t (loop6400 (jolt-inc i) as)) #f))))) (if (jolt= op (keyword #f "vector")) (let* ((i 0) (xs (jolt-get node (keyword #f "items")))) (let loop6401 ((i i) (xs xs)) (if (< i (jolt-count xs)) (if (jolt-truthy? (local-escapes? (jolt-nth xs i) nm)) #t (loop6401 (jolt-inc i) xs)) #f))) (if (jolt= op (keyword #f "set")) (let* ((i 0) (xs (jolt-get node (keyword #f "items")))) (let loop6402 ((i i) (xs xs)) (if (< i (jolt-count xs)) (if (jolt-truthy? (local-escapes? (jolt-nth xs i) nm)) #t (loop6402 (jolt-inc i) xs)) #f))) (if (jolt= op (keyword #f "map")) (let* ((i 0) (ps (jolt-get node (keyword #f "pairs")))) (let loop6403 ((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 (loop6403 (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 loop6404 ((i i)) (if (< i (jolt-count binds)) (if (jolt-truthy? (local-escapes? (jolt-nth (jolt-nth binds i) 1) nm)) #t (loop6404 (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 loop6405 ((i i) (as as)) (if (< i (jolt-count as)) (if (jolt-truthy? (local-escapes? (jolt-nth as i) nm)) #t (loop6405 (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 loop6406 ((i i)) (if (< i (jolt-count binds)) (if (jolt-truthy? (local-escapes? (jolt-nth (jolt-nth binds i) 1) nm)) #t (loop6406 (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 loop6407 ((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 (loop6407 (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$6408 (keyword #f "doc")) (_o$6409 "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$6408 _o$6409)))) + (def-var-with-meta! "jolt.passes.inline" "local-escapes?" (letrec ((local-escapes? (lambda (node nm) (let fnrec6398 ((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 loop6399 ((i i)) (if (< i (jolt-count args)) (if (jolt-truthy? (local-escapes? (jolt-nth args i) nm)) #t (loop6399 (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 loop6400 ((i i) (ss ss)) (if (< i (jolt-count ss)) (if (jolt-truthy? (local-escapes? (jolt-nth ss i) nm)) #t (loop6400 (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 loop6401 ((i i) (as as)) (if (< i (jolt-count as)) (if (jolt-truthy? (local-escapes? (jolt-nth as i) nm)) #t (loop6401 (jolt-inc i) as)) #f))))) (if (jolt= op (keyword #f "vector")) (let* ((i 0) (xs (jolt-get node (keyword #f "items")))) (let loop6402 ((i i) (xs xs)) (if (< i (jolt-count xs)) (if (jolt-truthy? (local-escapes? (jolt-nth xs i) nm)) #t (loop6402 (jolt-inc i) xs)) #f))) (if (jolt= op (keyword #f "set")) (let* ((i 0) (xs (jolt-get node (keyword #f "items")))) (let loop6403 ((i i) (xs xs)) (if (< i (jolt-count xs)) (if (jolt-truthy? (local-escapes? (jolt-nth xs i) nm)) #t (loop6403 (jolt-inc i) xs)) #f))) (if (jolt= op (keyword #f "map")) (let* ((i 0) (ps (jolt-get node (keyword #f "pairs")))) (let loop6404 ((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 (loop6404 (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 loop6405 ((i i)) (if (< i (jolt-count binds)) (if (jolt-truthy? (local-escapes? (jolt-nth (jolt-nth binds i) 1) nm)) #t (loop6405 (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 loop6406 ((i i) (as as)) (if (< i (jolt-count as)) (if (jolt-truthy? (local-escapes? (jolt-nth as i) nm)) #t (loop6406 (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 loop6407 ((i i)) (if (< i (jolt-count binds)) (if (jolt-truthy? (local-escapes? (jolt-nth (jolt-nth binds i) 1) nm)) #t (loop6407 (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 loop6408 ((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 (loop6408 (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$6409 (keyword #f "doc")) (_o$6410 "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$6409 _o$6410)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "ctor-shape" (letrec ((ctor-shape (lambda (node) (let fnrec6410 ((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$6415 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.inline" "rec-shapes"))) (_a$6416 (let* ((_a$6411 (var-deref "clojure.core" "str")) (_a$6412 (jolt-get f (keyword #f "ns"))) (_a$6413 "/") (_a$6414 (jolt-get f (keyword #f "name")))) (jolt-invoke _a$6411 _a$6412 _a$6413 _a$6414)))) (jolt-get _a$6415 _a$6416)))) (if (jolt-truthy? (let* ((and__25__auto rs)) (if (jolt-truthy? and__25__auto) (let* ((_a$6417 (jolt-count (jolt-get rs (keyword #f "fields")))) (_a$6418 (jolt-count (jolt-get node (keyword #f "args"))))) (jolt= _a$6417 _a$6418)) and__25__auto))) rs jolt-nil)) jolt-nil)) jolt-nil))))) ctor-shape) (let* ((_o$6419 (keyword #f "doc")) (_o$6420 "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$6419 _o$6420)))) + (def-var-with-meta! "jolt.passes.inline" "ctor-shape" (letrec ((ctor-shape (lambda (node) (let fnrec6411 ((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$6416 (jolt-invoke (var-deref "clojure.core" "deref") (var-deref "jolt.passes.inline" "rec-shapes"))) (_a$6417 (let* ((_a$6412 (var-deref "clojure.core" "str")) (_a$6413 (jolt-get f (keyword #f "ns"))) (_a$6414 "/") (_a$6415 (jolt-get f (keyword #f "name")))) (jolt-invoke _a$6412 _a$6413 _a$6414 _a$6415)))) (jolt-get _a$6416 _a$6417)))) (if (jolt-truthy? (let* ((and__25__auto rs)) (if (jolt-truthy? and__25__auto) (let* ((_a$6418 (jolt-count (jolt-get rs (keyword #f "fields")))) (_a$6419 (jolt-count (jolt-get node (keyword #f "args"))))) (jolt= _a$6418 _a$6419)) and__25__auto))) rs jolt-nil)) jolt-nil)) jolt-nil))))) ctor-shape) (let* ((_o$6420 (keyword #f "doc")) (_o$6421 "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$6420 _o$6421)))) (guard (e (#t #f)) - (def-var! "jolt.passes.inline" "ctor-all-args-pure?" (letrec ((ctor-all-args-pure? (lambda (node) (let fnrec6421 ((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?))) + (def-var! "jolt.passes.inline" "ctor-all-args-pure?" (letrec ((ctor-all-args-pure? (lambda (node) (let fnrec6422 ((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 fnrec6422 ((fields fields) (k k)) (let* ((n (jolt-count fields))) (let* ((i 0)) (let loop6423 ((i i)) (if (< i n) (if (jolt= (jolt-nth fields i) k) i (loop6423 (jolt-inc i))) jolt-nil)))))))) field-index) (let* ((_o$6424 (keyword #f "doc")) (_o$6425 "Index of scalar key k in the declared field tuple fields, or nil.")) (jolt-hash-map _o$6424 _o$6425)))) + (def-var-with-meta! "jolt.passes.inline" "field-index" (letrec ((field-index (lambda (fields k) (let fnrec6423 ((fields fields) (k k)) (let* ((n (jolt-count fields))) (let* ((i 0)) (let loop6424 ((i i)) (if (< i n) (if (jolt= (jolt-nth fields i) k) i (loop6424 (jolt-inc i))) jolt-nil)))))))) field-index) (let* ((_o$6425 (keyword #f "doc")) (_o$6426 "Index of scalar key k in the declared field tuple fields, or nil.")) (jolt-hash-map _o$6425 _o$6426)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "ctor-val" (letrec ((ctor-val (lambda (ctor rs k) (let fnrec6426 ((ctor ctor) (rs rs) (k k)) (let* ((_a$6427 (jolt-get ctor (keyword #f "args"))) (_a$6428 (jolt-invoke (var-deref "jolt.passes.inline" "field-index") (jolt-get rs (keyword #f "fields")) k))) (jolt-nth _a$6427 _a$6428)))))) ctor-val) (let* ((_o$6429 (keyword #f "doc")) (_o$6430 "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$6429 _o$6430)))) + (def-var-with-meta! "jolt.passes.inline" "ctor-val" (letrec ((ctor-val (lambda (ctor rs k) (let fnrec6427 ((ctor ctor) (rs rs) (k k)) (let* ((_a$6428 (jolt-get ctor (keyword #f "args"))) (_a$6429 (jolt-invoke (var-deref "jolt.passes.inline" "field-index") (jolt-get rs (keyword #f "fields")) k))) (jolt-nth _a$6428 _a$6429)))))) ctor-val) (let* ((_o$6430 (keyword #f "doc")) (_o$6431 "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$6430 _o$6431)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "collect-keys!" (letrec ((collect-keys! (lambda (node nm acc) (let fnrec6431 ((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 fnrec6432 ((c c)) (begin (collect-keys! c nm acc) c))) node))))))) collect-keys!) (let* ((_o$6433 (keyword #f "doc")) (_o$6434 "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$6433 _o$6434)))) + (def-var-with-meta! "jolt.passes.inline" "collect-keys!" (letrec ((collect-keys! (lambda (node nm acc) (let fnrec6432 ((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 fnrec6433 ((c c)) (begin (collect-keys! c nm acc) c))) node))))))) collect-keys!) (let* ((_o$6434 (keyword #f "doc")) (_o$6435 "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$6434 _o$6435)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "lookups-all-fields?" (letrec ((lookups-all-fields? (lambda (nodes nm fields) (let fnrec6435 ((nodes nodes) (nm nm) (fields fields)) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (node) (let fnrec6436 ((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$6438 (var-deref "clojure.core" "every?")) (_a$6439 (lambda (k) (let fnrec6437 ((k k)) (jolt-invoke (var-deref "jolt.passes.inline" "field-index") fields k)))) (_a$6440 (jolt-invoke (var-deref "clojure.core" "deref") acc))) (jolt-invoke _a$6438 _a$6439 _a$6440)))))) nodes))))) lookups-all-fields?) (let* ((_o$6441 (keyword #f "doc")) (_o$6442 "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$6441 _o$6442)))) + (def-var-with-meta! "jolt.passes.inline" "lookups-all-fields?" (letrec ((lookups-all-fields? (lambda (nodes nm fields) (let fnrec6436 ((nodes nodes) (nm nm) (fields fields)) (jolt-invoke (var-deref "clojure.core" "every?") (lambda (node) (let fnrec6437 ((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$6439 (var-deref "clojure.core" "every?")) (_a$6440 (lambda (k) (let fnrec6438 ((k k)) (jolt-invoke (var-deref "jolt.passes.inline" "field-index") fields k)))) (_a$6441 (jolt-invoke (var-deref "clojure.core" "deref") acc))) (jolt-invoke _a$6439 _a$6440 _a$6441)))))) nodes))))) lookups-all-fields?) (let* ((_o$6442 (keyword #f "doc")) (_o$6443 "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$6442 _o$6443)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "src-val" (letrec ((src-val (lambda (src k) (let fnrec6443 ((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$6444 (keyword #f "doc")) (_o$6445 "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$6444 _o$6445)))) + (def-var-with-meta! "jolt.passes.inline" "src-val" (letrec ((src-val (lambda (src k) (let fnrec6444 ((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$6445 (keyword #f "doc")) (_o$6446 "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$6445 _o$6446)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "subst-lookup" (letrec ((subst-lookup (lambda (node nm src) (let fnrec6446 ((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 fnrec6447 ((c c)) (subst-lookup c nm src))) node))))))) subst-lookup) (let* ((_o$6448 (keyword #f "doc")) (_o$6449 "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$6448 _o$6449)))) + (def-var-with-meta! "jolt.passes.inline" "subst-lookup" (letrec ((subst-lookup (lambda (node nm src) (let fnrec6447 ((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 fnrec6448 ((c c)) (subst-lookup c nm src))) node))))))) subst-lookup) (let* ((_o$6449 (keyword #f "doc")) (_o$6450 "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$6449 _o$6450)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "fold-kw-literal" (letrec ((fold-kw-literal (lambda (node) (let fnrec6450 ((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$6451 (keyword #f "doc")) (_o$6452 "(a) (:k ) -> the value at k. 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$6451 _o$6452)))) + (def-var-with-meta! "jolt.passes.inline" "fold-kw-literal" (letrec ((fold-kw-literal (lambda (node) (let fnrec6451 ((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$6452 (keyword #f "doc")) (_o$6453 "(a) (:k ) -> the value at k. 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$6452 _o$6453)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "elim-let-structs" (letrec ((elim-let-structs (lambda (node) (let fnrec6453 ((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 loop6454 ((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 loop6455 ((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 (loop6455 (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$6460 (var-deref "jolt.passes.inline" "lookups-all-fields?")) (_a$6461 (jolt-conj (let* ((_a$6457 (var-deref "clojure.core" "mapv")) (_a$6458 (lambda (bb) (let fnrec6456 ((bb bb)) (jolt-nth bb 1)))) (_a$6459 (jolt-invoke (var-deref "clojure.core" "subvec") binds (jolt-inc i) n))) (jolt-invoke _a$6457 _a$6458 _a$6459)) body)) (_a$6462 nm) (_a$6463 (jolt-get rs (keyword #f "fields")))) (jolt-invoke _a$6460 _a$6461 _a$6462 _a$6463)))) 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$6467 (var-deref "clojure.core" "mapv")) (_a$6468 (lambda (bb) (let fnrec6464 ((bb bb)) (let* ((_o$6465 (jolt-nth bb 0)) (_o$6466 (jolt-invoke (var-deref "jolt.passes.inline" "subst-lookup") (jolt-nth bb 1) nm init))) (jolt-vector _o$6465 _o$6466))))) (_a$6469 (jolt-invoke (var-deref "clojure.core" "subvec") binds (jolt-inc i) n))) (jolt-invoke _a$6467 _a$6468 _a$6469))) (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)))) (loop6454 (jolt-inc i)))) node)))))))) elim-let-structs) (let* ((_o$6470 (keyword #f "doc")) (_o$6471 "(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$6470 _o$6471)))) + (def-var-with-meta! "jolt.passes.inline" "elim-let-structs" (letrec ((elim-let-structs (lambda (node) (let fnrec6454 ((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 loop6455 ((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 loop6456 ((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 (loop6456 (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$6461 (var-deref "jolt.passes.inline" "lookups-all-fields?")) (_a$6462 (jolt-conj (let* ((_a$6458 (var-deref "clojure.core" "mapv")) (_a$6459 (lambda (bb) (let fnrec6457 ((bb bb)) (jolt-nth bb 1)))) (_a$6460 (jolt-invoke (var-deref "clojure.core" "subvec") binds (jolt-inc i) n))) (jolt-invoke _a$6458 _a$6459 _a$6460)) body)) (_a$6463 nm) (_a$6464 (jolt-get rs (keyword #f "fields")))) (jolt-invoke _a$6461 _a$6462 _a$6463 _a$6464)))) 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$6468 (var-deref "clojure.core" "mapv")) (_a$6469 (lambda (bb) (let fnrec6465 ((bb bb)) (let* ((_o$6466 (jolt-nth bb 0)) (_o$6467 (jolt-invoke (var-deref "jolt.passes.inline" "subst-lookup") (jolt-nth bb 1) nm init))) (jolt-vector _o$6466 _o$6467))))) (_a$6470 (jolt-invoke (var-deref "clojure.core" "subvec") binds (jolt-inc i) n))) (jolt-invoke _a$6468 _a$6469 _a$6470))) (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)))) (loop6455 (jolt-inc i)))) node)))))))) elim-let-structs) (let* ((_o$6471 (keyword #f "doc")) (_o$6472 "(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$6471 _o$6472)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.inline" "scalar-replace" (letrec ((scalar-replace (lambda (node) (let fnrec6472 ((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$6473 (keyword #f "doc")) (_o$6474 "Bottom-up: scalar-replace children, then apply (a) at invokes / (b) at lets.")) (jolt-hash-map _o$6473 _o$6474)))) + (def-var-with-meta! "jolt.passes.inline" "scalar-replace" (letrec ((scalar-replace (lambda (node) (let fnrec6473 ((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$6474 (keyword #f "doc")) (_o$6475 "Bottom-up: scalar-replace children, then apply (a) at invokes / (b) at lets.")) (jolt-hash-map _o$6474 _o$6475)))) (guard (e (#t #f)) - (def-var! "jolt.passes.types.lattice" "velem" (letrec ((velem (lambda (t) (let fnrec5797 ((t t)) (jolt-get t (keyword #f "vec")))))) velem))) + (def-var! "jolt.passes.types.lattice" "velem" (letrec ((velem (lambda (t) (let fnrec5798 ((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 fnrec5798 ((t t)) (jolt-get t (keyword #f "set")))))) selem))) + (def-var! "jolt.passes.types.lattice" "selem" (letrec ((selem (lambda (t) (let fnrec5799 ((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 fnrec5799 ((t t)) (jolt-get t (keyword #f "struct")))))) sfields))) + (def-var! "jolt.passes.types.lattice" "sfields" (letrec ((sfields (lambda (t) (let fnrec5800 ((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 fnrec5800 ((t t)) (jolt-some? (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") t)))))) vec-type?))) + (def-var! "jolt.passes.types.lattice" "vec-type?" (letrec ((vec-type? (lambda (t) (let fnrec5801 ((t t)) (jolt-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 fnrec5801 ((t t)) (jolt-some? (jolt-invoke (var-deref "jolt.passes.types.lattice" "selem") t)))))) set-type?))) + (def-var! "jolt.passes.types.lattice" "set-type?" (letrec ((set-type? (lambda (t) (let fnrec5802 ((t t)) (jolt-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 fnrec5802 ((t t)) (jolt-some? (jolt-invoke (var-deref "jolt.passes.types.lattice" "sfields") t)))))) struct-type?))) + (def-var! "jolt.passes.types.lattice" "struct-type?" (letrec ((struct-type? (lambda (t) (let fnrec5803 ((t t)) (jolt-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 fnrec5803 ((t t)) (let* ((_o$5804 (keyword #f "vec")) (_o$5805 (if (jolt-truthy? t) t (keyword #f "any")))) (jolt-hash-map _o$5804 _o$5805)))))) mk-vec))) + (def-var! "jolt.passes.types.lattice" "mk-vec" (letrec ((mk-vec (lambda (t) (let fnrec5804 ((t t)) (let* ((_o$5805 (keyword #f "vec")) (_o$5806 (if (jolt-truthy? t) t (keyword #f "any")))) (jolt-hash-map _o$5805 _o$5806)))))) mk-vec))) (guard (e (#t #f)) - (def-var! "jolt.passes.types.lattice" "mk-set" (letrec ((mk-set (lambda (t) (let fnrec5806 ((t t)) (let* ((_o$5807 (keyword #f "set")) (_o$5808 (if (jolt-truthy? t) t (keyword #f "any")))) (jolt-hash-map _o$5807 _o$5808)))))) mk-set))) + (def-var! "jolt.passes.types.lattice" "mk-set" (letrec ((mk-set (lambda (t) (let fnrec5807 ((t t)) (let* ((_o$5808 (keyword #f "set")) (_o$5809 (if (jolt-truthy? t) t (keyword #f "any")))) (jolt-hash-map _o$5808 _o$5809)))))) mk-set))) (guard (e (#t #f)) - (def-var! "jolt.passes.types.lattice" "mk-struct" (letrec ((mk-struct (lambda (fs) (let fnrec5809 ((fs fs)) (let* ((_o$5810 (keyword #f "struct")) (_o$5811 fs)) (jolt-hash-map _o$5810 _o$5811)))))) mk-struct))) + (def-var! "jolt.passes.types.lattice" "mk-struct" (letrec ((mk-struct (lambda (fs) (let fnrec5810 ((fs fs)) (let* ((_o$5811 (keyword #f "struct")) (_o$5812 fs)) (jolt-hash-map _o$5811 _o$5812)))))) 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 fnrec5812 ((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?))) + (def-var! "jolt.passes.types.lattice" "scalar-t?" (letrec ((scalar-t? (lambda (t) (let fnrec5813 ((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 fnrec5813 ((t t)) (jolt-some? (jolt-get t (keyword #f "union"))))))) union-type?))) + (def-var! "jolt.passes.types.lattice" "union-type?" (letrec ((union-type? (lambda (t) (let fnrec5814 ((t t)) (jolt-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 fnrec5814 ((t t)) (jolt-get t (keyword #f "union")))))) umembers))) + (def-var! "jolt.passes.types.lattice" "umembers" (letrec ((umembers (lambda (t) (let fnrec5815 ((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 fnrec5815 ((ts ts)) (let* ((flat (let* ((_a$5817 (lambda (acc t) (let fnrec5816 ((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$5818 (jolt-hash-set)) (_a$5819 ts)) (jolt-reduce _a$5817 _a$5818 _a$5819)))) (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$5820 (keyword #f "union")) (_o$5821 flat)) (jolt-hash-map _o$5820 _o$5821)) jolt-nil)))))))))) union-of) (let* ((_o$5822 (keyword #f "doc")) (_o$5823 "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$5822 _o$5823)))) + (def-var-with-meta! "jolt.passes.types.lattice" "union-of" (letrec ((union-of (lambda (ts) (let fnrec5816 ((ts ts)) (let* ((flat (let* ((_a$5818 (lambda (acc t) (let fnrec5817 ((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$5819 (jolt-hash-set)) (_a$5820 ts)) (jolt-reduce _a$5818 _a$5819 _a$5820)))) (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$5821 (keyword #f "union")) (_o$5822 flat)) (jolt-hash-map _o$5821 _o$5822)) jolt-nil)))))))))) union-of) (let* ((_o$5823 (keyword #f "doc")) (_o$5824 "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$5823 _o$5824)))) (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 fnrec5824 ((fa fa) (fb fb)) (let* ((m1 (let* ((_a$5829 (lambda (m k) (let fnrec5825 ((m m) (k k)) (jolt-assoc m k (let* ((_a$5826 (var-deref "jolt.passes.types.lattice" "join-t")) (_a$5827 (jolt-get fa k (keyword #f "any"))) (_a$5828 (jolt-get fb k (keyword #f "any")))) (jolt-invoke _a$5826 _a$5827 _a$5828)))))) (_a$5830 (jolt-hash-map)) (_a$5831 (jolt-keys fa))) (jolt-reduce _a$5829 _a$5830 _a$5831)))) (let* ((_a$5836 (lambda (m k) (let fnrec5832 ((m m) (k k)) (if (jolt-truthy? (jolt-get m k)) m (jolt-assoc m k (let* ((_a$5833 (var-deref "jolt.passes.types.lattice" "join-t")) (_a$5834 (jolt-get fa k (keyword #f "any"))) (_a$5835 (jolt-get fb k (keyword #f "any")))) (jolt-invoke _a$5833 _a$5834 _a$5835))))))) (_a$5837 m1) (_a$5838 (jolt-keys fb))) (jolt-reduce _a$5836 _a$5837 _a$5838))))))) merge-fields) (let* ((_o$5839 (keyword #f "doc")) (_o$5840 "Per-field join of two field maps (a key in only one side joins with :any).")) (jolt-hash-map _o$5839 _o$5840)))) + (def-var-with-meta! "jolt.passes.types.lattice" "merge-fields" (letrec ((merge-fields (lambda (fa fb) (let fnrec5825 ((fa fa) (fb fb)) (let* ((m1 (let* ((_a$5830 (lambda (m k) (let fnrec5826 ((m m) (k k)) (jolt-assoc m k (let* ((_a$5827 (var-deref "jolt.passes.types.lattice" "join-t")) (_a$5828 (jolt-get fa k (keyword #f "any"))) (_a$5829 (jolt-get fb k (keyword #f "any")))) (jolt-invoke _a$5827 _a$5828 _a$5829)))))) (_a$5831 (jolt-hash-map)) (_a$5832 (jolt-keys fa))) (jolt-reduce _a$5830 _a$5831 _a$5832)))) (let* ((_a$5837 (lambda (m k) (let fnrec5833 ((m m) (k k)) (if (jolt-truthy? (jolt-get m k)) m (jolt-assoc m k (let* ((_a$5834 (var-deref "jolt.passes.types.lattice" "join-t")) (_a$5835 (jolt-get fa k (keyword #f "any"))) (_a$5836 (jolt-get fb k (keyword #f "any")))) (jolt-invoke _a$5834 _a$5835 _a$5836))))))) (_a$5838 m1) (_a$5839 (jolt-keys fb))) (jolt-reduce _a$5837 _a$5838 _a$5839))))))) merge-fields) (let* ((_o$5840 (keyword #f "doc")) (_o$5841 "Per-field join of two field maps (a key in only one side joins with :any).")) (jolt-hash-map _o$5840 _o$5841)))) (guard (e (#t #f)) - (def-var! "jolt.passes.types.lattice" "join-t" (letrec ((join-t (lambda (a b) (let fnrec5841 ((a a) (b b)) (if (jolt= a b) a (if (jolt-nil? a) b (if (jolt-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$5842 (var-deref "jolt.passes.types.lattice" "merge-fields")) (_a$5843 (jolt-invoke (var-deref "jolt.passes.types.lattice" "sfields") a)) (_a$5844 (jolt-invoke (var-deref "jolt.passes.types.lattice" "sfields") b))) (jolt-invoke _a$5842 _a$5843 _a$5844))))) (if (jolt-truthy? (let* ((and__25__auto (jolt-get a (keyword #f "shape")))) (if (jolt-truthy? and__25__auto) (let* ((_a$5845 (jolt-get a (keyword #f "shape"))) (_a$5846 (jolt-get b (keyword #f "shape")))) (jolt= _a$5845 _a$5846)) 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$5847 (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") a)) (_a$5848 (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") b))) (join-t _a$5847 _a$5848))) (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$5849 (jolt-invoke (var-deref "jolt.passes.types.lattice" "selem") a)) (_a$5850 (jolt-invoke (var-deref "jolt.passes.types.lattice" "selem") b))) (join-t _a$5849 _a$5850))) (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))) + (def-var! "jolt.passes.types.lattice" "join-t" (letrec ((join-t (lambda (a b) (let fnrec5842 ((a a) (b b)) (if (jolt= a b) a (if (jolt-nil? a) b (if (jolt-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$5843 (var-deref "jolt.passes.types.lattice" "merge-fields")) (_a$5844 (jolt-invoke (var-deref "jolt.passes.types.lattice" "sfields") a)) (_a$5845 (jolt-invoke (var-deref "jolt.passes.types.lattice" "sfields") b))) (jolt-invoke _a$5843 _a$5844 _a$5845))))) (if (jolt-truthy? (let* ((and__25__auto (jolt-get a (keyword #f "shape")))) (if (jolt-truthy? and__25__auto) (let* ((_a$5846 (jolt-get a (keyword #f "shape"))) (_a$5847 (jolt-get b (keyword #f "shape")))) (jolt= _a$5846 _a$5847)) 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$5848 (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") a)) (_a$5849 (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") b))) (join-t _a$5848 _a$5849))) (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$5850 (jolt-invoke (var-deref "jolt.passes.types.lattice" "selem") a)) (_a$5851 (jolt-invoke (var-deref "jolt.passes.types.lattice" "selem") b))) (join-t _a$5850 _a$5851))) (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 fnrec5851 ((a a) (b b)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "join-t") a b))))) join))) + (def-var! "jolt.passes.types.lattice" "join" (letrec ((join (lambda (a b) (let fnrec5852 ((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 fnrec5852 ((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$5856 (lambda (m k) (let fnrec5853 ((m m) (k k)) (jolt-assoc m k (let* ((_a$5854 (jolt-get (jolt-invoke (var-deref "jolt.passes.types.lattice" "sfields") t) k)) (_a$5855 (jolt-dec d))) (cap _a$5854 _a$5855)))))) (_a$5857 (jolt-hash-map)) (_a$5858 (jolt-keys (jolt-invoke (var-deref "jolt.passes.types.lattice" "sfields") t)))) (jolt-reduce _a$5856 _a$5857 _a$5858)))) (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$5859 (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") t)) (_a$5860 (jolt-dec d))) (cap _a$5859 _a$5860))) (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$5861 (jolt-invoke (var-deref "jolt.passes.types.lattice" "selem") t)) (_a$5862 (jolt-dec d))) (cap _a$5861 _a$5862))) (if (jolt-truthy? (keyword #f "else")) t jolt-nil))))))))) cap))) + (def-var! "jolt.passes.types.lattice" "cap" (letrec ((cap (lambda (t d) (let fnrec5853 ((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$5857 (lambda (m k) (let fnrec5854 ((m m) (k k)) (jolt-assoc m k (let* ((_a$5855 (jolt-get (jolt-invoke (var-deref "jolt.passes.types.lattice" "sfields") t) k)) (_a$5856 (jolt-dec d))) (cap _a$5855 _a$5856)))))) (_a$5858 (jolt-hash-map)) (_a$5859 (jolt-keys (jolt-invoke (var-deref "jolt.passes.types.lattice" "sfields") t)))) (jolt-reduce _a$5857 _a$5858 _a$5859)))) (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$5860 (jolt-invoke (var-deref "jolt.passes.types.lattice" "velem") t)) (_a$5861 (jolt-dec d))) (cap _a$5860 _a$5861))) (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$5862 (jolt-invoke (var-deref "jolt.passes.types.lattice" "selem") t)) (_a$5863 (jolt-dec d))) (cap _a$5862 _a$5863))) (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 fnrec5863 ((t t)) (jolt-invoke (var-deref "jolt.passes.types.lattice" "struct-type?") t))))) struct-safe?))) + (def-var! "jolt.passes.types.lattice" "struct-safe?" (letrec ((struct-safe? (lambda (t) (let fnrec5864 ((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 fnrec5864 ((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))) + (def-var! "jolt.passes.types.lattice" "field-type" (letrec ((field-type (lambda (t k) (let fnrec5865 ((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 fnrec5865 ((ks ks)) (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "sort") (lambda (a b) (let fnrec5866 ((a a) (b b)) (let* ((_a$5867 (var-deref "clojure.core" "compare")) (_a$5868 (jolt-invoke (var-deref "clojure.core" "str") a)) (_a$5869 (jolt-invoke (var-deref "clojure.core" "str") b))) (jolt-invoke _a$5867 _a$5868 _a$5869)))) ks)))))) shape-order) (let* ((_o$5870 (keyword #f "doc")) (_o$5871 "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$5870 _o$5871)))) + (def-var-with-meta! "jolt.passes.types.lattice" "shape-order" (letrec ((shape-order (lambda (ks) (let fnrec5866 ((ks ks)) (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "sort") (lambda (a b) (let fnrec5867 ((a a) (b b)) (let* ((_a$5868 (var-deref "clojure.core" "compare")) (_a$5869 (jolt-invoke (var-deref "clojure.core" "str") a)) (_a$5870 (jolt-invoke (var-deref "clojure.core" "str") b))) (jolt-invoke _a$5868 _a$5869 _a$5870)))) ks)))))) shape-order) (let* ((_o$5871 (keyword #f "doc")) (_o$5872 "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$5871 _o$5872)))) (guard (e (#t #f)) - (def-var! "jolt.passes.types.lattice" "type-shape" (letrec ((type-shape (lambda (t) (let fnrec5872 ((t t)) (jolt-get t (keyword #f "shape")))))) type-shape))) + (def-var! "jolt.passes.types.lattice" "type-shape" (letrec ((type-shape (lambda (t) (let fnrec5873 ((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 fnrec5873 ((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))) + (def-var! "jolt.passes.types.lattice" "mark-struct" (letrec ((mark-struct (lambda (node t) (let fnrec5874 ((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 fnrec5874 ((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?))) + (def-var! "jolt.passes.types.lattice" "truthy-type?" (letrec ((truthy-type? (lambda (t) (let fnrec5875 ((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$5875 "+") (_o$5876 "-") (_o$5877 "*") (_o$5878 "/") (_o$5879 "inc") (_o$5880 "dec") (_o$5881 "mod") (_o$5882 "rem") (_o$5883 "quot") (_o$5884 "min") (_o$5885 "max") (_o$5886 "abs") (_o$5887 "bit-and") (_o$5888 "bit-or") (_o$5889 "bit-xor") (_o$5890 "count")) (jolt-hash-set _o$5875 _o$5876 _o$5877 _o$5878 _o$5879 _o$5880 _o$5881 _o$5882 _o$5883 _o$5884 _o$5885 _o$5886 _o$5887 _o$5888 _o$5889 _o$5890)))) + (def-var! "jolt.passes.types.lattice" "num-ret-fns" (let* ((_o$5876 "+") (_o$5877 "-") (_o$5878 "*") (_o$5879 "/") (_o$5880 "inc") (_o$5881 "dec") (_o$5882 "mod") (_o$5883 "rem") (_o$5884 "quot") (_o$5885 "min") (_o$5886 "max") (_o$5887 "abs") (_o$5888 "bit-and") (_o$5889 "bit-or") (_o$5890 "bit-xor") (_o$5891 "count")) (jolt-hash-set _o$5876 _o$5877 _o$5878 _o$5879 _o$5880 _o$5881 _o$5882 _o$5883 _o$5884 _o$5885 _o$5886 _o$5887 _o$5888 _o$5889 _o$5890 _o$5891)))) (guard (e (#t #f)) - (def-var! "jolt.passes.types.lattice" "vector-ret-fns" (let* ((_o$5891 "vec") (_o$5892 "vector") (_o$5893 "mapv") (_o$5894 "filterv") (_o$5895 "subvec")) (jolt-hash-set _o$5891 _o$5892 _o$5893 _o$5894 _o$5895)))) + (def-var! "jolt.passes.types.lattice" "vector-ret-fns" (let* ((_o$5892 "vec") (_o$5893 "vector") (_o$5894 "mapv") (_o$5895 "filterv") (_o$5896 "subvec")) (jolt-hash-set _o$5892 _o$5893 _o$5894 _o$5895 _o$5896)))) (guard (e (#t #f)) - (def-var! "jolt.passes.types.check" "not-number?" (letrec ((not-number? (lambda (t) (let fnrec5896 ((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?))) + (def-var! "jolt.passes.types.check" "not-number?" (letrec ((not-number? (lambda (t) (let fnrec5897 ((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 fnrec5897 ((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?))) + (def-var! "jolt.passes.types.check" "not-seqable?" (letrec ((not-seqable? (lambda (t) (let fnrec5898 ((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 fnrec5898 ((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?))) + (def-var! "jolt.passes.types.check" "not-callable?" (letrec ((not-callable? (lambda (t) (let fnrec5899 ((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$5899 "+") (_o$5900 "-") (_o$5901 "*") (_o$5902 "/") (_o$5903 "inc") (_o$5904 "dec") (_o$5905 "mod") (_o$5906 "rem") (_o$5907 "quot") (_o$5908 "min") (_o$5909 "max") (_o$5910 "abs") (_o$5911 "bit-and") (_o$5912 "bit-or") (_o$5913 "bit-xor") (_o$5914 "bit-not") (_o$5915 "bit-shift-left") (_o$5916 "bit-shift-right")) (jolt-hash-set _o$5899 _o$5900 _o$5901 _o$5902 _o$5903 _o$5904 _o$5905 _o$5906 _o$5907 _o$5908 _o$5909 _o$5910 _o$5911 _o$5912 _o$5913 _o$5914 _o$5915 _o$5916)) (let* ((_o$5917 (keyword #f "private")) (_o$5918 #t)) (jolt-hash-map _o$5917 _o$5918)))) + (def-var-with-meta! "jolt.passes.types.check" "num-ops" (let* ((_o$5900 "+") (_o$5901 "-") (_o$5902 "*") (_o$5903 "/") (_o$5904 "inc") (_o$5905 "dec") (_o$5906 "mod") (_o$5907 "rem") (_o$5908 "quot") (_o$5909 "min") (_o$5910 "max") (_o$5911 "abs") (_o$5912 "bit-and") (_o$5913 "bit-or") (_o$5914 "bit-xor") (_o$5915 "bit-not") (_o$5916 "bit-shift-left") (_o$5917 "bit-shift-right")) (jolt-hash-set _o$5900 _o$5901 _o$5902 _o$5903 _o$5904 _o$5905 _o$5906 _o$5907 _o$5908 _o$5909 _o$5910 _o$5911 _o$5912 _o$5913 _o$5914 _o$5915 _o$5916 _o$5917)) (let* ((_o$5918 (keyword #f "private")) (_o$5919 #t)) (jolt-hash-map _o$5918 _o$5919)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.types.check" "seq-ops" (let* ((_o$5919 "count") (_o$5920 "first") (_o$5921 "rest") (_o$5922 "next") (_o$5923 "seq") (_o$5924 "nth")) (jolt-hash-set _o$5919 _o$5920 _o$5921 _o$5922 _o$5923 _o$5924)) (let* ((_o$5925 (keyword #f "private")) (_o$5926 #t)) (jolt-hash-map _o$5925 _o$5926)))) + (def-var-with-meta! "jolt.passes.types.check" "seq-ops" (let* ((_o$5920 "count") (_o$5921 "first") (_o$5922 "rest") (_o$5923 "next") (_o$5924 "seq") (_o$5925 "nth")) (jolt-hash-set _o$5920 _o$5921 _o$5922 _o$5923 _o$5924 _o$5925)) (let* ((_o$5926 (keyword #f "private")) (_o$5927 #t)) (jolt-hash-map _o$5926 _o$5927)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.types.check" "type-name" (letrec ((type-name (lambda (t) (let fnrec5927 ((t t)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "union-type?") t)) (let* ((_a$5929 (lambda (s m) (let fnrec5928 ((s s) (m m)) (if (jolt= s "") (type-name m) (jolt-invoke (var-deref "clojure.core" "str") s " or " (type-name m)))))) (_a$5930 "") (_a$5931 (jolt-invoke (var-deref "jolt.passes.types.lattice" "umembers") t))) (jolt-reduce _a$5929 _a$5930 _a$5931)) (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$5932 (keyword #f "doc")) (_o$5933 "Render an inferred type for an error message.")) (jolt-hash-map _o$5932 _o$5933)))) + (def-var-with-meta! "jolt.passes.types.check" "type-name" (letrec ((type-name (lambda (t) (let fnrec5928 ((t t)) (if (jolt-truthy? (jolt-invoke (var-deref "jolt.passes.types.lattice" "union-type?") t)) (let* ((_a$5930 (lambda (s m) (let fnrec5929 ((s s) (m m)) (if (jolt= s "") (type-name m) (jolt-invoke (var-deref "clojure.core" "str") s " or " (type-name m)))))) (_a$5931 "") (_a$5932 (jolt-invoke (var-deref "jolt.passes.types.lattice" "umembers") t))) (jolt-reduce _a$5930 _a$5931 _a$5932)) (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$5933 (keyword #f "doc")) (_o$5934 "Render an inferred type for an error message.")) (jolt-hash-map _o$5933 _o$5934)))) (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 fnrec5934 ((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$5957 (lambda (_ i) (let fnrec5935 ((_ _) (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$5953 (var-deref "clojure.core" "swap!")) (_a$5954 (jolt-get env (keyword #f "diags"))) (_a$5955 jolt-conj) (_a$5956 (let* ((_o$5943 (keyword #f "op")) (_o$5944 cn) (_o$5945 (keyword #f "argpos")) (_o$5946 i) (_o$5947 (keyword #f "type")) (_o$5948 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") t)) (_o$5949 (keyword #f "pos")) (_o$5950 pos) (_o$5951 (keyword #f "msg")) (_o$5952 (let* ((_a$5936 (var-deref "clojure.core" "str")) (_a$5937 "`") (_a$5938 cn) (_a$5939 "` requires a number, but argument ") (_a$5940 (jolt-inc i)) (_a$5941 " is ") (_a$5942 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") t))) (jolt-invoke _a$5936 _a$5937 _a$5938 _a$5939 _a$5940 _a$5941 _a$5942)))) (jolt-hash-map _o$5943 _o$5944 _o$5945 _o$5946 _o$5947 _o$5948 _o$5949 _o$5950 _o$5951 _o$5952)))) (jolt-invoke _a$5953 _a$5954 _a$5955 _a$5956)) jolt-nil)) jolt-nil)))) (_a$5958 jolt-nil) (_a$5959 (jolt-range (jolt-count args)))) (jolt-reduce _a$5957 _a$5958 _a$5959)) (if (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$5977 (var-deref "clojure.core" "swap!")) (_a$5978 (jolt-get env (keyword #f "diags"))) (_a$5979 jolt-conj) (_a$5980 (let* ((_o$5967 (keyword #f "op")) (_o$5968 cn) (_o$5969 (keyword #f "argpos")) (_o$5970 0) (_o$5971 (keyword #f "type")) (_o$5972 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") t)) (_o$5973 (keyword #f "pos")) (_o$5974 pos) (_o$5975 (keyword #f "msg")) (_o$5976 (let* ((_a$5960 (var-deref "clojure.core" "str")) (_a$5961 "`") (_a$5962 cn) (_a$5963 "` requires ") (_a$5964 (if (jolt= cn "count") "a countable collection" "a seqable")) (_a$5965 ", but argument 1 is ") (_a$5966 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") t))) (jolt-invoke _a$5960 _a$5961 _a$5962 _a$5963 _a$5964 _a$5965 _a$5966)))) (jolt-hash-map _o$5967 _o$5968 _o$5969 _o$5970 _o$5971 _o$5972 _o$5973 _o$5974 _o$5975 _o$5976)))) (jolt-invoke _a$5977 _a$5978 _a$5979 _a$5980)) jolt-nil)) (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))))) check-invoke) (let* ((_o$5981 (keyword #f "doc")) (_o$5982 "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$5981 _o$5982)))) + (def-var-with-meta! "jolt.passes.types.check" "check-invoke" (letrec ((check-invoke (lambda (cn args arg-types pos env) (let fnrec5935 ((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$5958 (lambda (_ i) (let fnrec5936 ((_ _) (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$5954 (var-deref "clojure.core" "swap!")) (_a$5955 (jolt-get env (keyword #f "diags"))) (_a$5956 jolt-conj) (_a$5957 (let* ((_o$5944 (keyword #f "op")) (_o$5945 cn) (_o$5946 (keyword #f "argpos")) (_o$5947 i) (_o$5948 (keyword #f "type")) (_o$5949 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") t)) (_o$5950 (keyword #f "pos")) (_o$5951 pos) (_o$5952 (keyword #f "msg")) (_o$5953 (let* ((_a$5937 (var-deref "clojure.core" "str")) (_a$5938 "`") (_a$5939 cn) (_a$5940 "` requires a number, but argument ") (_a$5941 (jolt-inc i)) (_a$5942 " is ") (_a$5943 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") t))) (jolt-invoke _a$5937 _a$5938 _a$5939 _a$5940 _a$5941 _a$5942 _a$5943)))) (jolt-hash-map _o$5944 _o$5945 _o$5946 _o$5947 _o$5948 _o$5949 _o$5950 _o$5951 _o$5952 _o$5953)))) (jolt-invoke _a$5954 _a$5955 _a$5956 _a$5957)) jolt-nil)) jolt-nil)))) (_a$5959 jolt-nil) (_a$5960 (jolt-range (jolt-count args)))) (jolt-reduce _a$5958 _a$5959 _a$5960)) (if (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$5978 (var-deref "clojure.core" "swap!")) (_a$5979 (jolt-get env (keyword #f "diags"))) (_a$5980 jolt-conj) (_a$5981 (let* ((_o$5968 (keyword #f "op")) (_o$5969 cn) (_o$5970 (keyword #f "argpos")) (_o$5971 0) (_o$5972 (keyword #f "type")) (_o$5973 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") t)) (_o$5974 (keyword #f "pos")) (_o$5975 pos) (_o$5976 (keyword #f "msg")) (_o$5977 (let* ((_a$5961 (var-deref "clojure.core" "str")) (_a$5962 "`") (_a$5963 cn) (_a$5964 "` requires ") (_a$5965 (if (jolt= cn "count") "a countable collection" "a seqable")) (_a$5966 ", but argument 1 is ") (_a$5967 (jolt-invoke (var-deref "jolt.passes.types.check" "type-name") t))) (jolt-invoke _a$5961 _a$5962 _a$5963 _a$5964 _a$5965 _a$5966 _a$5967)))) (jolt-hash-map _o$5968 _o$5969 _o$5970 _o$5971 _o$5972 _o$5973 _o$5974 _o$5975 _o$5976 _o$5977)))) (jolt-invoke _a$5978 _a$5979 _a$5980 _a$5981)) jolt-nil)) (if (jolt-truthy? (keyword #f "else")) jolt-nil jolt-nil))))))) check-invoke) (let* ((_o$5982 (keyword #f "doc")) (_o$5983 "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$5982 _o$5983)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.types.check" "register-user-fn!" (letrec ((register-user-fn! (lambda (node env) (let fnrec5983 ((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 (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$5994 (var-deref "clojure.core" "swap!")) (_a$5995 (jolt-get env (keyword #f "user-sigs"))) (_a$5996 jolt-assoc) (_a$5997 (let* ((_a$5984 (var-deref "clojure.core" "str")) (_a$5985 (jolt-get node (keyword #f "ns"))) (_a$5986 "/") (_a$5987 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$5984 _a$5985 _a$5986 _a$5987))) (_a$5998 (let* ((_o$5988 (keyword #f "name")) (_o$5989 (jolt-get node (keyword #f "name"))) (_o$5990 (keyword #f "params")) (_o$5991 (jolt-get ar (keyword #f "params"))) (_o$5992 (keyword #f "body")) (_o$5993 (jolt-get ar (keyword #f "body")))) (jolt-hash-map _o$5988 _o$5989 _o$5990 _o$5991 _o$5992 _o$5993)))) (jolt-invoke _a$5994 _a$5995 _a$5996 _a$5997 _a$5998)) jolt-nil)) jolt-nil)) jolt-nil)))))) register-user-fn!) (let* ((_o$5999 (keyword #f "doc")) (_o$6000 "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$5999 _o$6000)))) + (def-var-with-meta! "jolt.passes.types.check" "register-user-fn!" (letrec ((register-user-fn! (lambda (node env) (let fnrec5984 ((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 (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$5995 (var-deref "clojure.core" "swap!")) (_a$5996 (jolt-get env (keyword #f "user-sigs"))) (_a$5997 jolt-assoc) (_a$5998 (let* ((_a$5985 (var-deref "clojure.core" "str")) (_a$5986 (jolt-get node (keyword #f "ns"))) (_a$5987 "/") (_a$5988 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$5985 _a$5986 _a$5987 _a$5988))) (_a$5999 (let* ((_o$5989 (keyword #f "name")) (_o$5990 (jolt-get node (keyword #f "name"))) (_o$5991 (keyword #f "params")) (_o$5992 (jolt-get ar (keyword #f "params"))) (_o$5993 (keyword #f "body")) (_o$5994 (jolt-get ar (keyword #f "body")))) (jolt-hash-map _o$5989 _o$5990 _o$5991 _o$5992 _o$5993 _o$5994)))) (jolt-invoke _a$5995 _a$5996 _a$5997 _a$5998 _a$5999)) jolt-nil)) jolt-nil)) jolt-nil)))))) register-user-fn!) (let* ((_o$6000 (keyword #f "doc")) (_o$6001 "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$6000 _o$6001)))) (guard (e (#t #f)) (def-var-with-meta! "jolt.passes.types" "config-box" (jolt-invoke (var-deref "clojure.core" "atom") (let* ((_o$5127 (keyword #f "rtenv")) (_o$5128 (jolt-hash-map)) (_o$5129 (keyword #f "vtypes")) (_o$5130 (jolt-hash-map)) (_o$5131 (keyword #f "record-shapes")) (_o$5132 (jolt-hash-map)) (_o$5133 (keyword #f "protocol-methods")) (_o$5134 (jolt-hash-map)) (_o$5135 (keyword #f "map-shapes?")) (_o$5136 #f)) (jolt-hash-map _o$5127 _o$5128 _o$5129 _o$5130 _o$5131 _o$5132 _o$5133 _o$5134 _o$5135 _o$5136))) (let* ((_o$5137 (keyword #f "private")) (_o$5138 #t)) (jolt-hash-map _o$5137 _o$5138)))) (guard (e (#t #f)) @@ -551,18 +551,18 @@ (guard (e (#t #f)) (def-var! "jolt.passes.types" "wp-pass" (letrec ((wp-pass (lambda (nodes spec ks ptypes) (let fnrec5703 ((nodes nodes) (spec spec) (ks ks) (ptypes ptypes)) (let* ((_a$5733 (lambda (acc node) (let fnrec5704 ((acc acc) (node node)) (let* ((k (if (jolt= (keyword #f "def") (jolt-get node (keyword #f "op"))) (let* ((_a$5705 (var-deref "clojure.core" "str")) (_a$5706 (jolt-get node (keyword #f "ns"))) (_a$5707 "/") (_a$5708 (jolt-get node (keyword #f "name")))) (jolt-invoke _a$5705 _a$5706 _a$5707 _a$5708)) jolt-nil)) (s (let* ((and__25__auto k)) (if (jolt-truthy? and__25__auto) (jolt-get spec k) and__25__auto)))) (if (jolt-truthy? s) (let* ((r (let* ((_a$5712 (var-deref "jolt.passes.types" "infer-body")) (_a$5713 (jolt-get s (keyword #f "body"))) (_a$5714 (let* ((_a$5709 (var-deref "clojure.core" "zipmap")) (_a$5710 (jolt-get s (keyword #f "params"))) (_a$5711 (jolt-get ptypes k))) (jolt-invoke _a$5709 _a$5710 _a$5711))) (_a$5715 (jolt-get s (keyword #f "name"))) (_a$5716 k)) (jolt-invoke _a$5712 _a$5713 _a$5714 _a$5715 _a$5716)))) (let* ((_a$5723 (var-deref "clojure.core" "update")) (_a$5724 (let* ((_a$5719 (var-deref "clojure.core" "assoc-in")) (_a$5720 acc) (_a$5721 (let* ((_o$5717 (keyword #f "rets")) (_o$5718 k)) (jolt-vector _o$5717 _o$5718))) (_a$5722 (jolt-nth r 0))) (jolt-invoke _a$5719 _a$5720 _a$5721 _a$5722))) (_a$5725 (keyword #f "ptypes")) (_a$5726 (var-deref "jolt.passes.types" "wp-accum")) (_a$5727 spec) (_a$5728 (jolt-nth r 2))) (jolt-invoke _a$5723 _a$5724 _a$5725 _a$5726 _a$5727 _a$5728))) (jolt-invoke (var-deref "clojure.core" "update") acc (keyword #f "ptypes") (var-deref "jolt.passes.types" "wp-accum") spec (jolt-nth (jolt-invoke (var-deref "jolt.passes.types" "infer-body") node (jolt-hash-map)) 2))))))) (_a$5734 (let* ((_o$5729 (keyword #f "rets")) (_o$5730 (jolt-hash-map)) (_o$5731 (keyword #f "ptypes")) (_o$5732 (jolt-invoke (var-deref "jolt.passes.types" "wp-empty-ptypes") spec ks))) (jolt-hash-map _o$5729 _o$5730 _o$5731 _o$5732))) (_a$5735 nodes)) (jolt-reduce _a$5733 _a$5734 _a$5735)))))) wp-pass))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.types" "wp-infer!" (letrec ((wp-infer! (lambda (nodes) (let fnrec5736 ((nodes nodes)) (let* ((spec (jolt-invoke (var-deref "jolt.passes.types" "wp-specializable") nodes)) (ks (jolt-keys spec))) (let* ((iter 0) (ptypes (jolt-invoke (var-deref "jolt.passes.types" "wp-empty-ptypes") spec ks)) (rets (jolt-hash-map))) (let loop5737 ((iter iter) (ptypes ptypes) (rets rets)) (begin (jolt-invoke (var-deref "jolt.passes.types" "set-rtenv!") (let* ((_a$5739 (lambda (m k) (let fnrec5738 ((m m) (k k)) (let* ((v (jolt-get rets k))) (if (jolt-some? v) (jolt-assoc m k v) m))))) (_a$5740 (jolt-hash-map)) (_a$5741 ks)) (jolt-reduce _a$5739 _a$5740 _a$5741))) (jolt-invoke (var-deref "jolt.passes.types" "reset-escapes!")) (let* ((pass (jolt-invoke (var-deref "jolt.passes.types" "wp-pass") nodes spec ks ptypes)) (escaped (jolt-invoke (var-deref "clojure.core" "set") (jolt-invoke (var-deref "jolt.passes.types" "collected-escapes")))) (new-ptypes (let* ((_a$5743 (lambda (m k) (let fnrec5742 ((m m) (k k)) (if (jolt-contains? escaped k) (jolt-assoc m k (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "repeat") (jolt-count (jolt-get m k)) (keyword #f "any")))) m)))) (_a$5744 (jolt-get pass (keyword #f "ptypes"))) (_a$5745 ks)) (jolt-reduce _a$5743 _a$5744 _a$5745))) (new-rets (jolt-get pass (keyword #f "rets")))) (if (let* ((or__26__auto (let* ((and__25__auto (jolt= new-ptypes ptypes))) (if (jolt-truthy? and__25__auto) (jolt= new-rets rets) and__25__auto)))) (if (jolt-truthy? or__26__auto) or__26__auto (>= iter 16))) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.passes.types" "wp-seeds-box") (let* ((_a$5754 (lambda (m k) (let fnrec5746 ((m m) (k k)) (let* ((s (jolt-get spec k)) (ptmap (let* ((_a$5751 (lambda (pm pr) (let fnrec5747 ((pm pm) (pr pr)) (let* ((nm (jolt-nth pr 0)) (t (jolt-nth pr 1))) (if (jolt-truthy? (let* ((and__25__auto t)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "not=") t (keyword #f "any")) and__25__auto))) (jolt-assoc pm nm t) pm))))) (_a$5752 (jolt-hash-map)) (_a$5753 (let* ((_a$5748 jolt-vector) (_a$5749 (jolt-get s (keyword #f "params"))) (_a$5750 (jolt-get new-ptypes k))) (jolt-map _a$5748 _a$5749 _a$5750)))) (jolt-reduce _a$5751 _a$5752 _a$5753)))) (if (jolt-truthy? (jolt-seq ptmap)) (jolt-assoc m k ptmap) m))))) (_a$5755 (jolt-hash-map)) (_a$5756 ks)) (jolt-reduce _a$5754 _a$5755 _a$5756))) (loop5737 (jolt-inc iter) new-ptypes new-rets))))))))))) wp-infer!) (let* ((_o$5757 (keyword #f "doc")) (_o$5758 "Run the closed-world param-type fixpoint over the unit's analyzed top-level\n nodes and stash the resulting per-def seed maps (read via param-seeds-for).\n record-shapes / protocol-methods must already be installed. Idempotent \x2014; resets\n the seed box; called once per build before per-form emit.")) (jolt-hash-map _o$5757 _o$5758)))) + (def-var-with-meta! "jolt.passes.types" "wp-infer!" (letrec ((wp-infer! (lambda (nodes) (let fnrec5736 ((nodes nodes)) (let* ((spec (jolt-invoke (var-deref "jolt.passes.types" "wp-specializable") nodes)) (ks (jolt-keys spec))) (let* ((iter 0) (ptypes (jolt-invoke (var-deref "jolt.passes.types" "wp-empty-ptypes") spec ks)) (rets (jolt-hash-map))) (let loop5737 ((iter iter) (ptypes ptypes) (rets rets)) (begin (jolt-invoke (var-deref "jolt.passes.types" "set-rtenv!") (let* ((_a$5739 (lambda (m k) (let fnrec5738 ((m m) (k k)) (let* ((v (jolt-get rets k))) (if (jolt-some? v) (jolt-assoc m k v) m))))) (_a$5740 (jolt-hash-map)) (_a$5741 ks)) (jolt-reduce _a$5739 _a$5740 _a$5741))) (jolt-invoke (var-deref "jolt.passes.types" "reset-escapes!")) (let* ((pass (jolt-invoke (var-deref "jolt.passes.types" "wp-pass") nodes spec ks ptypes)) (escaped (jolt-invoke (var-deref "clojure.core" "set") (jolt-invoke (var-deref "jolt.passes.types" "collected-escapes")))) (new-ptypes (let* ((_a$5743 (lambda (m k) (let fnrec5742 ((m m) (k k)) (if (jolt-contains? escaped k) (jolt-assoc m k (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "repeat") (jolt-count (jolt-get m k)) (keyword #f "any")))) m)))) (_a$5744 (jolt-get pass (keyword #f "ptypes"))) (_a$5745 ks)) (jolt-reduce _a$5743 _a$5744 _a$5745))) (new-rets (jolt-get pass (keyword #f "rets"))) (converged? (let* ((and__25__auto (jolt= new-ptypes ptypes))) (if (jolt-truthy? and__25__auto) (jolt= new-rets rets) and__25__auto)))) (if (jolt-truthy? (let* ((or__26__auto converged?)) (if (jolt-truthy? or__26__auto) or__26__auto (>= iter 16)))) (let* ((seed-ptypes (if (jolt-truthy? converged?) new-ptypes (jolt-reduce (lambda (m k) (let fnrec5746 ((m m) (k k)) (jolt-assoc m k (jolt-invoke (var-deref "clojure.core" "vec") (jolt-invoke (var-deref "clojure.core" "repeat") (jolt-count (jolt-get m k)) (keyword #f "any")))))) new-ptypes ks)))) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.passes.types" "wp-seeds-box") (let* ((_a$5755 (lambda (m k) (let fnrec5747 ((m m) (k k)) (let* ((s (jolt-get spec k)) (ptmap (let* ((_a$5752 (lambda (pm pr) (let fnrec5748 ((pm pm) (pr pr)) (let* ((nm (jolt-nth pr 0)) (t (jolt-nth pr 1))) (if (jolt-truthy? (let* ((and__25__auto t)) (if (jolt-truthy? and__25__auto) (jolt-invoke (var-deref "clojure.core" "not=") t (keyword #f "any")) and__25__auto))) (jolt-assoc pm nm t) pm))))) (_a$5753 (jolt-hash-map)) (_a$5754 (let* ((_a$5749 jolt-vector) (_a$5750 (jolt-get s (keyword #f "params"))) (_a$5751 (jolt-get seed-ptypes k))) (jolt-map _a$5749 _a$5750 _a$5751)))) (jolt-reduce _a$5752 _a$5753 _a$5754)))) (if (jolt-truthy? (jolt-seq ptmap)) (jolt-assoc m k ptmap) m))))) (_a$5756 (jolt-hash-map)) (_a$5757 ks)) (jolt-reduce _a$5755 _a$5756 _a$5757)))) (loop5737 (jolt-inc iter) new-ptypes new-rets))))))))))) wp-infer!) (let* ((_o$5758 (keyword #f "doc")) (_o$5759 "Run the closed-world param-type fixpoint over the unit's analyzed top-level\n nodes and stash the resulting per-def seed maps (read via param-seeds-for).\n record-shapes / protocol-methods must already be installed. Idempotent \x2014; resets\n the seed box; called once per build before per-form emit.")) (jolt-hash-map _o$5758 _o$5759)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.types" "set-check-mode!" (letrec ((set-check-mode! (lambda (on strict?) (let fnrec5759 ((on on) (strict? strict?)) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.passes.types" "check-mode-box") (let* ((_o$5760 (keyword #f "on")) (_o$5761 (if (jolt-truthy? on) #t #f)) (_o$5762 (keyword #f "strict")) (_o$5763 (if (jolt-truthy? strict?) #t #f))) (jolt-hash-map _o$5760 _o$5761 _o$5762 _o$5763))))))) set-check-mode!) (let* ((_o$5764 (keyword #f "doc")) (_o$5765 "Enable/disable checking during the next run-passes inference (direct-link).")) (jolt-hash-map _o$5764 _o$5765)))) + (def-var-with-meta! "jolt.passes.types" "set-check-mode!" (letrec ((set-check-mode! (lambda (on strict?) (let fnrec5760 ((on on) (strict? strict?)) (jolt-invoke (var-deref "clojure.core" "reset!") (var-deref "jolt.passes.types" "check-mode-box") (let* ((_o$5761 (keyword #f "on")) (_o$5762 (if (jolt-truthy? on) #t #f)) (_o$5763 (keyword #f "strict")) (_o$5764 (if (jolt-truthy? strict?) #t #f))) (jolt-hash-map _o$5761 _o$5762 _o$5763 _o$5764))))))) set-check-mode!) (let* ((_o$5765 (keyword #f "doc")) (_o$5766 "Enable/disable checking during the next run-passes inference (direct-link).")) (jolt-hash-map _o$5765 _o$5766)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.types" "take-diags!" (letrec ((take-diags! (lambda () (let fnrec5766 () (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$5767 (keyword #f "doc")) (_o$5768 "Diagnostics accumulated by the last checking run-passes; clears the buffer.")) (jolt-hash-map _o$5767 _o$5768)))) + (def-var-with-meta! "jolt.passes.types" "take-diags!" (letrec ((take-diags! (lambda () (let fnrec5767 () (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$5768 (keyword #f "doc")) (_o$5769 "Diagnostics accumulated by the last checking run-passes; clears the buffer.")) (jolt-hash-map _o$5768 _o$5769)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes.types" "run-inference" (letrec ((run-inference (lambda (opt) (let fnrec5769 ((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$5770 (keyword #f "doc")) (_o$5771 "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$5770 _o$5771)))) + (def-var-with-meta! "jolt.passes.types" "run-inference" (letrec ((run-inference (lambda (opt) (let fnrec5770 ((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$5771 (keyword #f "doc")) (_o$5772 "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$5771 _o$5772)))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes" "inline-fixpoint-cap" 8 (let* ((_o$5772 (keyword #f "private")) (_o$5773 #t)) (jolt-hash-map _o$5772 _o$5773)))) + (def-var-with-meta! "jolt.passes" "inline-fixpoint-cap" 8 (let* ((_o$5773 (keyword #f "private")) (_o$5774 #t)) (jolt-hash-map _o$5773 _o$5774)))) (guard (e (#t #f)) - (def-var! "jolt.passes" "inline-eligible?" (letrec ((inline-eligible? (lambda (node) (let fnrec5774 ((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?))) + (def-var! "jolt.passes" "inline-eligible?" (letrec ((inline-eligible? (lambda (node) (let fnrec5775 ((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 fnrec5775 ((node node)) (let* ((a (jolt-first (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "arities"))))) (let* ((_o$5776 (keyword #f "params")) (_o$5777 (jolt-get a (keyword #f "params"))) (_o$5778 (keyword #f "body")) (_o$5779 (jolt-get a (keyword #f "body"))) (_o$5780 (keyword #f "nhints")) (_o$5781 (jolt-get a (keyword #f "nhints"))) (_o$5782 (keyword #f "ret")) (_o$5783 (jolt-get a (keyword #f "ret-nhint")))) (jolt-hash-map _o$5776 _o$5777 _o$5778 _o$5779 _o$5780 _o$5781 _o$5782 _o$5783))))))) stash-of))) + (def-var! "jolt.passes" "stash-of" (letrec ((stash-of (lambda (node) (let fnrec5776 ((node node)) (let* ((a (jolt-first (jolt-get (jolt-get node (keyword #f "init")) (keyword #f "arities"))))) (let* ((_o$5777 (keyword #f "params")) (_o$5778 (jolt-get a (keyword #f "params"))) (_o$5779 (keyword #f "body")) (_o$5780 (jolt-get a (keyword #f "body"))) (_o$5781 (keyword #f "nhints")) (_o$5782 (jolt-get a (keyword #f "nhints"))) (_o$5783 (keyword #f "ret")) (_o$5784 (jolt-get a (keyword #f "ret-nhint")))) (jolt-hash-map _o$5777 _o$5778 _o$5779 _o$5780 _o$5781 _o$5782 _o$5783 _o$5784))))))) stash-of))) (guard (e (#t #f)) - (def-var-with-meta! "jolt.passes" "run-passes" (letrec ((run-passes (lambda (node ctx) (let fnrec5784 ((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$5785 (var-deref "jolt.host" "stash-inline!")) (_a$5786 ctx) (_a$5787 (jolt-get node (keyword #f "ns"))) (_a$5788 (jolt-get node (keyword #f "name"))) (_a$5789 (jolt-invoke (var-deref "jolt.passes" "stash-of") node))) (jolt-invoke _a$5785 _a$5786 _a$5787 _a$5788 _a$5789)) 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))) (_ (jolt-invoke (var-deref "jolt.passes.types" "set-protocol-methods!") (jolt-invoke (var-deref "jolt.host" "protocol-methods") ctx))) (opt (let* ((i 0) (n (jolt-invoke (var-deref "jolt.passes.fold" "const-fold") node))) (let loop5790 ((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))) (loop5790 (jolt-inc i) n2) n2)))))) (seeds (if (jolt= (keyword #f "def") (jolt-get opt (keyword #f "op"))) (jolt-invoke (var-deref "jolt.passes.types" "param-seeds-for") (let* ((_a$5791 (var-deref "clojure.core" "str")) (_a$5792 (jolt-get opt (keyword #f "ns"))) (_a$5793 "/") (_a$5794 (jolt-get opt (keyword #f "name")))) (jolt-invoke _a$5791 _a$5792 _a$5793 _a$5794))) jolt-nil))) (jolt-invoke (var-deref "jolt.passes.fold" "const-fold") (if (jolt-truthy? seeds) (jolt-invoke (var-deref "jolt.passes.types" "reinfer-def") opt seeds) (jolt-invoke (var-deref "jolt.passes.types" "run-inference") opt)))) (jolt-invoke (var-deref "jolt.passes.fold" "const-fold") node)))))))) run-passes) (let* ((_o$5795 (keyword #f "doc")) (_o$5796 "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$5795 _o$5796)))) \ No newline at end of file + (def-var-with-meta! "jolt.passes" "run-passes" (letrec ((run-passes (lambda (node ctx) (let fnrec5785 ((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$5786 (var-deref "jolt.host" "stash-inline!")) (_a$5787 ctx) (_a$5788 (jolt-get node (keyword #f "ns"))) (_a$5789 (jolt-get node (keyword #f "name"))) (_a$5790 (jolt-invoke (var-deref "jolt.passes" "stash-of") node))) (jolt-invoke _a$5786 _a$5787 _a$5788 _a$5789 _a$5790)) 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))) (_ (jolt-invoke (var-deref "jolt.passes.types" "set-protocol-methods!") (jolt-invoke (var-deref "jolt.host" "protocol-methods") ctx))) (opt (let* ((i 0) (n (jolt-invoke (var-deref "jolt.passes.fold" "const-fold") node))) (let loop5791 ((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))) (loop5791 (jolt-inc i) n2) n2)))))) (seeds (if (jolt= (keyword #f "def") (jolt-get opt (keyword #f "op"))) (jolt-invoke (var-deref "jolt.passes.types" "param-seeds-for") (let* ((_a$5792 (var-deref "clojure.core" "str")) (_a$5793 (jolt-get opt (keyword #f "ns"))) (_a$5794 "/") (_a$5795 (jolt-get opt (keyword #f "name")))) (jolt-invoke _a$5792 _a$5793 _a$5794 _a$5795))) jolt-nil))) (jolt-invoke (var-deref "jolt.passes.fold" "const-fold") (if (jolt-truthy? seeds) (jolt-invoke (var-deref "jolt.passes.types" "reinfer-def") opt seeds) (jolt-invoke (var-deref "jolt.passes.types" "run-inference") opt)))) (jolt-invoke (var-deref "jolt.passes.fold" "const-fold") node)))))))) run-passes) (let* ((_o$5796 (keyword #f "doc")) (_o$5797 "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$5796 _o$5797)))) \ No newline at end of file diff --git a/jolt-core/jolt/backend_scheme.clj b/jolt-core/jolt/backend_scheme.clj index f1d911a..5271426 100644 --- a/jolt-core/jolt/backend_scheme.clj +++ b/jolt-core/jolt/backend_scheme.clj @@ -509,15 +509,19 @@ ;; devirtualized protocol call: the inference proved the receiver (arg 0) is ;; one record type, so resolve the impl by that static tag instead of routing ;; through the protocol var -> jolt-invoke -> protocol-resolve (which recomputes - ;; the tag and walks the type table). find-protocol-method does the same table - ;; lookup the dispatch would, but with no var-deref, no rest-cons, and no - ;; receiver-type computation. Fires only on a monomorphic site (a megamorphic - ;; receiver joins to :any and carries no :devirt-type). + ;; the tag and walks the type table). devirt-resolve does the same table lookup + ;; the dispatch would, but with no var-deref and no receiver-type computation; + ;; it falls back to ordinary dispatch when the static tag has no direct impl (a + ;; record satisfying the protocol via an Object/host-tag default). Fires only on + ;; a monomorphic site (a megamorphic receiver joins to :any, no :devirt-type). + ;; The receiver is bound once — it feeds both the resolve and the application. (:devirt-type node) (order-args (fn [as] - (str "((find-protocol-method " (chez-str-lit (:devirt-type node)) " " - (chez-str-lit (:devirt-proto node)) " " (chez-str-lit (:devirt-method node)) - ") " (str/join " " as) ")"))) + (let [r (fresh-label "_r$")] + (str "(let* ((" r " " (first as) ")) " + "((devirt-resolve " (chez-str-lit (:devirt-type node)) " " + (chez-str-lit (:devirt-proto node)) " " (chez-str-lit (:devirt-method node)) + " " r ") " (str/join " " (cons r (rest as))) "))")))) ;; hint-directed fast arithmetic: jolt.passes.numeric proved every operand a ;; flonum (^double) or fixnum (^long), so emit the Chez fl*/fx* op. (:num-kind node) (emit-numeric (:num-kind node) (:name fnode) args order-args) diff --git a/jolt-core/jolt/passes/types.clj b/jolt-core/jolt/passes/types.clj index 7008489..e098022 100644 --- a/jolt-core/jolt/passes/types.clj +++ b/jolt-core/jolt/passes/types.clj @@ -740,17 +740,27 @@ (if (contains? escaped k) (assoc m k (vec (repeat (count (get m k)) :any))) m)) (:ptypes pass) ks) - new-rets (:rets pass)] - (if (or (and (= new-ptypes ptypes) (= new-rets rets)) (>= iter 16)) - (reset! wp-seeds-box - (reduce (fn [m k] - (let [s (get spec k) - ptmap (reduce (fn [pm pr] - (let [nm (nth pr 0) t (nth pr 1)] - (if (and t (not= t :any)) (assoc pm nm t) pm))) - {} (map vector (:params s) (get new-ptypes k)))] - (if (seq ptmap) (assoc m k ptmap) m))) - {} ks)) + new-rets (:rets pass) + converged? (and (= new-ptypes ptypes) (= new-rets rets))] + (if (or converged? (>= iter 16)) + ;; On convergence new-ptypes is the least fixpoint (sound). On hitting the + ;; cap without convergence it's a pre-fixpoint — more specific than the + ;; fixpoint, so seeding it would be unsound; widen every param to :any + ;; (emit no seeds). The cap isn't reached in practice (~2 passes), this is + ;; a defensive floor. + (let [seed-ptypes (if converged? + new-ptypes + (reduce (fn [m k] (assoc m k (vec (repeat (count (get m k)) :any)))) + new-ptypes ks))] + (reset! wp-seeds-box + (reduce (fn [m k] + (let [s (get spec k) + ptmap (reduce (fn [pm pr] + (let [nm (nth pr 0) t (nth pr 1)] + (if (and t (not= t :any)) (assoc pm nm t) pm))) + {} (map vector (:params s) (get seed-ptypes k)))] + (if (seq ptmap) (assoc m k ptmap) m))) + {} ks))) (recur (inc iter) new-ptypes new-rets)))))) ;; Piggyback checking (jolt audit). In direct-link mode infer-top already runs