anchor.diff:  
   (deflisp1-walker lambda-function-form (arguments body)
     ;; For any function-form (ie lambda), we just transform the body.
  -  ;; We also must add the parameters to the list of bound variables.
  -  (let1 *bound-vars*
  -      (append (mapcar #'name arguments) *bound-vars*)
  +  ;; We also must add the parameters to the variable namespace, and
  +  ;; remove the parameters from the function namespace.
  +  (with-vars-bound (mapcar #'name arguments)
       (new 'lambda-function-form
   	 :arguments arguments
   	 :body      (lisp1s body))))
   
  -(deflisp1-walker free-variable-reference (name)
  +(deflisp1-walker variable-reference (name)
     ;; If a free variable is bound in the toplevel, *and* not bound by
  -  ;; an enclosing lambda, then we'll return that function.  We take
  -  ;; advantage of the fact that the `name' slot is shared.
  -  (if (and (fboundp name) (not (member name *bound-vars*)))
  +  ;; an enclosing lambda, then we'll return that function.  Also, if
  +  ;; the variable has been bound by an enclosing function binding form
  +  ;; then we'll return that function.  We take advantage of the fact
  +  ;; that the `name' slot is shared.
  +  (if (or (and (fboundp name) (not (member name *vars-bound*)))
  +	  (member name *funs-bound*))
         (change-class form 'free-function-object-form)
         form))
   
  
positive.code:   "Define a function with BODY written in Lisp-1 style.
  
  This is just like DEFUN."
    (let1 *bound-vars*
        (append *bound-vars* (extract-argument-names args :allow-specializers nil))
      `(defun ,name ,args
         ,(lisp1 `(block ,name ,@body)))))
  
  (defmacro defmethod1 (name (&rest args) &body body)
    "Define a function with BODY written in Lisp-1 style.
  
  This is just like DEFMETHOD."
    (let1 *bound-vars*
        (append *bound-vars* (extract-argument-names args :allow-specializers t))
      `(defmethod ,name ,args
         ,(lisp1 `(block ,name ,@body)))))
  
  
negative.code: 
  ;;;; * Special Variables
  
  (defvar *vars-bound* nil
    "When walking code, this variable contains a list of
  variables (represented by symbols) which have been bound in
  the variable namespace.
  
  In essence these variables do not have to be sharp-quoted.")
  
  (defvar *funs-bound* nil
    "When walking code, this variable contains a list of
  variables (represented by symbols) which have been bound in
  the function namespace.
  
  In essence these variables must be sharp-quoted.")
  
  (defmacro with-vars-bound (vars &body body)
    "Execute BODY with VARS added to the variable namespace and
  VARS removed from the function namespace.
  
  This should only be used when code-walking."
    `(let ((*vars-bound* (append         *vars-bound* ,vars))
  	 (*funs-bound* (set-difference *funs-bound* ,vars)))
       ,@body))
  
  (defmacro with-funs-bound (funs &body body)
    "Execute BODY with FUNS added to the function namespace and
  FUNS removed from the variable namespace.
  
  This should only be used when code-walking."  
    `(let ((*funs-bound* (append         *funs-bound* ,funs))
  	 (*vars-bound* (set-difference *vars-bound* ,funs)))
       ,@body))
  
  ;;;; * Definers
  
  