anchor.diff:      (when (symbolp name)
         (push (cons name new-block) new-variables))
       (make-instance 'ast-block
  +                   :inherit inherit
                      :info new-block
  -                   :body (convert-ast-form body new-variables))))
  -
  -(defun convert-ast-function (new-variables name)
  +                   :body (convert-ast-form body inherit new-variables))))
  +
  +(defun convert-ast-function (inherit new-variables name)
     (declare (ignore new-variables))
  -  (make-instance 'ast-function :name name))
  -
  -(defun convert-ast-go (new-variables target info)
  +  (make-instance 'ast-function
  +                 :inherit inherit
  +                 :name name))
  +
  +(defun convert-ast-go (inherit new-variables target info)
     (make-instance 'ast-go
  -                 :target (convert-ast-form target new-variables)
  -                 :info (convert-ast-form info new-variables)))
  -
  -(defun convert-ast-if (new-variables test then else)
  +                 :inherit inherit
  +                 :target (convert-ast-form target inherit new-variables)
  +                 :info (convert-ast-form info inherit new-variables)))
  +
  +(defun convert-ast-if (inherit new-variables test then else)
     (make-instance 'ast-if
  -                 :test (convert-ast-form test new-variables)
  -                 :then (convert-ast-form then new-variables)
  -                 :else (convert-ast-form else new-variables)))
  -
  -(defun convert-ast-let (new-variables bindings body)
  +                 :inherit inherit
  +                 :test (convert-ast-form test inherit new-variables)
  +                 :then (convert-ast-form then inherit new-variables)
  +                 :else (convert-ast-form else inherit new-variables)))
  +
  +(defun convert-ast-let (inherit new-variables bindings body)
     (let ((real-bindings (loop
                             for (variable init-form) in bindings
                             collect (list (etypecase variable
                                             (symbol
                                              (let ((new (make-instance 'lexical-variable
  +                                                                     :inherit inherit
                                                                        :name variable
                                                                        :definition-point *current-lambda*
                                                                        :use-count 1)))
  
positive.code:                (push new real-bindings)))
              (t (push binding real-bindings))))
      (make-instance 'ast-multiple-value-bind
                     :bindings (reverse real-bindings)
                     :value-form value
                     :body (convert-ast-form body new-variables))))
  
  (defun convert-ast-multiple-value-call (new-variables function value-form)
    (make-instance 'ast-multiple-value-call
                   :function-form (convert-ast-form function new-variables)
                   :value-form (convert-ast-form value-form new-variables)))
  
  (defun convert-ast-multiple-value-prog1 (new-variables value-form body)
    (make-instance 'ast-multiple-value-prog1
                   :value-form (convert-ast-form value-form new-variables)
                   :body (convert-ast-form body new-variables)))
  
  (defun convert-ast-progn (new-variables &rest body)
    (make-instance 'ast-progn
                   :forms (loop
                             for form in body
                             collect (convert-ast-form form new-variables))))
  
  (defun convert-ast-quote (new-variables value)
    (declare (ignore new-variables))
    (make-instance 'ast-quote :value value))
  
  (defun convert-ast-return-from (new-variables target value-form info)
    (make-instance 'ast-return-from
                   :target (convert-ast-form target new-variables)
                   :value (convert-ast-form value-form new-variables)
                   :info (convert-ast-form info new-variables)))
  
  (defun convert-ast-setq (new-variables variable value)
    (check-type variable (or symbol lexical-variable))
    (make-instance 'ast-setq
                   :variable (convert-ast-form variable new-variables)
                   :value (convert-ast-form value new-variables)))
  
  (defun convert-ast-tagbody (new-variables info &rest statements)
    (check-type info (or symbol tagbody-information))
    (let ((tagbody-info (cond ((symbolp info)
                               (make-instance 'tagbody-information
                                       :name info
                                       :definition-point *current-lambda*
                                       :use-count 1))
                              (t info)))
          (new-go-tags '()))
      (when (symbolp info)
  
negative.code:            ((unwind-protect) #'convert-ast-unwind-protect)
             ((call) #'convert-ast-call)
             ((jump-table) #'convert-ast-jump-table))
           inherit
           new-variables
           (rest form)))
  
  (defun convert-ast-block (inherit new-variables name body)
    (check-type name (or block-information symbol))
    (let ((new-block (if (symbolp name)
                         (make-instance 'block-information
                                        :inherit inherit
                                        :name name
                                        :definition-point *current-lambda*
                                        :use-count 1)
  