Next: Copy propagation, Previous: Control optimization, Up: Design of CMU Common Lisp [Contents]
#| Single-use let var continuation substitution not really correct, since it can cause a spurious type error. Maybe we do want stuff to prove that an NLX can’t happen after all. Or go back to the idea of moving a combination arg to the ref location, and having that use the ref cont (with its output assertion.) This lossage doesn’t seem very likely to actually happen, though. [### must-reach stuff wouldn’t work quite as well as combination substitute in psetq, etc., since it would fail when one of the new values is random code (might unwind.)]
Is this really a general problem with eager type checking? It seems you could argue that there was no type error in this code:
(+ :foo (throw 'up nil))
But we would signal an error.
Emit explicit you-lose operation when we do a move between two non-T ptypes, even when type checking isn’t on. Can this really happen? Seems we should treat continuations like this as though type-check was true. Maybe LTN should leave type-check true in this case, even when the policy is unsafe. (Do a type check against NIL?)
At continuation use time, we may in general have to do both a coerce-to-t and a type check, allocating two temporary TNs to hold the intermediate results.