0.7.6.3:

[sbcl.git] / src / compiler / checkgen.lisp

diff --git a/src/compiler/checkgen.lisp b/src/compiler/checkgen.lisp
index 01f8e29..f7375d9 100644 (file)
--- a/src/compiler/checkgen.lisp
+++ b/src/compiler/checkgen.lisp
@@ -29,7 +29,7 @@
   (let ((info (info :function :info name))
        (call-cost (template-cost (template-or-lose 'call-named))))
     (if info
-       (let ((templates (function-info-templates info)))
+       (let ((templates (fun-info-templates info)))
          (if templates
              (template-cost (first templates))
              (case name
@@ -276,12 +276,12 @@
             (cond ((eq cont (basic-combination-fun dest)) t)
                   ((eq kind :local) t)
                   ((member kind '(:full :error)) nil)
-                  ((function-info-ir2-convert kind) t)
+                  ((fun-info-ir2-convert kind) t)
                   (t
-                   (dolist (template (function-info-templates kind) nil)
+                   (dolist (template (fun-info-templates kind) nil)
                      (when (eq (template-ltn-policy template) :fast-safe)
                        (multiple-value-bind (val win)
-                           (valid-function-use dest (template-type template))
+                           (valid-fun-use dest (template-type template))
                          (when (or val (not win)) (return t)))))))))
          (t t))))
 
@@ -361,7 +361,7 @@
        ;; said that somewhere in here we
        ;;   Set the new block's start and end cleanups to the *start*
        ;;   cleanup of PREV's block. This overrides the incorrect
-       ;;   default from WITH-BELATED-IR1-ENVIRONMENT.
+       ;;   default from WITH-IR1-ENVIRONMENT-FROM-NODE.
        ;; Unfortunately I can't find any code which corresponds to this.
        ;; Perhaps it was a stale comment? Or perhaps I just don't
        ;; understand.. -- WHN 19990521
@@ -404,7 +404,7 @@
 ;;; context. If the value is a constant, we print it specially. We
 ;;; ignore nodes whose type is NIL, since they are supposed to never
 ;;; return.
-(defun do-type-warning (node)
+(defun emit-type-warning (node)
   (declare (type node node))
   (let* ((*compiler-error-context* node)
         (cont (node-cont node))
@@ -431,7 +431,7 @@
   (values))
 
 ;;; Mark CONT as being a continuation with a manifest type error. We
-;;; set the kind to :ERROR, and clear any FUNCTION-INFO if the
+;;; set the kind to :ERROR, and clear any FUN-INFO if the
 ;;; continuation is an argument to a known call. The last is done so
 ;;; that the back end doesn't have to worry about type errors in
 ;;; arguments to known functions. This clearing is inhibited for
@@ -444,8 +444,8 @@
     (when (and (combination-p dest)
               (let ((kind (basic-combination-kind dest)))
                 (or (eq kind :full)
-                    (and (function-info-p kind)
-                         (not (function-info-ir2-convert kind))))))
+                    (and (fun-info-p kind)
+                         (not (fun-info-ir2-convert kind))))))
       (setf (basic-combination-kind dest) :error)))
   (values))
 
@@ -491,7 +491,7 @@
                           (node-derived-type use) atype)
                    (mark-error-continuation cont)
                    (unless (policy node (= inhibit-warnings 3))
-                     (do-type-warning use))))))
+                     (emit-type-warning use))))))
            (when (eq type-check t)
              (cond ((probable-type-check-p cont)
                     (conts cont))