(defun no-function-values-types (type)
(declare (type ctype type))
(multiple-value-bind (res count) (values-types type)
- (values (mapcar #'(lambda (type)
- (if (function-type-p type)
- (specifier-type 'function)
- type))
+ (values (mapcar (lambda (type)
+ (if (fun-type-p type)
+ (specifier-type 'function)
+ type))
res)
count)))
;;; the proven type and the corresponding type in TYPES. If so, we opt
;;; for a :HAIRY check with that test negated. Otherwise, we try to do
;;; a simple test, and if that is impossible, we do a hairy test with
-;;; non-negated types. If true, Force-Hairy forces a hairy type check.
+;;; non-negated types. If true, FORCE-HAIRY forces a hairy type check.
;;;
;;; When doing a non-negated check, we call MAYBE-WEAKEN-CHECK to
;;; weaken the test to a convenient supertype (conditional on policy.)
(if (and (every #'type-check-template types) (not force-hairy))
(values :simple types)
(values :hairy
- (mapcar #'(lambda (x)
- (list nil (maybe-weaken-check x cont) x))
+ (mapcar (lambda (x)
+ (list nil (maybe-weaken-check x cont) x))
types)))
- (let ((res (mapcar #'(lambda (p c)
- (let ((diff (type-difference p c))
- (weak (maybe-weaken-check c cont)))
- (if (and diff
- (< (type-test-cost diff)
- (type-test-cost weak))
- *complement-type-checks*)
- (list t diff c)
- (list nil weak c))))
+ (let ((res (mapcar (lambda (p c)
+ (let ((diff (type-difference p c))
+ (weak (maybe-weaken-check c cont)))
+ (if (and diff
+ (< (type-test-cost diff)
+ (type-test-cost weak))
+ *complement-type-checks*)
+ (list t diff c)
+ (list nil weak c))))
ptypes types)))
(cond ((or force-hairy (find-if #'first res))
(values :hairy res))
(declare (type continuation cont))
(let ((type (continuation-asserted-type cont))
(dest (continuation-dest cont)))
- (assert (not (eq type *wild-type*)))
+ (aver (not (eq type *wild-type*)))
(multiple-value-bind (types count) (no-function-values-types type)
(cond ((not (eq count :unknown))
(if (or (exit-p dest)
(maybe-negate-check cont types nil)))
((and (mv-combination-p dest)
(eq (basic-combination-kind dest) :local))
- (assert (values-type-p type))
+ (aver (values-type-p type))
(maybe-negate-check cont (args-type-optional type) nil))
(t
(values :too-hairy nil))))))
(declare (type continuation cont))
(let ((dest (continuation-dest cont)))
(cond ((eq (continuation-type-check cont) :error)
- (if (and (combination-p dest) (eq (combination-kind dest) :error))
+ (if (and (combination-p dest)
+ (eq (combination-kind dest) :error))
nil
t))
((or (not dest)
(defun make-type-check-form (types)
(let ((temps (make-gensym-list (length types))))
`(multiple-value-bind ,temps 'dummy
- ,@(mapcar #'(lambda (temp type)
- (let* ((spec
- (let ((*unparse-function-type-simplify* t))
- (type-specifier (second type))))
- (test (if (first type) `(not ,spec) spec)))
- `(unless (typep ,temp ',test)
- (%type-check-error
- ,temp
- ',(type-specifier (third type))))))
+ ,@(mapcar (lambda (temp type)
+ (let* ((spec
+ (let ((*unparse-fun-type-simplify* t))
+ (type-specifier (second type))))
+ (test (if (first type) `(not ,spec) spec)))
+ `(unless (typep ,temp ',test)
+ (%type-check-error
+ ,temp
+ ',(type-specifier (third type))))))
temps
types)
(values ,@temps))))
;;; passes them on to CONT.
(defun convert-type-check (cont types)
(declare (type continuation cont) (type list types))
- (with-ir1-environment (continuation-dest cont)
+ (with-ir1-environment-from-node (continuation-dest cont)
;; Ensuring that CONT starts a block lets us freely manipulate its uses.
(ensure-block-start cont)
(ir1-convert new-start dummy (make-type-check-form types))
;; TO DO: Why should this be true? -- WHN 19990601
- (assert (eq (continuation-block dummy) new-block))
+ (aver (eq (continuation-block dummy) new-block))
;; KLUDGE: Comments at the head of this function in CMU CL
;; 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-IR1-ENVIRONMENT.
+ ;; default from WITH-BELATED-IR1-ENVIRONMENT.
;; 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
(let* ((node (continuation-use cont))
(args (basic-combination-args node))
(victim (first args)))
- (assert (and (= (length args) 1)
+ (aver (and (= (length args) 1)
(eq (constant-value
(ref-leaf
(continuation-use victim)))
(substitute-continuation new-start victim)))
;; Invoking local call analysis converts this call to a LET.
- (local-call-analyze *current-component*))
+ (locall-analyze-component *current-component*))
(values))
(format nil "~:[A possible~;The~] binding of ~S"
(and (continuation-use cont)
(eq (functional-kind lambda) :let))
- (leaf-name (elt (lambda-vars lambda) pos)))))))
+ (leaf-source-name (elt (lambda-vars lambda)
+ pos)))))))
(cond ((eq dtype *empty-type*))
((and (ref-p node) (constant-p (ref-leaf node)))
(compiler-warning "~:[This~;~:*~A~] is not a ~<~%~9T~:;~S:~>~% ~S"
(setf (basic-combination-kind dest) :error)))
(values))
-;;; Loop over all blocks in Component that have TYPE-CHECK set,
+;;; Loop over all blocks in COMPONENT that have TYPE-CHECK set,
;;; looking for continuations with TYPE-CHECK T. We do two mostly
;;; unrelated things: detect compile-time type errors and determine if
;;; and how to do run-time type checks.
(unless (member type-check '(nil :error :deleted))
(let ((atype (continuation-asserted-type cont)))
(do-uses (use cont)
- (unless (values-types-intersect (node-derived-type use)
- atype)
+ (unless (values-types-equal-or-intersect
+ (node-derived-type use) atype)
(mark-error-continuation cont)
(unless (policy node (= inhibit-warnings 3))
(do-type-warning use))))))
- (when (and (eq type-check t)
- (not *byte-compiling*))
+ (when (eq type-check t)
(cond ((probable-type-check-p cont)
(conts cont))
(t
projects / sbcl.git / blobdiff