anchor.diff:                (lambda-export-gather fi x)
                 (lambda-export-transform fi x))
   		  `#'(,@(make-lambda-funinfo-if-missing x
  -				  (make-funinfo :env (lambda-args x)
  -								:args (lambda-args x)
  +				  (make-funinfo :args (lambda-args x)
   								:parent fi))
   			  ,(lambda-args x)
   			  ,@(lambda-body x)))
  
positive.code: 	  ; temporarily to make stack-places; so the stack-places can be
  	  ; reused by the next lambda-call on the same level.
        ;(with-funinfo-env-temporary fi args
        (dolist (i a)
  		(unless (funinfo-env-pos fi i)
  		  (funinfo-env-add fi i)))
        (make-inline-body
  		  (vars-to-stackplaces fi a)
        	  v
  		  (lambda-expand-gather-or-transform fi body export-lambdas gather)))));)
  
  ;;; Export
  
  (defun make-var-declarations (fi)
    (vars-to-stackplaces fi
      (mapcan (fn (unless (and (not (eq (funinfo-lexical fi)
  									  _))
  						 	 (or (funinfo-arg? fi _)
  						    	 (funinfo-lexical-pos fi _)))
  				  `((%var ,_))))
  	        (funinfo-env fi))))
  
  
negative.code: 	  exported)))
  
  ;;; Export gathering
  ;;;
  ;;; XXX as far as I now understand a gathering pass is not required
  ;;; anymore since we can build the tree at once.
  
  (defun lambda-export-gather-child-make-funinfo (fi)
    (with ((args exported-closures) (lambda-expand (lambda-args x)
  												 t))
  	(lambda-expand-add-closures exported-closures)
      (make-funinfo :args args
  			      :parent fi)))
  
  ;; Do a gathering expansion. Builds FUNINFO tree.
  