anchor.diff:                                              :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)))
  +        (setf (body inner) (let ((env (extend-environment env :declarations declares)))
  +                             (pass1-wrap-body-with-type-declarations
  +                              (pass1-form `(progn ,@body) env)
  +                              env declares var-names)))
           (dolist (var vars)
             (when (lexical-variable-p var)
               (check-variable-usage var)))
  
positive.code:                                       (list name init-form var))))
                                  bindings)))
          (prog1
              (make-instance 'ast-let
                             :environment env
                             :bindings (mapcar (lambda (b)
                                                 (list (third b)
                                                       (wrap-type-check (third b)
                                                                        (pass1-form (wrap-initform-with-the (second b) (third b) declares) env))))
                                               variables)
                             :body (pass1-form `(progn ,@body)
                                               (extend-environment env
                                                                   :variables (mapcar (lambda (b)
                                                                                        (list (first b) (third b)))
                                                                                      variables)
                                                                   :declarations declares)))
            (loop
               for (name init-form var) in variables
               when (lexical-variable-p var)
  
negative.code:                                       :declarations (remove-if-not (lambda (x) (eql x 'optimize))
                                                                     declares
                                                                     :key #'first))))
           (make-instance 'ast-let
                          :environment env
                          :bindings (mapcar (lambda (x)
                                              (let ((lambda (pass1-lambda-inner (third x) env)))
                                                (when (function-declared-dynamic-extent-p (first x) declares)
                                                  (setf (getf (lambda-information-plist lambda) 'declared-dynamic-extent) t))
                                                (when (function-declared-notinline-p (first x) declares)
                                                  (setf (getf (lambda-information-plist lambda) 'notinline) t))
                                                (list (second x) lambda)))
                                            raw-bindings)
                          :body (let ((env (extend-environment env :declarations declares)))
                                  (pass1-wrap-body-with-type-declarations
                                   (pass1-form `(progn ,@body) env)
                                   env declares '())))))))
  
  (defun check-variable-bindable (var)
    (when (and (typep var 'special-variable)
  