anchor.diff:    ;; stricter, this terminates.
     (labels ((apply-rel (tc rel)
                (let* ((result (compute-rel (car rel) (resolve-tc (second rel))
  -                                         (and (third rel) (resolve-tc (third rel)))))
  +                                         (if (third rel) (resolve-tc (third rel)) :none)))
                       (combined (combine-types result (tc-tp tc))))
                  (unless (eq combined (tc-tp tc))
                    (setf (tc-tp tc) combined)
  
positive.code: ;; since some of the methods need direct access to those.
  (defparameter *function-tcs* nil)
  
  (defun may-fall-off (fbody)
    (labels ((see-body (stats)
               (see (car (last stats))))
             (see (stat)
               (case (car stat)
                 ((nil :for :for-in :do :while :throw :stat :break
                       :continue :defun :var :switch) t)
                 (:return nil)
                 (:if (or (see (second stat)) (see (third stat))))
                 (:with (see (third stat)))
                 (:block (see-body (second stat)))
                 (:try (if (fourth stat)
                           (see (fourth stat))
                           (or (see (second stat)) (see (third stat))))))))
      (see-body fbody)))
  
  (defun infer-func (name args body env)
    (let ((locals (find-locals body `("this" "arguments" ,@args
                                      ,@(and name (list name)))))
  
negative.code:     (:and a) ;; used by link-tc
      (:+ ;; the interesting effects of the + operator
       (cond ((or (eq a :string) (eq b :string)) :string)
             ((or (member a '(t :object)) (member b '(t :object))) t)
             ((and (eq a :integer) (eq b :integer)) :integer)
             ((or (not a) (not b)) nil) ;; Will be recomputed later
             (t :number)))
      (:either (combine-types a b))
      (:maybe-int ;; result of other numeric operations
       (cond ((eq b :none) (case a (:integer :integer) ((nil) nil) (t :number)))
             ((and (eq a :integer) (eq b :integer)) :integer)
             ((or (not a) (not b)) nil)
             (t :number)))))
  
  ;; 'Resolve' a type-cell, computing its final type from its current
  ;; type and its relations. Done in a second pass after inference has
  