anchor.diff:  		 (augment-environment-from-fdef result definition))
   	finally (return result)))
   
  +;;; As of now, this unconditionally saves an inline expansion
  +;;;  for all local functions. Hypothetically, we could be more
  +;;;  thrifty and only safe if there's a bound inline decl or w/e.
  +;;; But (a) we need the AST anyway and referencing it isn't a big
  +;;;  deal, and (b) we're in the middle of compiling, these local
  +;;;  environments are ephemeral.
  +(defun augment-environment-with-ast (environment definition)
  +  (db origin (name . ast) definition
  +    (cleavir-env:add-inline-expansion environment name ast)))
  +
  +;;; This is done separately from augmenting with fdefs for the sake
  +;;;  of recursive bindings, which need just the names and not
  +;;;  inline expansions in their bodies.
  +(defun augment-environment-with-asts (environment definitions)
  +  (loop with result = environment
  +	for definition in definitions
  +	do (setf result
  +		 (augment-environment-with-ast result definition))
  +	finally (return result)))
  +
   ;;; Given an environment and the name of a function, return the
   ;;; LEXICAL-AST that will have the function with that name as a value.
   ;;; It is known that the environment contains an entry corresponding
  
positive.code:     (let ((block-name (block-name-from-function-name name)))
        (convert-code lambda-list body environment system block-name))))
  
  ;;; Convert a list of local function definitions.
  (defun convert-local-functions (definitions environment system)
    (loop for definition in (raw definitions)
  	collect (convert-local-function definition environment system)))
  
  ;;; Given a list of local function definitions, return a list of
  ;;; the names of those functions.
  (defun function-names (definitions)
    (mapcar #'car definitions))
  
  ;;; Compute and return a list of SETQ-ASTs that will assign the
  ;;; definition of each function in a list of function definitions to
  ;;; its associated LEXICAL-AST.  ENV1 is the environment in which the
  ;;; function definitions will be converted.  ENV2 is the environment
  ;;; in which the LEXICAL-AST associated with the function name is
  ;;; looked up.
  (defun compute-function-init-asts (definitions env1 env2 system)
    (loop for fun in (convert-local-functions definitions env1 system)
  	for name in (function-names definitions)
  	collect (cleavir-ast:make-setq-ast
  		 (function-lexical env2 name)
  		 fun)))
  
  ;;; Given a list of declarations, i.e., a list of the form:
  ;;;
  
negative.code: 
  ;;; Take an environment and a single function definition, and return a
  ;;; new environment which is like the one passed as an argument except
  ;;; that it has been augmented by the local function name.
  (defun augment-environment-from-fdef (environment definition)
    (db origin (name . rest) definition
      (declare (ignore rest))
      (let ((var-ast (cleavir-ast:make-lexical-ast (raw name)
  						 :origin origin)))
        (cleavir-env:add-local-function environment name var-ast))))
  
  ;;; Take an environment, a list of function definitions, and bound
  ;;; decls, and return a new environment which is like the one passed
  ;;; as an argument, except that is has been augmented by the
  ;;; local function names in the list.
  (defun augment-environment-from-fdefs (environment definitions)
    (loop with result = environment
  	for definition in (raw definitions)
  