anchor.diff:      (:typeof
        (get-exemplar-value-nodes graph "String"))
       (:void
  -     (get-exemplar-value-nodes graph "undefined"))
  +     (compute-types #s(special-value :symbol :undefined) graph))
       (otherwise
        (error "unrecognized unary operation ~A" (unary-operator-op-symbol elm)))))
   
  
positive.code:   "Return the location node named NAME from GRAPH, creating it
     if necessary.  If the node is created and QUEUE is non-NIL,
     then the new node will be queued for processing."
  
    (let ((ret-node 
           (multiple-value-bind (node found-p)
               (gethash name graph)
             (if found-p
               node
               (let ((node (make-location-node :name name)))
                 (when queue
                   (enqueue-node queue node))
                 (setf (gethash name graph) node))))))
  
      ;;TODO This might be the sort of thing that gets declared in a "prelude" of
      ;; type-declarations, but for now we'll ensure that built-in types have their
      ;; constructors set up on demand.
      (when (find name '("Array" "Boolean" "Function" "null" "Number" "Object" "RegExp" "String" "undefined")
                  :test 'equal)
        (setup-function-node graph ret-node))
      ret-node))
  
  (defun find-node-property (node name)
    "Return the location node pointed to by NODE's NAME property if
  
negative.code:   (let ((left-node (get-location-node graph (var-decl-name elm))))
      (if (var-decl-initializer elm)
        (add-assignment-edge left-node (populate-nodes graph (var-decl-initializer elm)))
        (add-assignment-edge left-node (get-location-node graph "undefined")))))
  
  (defmethod populate-nodes (graph (elm fn-call))
    (let* ((target-node (populate-nodes graph (fn-call-fn elm)))
  