anchor.diff:  	     (:include leaf
   		       (source-name '.anonymous.)
   		       (where-from :defined)
  +		       ;; No, obey JS rule.
   		       (type (specifier-type 'function))))
     ;; the name of FUNCTIONAL for debugging purposes, or NIL if we
     ;; should just let the SOURCE-NAME fall through
  
positive.code:   ;; be true when REFS and SETS are null, since code can be deleted.
    (ever-used nil :type boolean)
    ;; is it declared dynamic-extent, or truly-dynamic-extent?
    (extent nil :type (member nil :maybe-dynamic :always-dynamic :indefinite))
    ;; some kind of info used by the back end
    (info nil))
  
  ;;; The CONSTANT structure is used to represent known constant values.
  ;;; Since the same constant leaf may be shared between named and anonymous
  ;;; constants, SOURCE-NAME is never used.
  (defstruct (constant-leaf
  	     (:constructor make-constant (value
  					  &aux
  					  (type (type-of value))
  					  (source-name '.anonymous.)
  					  (where-from :defined)))
  	     (:include leaf))
    ;; the value of the constant
    (value nil)
    ;; Boxed TN for this constant, if any.
    (boxed-tn nil :type (or null tn)))
  
  ;;; We default the WHERE-FROM and TYPE slots to :DEFINED and FUNCTION.
  
negative.code: 
  (defstruct lvar
    ;; The node which receives this value. NIL only temporarily.
    ;; NOTE: If the LVAR is a direct computation with no explicit exit,
    ;; I suppose the DEST is the current node.
    (dest nil :type (or node null))
    ;; cached type of this lvar's value. Default will be UNDEFINED.
    ;; NOTE: When a LVAR is generated and determined, we can tell the type
    ;; somehow...
    (derived-type :undefined :type +js-type+)
    ;; the node (if unique) or a list of nodes where this lvar is used.
    (uses nil :type (or node list))
    ;; set to true when something about this lvar's value has changed.
    (reoptimize t :type boolean)
    ;; Cached type which is checked by DEST. If NIL, then this must be
    ;; recomputed.
    (externally-checkable-type :undefined :type +js-type+))
  
  ;;; NODE will be the generic interface of all different type of nodes,
  