anchor.diff:  
   (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: see LVAR-EXTERNALLY-CHECKABLE-TYPE.
  +  ;; recomputed.
     (externally-checkable-type :undefined :type +js-type+))
   
   ;;; NODE will be the generic interface of all different type of nodes,
  
positive.code:   ;;    marked for deletion.
    ;;    :ZOMBIE
    ;;    Effectless [MV-]LET; has no BIND node.
    ;; TODO: Some of them are not valid semantic in js, remove them.
    (kind nil :type (member nil :optional :deleted :external :toplevel
                            :escape :cleanup :let :mv-let :assignment
                            :zombie :toplevel-xep))
    ;; Is this a function that some external entity (e.g. the fasl dumper)
    ;; refers to, so that even when it appears to have no references, it
    ;; shouldn't be deleted? In the old days (before
    ;; sbcl-0.pre7.37.flaky5.2) this was sort of implicitly true when
    ;; KIND was :TOPLEVEL. Now it must be set explicitly, both for
    ;; :TOPLEVEL functions and for any other kind of functions that we
    ;; want to dump or return from #'CL:COMPILE or whatever.
  
negative.code:   ;;
    ;; E.g. for the function which implements (DEFUN FOO ...), we could
    ;; have
    ;;   SOURCE-NAME=FOO
    ;;   DEBUG-NAME=NIL
    ;; for the function which implements the top level form
    ;; (IN-PACKAGE :FOO) we could have
    ;;   SOURCE-NAME=NIL
    ;;   DEBUG-NAME=(TOP-LEVEL-FORM (IN-PACKAGE :FOO)
    ;; for the function which implements FOO in
    ;;   (DEFUN BAR (...) (FLET ((FOO (...) ...)) ...))
    ;; we could have
    ;;   SOURCE-NAME=FOO
    ;;   DEBUG-NAME=(FLET FOO)
    ;; and for the function which implements FOO in
    ;;   (DEFMACRO FOO (...) ...)
    ;; we could have
    ;;   SOURCE-NAME=FOO (or maybe .ANONYMOUS.?)
    ;;   DEBUG-NAME=(MACRO-FUNCTION FOO)
    (debug-name nil
  	      :type (or null (not (satisfies legal-fun-name-p)))
  	      :read-only t)
  