(cond ((policy (continuation-dest cont)
(and (<= speed safety)
(<= space safety)
- (<= cspeed safety)))
+ (<= compilation-speed safety)))
type)
(t
(let ((min-cost (type-test-cost type))
;;; 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
((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)))))))))
(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*))
(: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)))))