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:       (when (may-fall-off body) (add-type ret-tc :undefined))
        (let* ((*function-tcs* (cons arg-tcs ret-tc))
               tmp
               ;; The new scope list
               (sc (loop :for name :in locals :collect
                      (cond ((string= name "this") (list t nil name (tc :object)))
                            ;; defuns get some magic to store them as delayed functions,
                            ;; and to be able to keep their ftype
                            ((setf tmp (find name defuns :key #'second :test #'string=))
                             (list (list nil) (cons :function (cdr tmp)) name (tc :object)))
                            ;; arguments
                            ((setf tmp (position name args :test #'string=))
                             (list t nil name (nth tmp arg-tcs)))
                            ((string= name "arguments") (list t nil name (tc :object)))
                            (t (list nil nil name (tc ()))))))
               (env (cons sc env)))
          (dolist (stat body) (setf env (infer stat env)))
  