-192: "Python treats free type declarations as promises."
- a. original report by Alexey Dejneka (on sbcl-devel 2002-08-26):
- (declaim (optimize (speed 0) (safety 3)))
- (defun f (x)
- (declare (real x))
- (+ x
- (locally (declare (single-float x))
- (sin x))))
- Now (F NIL) correctly gives a type error, but (F 100) gives
- a segmentation violation.
- b. same fundamental problem in a different way, easy to stumble
- across if you mistype and declare the wrong index in
- (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
-
-193: "unhelpful CLOS error reporting when the primary method is missing"
- In sbcl-0.7.7, when
- (defmethod foo :before ((x t)) (print x))
- is the only method defined on FOO, the error reporting when e.g.
- (foo 12)
- is relatively unhelpful:
- There is no primary method for the generic function
- #<STANDARD-GENERIC-FUNCTION FOO (1)>.
- with the offending argument nowhere visible in the backtrace. This
- continues even if there *are* primary methods, just not for the
- specified arg type, e.g.
- (defmethod foo ((x character)) (print x))
- (defmethod foo ((x string)) (print x))
- (defmethod foo ((x pathname)) ...)
- In that case it could be very helpful to know what argument value is
- falling through the cracks of the defined primary methods, but the
- error message stays the same (even BACKTRACE doesn't tell you what the
- bad argument value is).
-
-194: "no error from (THE REAL '(1 2 3)) in some cases"
- In sbcl-0.7.7.9,
- (multiple-value-prog1 (progn (the real '(1 2 3))))
- returns (1 2 3) instead of signalling an error. Also in sbcl-0.7.7.9,
- a more complicated instance of this bug kept
- (IGNORE-ERRORS (MIN '(1 2 3))) from returning NIL as it should when
- the MIN source transform expanded to (THE REAL '(1 2 3)), because
- (IGNORE-ERRORS (THE REAL '(1 2 3))) returns (1 2 3).
- Alexey Dejneka pointed out that
- (IGNORE-ERRORS (IDENTITY (THE REAL '(1 2 3)))) works as it should.
- (IGNORE-ERRORS (VALUES (THE REAL '(1 2 3)))) also works as it should.
- Perhaps this is another case of VALUES type intersections behaving
- in non-useful ways?
- When I (WHN) tried to use the VALUES trick to work around this bug
- in the MIN source transform, it didn't work for
- (assert (null (ignore-errors (min 1 #(1 2 3)))))
- Hand-expanding the source transform, I get
- (assert (null (ignore-errors
- (let ((arg1 1)
- (arg2 (identity (the real #(1 2 3)))))
- (if (< arg1 arg2) arg1 arg2)))))
- which fails (i.e. the assertion fails, because the IGNORE-ERRORS
- doesn't report MIN signalling a type error). At the REPL
- (null (ignore-errors
- (let ((arg1 1)
- (arg2 (identity (the real #(1 2 3)))))
- (if (< arg1 arg2) arg1 arg2))))
- => T
- but when this expression is used as the body of (DEFUN FOO () ...)
- then (FOO)=>NIL.
-
-195: "confusing reporting of not-a-REAL TYPE-ERRORs from THE REAL"
- In sbcl-0.7.7.10, (THE REAL #(1 2 3)) signals a type error which
- prints as "This is not a (OR SINGLE-FLOAT DOUBLE-FLOAT RATIONAL)".
- The (OR SINGLE-FLOAT DOUBLE-FLOAT RATIONAL) representation of
- REAL is unnecessarily confusing, especially since it relies on
- internal implementation knowledge that even with SHORT-FLOAT
- and LONG-FLOAT left out of the union, this type is equal to REAL.
- So it'd be better just to say "This is not a REAL".
+
+201: "Incautious type inference from compound types"
+ a. (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"
+
+ b.
+ * (defun foo (x)
+ (declare (type (array * (4 4)) x))
+ (let ((y x))
+ (setq x (make-array '(4 4)))
+ (adjust-array y '(3 5))
+ (= (array-dimension y 0) (eval `(array-dimension ,y 0)))))
+ FOO
+ * (foo (make-array '(4 4) :adjustable t))
+ NIL
+
+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.
+ c. The cross-compiler cannot inline functions defined in a non-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?
+
+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.)
+
+220:
+ Sbcl 0.7.9 fails to compile
+
+ (multiple-value-call #'list
+ (the integer (helper))
+ nil)
+
+ Type check for INTEGER, 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 the check between evaluation of arguments, but it
+ could be tricky to check result types of PROG1, IF etc.
+
+233: bugs in constraint propagation
+ a.
+ (defun foo (x)
+ (declare (optimize (speed 2) (safety 3)))
+ (let ((y 0d0))
+ (values
+ (the double-float x)
+ (setq y (+ x 1d0))
+ (setq x 3d0)
+ (quux y (+ y 2d0) (* y 3d0)))))
+ (foo 4) => segmentation violation
+
+ (see usage of CONTINUATION-ASSERTED-TYPE in USE-RESULT-CONSTRAINTS)
+ (see also bug 236)
+
+ b.
+ (declaim (optimize (speed 2) (safety 3)))
+ (defun foo (x y)
+ (if (typep (prog1 x (setq x y)) 'double-float)
+ (+ x 1d0)
+ (+ x 2)))
+ (foo 1d0 5) => segmentation violation
+
+235: "type system and inline expansion"
+ a.
+ (declaim (ftype (function (cons) number) acc))
+ (declaim (inline acc))
+ (defun acc (c)
+ (the number (car c)))
+
+ (defun foo (x y)
+ (values (locally (declare (optimize (safety 0)))
+ (acc x))
+ (locally (declare (optimize (safety 3)))
+ (acc y))))
+
+ (foo '(nil) '(t)) => NIL, T.
+
+237: "Environment arguments to type functions"
+ a. Functions SUBTYPEP, TYPEP, UPGRADED-ARRAY-ELEMENT-TYPE, and
+ UPGRADED-COMPLEX-PART-TYPE now have an optional environment
+ argument, but they ignore it completely. This is almost
+ certainly not correct.
+ b. Also, the compiler's optimizers for TYPEP have not been informed
+ about the new argument; consequently, they will not transform
+ calls of the form (TYPEP 1 'INTEGER NIL), even though this is
+ just as optimizeable as (TYPEP 1 'INTEGER).
+
+238: "REPL compiler overenthusiasm for CLOS code"
+ From the REPL,
+ * (defclass foo () ())
+ * (defmethod bar ((x foo) (foo foo)) (call-next-method))
+ causes approximately 100 lines of code deletion notes. Some
+ discussion on this issue happened under the title 'Three "interesting"
+ bugs in PCL', resulting in a fix for this oververbosity from the
+ compiler proper; however, the problem persists in the interactor
+ because the notion of original source is not preserved: for the
+ compiler, the original source of the above expression is (DEFMETHOD
+ BAR ((X FOO) (FOO FOO)) (CALL-NEXT-METHOD)), while by the time the
+ compiler gets its hands on the code needing compilation from the REPL,
+ it has been macroexpanded several times.
+
+ A symptom of the same underlying problem, reported by Tony Martinez:
+ * (handler-case
+ (with-input-from-string (*query-io* " no")
+ (yes-or-no-p))
+ (simple-type-error () 'error))
+ ; in: LAMBDA NIL
+ ; (SB-KERNEL:FLOAT-WAIT)
+ ;
+ ; note: deleting unreachable code
+ ; compilation unit finished
+ ; printed 1 note
+
+241: "DEFCLASS mysteriously remembers uninterned accessor names."
+ (from tonyms on #lisp IRC 2003-02-25)
+ In sbcl-0.7.12.55, typing
+ (defclass foo () ((bar :accessor foo-bar)))
+ (profile foo-bar)
+ (unintern 'foo-bar)
+ (defclass foo () ((bar :accessor foo-bar)))
+ gives the error message
+ "#:FOO-BAR already names an ordinary function or a macro."
+ So it's somehow checking the uninterned old accessor name instead
+ of the new requested accessor name, which seems broken to me (WHN).
+
+242: "WRITE-SEQUENCE suboptimality"
+ (observed from clx performance)
+ In sbcl-0.7.13, WRITE-SEQUENCE of a sequence of type
+ (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)) on a stream with element-type
+ (UNSIGNED-BYTE 8) will write to the stream one byte at a time,
+ rather than writing the sequence in one go, leading to severe
+ performance degradation.
+
+243: "STYLE-WARNING overenthusiasm for unused variables"
+ (observed from clx compilation)
+ In sbcl-0.7.14, in the presence of the macros
+ (DEFMACRO FOO (X) `(BAR ,X))
+ (DEFMACRO BAR (X) (DECLARE (IGNORABLE X)) 'NIL)
+ somewhat surprising style warnings are emitted for
+ (COMPILE NIL '(LAMBDA (Y) (FOO Y))):
+ ; in: LAMBDA (Y)
+ ; (LAMBDA (Y) (FOO Y))
+ ;
+ ; caught STYLE-WARNING:
+ ; The variable Y is defined but never used.
+
+245: bugs in disassembler
+ a. On X86 an immediate operand for IMUL is printed incorrectly.
+ b. On X86 operand size prefix is not recognized.
+
+248: "reporting errors in type specifier syntax"
+ (TYPEP 1 '(SYMBOL NIL)) says something about "unknown type
+ specifier".
+
+251:
+ (defun foo (&key (a :x))
+ (declare (fixnum a))
+ a)
+
+ does not cause a warning. (BTW: old SBCL issued a warning, but for a
+ function, which was never called!)
+
+256:
+ Compiler does not emit warnings for
+
+ a. (lambda () (svref (make-array 8 :adjustable t) 1))
+
+ b. (lambda (x)
+ (list (let ((y (the real x)))
+ (unless (floatp y) (error ""))
+ y)
+ (integer-length x)))
+
+ c. (lambda (x)
+ (declare (optimize (debug 0)))
+ (declare (type vector x))
+ (list (fill-pointer x)
+ (svref x 1)))
+
+257:
+ Complex array type does not have corresponding type specifier.
projects / sbcl.git / blobdiff