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:   (cleavir-code-utilities:canonicalize-declaration-specifiers
     (declaration-specifiers declarations)))
  
  (defmethod convert-special
      ((symbol (eql 'flet)) form env system)
    (db s (flet definitions . body) form
      (declare (ignore flet))
      (let* ((new-env (augment-environment-from-fdefs env definitions))
  	   (init-asts
  	     (compute-function-init-asts definitions env new-env system)))
        (multiple-value-bind (declarations forms)
  	  (cleavir-code-utilities:separate-ordinary-body body)
  	(let ((canonicalized-dspecs (canonicalize-declarations declarations)))
  	  (setf new-env (augment-environment-with-declarations
  			 new-env canonicalized-dspecs)))
  	(process-progn
  	 (append init-asts (convert-sequence forms new-env system)))))))
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;;
  
negative.code:     (let ((block-name (block-name-from-function-name name)))
        (convert-code lambda-list body environment system block-name))))
  
  ;;; 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.
  (defun compute-function-init-asts (definitions env)
    (loop for (name . fun-ast) in definitions
  	collect (cleavir-ast:make-setq-ast
  		 (function-lexical env name)
  		 fun-ast)))
  
  ;;; Given a list of declarations, i.e., a list of the form:
  ;;;
  