anchor.diff:    ;; next block in the loop.
     (loop-next nil :type (or null block-node))
     ;; the component this block is in, or NIL temporarily during IR1
  -  ;; conversion and in deleted blocks
  -  (component (progn
  -               (aver-live-component *current-component*)
  -               *current-component*)
  -             :type (or component null))
  +  ;; conversion and in deleted blocks.
  +  ;; FIXME: change it into PIECE and change related functions.
  +  (piece (progn
  +	   (aver-live-component *current-component*)
  +	   *current-component*)
  +	 :type (or piece null))
     ;; a flag used by various graph-walking code to determine whether
     ;; this block has been processed already or what. We make this
     ;; initially NIL so that FIND-INITIAL-DFO doesn't have to scan the
  
positive.code:   ;; can null out this slot.
    (tail-p nil :type boolean))
  
  ;;; XXX: Do we need a special print function?
  ;;; LEAF-NODE is created when facing a leaf object, like 
  (defstruct (leaf-node
  	     (:include node))
    )
  
  (defstruct (value-node
  	     (:include node))
    (derived-type :undefined :type +js-type+)
    (lvar nil :type (or lvar null)))
  
  (defstruct (cond-node
  	     (:include node))
    )
  
  (defstruct (funcall-node
  	     (:include node))
    )
  
  (defstruct (var-node
  	     (:include leaf-node))
    )
  
  (defstruct (func-node
  	     (:include leaf-node))
    )
  
  (defstruct (block-node
  
negative.code: 	     (:include node))
    )
  
  ;;; An TAIL-SET structure is used to accumulate information about
  ;;; tail-recursive local calls. The "tail set" is effectively the
  ;;; transitive closure of the "is called tail-recursively by"
  ;;; relation.
  ;;;
  ;;; All functions in the same tail set share the same TAIL-SET
  ;;; structure. Initially each function has its own TAIL-SET, but when
  ;;; IR1-OPTIMIZE-RETURN notices a tail local call, it joins the tail
  ;;; sets of the called function and the calling function.
  ;;;
  ;;; The tail set is somewhat approximate, because it is too early to
  ;;; be sure which calls will be tail-recursive. Any call that *might*
  ;;; end up tail-recursive causes TAIL-SET merging.
  (defstruct tail-set
    ;; a list of all the LAMBDAs in this tail set
    (funs nil :type list)
    ;; our current best guess of the type returned by these functions.
    ;; This is the union across all the functions of the return node's
    ;; RESULT-TYPE, excluding local calls.
    (type :undefined :type +js-type+))
  
  ;;; FIXME: Move it to the piece module, and remove some unused slots.
  ;;; A COMPONENT structure provides a handle on a connected piece of
  ;;; the flow graph. Most of the passes in the compiler operate on
  ;;; COMPONENTs rather than on the entire flow graph.
  