Joseph Ferano
26c53e0a19
The mechanical half, ahead of the parser change that needs it. tools/unit-return.py
fills the empty slot with () and rewrites Unit as () wherever a type is spelled --
(Fn [i32] Unit), (Map i32 Unit), a return type written out.
Deciding whether a defn already had a return type is the whole difficulty, and
the script does it the way parse.ml did: is_type_form is transcribed rather than
improved, because being identical to the parser it replaces is what makes the
sweep meaning-preserving. It is re-runnable, so the lanes that branched before
this can have the same pass at merge:
python3 tools/unit-return.py .
python3 tools/unit-return.py --in-strings test/test_flan.ml test/test_acceptance.ml \
test/test_session.ml emacs/test-flan-dev.el emacs/test-flan-mode.el
python3 tools/unit-return.py --raw-ml lib/prelude.ml
python3 tools/unit-return.py --in-html web/index.html
-v logs every defn it saw and what it decided, which is how a sweep of 440 sites
gets reviewed at all. Embedded modes pool a file's type declarations across all
its fragments, because a snippet split across concatenation -- decls ^ "(defn f
[s [u8]] Cursor ...)" -- cannot see the names the other half declared; pooled
names count only in bare-symbol position, for the same reason the prelude's do.
A fragment that cuts off mid-form is skipped rather than guessed at. Five sites
in test_flan.ml still needed a hand, and they are in this commit.
Two things ride along because the sweep needs them: parse.ml reads a lone () as
the return type of a function with no body, which was not a shape the old
optional slot could produce; and the map refusals name () rather than Unit, since
that is now the spelling a caller wrote.
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)
|