Joseph Ferano
96ab4c9cf0
print-str, print-i64, print-f64, print-bytes, print-line and newline leave the prelude. print and println are the whole printing surface now, and print is the better call at every one of the sites that used them: it is the same structural walk without the newline, so the no-newline case the family was kept for is covered, and it takes the value as it is. The old print-i64 forced an explicit (i64 x) at every call site, because this language widens nothing implicitly; that cast is gone from 127 places. Dropping it moves one answer. hash-grid returns u64, and the cast through the signed printer showed sand-headless's hash as -2851001042534928384. print routes a u64 through flan_u64_to_bytes, so it now prints 15595743031174623232 — the same 64 bits, read as the unsigned number they are. The pinned expectation follows the correction. test-flan-dev.el and test_session.ml both reached for print-line as "a name the prelude has"; they reach for rand-seed instead.
62 lines
2.2 KiB
Plaintext
62 lines
2.2 KiB
Plaintext
;;;; The cleanup paths nothing was watching.
|
|
;;;;
|
|
;;;; Found by mutation testing: each of the six claims below could be broken in
|
|
;;;; lib/check.ml, lib/emit.ml or runtime/flan_rt.c and the whole suite stayed
|
|
;;;; green. Every case here is one a plausible wrong version gets wrong, and
|
|
;;;; the numbers differ per failure so a single wrong answer names its cause.
|
|
(defstruct Missing [id i32])
|
|
(defstruct Other [id i32])
|
|
|
|
(defvar log i64)
|
|
(defvar order i64)
|
|
(defvar seen i64)
|
|
|
|
(defn note [n i64] (set order (+ (* order 10) n)))
|
|
|
|
;;; (1) An early return must run the defers registered above it, and (2) it
|
|
;;; must run them innermost-first. A defer that (8) *calls* something is the
|
|
;;; case that puts a guard inside the defer, on the transfer path.
|
|
(defn early [] i64
|
|
(defer (note 1))
|
|
(defer (note 2))
|
|
(return 7)
|
|
0)
|
|
|
|
;;; (5) A transfer out of a handler-bind has to pop its frames on the way past,
|
|
;;; and (6) a handler-bind with two clauses has to pop both, innermost-first.
|
|
;;; If either leaks, the stack keeps a frame pointing into a function that has
|
|
;;; gone, and the next signal calls into it.
|
|
(defn deep [] i32 (signal (Missing {:id 1})) 0)
|
|
|
|
(defn leaky [] i32
|
|
(restart-case
|
|
(handler-bind [(Other [c] (set seen (+ seen 1000)))
|
|
(Missing [c] (invoke-restart 'skip))]
|
|
(deep))
|
|
(skip [] 42)))
|
|
|
|
;;; (7) Once a handler has answered a signal by transferring, the walk stops:
|
|
;;; an outer handler of the same type must not also run.
|
|
(defn nested [] i32
|
|
(restart-case
|
|
(handler-bind [(Missing [c] (set seen (+ seen 100)))]
|
|
(handler-bind [(Missing [c] (invoke-restart 'stop))]
|
|
(deep)))
|
|
(stop [] 5)))
|
|
|
|
(defn main [] i32
|
|
(print (early)) (println "") ; 7
|
|
(print order) (println "") ; 21 — innermost first, both ran
|
|
|
|
(print (leaky)) (println "") ; 42
|
|
;; The handler stack must be empty again. If a frame leaked, this signal
|
|
;; reaches it and seen moves.
|
|
(deep)
|
|
(print seen) (println "") ; 0
|
|
|
|
(set seen 0)
|
|
(print (nested)) (println "") ; 5
|
|
(print seen) (println "") ; 0 — the outer handler did not run
|
|
(print log) (println "") ; 0
|
|
0)
|