+192: "Python treats free type declarations as promises."
+ b. What seemed like the same fundamental problem as bug 192a, but
+ was not fixed by the same (APD "more strict type checking
+ sbcl-devel 2002-08-97) patch:
+ (DOTIMES (I ...) (DOTIMES (J ...) (DECLARE ...) ...)):
+ (declaim (optimize (speed 1) (safety 3)))
+ (defun trust-assertion (i)
+ (dotimes (j i)
+ (declare (type (mod 4) i)) ; when commented out, behavior changes!
+ (unless (< i 5)
+ (print j))))
+ (trust-assertion 6) ; prints nothing unless DECLARE is commented out
+
+ (see bug 203)
+
+194: "no error from (THE REAL '(1 2 3)) in some cases"
+ fixed parts:
+ a. In sbcl-0.7.7.9,
+ (multiple-value-prog1 (progn (the real '(1 2 3))))
+ returns (1 2 3) instead of signalling an error. This was fixed by
+ APD's "more strict type checking patch", but although the fixed
+ code (in sbcl-0.7.7.19) works (signals TYPE-ERROR) interactively,
+ it's difficult to write a regression test for it, because
+ (IGNORE-ERRORS (MULTIPLE-VALUE-PROG1 (PROGN (THE REAL '(1 2 3)))))
+ still returns (1 2 3).
+ still-broken parts:
+ b. (IGNORE-ERRORS (MULTIPLE-VALUE-PROG1 (PROGN (THE REAL '(1 2 3)))))
+ returns (1 2 3). (As above, this shows up when writing regression
+ tests for fixed-ness of part a.)
+ c. Also in sbcl-0.7.7.9, (IGNORE-ERRORS (THE REAL '(1 2 3))) => (1 2 3).
+ d. At the REPL,
+ (null (ignore-errors
+ (let ((arg1 1)
+ (arg2 (identity (the real #(1 2 3)))))
+ (if (< arg1 arg2) arg1 arg2))))
+ => T
+ but putting the same expression inside (DEFUN FOO () ...),
+ (FOO) => NIL.
+ notes:
+ * Actually this entry is probably multiple bugs, as
+ Alexey Dejneka commented on sbcl-devel 2002-09-03:)
+ I don't think that placing these two bugs in one entry is
+ a good idea: they have different explanations. The second
+ (min 1 nil) is caused by flushing of unused code--IDENTITY
+ can do nothing with it. So it is really bug 122. The first
+ (min nil) is due to M-V-PROG1: substituting a continuation
+ for the result, it forgets about type assertion. The purpose
+ of IDENTITY is to save the restricted continuation from
+ inaccurate transformations.
+ * Alexey Dejneka pointed out that
+ (IGNORE-ERRORS (IDENTITY (THE REAL '(1 2 3))))
+ works as it should. Also
+ (IGNORE-ERRORS (VALUES (THE REAL '(1 2 3))))
+ works as it should. Perhaps this is another case of VALUES type
+ intersections behaving in non-useful ways?
+
+199: "hairy FUNCTION types confuse the compiler"
+ (reported by APD sbcl-devel 2002-09-15)
+ (DEFUN MUR (F)
+ (EQ NIL (FUNCALL F)))
+
+ (DEFUN FOO (F X)
+ (DECLARE (TYPE (AND FUNCTION (SATISFIES MUR)) F))
+ (FUNCALL F X))
+
+ fails to compile, printing
+ failed AVER:
+ "(AND (EQ (IR2-CONTINUATION-PRIMITIVE-TYPE 2CONT) FUNCTION-PTYPE) (EQ CHECK T))"
+
+ APD further reports that this bug is not present in CMUCL.
+
+ (this case was fixed in 0.7.8.9; see also bug 178)
+
+201: "Incautious type inference from compound CONS types"
+ (reported by APD sbcl-devel 2002-09-17)
+ (DEFUN FOO (X)
+ (LET ((Y (CAR (THE (CONS INTEGER *) X))))
+ (SETF (CAR X) NIL)
+ (FORMAT NIL "~S IS ~S, Y = ~S"
+ (CAR X)
+ (TYPECASE (CAR X)
+ (INTEGER 'INTEGER)
+ (T '(NOT INTEGER)))
+ Y)))
+
+ (FOO ' (1 . 2)) => "NIL IS INTEGER, Y = 1"
+
+203:
+ Compiler does not check THEs on unused values, e.g. in
+
+ (progn (the real (list 1)) t)
+
+ This situation may appear during optimizing away degenerate cases of
+ certain functions: see bugs 54, 192b.
+
+205: "environment issues in cross compiler"
+ (These bugs have no impact on user code, but should be fixed or
+ documented.)
+ a. Macroexpanders introduced with MACROLET are defined in the null
+ lexical environment.
+ b. The body of (EVAL-WHEN (:COMPILE-TOPLEVEL) ...) is evaluated in
+ the null lexical environment.
+
+206: ":SB-FLUID feature broken"
+ (reported by Antonio Martinez-Shotton sbcl-devel 2002-10-07)
+ Enabling :SB-FLUID in the target-features list in sbcl-0.7.8 breaks
+ the build.
+
+207: "poorly distributed SXHASH results for compound data"
+ SBCL's SXHASH could probably try a little harder. ANSI: "the
+ intent is that an implementation should make a good-faith
+ effort to produce hash-codes that are well distributed
+ within the range of non-negative fixnums". But
+ (let ((hits (make-hash-table)))
+ (dotimes (i 16)
+ (dotimes (j 16)
+ (let* ((ij (cons i j))
+ (newlist (push ij (gethash (sxhash ij) hits))))
+ (when (cdr newlist)
+ (format t "~&collision: ~S~%" newlist))))))
+ reports lots of collisions in sbcl-0.7.8. A stronger MIX function
+ would be an obvious way of fix. Maybe it would be acceptably efficient
+ to redo MIX using a lookup into a 256-entry s-box containing
+ 29-bit pseudorandom numbers?
+
+208: "package confusion in PCL handling of structure slot handlers"
+ In sbcl-0.7.8 compiling and loading
+ (in-package :cl)
+ (defstruct foo (slot (error "missing")) :type list :read-only t)
+ (defmethod print-object ((foo foo) stream) (print nil stream))
+ causes CERROR "attempting to modify a symbol in the COMMON-LISP
+ package: FOO-SLOT". (This is fairly bad code, but still it's hard
+ to see that it should cause symbols to be interned in the CL package.)
+
+211: "keywords processing"
+ a. :ALLOW-OTHER-KEYS T should allow a function to receive an odd
+ number of keyword arguments.
+ e. Compiling
+
+ (flet ((foo (&key y) (list y)))
+ (list (foo :y 1 :y 2)))
+
+ issues confusing message
+
+ ; in: LAMBDA NIL
+ ; (FOO :Y 1 :Y 2)
+ ;
+ ; caught STYLE-WARNING:
+ ; The variable #:G15 is defined but never used.
+
+212: "Sequence functions and circular arguments"
+ COERCE, MERGE and CONCATENATE go into an infinite loop when given
+ circular arguments; it would be good for the user if they could be
+ given an error instead (ANSI 17.1.1 allows this behaviour on the part
+ of the implementation, as conforming code cannot give non-proper
+ sequences to these functions. MAP also has this problem (and
+ solution), though arguably the convenience of being able to do
+ (MAP 'LIST '+ FOO '#1=(1 . #1#))
+ might be classed as more important (though signalling an error when
+ all of the arguments are circular is probably desireable).
+
+213: "Sequence functions and type checking"
+ a. MAKE-SEQUENCE, COERCE, MERGE and CONCATENATE cannot deal with
+ various complicated, though recognizeable, CONS types [e.g.
+ (CONS * (CONS * NULL))
+ which according to ANSI should be recognized] (and, in SAFETY 3
+ code, should return a list of LENGTH 2 or signal an error)
+ b. MAP, when given a type argument that is SUBTYPEP LIST, does not
+ check that it will return a sequence of the given type. Fixing
+ it along the same lines as the others (cf. work done around
+ sbcl-0.7.8.45) is possible, but doing so efficiently didn't look
+ entirely straightforward.
+ c. All of these functions will silently accept a type of the form
+ (CONS INTEGER *)
+ whether or not the return value is of this type. This is
+ probably permitted by ANSI (see "Exceptional Situations" under
+ ANSI MAKE-SEQUENCE), but the DERIVE-TYPE mechanism does not
+ know about this escape clause, so code of the form
+ (INTEGERP (CAR (MAKE-SEQUENCE '(CONS INTEGER *) 2)))
+ can erroneously return T.
+
+214:
+ SBCL 0.6.12.43 fails to compile
+
+ (locally
+ (declare (optimize (inhibit-warnings 0) (compilation-speed 2)))
+ (flet ((foo (&key (x :vx x-p)) (list x x-p)))
+ (foo 1 2)))
+
+ or a more simple example:
+
+ (locally
+ (declare (optimize (inhibit-warnings 0) (compilation-speed 2)))
+ (lambda (x) (declare (fixnum x)) (if (< x 0) 0 (1- x))))
+
+215: ":TEST-NOT handling by functions"
+ a. FIND and POSITION currently signal errors when given non-NIL for
+ both their :TEST and (deprecated) :TEST-NOT arguments, but by
+ ANSI 17.2 "the consequences are unspecified", which by ANSI 1.4.2
+ means that the effect is "unpredictable but harmless". It's not
+ clear what that actually means; it may preclude conforming
+ implementations from signalling errors.
+ b. COUNT, REMOVE and the like give priority to a :TEST-NOT argument
+ when conflict occurs. As a quality of implementation issue, it
+ might be preferable to treat :TEST and :TEST-NOT as being in some
+ sense the same &KEY, and effectively take the first test function in
+ the argument list.
+ c. Again, a quality of implementation issue: it would be good to issue a
+ STYLE-WARNING at compile-time for calls with :TEST-NOT, and a
+ WARNING for calls with both :TEST and :TEST-NOT; possibly this
+ latter should be WARNed about at execute-time too.
+
+216: "debugger confused by frames with invalid number of arguments"
+ In sbcl-0.7.8.51, executing e.g. (VECTOR-PUSH-EXTEND T), BACKTRACE, Q
+ leaves the system confused, enough so that (QUIT) no longer works.
+ It's as though the process of working with the uninitialized slot in
+ the bad VECTOR-PUSH-EXTEND frame causes GC problems, though that may
+ not be the actual problem. (CMU CL 18c doesn't have problems with this.)
+
+217: "Bad type operations with FUNCTION types"
+ In sbcl.0.7.7:
+
+ * (values-type-union (specifier-type '(function (base-char)))
+ (specifier-type '(function (integer))))
+
+ #<FUN-TYPE (FUNCTION (BASE-CHAR) *)>
+
+ It causes insertion of wrong type assertions into generated
+ code. E.g.
+
+ (defun foo (x s)
+ (let ((f (etypecase x
+ (character #'write-char)
+ (integer #'write-byte))))
+ (funcall f x s)
+ (etypecase x
+ (character (write-char x s))
+ (integer (write-byte x s)))))
+
+ Then (FOO #\1 *STANDARD-OUTPUT*) signals type error.
+
+ (In 0.7.9.1 the result type is (FUNCTION * *), so Python does not
+ produce invalid code, but type checking is not accurate. Similar
+ problems exist with VALUES-TYPE-INTERSECTION.)
+
+218: "VALUES type specifier semantics"
+ (THE (VALUES ...) ...) in safe code discards extra values.
+
+ (defun test (x y) (the (values integer) (truncate x y)))
+ (test 10 4) => 2
+
+219: "DEFINE-COMPILER-MACRO in non-toplevel contexts evaluated at compile-time"
+ In sbcl-0.7.9:
+
+ * (defun foo (x)
+ (when x
+ (define-compiler-macro bar (&whole whole)
+ (declare (ignore whole))
+ (print "expanding compiler macro")
+ 1)))
+ FOO
+ * (defun baz (x) (bar))
+ [ ... ]
+ "expanding compiler macro"
+ BAZ
+ * (baz t)
+ 1
+
+220:
+ Sbcl 0.7.9 fails to compile
+
+ (multiple-value-call #'list
+ (the integer (helper))
+ nil)
+
+ Type check for INTEGER is inserted, the result of which serves as
+ the first argument of M-V-C, is inserted after evaluation of NIL. So
+ arguments of M-V-C are pushed in the wrong order. As a temporary
+ workaround type checking was disabled for M-V-Cs in 0.7.9.13. A
+ better solution would be to put a check between evaluation of
+ arguments, but it could be tricky to check result types of PROG1, IF
+ etc.
+
+222: "environment problems in PCL"
+ Evaluating
+
+ (symbol-macrolet ((x 1))
+ (defmethod foo (z)
+ (macrolet ((ml (form) `(progn ,form ,x)))
+ (ml (print x)))))
+
+ causes
+
+ debugger invoked on condition of type UNBOUND-VARIABLE:
+ The variable X is unbound.
+
+223: "(SETF FDEFINITION) and #' semantics broken for wrappers"
+ Although this
+ (defun foo (x)
+ (print x))
+ (defun traced (fn)
+ (lambda (&rest rest)
+ (format t "~&about to call ~S on ~S~%" fn rest)
+ (apply fn rest)
+ (format t "~&returned from ~S~%" fn)))
+ (setf (fdefinition 'foo)
+ (traced #'foo))
+ (foo 11)
+ does what one would expect, this
+ (defun bar (x)
+ (print x))
+ (let ((bar0 #'bar))
+ (setf (fdefinition 'bar)
+ (lambda (&rest rest)
+ (format t "~&about to enter BAR ~S~%" rest)
+ (apply bar0 rest)
+ (format t "~&back from BAR~%"))))
+ (bar 12)
+ recurses endlessly in sbcl-0.7.9.32. (Or it works if #' and
+ FDEFINITION are replaced by SYMBOL-FUNCTION.)
+
+224:
+ SBCL 0.7.8 fails to compile
+
+ (localy (declare (optimize (safety 3)))
+ (ignore-errors (progn (values-list (car (list '(1 . 2)))) t)))
+
+225:
+ (fixed in 0.7.9.42)
+
+226: "AVER failure in COMPILE-FILE of clocc-ansi-test/tests.lisp"
+ (APD points out that this seems to be another symptom of bug #115.)
+ sbcl-0.7.9.43 dies with failed AVER "(EQ (TN-PHYSENV TN) TN-ENV)" when
+ trying to compile clocc-ansi-test/tests.lisp. sbcl-0.7.9.31 was able to
+ to compile it. A smaller test case exhibiting the same problem is
+ (declaim (optimize (speed 0) (safety 3) (debug 3)))
+ (defun c-a-p ()
+ (flet ((safe-format (stream string &rest r)
+ (unless (ignore-errors (progn
+ (apply #'format stream string r)
+ t))
+ (format stream "~&foo ~S" string))))
+ (cond
+ ((eq my-result :ERROR)
+ (cond
+ ((ignore-errors (typep condition result))
+ (safe-format t "~&bar ~S" result))
+ (t
+ (safe-format t "~&baz ~S (~A) ~S" condition condition result)))))))
+
+
projects / sbcl.git / blobdiff