0.7.12.47:

[sbcl.git] / BUGS

diff --git a/BUGS b/BUGS
index cc65d1f..bb197f8 100644 (file)
--- a/BUGS
+++ b/BUGS
@@ -42,7 +42,8 @@ KNOWN BUGS OF NO SPECIAL CLASS:
   program, even if you know or guess enough about the internals of
   SBCL to wager that this (undefined in ANSI) operation would be safe.
 
   program, even if you know or guess enough about the internals of
   SBCL to wager that this (undefined in ANSI) operation would be safe.
 

-3:
+3: "type checking of structure slots"
+  a:

   ANSI specifies that a type mismatch in a structure slot
   initialization value should not cause a warning.
 WORKAROUND:
   ANSI specifies that a type mismatch in a structure slot
   initialization value should not cause a warning.
 WORKAROUND:

@@ -78,6 +79,28 @@ WORKAROUND:
   Such code should compile without complaint and work correctly either
   on SBCL or on any other completely compliant Common Lisp system.
 
   Such code should compile without complaint and work correctly either
   on SBCL or on any other completely compliant Common Lisp system.
 

+  b: &AUX argument in a boa-constructor without a default value means
+     "do not initilize this slot" and does not cause type error. But
+     an error may be signalled at read time and it would be good if
+     SBCL did it.
+
+  c: Reading of not initialized slot sometimes causes SEGV.
+
+  d:
+    (declaim (optimize (safety 3) (speed 1) (space 1)))
+    (defstruct foo
+      x y)
+    (defstruct (stringwise-foo (:include foo
+                                         (x "x" :type simple-string)
+                                         (y "y" :type simple-string))))
+    (defparameter *stringwise-foo*
+      (make-stringwise-foo))
+    (setf (foo-x *stringwise-foo*) 0)
+    (defun frob-stringwise-foo (sf)
+      (aref (stringwise-foo-x sf) 0))
+    (frob-stringwise-foo *stringwise-foo*)
+  SEGV.
+

 6:
   bogus warnings about undefined functions for magic functions like
   SB!C::%%DEFUN and SB!C::%DEFCONSTANT when cross-compiling files
 6:
   bogus warnings about undefined functions for magic functions like
   SB!C::%%DEFUN and SB!C::%DEFCONSTANT when cross-compiling files

@@ -293,40 +316,6 @@ WORKAROUND:
   then requesting a BACKTRACE at the debugger prompt gives no information
   about where in the user program the problem occurred.
 
   then requesting a BACKTRACE at the debugger prompt gives no information
   about where in the user program the problem occurred.
 

-62:
-  The compiler is supposed to do type inference well enough that 
-  the declaration in
-    (TYPECASE X
-      ((SIMPLE-ARRAY SINGLE-FLOAT)
-       (LOCALLY
-         (DECLARE (TYPE (SIMPLE-ARRAY SINGLE-FLOAT) X))
-         ..))
-      ..)
-  is redundant. However, as reported by Juan Jose Garcia Ripoll for
-  CMU CL, it sometimes doesn't. Adding declarations is a pretty good
-  workaround for the problem for now, but can't be done by the TYPECASE
-  macros themselves, since it's too hard for the macro to detect
-  assignments to the variable within the clause. 
-    Note: The compiler *is* smart enough to do the type inference in
-  many cases. This case, derived from a couple of MACROEXPAND-1
-  calls on Ripoll's original test case,
-    (DEFUN NEGMAT (A)
-      (DECLARE (OPTIMIZE SPEED (SAFETY 0)))
-      (COND ((TYPEP A '(SIMPLE-ARRAY SINGLE-FLOAT)) NIL
-             (LET ((LENGTH (ARRAY-TOTAL-SIZE A)))
-               (LET ((I 0) (G2554 LENGTH))
-                 (DECLARE (TYPE REAL G2554) (TYPE REAL I))
-                 (TAGBODY
-                  SB-LOOP::NEXT-LOOP
-                  (WHEN (>= I G2554) (GO SB-LOOP::END-LOOP))
-                  (SETF (ROW-MAJOR-AREF A I) (- (ROW-MAJOR-AREF A I)))
-                  (GO SB-LOOP::NEXT-LOOP)
-                  SB-LOOP::END-LOOP))))))
-  demonstrates the problem; but the problem goes away if the TAGBODY
-  and GO forms are removed (leaving the SETF in ordinary, non-looping
-  code), or if the TAGBODY and GO forms are retained, but the 
-  assigned value becomes 0.0 instead of (- (ROW-MAJOR-AREF A I)).
-

 63:
   Paul Werkowski wrote on cmucl-imp@cons.org 2000-11-15
     I am looking into this problem that showed up on the cmucl-help
 63:
   Paul Werkowski wrote on cmucl-imp@cons.org 2000-11-15
     I am looking into this problem that showed up on the cmucl-help

@@ -626,13 +615,16 @@ WORKAROUND:
   forever, even when it is uninterned and all other references to it
   are lost.
 
   forever, even when it is uninterned and all other references to it
   are lost.
 

-141: 
-  Pretty-printing nested backquotes doesn't work right, as 
-  reported by Alexey Dejneka sbcl-devel 2002-01-13:
-  * '``(FOO ,@',@S)
-  ``(FOO SB-IMPL::BACKQ-COMMA-AT S)
-  * (lisp-implementation-version)
-  "0.pre7.129"
+141: "pretty printing and backquote"
+  a.
+    * '``(FOO ,@',@S)
+    ``(FOO SB-IMPL::BACKQ-COMMA-AT S)
+
+  b.
+    * (write '`(, .ala.) :readably t :pretty t)
+    `(,.ALA.)
+
+  (note the space between the comma and the point)

 
 143:
   (reported by Jesse Bouwman 2001-10-24 through the unfortunately
 
 143:
   (reported by Jesse Bouwman 2001-10-24 through the unfortunately

@@ -724,11 +716,6 @@ WORKAROUND:
   expansion, leaving garbage consisting of infinished blocks of the
   partially converted function.)
 
   expansion, leaving garbage consisting of infinished blocks of the
   partially converted function.)
 

-157:
-  Functions SUBTYPEP, TYPEP, UPGRADED-ARRAY-ELEMENT-TYPE, and 
-  UPGRADED-COMPLEX-PART-TYPE should have an optional environment argument.
-  (reported by Alexey Dejneka sbcl-devel 2002-04-12)
-

 162:
   (reported by Robert E. Brown 2002-04-16) 
   When a function is called with too few arguments, causing the
 162:
   (reported by Robert E. Brown 2002-04-16) 
   When a function is called with too few arguments, causing the

@@ -778,19 +765,6 @@ WORKAROUND:
   code. Since then the warning has been downgraded to STYLE-WARNING, 
   so it's still a bug but at least it's a little less annoying.
 
   code. Since then the warning has been downgraded to STYLE-WARNING, 
   so it's still a bug but at least it's a little less annoying.
 

-178: "AVER failure compiling confused THEs in FUNCALL"
-  In sbcl-0.7.4.24, compiling
-    (defun bug178 (x)
-      (funcall (the function (the standard-object x))))
-  gives
-    failed AVER:
-      "(AND (EQ (IR2-CONTINUATION-PRIMITIVE-TYPE 2CONT) FUNCTION-PTYPE) (EQ CHECK T))"
-  This variant compiles OK, though:
-    (defun bug178alternative (x)
-      (funcall (the nil x)))
-
-  (since 0.7.8.9 it does not signal an error; see also bug 199)
-

 183: "IEEE floating point issues"
   Even where floating point handling is being dealt with relatively
   well (as of sbcl-0.7.5, on sparc/sunos and alpha; see bug #146), the
 183: "IEEE floating point issues"
   Even where floating point handling is being dealt with relatively
   well (as of sbcl-0.7.5, on sparc/sunos and alpha; see bug #146), the

@@ -953,6 +927,11 @@ WORKAROUND:
 
      (see bug 203)
 
 
      (see bug 203)
 

+  c. (defun foo (x y)
+       (locally (declare (type fixnum x y))
+         (+ x (* 2 y))))
+     (foo 1.1 2) => 5.1
+

 194: "no error from (THE REAL '(1 2 3)) in some cases"
   fixed parts:
     a. In sbcl-0.7.7.9, 
 194: "no error from (THE REAL '(1 2 3)) in some cases"
   fixed parts:
     a. In sbcl-0.7.7.9, 

@@ -989,27 +968,9 @@ WORKAROUND:
        inaccurate transformations.
     * Alexey Dejneka pointed out that
        (IGNORE-ERRORS (IDENTITY (THE REAL '(1 2 3))))
        inaccurate transformations.
     * Alexey Dejneka pointed out that
        (IGNORE-ERRORS (IDENTITY (THE REAL '(1 2 3))))

-      works as it should. Also
+      and

        (IGNORE-ERRORS (VALUES (THE REAL '(1 2 3))))
        (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)
+      work as they should.

 
 201: "Incautious type inference from compound CONS types"
   (reported by APD sbcl-devel 2002-09-17)
 
 201: "Incautious type inference from compound CONS types"
   (reported by APD sbcl-devel 2002-09-17)

@@ -1198,73 +1159,140 @@ WORKAROUND:
     (the integer (helper))
     nil)
 
     (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)))
-  (the LOCALY there is not a typo; any unknown function (e.g. FROB)
-  will do).
-
-228: "function-lambda-expression problems"
-  in sbcl-0.7.9.6x, from the REPL:
-    * (progn (declaim (inline foo)) (defun foo (x) x))
-    FOO
-    * (function-lambda-expression #'foo)
-    (SB-C:LAMBDA-WITH-LEXENV NIL NIL NIL (X) (BLOCK FOO X)), NIL, FOO
-  but this first return value is not suitable for input to FUNCTION or
-  COMPILE, as required by ANSI.
+  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.

 
 229:
   (subtypep 'function '(function)) => nil, t.
 
 
 229:
   (subtypep 'function '(function)) => nil, t.
 

-230:
-  (fixed in 0.7.10.5)
+231: "SETQ does not correctly check the type of a variable being set"
+  b.
+    (defun foo (x z)
+      (declare (type integer x))
+      (locally (declare (type (real 1) x))
+        (setq x z))
+      (list x z))
+    (foo 0 0) => (0 0).
+
+  (fixed in 0.7.12.8)
+
+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
+
+234:
+  (fixed in sbcl-0.7.10.36)
+
+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.
+
+  b. (reported by brown on #lisp 2003-01-21)
+
+    (defun find-it (x)
+      (declare (optimize (speed 3) (safety 0)))
+      (declare (notinline mapcar))
+      (let ((z (mapcar #'car x)))
+        (find 'foobar z)))
+
+  Without (DECLARE (NOTINLINE MAPCAR)), Python cannot derive that Z is
+  LIST.
+
+236: "THE semantics is broken"
+
+  (defun foo (a f)
+    (declare (optimize (speed 2) (safety 0)))
+    (+ 1d0
+       (the double-float
+         (multiple-value-prog1
+             (svref a 0)
+           (unless f (return-from foo 0))))))
+
+  (foo #(4) nil) => SEGV
+
+  VOP selection thinks that in unsafe code result type assertions
+  should be valid immediately. (See also bug 233a.)
+
+  The similar problem exists for TRULY-THE.
+
+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.
+
+239:
+  Since 0.7.0:
+  (defun foo (bit-array-2 &optional result-bit-array)
+    (declare (type (array bit) bit-array-2)
+             (type (or (array bit) (member t nil)) result-bit-array))
+    (unless (simple-bit-vector-p bit-array-2)
+      (multiple-value-call
+          (lambda (data1 start1)
+            (multiple-value-call
+                (lambda (data2 start2)
+                  (multiple-value-call
+                      (lambda (data3 start3)
+                        (declare (ignore start3))
+                        (print (list data1 data2)))
+                    (values 0 0)))
+              (values bit-array-2 0)))
+        (values 444 0))))
+
+  Then (foo (make-array 4 :element-type 'bit :adjustable t) nil)
+  must return the same value as it prints, but it returns random garbage.

 
 DEFUNCT CATEGORIES OF BUGS
   IR1-#:
 
 DEFUNCT CATEGORIES OF BUGS
   IR1-#: