`(lambda (f)
(declare (optimize (speed 2) (safety ,policy1)))
(multiple-value-list
- (the (values (integer 2 3) t)
+ (the (values (integer 2 3) t &optional)
(locally (declare (optimize (safety ,policy2)))
- (the (values t (single-float 2f0 3f0))
+ (the (values t (single-float 2f0 3f0) &optional)
(funcall f)))))))
(lambda () (values x y)))
(type-error (error)
;;; COERCE got its own DEFOPTIMIZER which has to reimplement most of
;;; SPECIFIER-TYPE-NTH-ARG. For a while, an illegal type would throw
;;; you into the debugger on compilation.
-(defun coerce-defopt (x)
+(defun coerce-defopt1 (x)
;; illegal, but should be compilable.
(coerce x '(values t)))
-(assert (null (ignore-errors (coerce-defopt 3))))
+(defun coerce-defopt2 (x)
+ ;; illegal, but should be compilable.
+ (coerce x '(values t &optional)))
+(assert (null (ignore-errors (coerce-defopt1 3))))
+(assert (null (ignore-errors (coerce-defopt2 3))))
\f
;;; Oops. In part of the (CATCH ..) implementation of DEBUG-RETURN,
;;; it was possible to confuse the type deriver of the compiler
(assert (eq l nil))
(assert (eq (sswo-a s) :v)))
+(defun bug249 (x)
+ (flet ((bar (y)
+ (declare (fixnum y))
+ (incf x)))
+ (list (bar x) (bar x) (bar x))))
+
+(assert (raises-error? (bug249 1.0) type-error))
+
+;;; bug reported by ohler on #lisp 2003-07-10
+(defun bug-ohler-2003-07-10 (a b)
+ (declare (optimize (speed 0) (safety 3) (space 0)
+ (debug 1) (compilation-speed 0)))
+ (adjoin a b))
+
+;;; bug reported by Doug McNaught on sbcl-devel 2003-09-14:
+;;; COMPILE-FILE did not bind *READTABLE*
+(let* ((source "bug-doug-mcnaught-20030914.lisp")
+ (fasl (compile-file-pathname source)))
+ (labels ((check ()
+ (assert (null (get-macro-character #\]))))
+ (full-check ()
+ (check)
+ (assert (typep *bug-doug-mcnaught-20030914*
+ '(simple-array (unsigned-byte 4) (*))))
+ (assert (equalp *bug-doug-mcnaught-20030914* #(1 2 3)))
+ (makunbound '*bug-doug-mcnaught-20030914*)))
+ (compile-file source)
+ (check)
+ (load fasl)
+ (full-check)
+ (load source)
+ (full-check)
+ (delete-file fasl)))
+\f
+(defun expt-derive-type-bug (a b)
+ (unless (< a b)
+ (truncate (expt a b))))
+(assert (equal (multiple-value-list (expt-derive-type-bug 1 1))
+ '(1 0)))
+
+;;; Problems with type checking in functions with EXPLICIT-CHECK
+;;; attribute (reported by Peter Graves)
+(loop for (fun . args) in '((= a) (/= a)
+ (< a) (<= a) (> a) (>= a))
+ do (assert (raises-error? (apply fun args) type-error)))
+
+(defclass broken-input-stream (sb-gray:fundamental-input-stream) ())
+(defmethod sb-gray:stream-read-char ((stream broken-input-stream))
+ (throw 'break :broken))
+(assert (eql (block return
+ (handler-case
+ (catch 'break
+ (funcall (eval ''peek-char)
+ 1 (make-instance 'broken-input-stream))
+ :test-broken)
+ (type-error (c)
+ (return-from return :good))))
+ :good))
+
\f
;;;; tests not in the problem domain, but of the consistency of the
;;;; compiler machinery itself