4 commits

Author	SHA1	Message	Date
Dmitri Sotnikov	1ded89b47b	Stage1 analyzer parity (#11) ... * compiler: self-hosted analyzer compiles set literals (#{…}) Stage 1 Task 1. analyzer.clj punted set literals to the interpreter ((form-set? form) (uncompilable "set literal")); now it builds the set-node IR (already defined in ir.clj) from (form-set-items form), and backend.janet emits (make-phs e1 e2 …) — each element evaluated then the persistent set built, mirroring compiler.janet's emit-set-expr and the interpreter's :jolt/set path. Closes a self-hosted-analyzer vs bootstrap-compiler parity gap: #{…} no longer forces interpreter fallback on the compile path. Gate: conformance 262x3 (+4 set-literal cases incl computed elements / empty / in-let), fixpoint, self-host, sci, suite 3981/66, specs+unit green; core-bench neutral (A/B). set?/disj-as-fns remain deliberately interpreted (in-sync across all three lists) — adjudicated in Task 2. * test: fallback-zero harness — assert non-stateful forms compile (not interpret) Stage 1 Task 3. self-host-test checks results but not which path ran. This runs the portable analyzer (backend/analyze-form) on a corpus of non-stateful forms and asserts NONE raise :jolt/uncompilable — i.e. the self-hosted analyzer compiled them, not the interpreter fallback. Inverse sanity list confirms a few intentional-interpret forms (ns/defmacro/require/set?/letfn) still punt, so the harness can't pass by compiling everything. 29 must-compile (incl set literals from Task 1) + 5 must-punt, 0 failures. As Stage 1 parity grows, forms move from the punt list into must-compile; when the fallback set equals the frozen intentional stateful set, the bootstrap is retireable. * core: migrate 7 lazy seq fns from the Janet seed to the Clojure overlay (40-lazy) Finishes a port the prior team started and reverted (bb4a3e0): the 40-lazy.clj tier moved lazy seq fns Janet→Clojure but regressed the suite to 849 because lazy-seq's expansion leaked as data in compile mode — that was jolt-r81, since root-fixed (lazy-seq/lazy-cat moved to 00-syntax). With the wall gone, the port works. This shrinks the Janet seed toward the north star (self-hosted clojure-in-clojure on a minimal host bootstrap). Moved to core/40-lazy.clj (wired as a loaded tier after 30-macros): distinct keep keep-indexed map-indexed cycle repeat iterate 40-lazy.clj completed to full parity: distinct gains its transducer arity; keep/keep-indexed/map-indexed already had both arities. Removed from the Janet seed (core.janet): the 7 core-* fns + their core-bindings entries, the now-dead td-keep/td-map-indexed transducer helpers (the CLJ versions carry their own), and the already-dead core-partition-by/core-xml-seq (shadowed by 10-seq/20-coll). Net: core.janet −131 lines. Deferred (kept in Janet, separate follow-ups): partition-all (a CLJ port via take/drop realizes a non-minimal element count, tripping the §6.3 laziness counters + a suite file) and repeatedly (canonical CLJ doesn't validate args, so the repeatedly.cljc throw cases regress). Both need behavior-matching first. Gate: conformance 262x3, lazy-infinite 44/44, clojure-test-suite 4004/66 (UP from 3981 — the CLJ versions add coverage, e.g. distinct value-equality), fixpoint, self-host, sci 422/0, fallback-zero, specs+unit, core-bench all green. * test: raise clojure-test-suite baseline 3981 -> 4004 (lazy-fn migration coverage) * core: migrate partition-all to the Clojure overlay (minimal realization) Resolves the deferred partition-all port (jolt-yo3). The earlier CLJ attempt via lazy take/drop over-realized vs the Janet pstep, tripping the §6.3 laziness counter. The collection arities now realize EXACTLY n per chunk with a first/rest loop and continue from the advanced cursor (no re-drop), so (take 3 (partition-all 2 (map counting (range)))) realizes exactly 6 — matching minimal realization in both interpret and compile modes. Keeps transducer + [n coll] + [n step coll] arities. letfn-bound recursion sidesteps the compile-mode multi-arity closure bug (jolt-zxw), like keep-indexed/map-indexed. Removed from the Janet seed: core-partition-all + its binding + the now-dead td-partition-all helper (the CLJ version carries its own transducer arity). Gate: conformance 262x3, lazy-infinite 44/44 (incl the §6.3 partition-all counter), clojure-test-suite 4004/66, fixpoint, self-host, specs+unit green. * core: migrate repeatedly to Clojure + fix char-not-callable / take count validation Resolves the deferred repeatedly port (jolt-8qx). The blockers were two jolt leniencies vs Clojure, now fixed (and correct beyond repeatedly): - A char (a :jolt/type-tagged struct) fell into the struct-as-map branch of both jolt-call (compile path) and the interpreter's apply dispatch, so (\a) returned nil instead of throwing. Now only an UNtagged struct (a map literal) — or a record — is callable as a key lookup; tagged structs fall through to "Cannot call … as a function". Symbols are still handled (keyword-style get). - core-take didn't validate its count, letting Janet's >= silently compare an int to a char/string. It now rejects a non-number n like Clojure. With those, the canonical CLJ repeatedly matches: (first (repeatedly non-fn)) and (repeatedly non-number f) throw. Moved repeatedly to core/40-lazy.clj; removed core-repeatedly + its binding from the seed. These correctness fixes help broadly: repeatedly.cljc goes clean (19/10 -> 29/0), and the suite rises 4004 -> 4034 pass / 66 -> 67 clean. Baseline raised. Gate: conformance 262x3, lazy-infinite 44/44, clojure-test-suite 4034/67, fixpoint, self-host, sci, fallback-zero, specs+unit green. * test: document the 4004 -> 4034 baseline raise (partition-all/repeatedly + char/take fixes) * docs: partition-all letfn is for minimal realization, not jolt-zxw jolt-zxw (multi-arity arity-param mis-capture in a nested lazy-seq under :compile?) is no longer reproducible: an arity-direct partition-all now compiles correctly in the overlay. The original failure was an artifact of the CLJ multi-arity version coexisting with the Janet core-partition-all ([n & rest]) during migration — the shadowing confused multi-arity dispatch; removing the Janet version resolved it. The letfn in partition-all stays purely for minimal realization (jolt-yo3). * compiler: compile set?/disj as plain fns (close the last Stage-1 fallback gap) Stage 1 jolt-g3h. set? and disj were special-cased in all three "can't compile" lists (host_iface special-names, compiler.janet uncompilable-heads, evaluator special-symbol? + handlers) — but they're pure value-production with callable core vars (core-set?/core-disj), and those vars are byte-for-byte equivalent to the evaluator handlers. Removed them from all three lists + dropped the now-dead evaluator handler arms, so they're ordinary clojure.core fns everywhere: the analyzer compiles (set? x)/(disj s x) as normal var calls instead of punting to the interpreter. Verified identical results in default AND JOLT_MUTABLE builds (no representation sensitivity — sets are phs in both, unlike vector?/list? which collapse). With this, the self-hosted analyzer's compile-path fallback set equals the frozen intentional stateful set (Task 2) — it's now a strict superset of the bootstrap compiler's compilable surface, so the Janet bootstrap is retireable (Stage 2). fallback-zero: set?/disj moved to must-compile (31 now), set! into must-punt. Gate: conformance 267x3 (+5 set?/disj cases), lazy-infinite 44/44, suite 4034/67, fixpoint, self-host, sci, specs+unit green.	2026-06-09 12:24:37 +08:00
Dmitri Sotnikov	d3194aae59	Compiler research (#10) ... adds self-hosted compiler is functionally: - The default compile path is the portable pipeline using jolt.analyzer (Clojure) → host-neutral IR → backend.janet. - The analyzer is itself Clojure, compiled by jolt for true self-hosting. - bootstrap-fixpoint passes (stage1 == stage2 == stage3): rebuilding the compiler on its own output. - clojure.core is now self-hosted in the overlay. - Stateful forms (defmacro/ns/deftype/defmulti/require/in-ns) are interpreted by design.	2026-06-09 07:30:25 +08:00
Yogthos	360b23c8af	feat: distinguish map entries from vectors; min-key NaN ordering; subvec float coercion ... - A map entry is a 2-element tuple (Jolt produces tuples only from map iteration; vector literals are pvecs, lists are arrays). key/val/map-entry? now accept a 2-tuple and reject a plain vector, matching Clojure's MapEntry-vs-vector distinction — no metadata needed, the representations already differ. - min-key/max-key reproduce Clojure's NaN-aware folding (2-arg strict </>, then <=/>=) and require numeric keys (NaN allowed, strings throw). - subvec coerces float/NaN indices like (int ...) (truncate, NaN->0) then bounds-checks, instead of throwing on non-integers. min_key 35/14 -> 49/0 (clean); key/val recover the 2-vector cases; subvec floats fixed. clojure-test-suite pass 3898->3921. Updated conformance-test (key/val now needs a real entry). spec: map/map-entry-&-key-ordering (14). jpm test green.	2026-06-05 14:22:06 -04:00
Yogthos	16428179fa	test: restructure into unit / integration / spec layers + shared harness ... Reorganize the flat 49-file test/ into three layers (jpm test recurses, so all are still discovered): - test/unit/ white-box component tests (reader, evaluator, types, persistent-map, lazy-seq, macro, interop, compiler) - test/integration/ cross-cutting + regression batteries (conformance, jank, sci-bootstrap/runtime, features, systematic-coverage, api, core, namespaces, ported clojure suites) and .../ports/ ported clojure/cljs test batches pending consolidation - test/spec/ the behavioral contract (built out in following commits) - test/support/harness.janet shared defspec table runner (cases compared via Jolt's own =, with a :throws sentinel) + expect= helpers Files moved with git mv (history preserved) and import paths fixed for depth. jpm test green. README Test section updated. Next: build out test/spec/ to cover the public API area-by-area, mining the integration batteries and filling gaps.	2026-06-05 00:00:16 -04:00

Renamed from test/conformance.janet (Browse further)