77e80dab9c
Running the rewrite-clj test suite under jolt exposed six bugs, each fixed here:
- `for`/`doseq` `:let` bindings never went through `destructure`, so a
destructuring pattern (`:let [{:keys [y]} x]`) hit `let*` raw and failed to
compile. Emit `let`, like Clojure.
- `with-open` couldn't close a deftype/defrecord that implements a `close` method
(java.io.Closeable / AutoCloseable, e.g. tools.reader's readers) — `__close`
only knew jhost readers and map `:close` fns. Dispatch a record's `close`.
- A deftype/defrecord method param named like a field didn't shadow the field
(the field's let-binding wrapped the params). Params now shadow, as in Clojure.
- A deftype whose simple name collided with a built-in host class clobbered it in
the global ctor table, so `(java.io.PushbackReader. …)` built tools.reader's
same-named deftype. Register deftypes/built-ins by FQN, don't let a deftype
overwrite a built-in's simple name, and qualify a bare `(Name. …)` to the
deftype's FQN only in the ns that defined it.
- `clojure.walk` was lazy over a non-list seq (missing `doall`), so a walk whose
fn has side effects read stale state. Make it eager, like Clojure.
- `Character/isWhitespace` used an ASCII-only check that missed U+2028 and other
Unicode whitespace. Use the JVM's Unicode set (minus the no-break spaces it
excludes).
Regressions: corpus rows (for-let destructure, method-param shadow, walk eager,
isWhitespace), a unit row (with-open closes a record), and smoke checks (the
class-name collision, run in a fresh -e process so the deftype doesn't leak).
One divergence remains unfixed: a submatch from a losing regex alternation branch
leaks when the winning branch has a quantified group (a bug in the vendored
irregex engine, not jolt) — tracked separately.
67 lines
2.7 KiB
Clojure
67 lines
2.7 KiB
Clojure
; Jolt Standard Library: clojure.walk
|
|
; Tree walking for Clojure data structures.
|
|
|
|
(defn walk
|
|
[inner outer form]
|
|
(cond
|
|
; vectors/maps first so seq? can't swallow them (a vector is not seq? on
|
|
; jolt, but keep the concrete branches authoritative). Re-attach the form's
|
|
; metadata to the rebuilt collection, as Clojure does — a metadata-driven walk
|
|
; (aero/spec) needs ^:ref and friends to survive the rebuild.
|
|
(vector? form) (outer (with-meta (vec (map inner form)) (meta form)))
|
|
; a record is also map?, but (empty record) yields a plain map — rebuild by
|
|
; conj-ing the walked entries back onto the original so the record TYPE
|
|
; survives. Type-dispatched walks depend on it (e.g. integrant resolves
|
|
; #ig/ref by detecting its Ref record while postwalking the config).
|
|
(record? form) (outer (reduce (fn [r x] (conj r (inner x))) form form))
|
|
(map? form) (outer (with-meta (into (empty form) (map inner form)) (meta form)))
|
|
; lists rebuild as lists, other seqs (incl. macro/template output: cons/
|
|
; concat/lazy-seq) walk too — without this, postwalk-replace silently no-op'd
|
|
; a quoted list, breaking clojure.template/apply-template
|
|
(list? form) (outer (with-meta (apply list (map inner form)) (meta form)))
|
|
; doall like Clojure: walk must be eager so an `inner` with side effects
|
|
; (rewrite-clj's #() reader bumps an arg-count atom during the walk, read right
|
|
; after) runs now, not lazily when the result is later realized.
|
|
(seq? form) (outer (with-meta (doall (map inner form)) (meta form)))
|
|
:else (outer form)))
|
|
|
|
(defn postwalk
|
|
[f form]
|
|
(walk (partial postwalk f) f form))
|
|
|
|
(defn prewalk
|
|
[f form]
|
|
(walk (partial prewalk f) identity (f form)))
|
|
|
|
(defn postwalk-demo
|
|
"Demonstrates the behavior of postwalk by printing each form as it is walked."
|
|
[form]
|
|
(postwalk (fn [x] (print "Walked: ") (prn x) x) form))
|
|
|
|
(defn prewalk-demo
|
|
"Demonstrates the behavior of prewalk by printing each form as it is walked."
|
|
[form]
|
|
(prewalk (fn [x] (print "Walked: ") (prn x) x) form))
|
|
|
|
(defn postwalk-replace
|
|
[smap form]
|
|
(postwalk (fn [x] (if (contains? smap x) (get smap x) x)) form))
|
|
|
|
(defn prewalk-replace
|
|
[smap form]
|
|
(prewalk (fn [x] (if (contains? smap x) (get smap x) x)) form))
|
|
|
|
(defn macroexpand-all
|
|
"Recursively performs all possible macroexpansions in form."
|
|
[form]
|
|
(prewalk (fn [x] (if (seq? x) (macroexpand x) x)) form))
|
|
|
|
(defn keywordize-keys
|
|
[m]
|
|
(let [f (fn [[k v]] (if (string? k) [(keyword k) v] [k v]))]
|
|
(postwalk (fn [x] (if (map? x) (into {} (map f x)) x)) m)))
|
|
|
|
(defn stringify-keys
|
|
[m]
|
|
(let [f (fn [[k v]] (if (keyword? k) [(name k) v] [k v]))]
|
|
(postwalk (fn [x] (if (map? x) (into {} (map f x)) x)) m)))
|