anchor.diff:                                                             (pick-variables 'special declares))
                                           :declarations declares))
                  ;; Process lambda body.
  -               (body-ast (pass1-form `(progn ,@body) env))
  +               (body-ast (pass1-wrap-body-with-type-declarations
  +                          (pass1-form `(progn ,@body) env)
  +                          env declares '()))
                  ;; Actually bind &AUX variables, now that the body has been processed.
                  (body-with-aux (if aux-bindings
                                     (ast `(let ,aux-bindings ,body-ast))
  
positive.code:                                             :variables (list (list name var))
                                              :declarations (fake-type-declarations-for declares name)))
                (push var vars))))
          (setf (body inner) (pass1-form `(progn ,@body)
                                         (extend-environment env :declarations declares)))
          (dolist (var vars)
            (when (lexical-variable-p var)
              (check-variable-usage var)))
  
negative.code:   (destructuring-bind (form &optional read-only-p) (cdr form)
      (pass1-form (funcall *load-time-value-hook* form read-only-p) '())))
  
  ;; As soon as a scope with a type declaration is entered, it is as though
  ;; ```(the typespec var)``` is executed. So do that.
  ;; Inserting references to the variable will get this right.
  ;; This has an unusual interaction with special variables and requires that
  ;; they must be bound on entry to the block.
  (defun pass1-wrap-body-with-type-declarations (body env declarations exclude-variables)
    (let ((vars '()))
      (flet ((process (var)
               (when (not (member var exclude-variables))
                 (push var vars))))
        (loop
           for (what type . names) in declarations
           when (eql what 'type)
           do (loop for name in names do (process name)))
        (loop
           for (what . names) in declarations
           when (non-type-type-declaration-p what)
           do (loop for name in names do (process name))))
      (if vars
          (make-instance 'ast-progn
                         :environment env
                         :forms (append (loop
                                           for var in (remove-duplicates (reverse vars))
                                           collect (pass1-form var env))
                                        (list body)))
          body)))
  
  (defun pass1-locally-body (forms env)
    (multiple-value-bind (body declares)
        (sys.int::parse-declares forms)
      (check-known-declarations declares)
      (let ((env (extend-environment env :declarations declares)))
        (pass1-wrap-body-with-type-declarations
         (pass1-form `(progn ,@body) env)
         env
         declares
         '()))))
  
  (defun pass1-locally (form env)
    (pass1-locally-body (cdr form) env))
  