+367: TYPE-ERROR at compile time, undetected TYPE-ERROR at runtime
+ This test program
+ (declaim (optimize (safety 3) (debug 2) (speed 2) (space 1)))
+ (defstruct e367)
+ (defstruct i367)
+ (defstruct g367
+ (i367s (make-array 0 :fill-pointer t) :type (or (vector i367) null)))
+ (defstruct s367
+ (g367 (error "missing :G367") :type g367 :read-only t))
+ ;;; In sbcl-0.8.18, commenting out this (DECLAIM (FTYPE ... R367))
+ ;;; gives an internal error at compile time:
+ ;;; The value #<SB-KERNEL:NAMED-TYPE NIL> is not of
+ ;;; type SB-KERNEL:VALUES-TYPE.
+ (declaim (ftype (function ((vector i367) e367) (or s367 null)) r367))
+ (declaim (ftype (function ((vector e367)) (values)) h367))
+ (defun frob (v w)
+ (let ((x (g367-i367s (make-g367))))
+ (let* ((y (or (r367 x w)
+ (h367 x)))
+ (z (s367-g367 y)))
+ (format t "~&Y=~S Z=~S~%" y z)
+ (g367-i367s z))))
+ (defun r367 (x y) (declare (ignore x y)) nil)
+ (defun h367 (x) (declare (ignore x)) (values))
+ ;;; In sbcl-0.8.18, executing this form causes an low-level error
+ ;;; segmentation violation at #X9B0E1F4
+ ;;; (instead of the TYPE-ERROR that one might like).
+ (frob 0 (make-e367))
+ can be made to cause two different problems, as noted in the comments:
+ bug 367a: Compile and load the file. No TYPE-ERROR is signalled at
+ run time (in the (S367-G367 Y) form of FROB, when Y is NIL
+ instead of an instance of S367). Instead (on x86/Linux at least)
+ we end up with a segfault.
+ bug 367b: Comment out the (DECLAIM (FTYPE ... R367)), and compile
+ the file. The compiler fails with TYPE-ERROR at compile time.
+
+368: miscompiled OR (perhaps related to bug 367)
+ Trying to relax type declarations to find a workaround for bug 367,
+ it turns out that even when the return type isn't declared (or
+ declared to be T, anyway) the system remains confused about type
+ inference in code similar to that for bug 367:
+ (in-package :cl-user)
+ (declaim (optimize (safety 3) (debug 2) (speed 2) (space 1)))
+ (defstruct e368)
+ (defstruct i368)
+ (defstruct g368
+ (i368s (make-array 0 :fill-pointer t) :type (or (vector i368) null)))
+ (defstruct s368
+ (g368 (error "missing :G368") :type g368 :read-only t))
+ (declaim (ftype (function (fixnum (vector i368) e368) t) r368))
+ (declaim (ftype (function (fixnum (vector e368)) t) h368))
+ (defparameter *h368-was-called-p* nil)
+ (defun nsu (vertices e368)
+ (let ((i368s (g368-i368s (make-g368))))
+ (let ((fuis (r368 0 i368s e368)))
+ (format t "~&FUIS=~S~%" fuis)
+ (or fuis (h368 0 i368s)))))
+ (defun r368 (w x y)
+ (declare (ignore w x y))
+ nil)
+ (defun h368 (w x)
+ (declare (ignore w x))
+ (setf *h368-was-called-p* t)
+ (make-s368 :g368 (make-g368)))
+ (trace r368 h368)
+ (format t "~&calling NSU~%")
+ (let ((nsu (nsu #() (make-e368))))
+ (format t "~&NSU returned ~S~%" nsu)
+ (format t "~&*H368-WAS-CALLED-P*=~S~%" *h368-was-called-p*)
+ (assert (s368-p nsu))
+ (assert *h368-was-called-p*))
+ In sbcl-0.8.18, both ASSERTs fail, and (DISASSEMBLE 'NSU) shows
+ that no call to H368 is compiled.
+
+369: unlike-an-intersection behavior of VALUES-TYPE-INTERSECTION
+ In sbcl-0.8.18.2, the identity $(x \cap y \cap y)=(x \cap y)$
+ does not hold for VALUES-TYPE-INTERSECTION, even for types which
+ can be intersected exactly, so that ASSERTs fail in this test case:
+ (in-package :cl-user)
+ (let ((types (mapcar #'sb-c::values-specifier-type
+ '((values (vector package) &optional)
+ (values (vector package) &rest t)
+ (values (vector hash-table) &rest t)
+ (values (vector hash-table) &optional)
+ (values t &optional)
+ (values t &rest t)
+ (values nil &optional)
+ (values nil &rest t)
+ (values sequence &optional)
+ (values sequence &rest t)
+ (values list &optional)
+ (values list &rest t)))))
+ (dolist (x types)
+ (dolist (y types)
+ (let ((i (sb-c::values-type-intersection x y)))
+ (assert (sb-c::type= i (sb-c::values-type-intersection i x)))
+ (assert (sb-c::type= i (sb-c::values-type-intersection i y)))))))
+
+370: reader misbehaviour on large-exponent floats
+ (read-from-string "1.0s1000000000000000000000000000000000000000")
+ causes the reader to attempt to create a very large bignum (which it
+ will then attempt to coerce to a rational). While this isn't
+ completely wrong, it is probably not ideal -- checking the floating
+ point control word state and then returning the relevant float
+ (most-positive-short-float or short-float-infinity) or signalling an
+ error immediately would seem to make more sense.
+
+372: floating-point overflow not signalled on ppc/darwin
+ The following assertions in float.pure.lisp fail on ppc/darwin
+ (Mac OS X version 10.3.7):
+ (assert (raises-error? (scale-float 1.0 most-positive-fixnum)
+ floating-point-overflow))
+ (assert (raises-error? (scale-float 1.0d0 (1+ most-positive-fixnum))
+ floating-point-overflow)))
+ as the SCALE-FLOAT just returns
+ #.SB-EXT:SINGLE/DOUBLE-FLOAT-POSITIVE-INFINITY. These tests have been
+ disabled on Darwin for now.
+
+373: profiling issues on ppc/darwin
+ The following bit from smoke.impure.lisp fails on ppc/darwin:
+ (progn
+ (defun profiled-fun ()
+ (random 1d0))
+ (profile profiled-fun)
+ (loop repeat 100000 do (profiled-fun))
+ (report))
+ dropping into the debugger with a TYPE-ERROR:
+ The value -1073741382 is not of type UNSIGNED-BYTE.
+ The test has been disabled on Darwin till the bug is fixed.
+
+374: BIT-AND problem on ppc/darwin:
+ The BIT-AND test in bit-vector.impure-cload.lisp results in
+ fatal error encountered in SBCL pid 8356:
+ GC invariant lost, file "gc-common.c", line 605
+ on ppc/darwin. Test disabled for the duration.