0.6.10.3:

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

diff --git a/src/compiler/checkgen.lisp b/src/compiler/checkgen.lisp
index 2a91eda..89a6cc4 100644 (file)
--- a/src/compiler/checkgen.lisp
+++ b/src/compiler/checkgen.lisp
@@ -90,7 +90,9 @@
 (defun maybe-weaken-check (type cont)
   (declare (type ctype type) (type continuation cont))
   (cond ((policy (continuation-dest cont)
-                (<= speed safety) (<= space safety) (<= cspeed safety))
+                (and (<= speed safety)
+                     (<= space safety)
+                     (<= compilation-speed safety)))
         type)
        (t
         (let ((min-cost (type-test-cost type))
@@ -247,7 +249,9 @@
 ;;; We must only return NIL when it is *certain* that a check will not
 ;;; be done, since if we pass up this chance to do the check, it will
 ;;; be too late. The penalty for being too conservative is duplicated
-;;; type checks.
+;;; type checks. The penalty for erring by being too speculative is
+;;; much nastier, e.g. falling through without ever being able to find
+;;; an appropriate VOP.
 ;;;
 ;;; If there is a compile-time type error, then we always return true
 ;;; unless the DEST is a full call. With a full call, the theory is
@@ -276,7 +280,7 @@
                   ((function-info-ir2-convert kind) t)
                   (t
                    (dolist (template (function-info-templates kind) nil)
-                     (when (eq (template-policy template) :fast-safe)
+                     (when (eq (template-ltn-policy template) :fast-safe)
                        (multiple-value-bind (val win)
                            (valid-function-use dest (template-type template))
                          (when (or val (not win)) (return t)))))))))
@@ -486,7 +490,7 @@
                  (unless (values-types-intersect (node-derived-type use)
                                                  atype)
                    (mark-error-continuation cont)
-                   (unless (policy node (= brevity 3))
+                   (unless (policy node (= inhibit-warnings 3))
                      (do-type-warning use))))))
            (when (and (eq type-check t)
                       (not *byte-compiling*))
@@ -504,7 +508,7 @@
          (:too-hairy
           (let* ((context (continuation-dest cont))
                  (*compiler-error-context* context))
-            (when (policy context (>= safety brevity))
+            (when (policy context (>= safety inhibit-warnings))
               (compiler-note
                "type assertion too complex to check:~% ~S."
                (type-specifier (continuation-asserted-type cont)))))