+ This is probably the same bug as 162
+
+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.)
+
+233: bugs in constraint propagation
+ 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
+
+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.
+ As of sbcl-0.9.0.36, this is solved for fd-streams, so is less of a
+ problem in practice. (Fully fixing this would require adding a
+ ansi-stream-n-bout slot and associated methods to write a byte
+ sequence to ansi-stream, similar to the existing ansi-stream-sout
+ slot/functions.)
+
+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
+ b. On X86 operand size prefix is not recognized.
+
+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.
+
+ This is a problem because the compiler emits optimization notes when
+ you use a non-simple array, and without a type specifier for hairy
+ array types, there's no good way to tell it you're doing it
+ intentionally so that it should shut up and just compile the code.
+
+ Another problem is confusing error message "asserted type ARRAY
+ conflicts with derived type (VALUES SIMPLE-VECTOR &OPTIONAL)" during
+ compiling (LAMBDA (V) (VALUES (SVREF V 0) (VECTOR-POP V))).
+
+ The last problem is that when type assertions are converted to type
+ checks, types are represented with type specifiers, so we could lose
+ complex attribute. (Now this is probably not important, because
+ currently checks for complex arrays seem to be performed by
+ callees.)
+
+259:
+ (compile nil '(lambda () (aref (make-array 0) 0))) compiles without
+ warning. Analogous cases with the index and length being equal and
+ greater than 0 are warned for; the problem here seems to be that the
+ type required for an array reference of this type is (INTEGER 0 (0))
+ which is canonicalized to NIL.
+
+260:
+ a.
+ (let* ((s (gensym))
+ (t1 (specifier-type s)))
+ (eval `(defstruct ,s))
+ (type= t1 (specifier-type s)))
+ => NIL, NIL
+
+ (fixed in 0.8.1.24)
+
+ b. The same for CSUBTYPEP.
+
+262: "yet another bug in inline expansion of local functions"
+ During inline expansion of a local function Python can try to
+ reference optimized away objects (functions, variables, CTRANs from
+ tags and blocks), which later may lead to problems. Some of the
+ cases are worked around by forbidding expansion in such cases, but
+ the better way would be to reimplement inline expansion by copying
+ IR1 structures.
+
+266:
+ David Lichteblau provided (sbcl-devel 2003-06-01) a patch to fix
+ behaviour of streams with element-type (SIGNED-BYTE 8). The patch
+ looks reasonable, if not obviously correct; however, it caused the
+ PPC/Linux port to segfault during warm-init while loading
+ src/pcl/std-class.fasl. A workaround patch was made, but it would
+ be nice to understand why the first patch caused problems, and to
+ fix the cause if possible.
+
+268: "wrong free declaration scope"
+ The following code must signal type error:
+
+ (locally (declare (optimize (safety 3)))
+ (flet ((foo (x &optional (y (car x)))
+ (declare (optimize (safety 0)))
+ (list x y)))
+ (funcall (eval #'foo) 1)))
+
+270:
+ In the following function constraint propagator optimizes nothing:
+
+ (defun foo (x)
+ (declare (integer x))
+ (declare (optimize speed))
+ (typecase x
+ (fixnum "hala")
+ (fixnum "buba")
+ (bignum "hip")
+ (t "zuz")))
+
+273:
+ Compilation of the following two forms causes "X is unbound" error:
+
+ (symbol-macrolet ((x pi))
+ (macrolet ((foo (y) (+ x y)))
+ (declaim (inline bar))
+ (defun bar (z)
+ (* z (foo 4)))))
+ (defun quux (z)
+ (bar z))
+
+ (See (COERCE (CDR X) 'FUNCTION) in IR1-CONVERT-INLINE-LAMBDA.)
+
+274:
+ CLHS says that type declaration of a symbol macro should not affect
+ its expansion, but in SBCL it does. (If you like magic and want to
+ fix it, don't forget to change all uses of MACROEXPAND to
+ MACROEXPAND*.)
+
+275:
+ The following code (taken from CLOCC) takes a lot of time to compile:
+
+ (defun foo (n)
+ (declare (type (integer 0 #.large-constant) n))
+ (expt 1/10 n))
+
+ (fixed in 0.8.2.51, but a test case would be good)
+
+276:
+ b. The same as in a., but using MULTIPLE-VALUE-SETQ instead of SETQ.
+ c. (defvar *faa*)
+ (defmethod faa ((*faa* double-float))
+ (set '*faa* (when (< *faa* 0) (- *faa*)))
+ (1+ *faa*))
+ (faa 1d0) => type error
+
+278:
+ a.
+ (defun foo ()
+ (declare (optimize speed))
+ (loop for i of-type (integer 0) from 0 by 2 below 10
+ collect i))
+
+ uses generic arithmetic.
+
+ b. (fixed in 0.8.3.6)
+
+279: type propagation error -- correctly inferred type goes astray?
+ In sbcl-0.8.3 and sbcl-0.8.1.47, the warning
+ The binding of ABS-FOO is a (VALUES (INTEGER 0 0)
+ &OPTIONAL), not a (INTEGER 1 536870911)
+ is emitted when compiling this file:
+ (declaim (ftype (function ((integer 0 #.most-positive-fixnum))
+ (integer #.most-negative-fixnum 0))
+ foo))
+ (defun foo (x)
+ (- x))
+ (defun bar (x)
+ (let* (;; Uncomment this for a type mismatch warning indicating
+ ;; that the type of (FOO X) is correctly understood.
+ #+nil (fs-foo (float-sign (foo x)))
+ ;; Uncomment this for a type mismatch warning
+ ;; indicating that the type of (ABS (FOO X)) is
+ ;; correctly understood.
+ #+nil (fs-abs-foo (float-sign (abs (foo x))))
+ ;; something wrong with this one though
+ (abs-foo (abs (foo x))))
+ (declare (type (integer 1 100) abs-foo))
+ (print abs-foo)))
+
+ (see also bug 117)
+
+283: Thread safety: libc functions
+ There are places that we call unsafe-for-threading libc functions
+ that we should find alternatives for, or put locks around. Known or
+ strongly suspected problems, as of 0.8.3.10: please update this
+ bug instead of creating new ones
+
+ localtime() - called for timezone calculations in code/time.lisp
+
+284: Thread safety: special variables
+ There are lots of special variables in SBCL, and I feel sure that at
+ least some of them are indicative of potentially thread-unsafe
+ parts of the system. See doc/internals/notes/threading-specials
+
+286: "recursive known functions"
+ Self-call recognition conflicts with known function
+ recognition. Currently cross compiler and target COMPILE do not
+ recognize recursion, and in target compiler it can be disabled. We
+ can always disable it for known functions with RECURSIVE attribute,
+ but there remains a possibility of a function with a
+ (tail)-recursive simplification pass and transforms/VOPs for base
+ cases.
+
+287: PPC/Linux miscompilation or corruption in first GC
+ When the runtime is compiled with -O3 on certain PPC/Linux machines, a
+ segmentation fault is reported at the point of first triggered GC,
+ during the compilation of DEFSTRUCT WRAPPER. As a temporary workaround,
+ the runtime is no longer compiled with -O3 on PPC/Linux, but it is likely
+ that this merely obscures, not solves, the underlying problem; as and when
+ underlying problems are fixed, it would be worth trying again to provoke
+ this problem.
+
+288: fundamental cross-compilation issues (from old UGLINESS file)
+ Using host floating point numbers to represent target floating point
+ numbers, or host characters to represent target characters, is
+ theoretically shaky. (The characters are OK as long as the characters
+ are in the ANSI-guaranteed character set, though, so they aren't a
+ real problem as long as the sources don't need anything but that;
+ the floats are a real problem.)
+
+289: "type checking and source-transforms"
+ a.
+ (block nil (let () (funcall #'+ (eval 'nil) (eval '1) (return :good))))
+ signals type error.
+
+ Our policy is to check argument types at the moment of a call. It
+ disagrees with ANSI, which says that type assertions are put
+ immediately onto argument expressions, but is easier to implement in
+ IR1 and is more compatible to type inference, inline expansion,
+ etc. IR1-transforms automatically keep this policy, but source
+ transforms for associative functions (such as +), being applied
+ during IR1-convertion, do not. It may be tolerable for direct calls
+ (+ x y z), but for (FUNCALL #'+ x y z) it is non-conformant.
+
+ b. Another aspect of this problem is efficiency. [x y + z +]
+ requires less registers than [x y z + +]. This transformation is
+ currently performed with source transforms, but it would be good to
+ also perform it in IR1 optimization phase.
+
+290: Alpha floating point and denormalized traps
+ In SBCL 0.8.3.6x on the alpha, we work around what appears to be a
+ hardware or kernel deficiency: the status of the enable/disable
+ denormalized-float traps bit seems to be ambiguous; by the time we
+ get to os_restore_fp_control after a trap, denormalized traps seem
+ to be enabled. Since we don't want a trap every time someone uses a
+ denormalized float, in general, we mask out that bit when we restore
+ the control word; however, this clobbers any change the user might
+ have made.
+
+296:
+ (reported by Adam Warner, sbcl-devel 2003-09-23)
+
+ The --load toplevel argument does not perform any sanitization of its
+ argument. As a result, files with Lisp pathname pattern characters
+ (#\* or #\?, for instance) or quotation marks can cause the system
+ to perform arbitrary behaviour.
+
+297:
+ LOOP with non-constant arithmetic step clauses suffers from overzealous
+ type constraint: code of the form
+ (loop for d of-type double-float from 0d0 to 10d0 by x collect d)
+ compiles to a type restriction on X of (AND DOUBLE-FLOAT (REAL
+ (0))). However, an integral value of X should be legal, because
+ successive adds of integers to double-floats produces double-floats,
+ so none of the type restrictions in the code is violated.
+
+300: (reported by Peter Graves) Function PEEK-CHAR checks PEEK-TYPE
+ argument type only after having read a character. This is caused
+ with EXPLICIT-CHECK attribute in DEFKNOWN. The similar problem
+ exists with =, /=, <, >, <=, >=. They were fixed, but it is probably
+ less error prone to have EXPLICIT-CHECK be a local declaration,
+ being put into the definition, instead of an attribute being kept in
+ a separate file; maybe also put it into SB-EXT?
+
+301: ARRAY-SIMPLE-=-TYPE-METHOD breaks on corner cases which can arise
+ in NOTE-ASSUMED-TYPES
+ In sbcl-0.8.7.32, compiling the file
+ (defun foo (x y)
+ (declare (type integer x))
+ (declare (type (vector (or hash-table bit)) y))
+ (bletch 2 y))
+ (defun bar (x y)
+ (declare (type integer x))
+ (declare (type (simple-array base (2)) y))
+ (bletch 1 y))
+ gives the error
+ failed AVER: "(NOT (AND (NOT EQUALP) CERTAINP))"
+
+303: "nonlinear LVARs" (aka MISC.293)
+ (defun buu (x)
+ (multiple-value-call #'list
+ (block foo
+ (multiple-value-prog1
+ (eval '(values :a :b :c))
+ (catch 'bar
+ (if (> x 0)
+ (return-from foo
+ (eval `(if (> ,x 1)
+ 1
+ (throw 'bar (values 3 4)))))))))))
+
+ (BUU 1) returns garbage.
+
+ The problem is that both EVALs sequentially write to the same LVAR.
+
+306: "Imprecise unions of array types"
+ a.(defun foo (x)
+ (declare (optimize speed)
+ (type (or (array cons) (array vector)) x))
+ (elt (aref x 0) 0))
+ (foo #((0))) => TYPE-ERROR
+
+ relatedly,
+
+ b.(subtypep
+ 'array
+ `(or
+ ,@(loop for x across sb-vm:*specialized-array-element-type-properties*
+ collect `(array ,(sb-vm:saetp-specifier x)))))
+ => NIL, T (when it should be T, T)
+
+309: "Dubious values for implementation limits"
+ (reported by Bruno Haible sbcl-devel "Incorrect value of
+ multiple-values-limit" 2004-04-19)
+ (values-list (make-list 1000000)), on x86/linux, signals a stack
+ exhaustion condition, despite MULTIPLE-VALUES-LIMIT being
+ significantly larger than 1000000. There are probably similar
+ dubious values for CALL-ARGUMENTS-LIMIT (see cmucl-help/cmucl-imp
+ around the same time regarding a call to LIST on sparc with 1000
+ arguments) and other implementation limit constants.
+
+311: "Tokeniser not thread-safe"
+ (see also Robert Marlow sbcl-help "Multi threaded read chucking a
+ spak" 2004-04-19)
+ The tokenizer's use of *read-buffer* and *read-buffer-length* causes
+ spurious errors should two threads attempt to tokenise at the same
+ time.
+
+314: "LOOP :INITIALLY clauses and scope of initializers"
+ reported by Bruno Haible sbcl-devel "various SBCL bugs" from CLISP
+ test suite, originally by Thomas F. Burdick.
+ ;; <http://www.lisp.org/HyperSpec/Body/sec_6-1-7-2.html>
+ ;; According to the HyperSpec 6.1.2.1.4, in for-as-equals-then, var is
+ ;; initialized to the result of evaluating form1. 6.1.7.2 says that
+ ;; initially clauses are evaluated in the loop prologue, which precedes all
+ ;; loop code except for the initial settings provided by with, for, or as.
+ (loop :for x = 0 :then (1+ x)
+ :for y = (1+ x) :then (ash y 1)
+ :for z :across #(1 3 9 27 81 243)
+ :for w = (+ x y z)
+ :initially (assert (zerop x)) :initially (assert (= 2 w))
+ :until (>= w 100) :collect w)
+ Expected: (2 6 15 38)
+ Got: ERROR
+
+318: "stack overflow in compiler warning with redefined class"
+ reported by Bruno Haible sbcl-devel "various SBCL bugs" from CLISP
+ test suite.
+ (defstruct foo a)
+ (setf (find-class 'foo) nil)
+ (defstruct foo slot-1)
+ This used to give a stack overflow from within the printer, which has
+ been fixed as of 0.8.16.11. Current result:
+ ; caught ERROR:
+ ; can't compile TYPEP of anonymous or undefined class:
+ ; #<SB-KERNEL:STRUCTURE-CLASSOID FOO>
+ ...
+ debugger invoked on a TYPE-ERROR in thread 19973:
+ The value NIL is not of type FUNCTION.
+
+ CSR notes: it's not really clear what it should give: is (SETF FIND-CLASS)
+ meant to be enough to delete structure classes from the system?
+
+319: "backquote with comma inside array"
+ reported by Bruno Haible sbcl-devel "various SBCL bugs" from CLISP
+ test suite.
+ (read-from-string "`#1A(1 2 ,(+ 2 2) 4)")
+ gives
+ #(1 2 ((SB-IMPL::|,|) + 2 2) 4)
+ which probably isn't intentional.
+
+323: "REPLACE, BIT-BASH and large strings"
+ The transform for REPLACE on simple-base-strings uses BIT-BASH, which
+ at present has an upper limit in size. Consequently, in sbcl-0.8.10
+ (defun foo ()
+ (declare (optimize speed (safety 1)))
+ (let ((x (make-string 140000000))
+ (y (make-string 140000000)))
+ (length (replace x y))))
+ (foo)
+ gives
+ debugger invoked on a TYPE-ERROR in thread 2412:
+ The value 1120000000 is not of type (MOD 536870911).
+ (see also "more and better sequence transforms" sbcl-devel 2004-05-10)
+
+324: "STREAMs and :ELEMENT-TYPE with large bytesize"
+ In theory, (open foo :element-type '(unsigned-byte <x>)) should work
+ for all positive integral <x>. At present, it only works for <x> up
+ to about 1024 (and similarly for signed-byte), so
+ (open "/dev/zero" :element-type '(unsigned-byte 1025))
+ gives an error in sbcl-0.8.10.
+
+325: "CLOSE :ABORT T on supeseding streams"
+ Closing a stream opened with :IF-EXISTS :SUPERSEDE with :ABORT T leaves no
+ file on disk, even if one existed before opening.
+
+ The illegality of this is not crystal clear, as the ANSI dictionary
+ entry for CLOSE says that when :ABORT is T superseded files are not
+ superseded (ie. the original should be restored), whereas the OPEN
+ entry says about :IF-EXISTS :SUPERSEDE "If possible, the
+ implementation should not destroy the old file until the new stream
+ is closed." -- implying that even though undesirable, early deletion
+ is legal. Restoring the original would none the less be the polite
+ thing to do.
+
+326: "*PRINT-CIRCLE* crosstalk between streams"
+ In sbcl-0.8.10.48 it's possible for *PRINT-CIRCLE* references to be
+ mixed between streams when output operations are intermingled closely
+ enough (as by doing output on S2 from within (PRINT-OBJECT X S1) in the
+ test case below), so that e.g. the references #2# appears on a stream
+ with no preceding #2= on that stream to define it (because the #2= was
+ sent to another stream).
+ (cl:in-package :cl-user)
+ (defstruct foo index)
+ (defparameter *foo* (make-foo :index 4))
+ (defstruct bar)
+ (defparameter *bar* (make-bar))
+ (defparameter *tangle* (list *foo* *bar* *foo*))
+ (defmethod print-object ((foo foo) stream)
+ (let ((index (foo-index foo)))
+ (format *trace-output*
+ "~&-$- emitting FOO ~D, ambient *BAR*=~S~%"
+ index *bar*)
+ (format stream "[FOO ~D]" index))
+ foo)
+ (let ((tsos (make-string-output-stream))
+ (ssos (make-string-output-stream)))
+ (let ((*print-circle* t)
+ (*trace-output* tsos)
+ (*standard-output* ssos))
+ (prin1 *tangle* *standard-output*))
+ (let ((string (get-output-stream-string ssos)))
+ (unless (string= string "(#1=[FOO 4] #S(BAR) #1#)")
+ ;; In sbcl-0.8.10.48 STRING was "(#1=[FOO 4] #2# #1#)".:-(
+ (error "oops: ~S" string)))))
+ It might be straightforward to fix this by turning the
+ *CIRCULARITY-HASH-TABLE* and *CIRCULARITY-COUNTER* variables into
+ per-stream slots, but (1) it would probably be sort of messy faking
+ up the special variable binding semantics using UNWIND-PROTECT and
+ (2) it might be sort of a pain to test that no other bugs had been
+ introduced.
+
+328: "Profiling generic functions", transplanted from #241
+ (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."
+
+ Problem: when a generic function is profiled, it appears as an ordinary
+ function to PCL. (Remembering the uninterned accessor is OK, as the
+ redefinition must be able to remove old accessors from their generic
+ functions.)
+
+329: "Sequential class redefinition"
+ reported by Bruno Haible:
+ (defclass reactor () ((max-temp :initform 10000000)))
+ (defvar *r1* (make-instance 'reactor))
+ (defvar *r2* (make-instance 'reactor))
+ (slot-value *r1* 'max-temp)
+ (slot-value *r2* 'max-temp)
+ (defclass reactor () ((uptime :initform 0)))
+ (slot-value *r1* 'uptime)
+ (defclass reactor () ((uptime :initform 0) (max-temp :initform 10000)))
+ (slot-value *r1* 'max-temp) ; => 10000
+ (slot-value *r2* 'max-temp) ; => 10000000 oops...
+
+ Possible solution:
+ The method effective when the wrapper is obsoleted can be saved
+ in the wrapper, and then to update the instance just run through
+ all the old wrappers in order from oldest to newest.
+
+332: "fasl stack inconsistency in structure redefinition"
+ (reported by Tim Daly Jr sbcl-devel 2004-05-06)
+ Even though structure redefinition is undefined by the standard, the
+ following behaviour is suboptimal: running
+ (defun stimulate-sbcl ()
+ (let ((filename (format nil "/tmp/~A.lisp" (gensym))))
+ ;;create a file which redefines a structure incompatibly
+ (with-open-file (f filename :direction :output :if-exists :supersede)
+ (print '(defstruct astruct foo) f)
+ (print '(defstruct astruct foo bar) f))
+ ;;compile and load the file, then invoke the continue restart on
+ ;;the structure redefinition error
+ (handler-bind ((error (lambda (c) (continue c))))
+ (load (compile-file filename)))))
+ (stimulate-sbcl)
+ and choosing the CONTINUE restart yields the message
+ debugger invoked on a SB-INT:BUG in thread 27726:
+ fasl stack not empty when it should be
+
+336: "slot-definitions must retain the generic functions of accessors"
+ reported by Tony Martinez:
+ (defclass foo () ((bar :reader foo-bar)))
+ (defun foo-bar (x) x)
+ (defclass foo () ((bar :reader get-bar))) ; => error, should work
+
+ Note: just punting the accessor removal if the fdefinition
+ is not a generic function is not enough:
+
+ (defclass foo () ((bar :reader foo-bar)))
+ (defvar *reader* #'foo-bar)
+ (defun foo-bar (x) x)
+ (defclass foo () ((bar :initform 'ok :reader get-bar)))
+ (funcall *reader* (make-instance 'foo)) ; should be an error, since
+ ; the method must be removed
+ ; by the class redefinition
+
+ Fixing this should also fix a subset of #328 -- update the
+ description with a new test-case then.
+
+337: MAKE-METHOD and user-defined method classes
+ (reported by Bruno Haible sbcl-devel 2004-06-11)
+
+ In the presence of
+
+(defclass user-method (standard-method) (myslot))
+(defmacro def-user-method (name &rest rest)
+ (let* ((lambdalist-position (position-if #'listp rest))
+ (qualifiers (subseq rest 0 lambdalist-position))
+ (lambdalist (elt rest lambdalist-position))
+ (body (subseq rest (+ lambdalist-position 1)))
+ (required-part
+ (subseq lambdalist 0 (or
+ (position-if
+ (lambda (x) (member x lambda-list-keywords))
+ lambdalist)
+ (length lambdalist))))
+ (specializers (mapcar #'find-class
+ (mapcar (lambda (x) (if (consp x) (second x) t))
+ required-part)))
+ (unspecialized-required-part
+ (mapcar (lambda (x) (if (consp x) (first x) x)) required-part))
+ (unspecialized-lambdalist
+ (append unspecialized-required-part
+ (subseq lambdalist (length required-part)))))
+ `(PROGN
+ (ADD-METHOD #',name
+ (MAKE-INSTANCE 'USER-METHOD
+ :QUALIFIERS ',qualifiers
+ :LAMBDA-LIST ',unspecialized-lambdalist
+ :SPECIALIZERS ',specializers
+ :FUNCTION
+ (LAMBDA (ARGUMENTS NEXT-METHODS-LIST)
+ (FLET ((NEXT-METHOD-P () NEXT-METHODS-LIST)
+ (CALL-NEXT-METHOD (&REST NEW-ARGUMENTS)
+ (UNLESS NEW-ARGUMENTS (SETQ NEW-ARGUMENTS ARGUMENTS))
+ (IF (NULL NEXT-METHODS-LIST)
+ (ERROR "no next method for arguments ~:S" ARGUMENTS)
+ (FUNCALL (SB-PCL:METHOD-FUNCTION
+ (FIRST NEXT-METHODS-LIST))
+ NEW-ARGUMENTS (REST NEXT-METHODS-LIST)))))
+ (APPLY #'(LAMBDA ,unspecialized-lambdalist ,@body) ARGUMENTS)))))
+ ',name)))
+
+ (progn
+ (defgeneric test-um03 (x))
+ (defmethod test-um03 ((x integer))
+ (list* 'integer x (not (null (next-method-p))) (call-next-method)))
+ (def-user-method test-um03 ((x rational))
+ (list* 'rational x (not (null (next-method-p))) (call-next-method)))
+ (defmethod test-um03 ((x real))
+ (list 'real x (not (null (next-method-p)))))
+ (test-um03 17))
+ works, but
+
+ a.(progn
+ (defgeneric test-um10 (x))
+ (defmethod test-um10 ((x integer))
+ (list* 'integer x (not (null (next-method-p))) (call-next-method)))
+ (defmethod test-um10 ((x rational))
+ (list* 'rational x (not (null (next-method-p))) (call-next-method)))
+ (defmethod test-um10 ((x real))
+ (list 'real x (not (null (next-method-p)))))
+ (defmethod test-um10 :after ((x real)))
+ (def-user-method test-um10 :around ((x integer))
+ (list* 'around-integer x
+ (not (null (next-method-p))) (call-next-method)))
+ (defmethod test-um10 :around ((x rational))
+ (list* 'around-rational x
+ (not (null (next-method-p))) (call-next-method)))
+ (defmethod test-um10 :around ((x real))
+ (list* 'around-real x (not (null (next-method-p))) (call-next-method)))
+ (test-um10 17))
+ fails with a type error, and
+
+ b.(progn
+ (defgeneric test-um12 (x))
+ (defmethod test-um12 ((x integer))
+ (list* 'integer x (not (null (next-method-p))) (call-next-method)))
+ (defmethod test-um12 ((x rational))
+ (list* 'rational x (not (null (next-method-p))) (call-next-method)))
+ (defmethod test-um12 ((x real))
+ (list 'real x (not (null (next-method-p)))))
+ (defmethod test-um12 :after ((x real)))
+ (defmethod test-um12 :around ((x integer))
+ (list* 'around-integer x
+ (not (null (next-method-p))) (call-next-method)))
+ (defmethod test-um12 :around ((x rational))
+ (list* 'around-rational x
+ (not (null (next-method-p))) (call-next-method)))
+ (def-user-method test-um12 :around ((x real))
+ (list* 'around-real x (not (null (next-method-p))) (call-next-method)))
+ (test-um12 17))
+ fails with NO-APPLICABLE-METHOD.
+
+339: "DEFINE-METHOD-COMBINATION bugs"
+ (reported by Bruno Haible via the clisp test suite)
+
+ a. Syntax checking laxity (should produce errors):
+ i. (define-method-combination foo :documentation :operator)
+ ii. (define-method-combination foo :documentation nil)
+ iii. (define-method-combination foo nil)
+ iv. (define-method-combination foo nil nil
+ (:arguments order &aux &key))
+ v. (define-method-combination foo nil nil (:arguments &whole))
+ vi. (define-method-combination foo nil nil (:generic-function))
+ vii. (define-method-combination foo nil nil (:generic-function bar baz))
+ viii. (define-method-combination foo nil nil (:generic-function (bar)))
+ ix. (define-method-combination foo nil ((3)))
+ x. (define-method-combination foo nil ((a)))
+
+ b. define-method-combination arguments lambda list badness
+ i. &aux args are currently unsupported;
+ ii. default values of &optional and &key arguments are ignored;
+ iii. supplied-p variables for &optional and &key arguments are not
+ bound.
+
+ c. qualifier matching incorrect
+ (progn
+ (define-method-combination mc27 ()
+ ((normal ())
+ (ignored (:ignore :unused)))
+ `(list 'result
+ ,@(mapcar #'(lambda (method) `(call-method ,method)) normal)))
+ (defgeneric test-mc27 (x)
+ (:method-combination mc27)
+ (:method :ignore ((x number)) (/ 0)))
+ (test-mc27 7))
+
+ should signal an invalid-method-error, as the :IGNORE (NUMBER)
+ method is applicable, and yet matches neither of the method group
+ qualifier patterns.
+
+341: PPRINT-LOGICAL-BLOCK / PPRINT-FILL / PPRINT-LINEAR sharing detection.
+ (from Paul Dietz' test suite)
+
+ CLHS on PPRINT-LINEAR and PPRINT-FILL (and PPRINT-TABULAR, though
+ that's slightly different) states that these functions perform
+ circular and shared structure detection on their object. Therefore,
+
+ a.(let ((*print-circle* t))
+ (pprint-linear *standard-output* (let ((x '(a))) (list x x))))
+ should print "(#1=(A) #1#)"
+
+ b.(let ((*print-circle* t))
+ (pprint-linear *standard-output*
+ (let ((x (cons nil nil))) (setf (cdr x) x) x)))
+ should print "#1=(NIL . #1#)"
+
+ (it is likely that the fault lies in PPRINT-LOGICAL-BLOCK, as
+ suggested by the suggested implementation of PPRINT-TABULAR)
+
+343: MOP:COMPUTE-DISCRIMINATING-FUNCTION overriding causes error
+ Even the simplest possible overriding of
+ COMPUTE-DISCRIMINATING-FUNCTION, suggested in the PCL implementation
+ as "canonical", does not work:
+ (defclass my-generic-function (standard-generic-function) ()
+ (:metaclass funcallable-standard-class))
+ (defmethod compute-discriminating-function ((gf my-generic-function))
+ (let ((dfun (call-next-method)))
+ (lambda (&rest args)
+ (apply dfun args))))
+ (defgeneric foo (x)
+ (:generic-function-class my-generic-function))
+ (defmethod foo (x) (+ x x))
+ (foo 5)
+ signals an error. This error is the same even if the LAMBDA is
+ replaced by (FUNCTION (SB-KERNEL:INSTANCE-LAMBDA ...)). Maybe the
+ SET-FUNCALLABLE-INSTANCE-FUN scary stuff in
+ src/code/target-defstruct.lisp is broken? This seems to be broken
+ in CMUCL 18e, so it's not caused by a recent change.
+
+344: more (?) ROOM T problems (possibly part of bug 108)
+ In sbcl-0.8.12.51, and off and on leading up to it, the
+ SB!VM:MEMORY-USAGE operations in ROOM T caused
+ unhandled condition (of type SB-INT:BUG):
+ failed AVER: "(SAP= CURRENT END)"
+ Several clever people have taken a shot at this without fixing
+ it; this time around (before sbcl-0.8.13 release) I (WHN) just
+ commented out the SB!VM:MEMORY-USAGE calls until someone figures
+ out how to make them work reliably with the rest of the GC.
+
+ (Note: there's at least one dubious thing in room.lisp: see the
+ comment in VALID-OBJ)
+
+346: alpha backtrace
+ In sbcl-0.8.13, all backtraces from errors caused by internal errors
+ on the alpha seem to have a "bogus stack frame".
+
+349: PPRINT-INDENT rounding implementation decisions
+ At present, pprint-indent (and indeed the whole pretty printer)
+ more-or-less assumes that it's using a monospace font. That's
+ probably not too silly an assumption, but one piece of information
+ the current implementation loses is from requests to indent by a
+ non-integral amount. As of sbcl-0.8.15.9, the system silently
+ truncates the indentation to an integer at the point of request, but
+ maybe the non-integral value should be propagated through the
+ pprinter and only truncated at output? (So that indenting by 1/2
+ then 3/2 would indent by two spaces, not one?)
+
+352: forward-referenced-class trouble
+ reported by Bruno Haible on sbcl-devel
+ (defclass c (a) ())
+ (setf (class-name (find-class 'a)) 'b)
+ (defclass a () (x))
+ (defclass b () (y))
+ (make-instance 'c)
+ Expected: an instance of c, with a slot named x
+ Got: debugger invoked on a SIMPLE-ERROR in thread 78906:
+ While computing the class precedence list of the class named C.
+ The class named B is a forward referenced class.
+ The class named B is a direct superclass of the class named C.
+
+353: debugger suboptimalities on x86
+ On x86 backtraces for undefined functions start with a bogus stack
+ frame, and backtraces for throws to unknown catch tags with a "no
+ debug information" frame. These are both due to CODE-COMPONENT-FROM-BITS
+ (used on non-x86 platforms) being a more complete solution then what
+ is done on x86.
+
+ On x86/linux large portions of tests/debug.impure.lisp have been commented
+ out as failures. The probable culprit for these problems is in x86-call-context
+ (things work fine on x86/freebsd).
+
+ More generally, the debugger internals suffer from excessive x86/non-x86
+ conditionalization and OAOOMization: refactoring the common parts would
+ be good.
+
+354: XEPs in backtraces
+ Under default compilation policy
+ (defun test ()
+ (throw :unknown t))
+ (test)
+ Has the XEP for TEST in the backtrace, not the TEST frame itself.
+ (sparc and x86 at least)
+
+ Since SBCL 0.8.20.1 this is hidden unless *SHOW-ENTRY-POINT-DETAILS*
+ is true (instead there appear two TEST frames at least on ppc). The
+ underlying cause seems to be that SB-C::TAIL-ANNOTATE will not merge
+ the tail-call for the XEP, since Python has by that time proved that
+ the function can never return; same happens if the function holds an
+ unconditional call to ERROR.
+
+355: change-class of generic-function
+ (reported by Bruno Haible)
+ The MOP doesn't support change-class on a generic-function. However, SBCL
+ apparently supports it, since it doesn't give an error or warning when doing
+ so so. Then, however, it produces wrong results for calls to this generic
+ function.
+ ;;; The effective-methods cache:
+ (progn
+ (defgeneric testgf35 (x))
+ (defmethod testgf35 ((x integer))
+ (cons 'integer (if (next-method-p) (call-next-method))))
+ (defmethod testgf35 ((x real))
+ (cons 'real (if (next-method-p) (call-next-method))))
+ (defclass customized5-generic-function (standard-generic-function)
+ ()
+ (:metaclass sb-pcl:funcallable-standard-class))
+ (defmethod sb-pcl:compute-effective-method ((gf customized5-generic-function) method-combination methods)
+ `(REVERSE ,(call-next-method)))
+ (list
+ (testgf35 3)
+ (progn
+ (change-class #'testgf35 'customized5-generic-function)
+ (testgf35 3))))
+ Expected: ((INTEGER REAL) (REAL INTEGER))
+ Got: ((INTEGER REAL) (INTEGER REAL))
+ ;;; The discriminating-function cache:
+ (progn
+ (defgeneric testgf36 (x))
+ (defmethod testgf36 ((x integer))
+ (cons 'integer (if (next-method-p) (call-next-method))))
+ (defmethod testgf36 ((x real))
+ (cons 'real (if (next-method-p) (call-next-method))))
+ (defclass customized6-generic-function (standard-generic-function)
+ ()
+ (:metaclass sb-pcl:funcallable-standard-class))
+ (defmethod sb-pcl:compute-discriminating-function ((gf customized6-generic-function))
+ (let ((orig-df (call-next-method)))
+ #'(lambda (&rest arguments)
+ (reverse (apply orig-df arguments)))))
+ (list
+ (testgf36 3)
+ (progn
+ (change-class #'testgf36 'customized6-generic-function)
+ (testgf36 3))))
+ Expected: ((INTEGER REAL) (REAL INTEGER))
+ Got: ((INTEGER REAL) (INTEGER REAL))
+
+356: PCL corruption
+ (reported by Bruno Haible)
+ After the "layout depth conflict" error, the CLOS is left in a state where
+ it's not possible to define new standard-class subclasses any more.
+ Test case:
+ (defclass prioritized-dispatcher ()
+ ((dependents :type list :initform nil)))
+ (defmethod sb-pcl:validate-superclass ((c1 sb-pcl:funcallable-standard-class)
+ (c2 (eql (find-class 'prioritized-dispatcher))))
+ t)
+ (defclass prioritized-generic-function (prioritized-dispatcher standard-generic-function)
+ ()
+ (:metaclass sb-pcl:funcallable-standard-class))
+ ;; ERROR, Quit the debugger with ABORT
+ (defclass typechecking-reader-class (standard-class)
+ ())
+ Expected: #<STANDARD-CLASS TYPECHECKING-READER-CLASS>
+ Got: ERROR "The assertion SB-PCL::WRAPPERS failed."
+
+357: defstruct inheritance of initforms
+ (reported by Bruno Haible)
+ When defstruct and defclass (with :metaclass structure-class) are mixed,
+ 1. some slot initforms are ignored by the DEFSTRUCT generated constructor
+ function, and
+ 2. all slot initforms are ignored by MAKE-INSTANCE. (This can be arguably
+ OK for initforms that were given in a DEFSTRUCT form, but for those
+ given in a DEFCLASS form, I think it qualifies as a bug.)
+ Test case:
+ (defstruct structure02a
+ slot1
+ (slot2 t)
+ (slot3 (floor pi)))
+ (defclass structure02b (structure02a)
+ ((slot4 :initform -44)
+ (slot5)
+ (slot6 :initform t)
+ (slot7 :initform (floor (* pi pi)))
+ (slot8 :initform 88))
+ (:metaclass structure-class))
+ (defstruct (structure02c (:include structure02b (slot8 -88)))
+ slot9
+ (slot10 t)
+ (slot11 (floor (exp 3))))
+ ;; 1. Form:
+ (let ((a (make-structure02c)))
+ (list (structure02c-slot4 a)
+ (structure02c-slot5 a)
+ (structure02c-slot6 a)
+ (structure02c-slot7 a)))
+ Expected: (-44 nil t 9)
+ Got: (SB-PCL::..SLOT-UNBOUND.. SB-PCL::..SLOT-UNBOUND..
+ SB-PCL::..SLOT-UNBOUND.. SB-PCL::..SLOT-UNBOUND..)
+ ;; 2. Form:
+ (let ((b (make-instance 'structure02c)))
+ (list (structure02c-slot2 b)
+ (structure02c-slot3 b)
+ (structure02c-slot4 b)
+ (structure02c-slot6 b)
+ (structure02c-slot7 b)
+ (structure02c-slot8 b)
+ (structure02c-slot10 b)
+ (structure02c-slot11 b)))
+ Expected: (t 3 -44 t 9 -88 t 20)
+ Got: (0 0 0 0 0 0 0 0)
+
+358: :DECLARE argument to ENSURE-GENERIC-FUNCTION
+ (reported by Bruno Haible)
+ According to ANSI CL, ensure-generic-function must accept a :DECLARE
+ keyword argument. In SBCL 0.8.16 it does not.
+ Test case:
+ (progn
+ (ensure-generic-function 'foo113 :declare '((optimize (speed 3))))
+ (sb-pcl:generic-function-declarations #'foo113))
+ Expected: ((OPTIMIZE (SPEED 3)))
+ Got: ERROR
+ Invalid initialization argument:
+ :DECLARE
+ in call for class #<SB-MOP:FUNCALLABLE-STANDARD-CLASS STANDARD-GENERIC-FUNCTION>.
+ See also:
+ The ANSI Standard, Section 7.1.2
+
+ Bruno notes: The MOP specifies that ensure-generic-function accepts :DECLARATIONS.
+ The easiest way to be compliant to both specs is to accept both (exclusively
+ or cumulatively).
+
+359: wrong default value for ensure-generic-function's :generic-function-class argument
+ (reported by Bruno Haible)
+ ANSI CL is silent on this, but the MOP's specification of ENSURE-GENERIC-FUNCTION says:
+ "The remaining arguments are the complete set of keyword arguments
+ received by ENSURE-GENERIC-FUNCTION."
+ and the spec of ENSURE-GENERIC-FUNCTION-USING-CLASS:
+ ":GENERIC-FUNCTION-CLASS - a class metaobject or a class name. If it is not
+ supplied, it defaults to the class named STANDARD-GENERIC-FUNCTION."
+ This is not the case in SBCL. Test case:
+ (defclass my-generic-function (standard-generic-function)
+ ()
+ (:metaclass sb-pcl:funcallable-standard-class))
+ (setf (fdefinition 'foo1)
+ (make-instance 'my-generic-function :name 'foo1))
+ (ensure-generic-function 'foo1
+ :generic-function-class (find-class 'standard-generic-function))
+ (class-of #'foo1)
+ ; => #<SB-MOP:FUNCALLABLE-STANDARD-CLASS STANDARD-GENERIC-FUNCTION>
+ (setf (fdefinition 'foo2)
+ (make-instance 'my-generic-function :name 'foo2))
+ (ensure-generic-function 'foo2)
+ (class-of #'foo2)
+ Expected: #<SB-MOP:FUNCALLABLE-STANDARD-CLASS STANDARD-GENERIC-FUNCTION>
+ Got: #<SB-MOP:FUNCALLABLE-STANDARD-CLASS MY-GENERIC-FUNCTION>
+
+360: CALL-METHOD not recognized in method-combination body
+ (reported by Bruno Haible)
+ This method combination, which adds 'redo' and 'return' restarts for each
+ method invocation to standard method combination, gives an error in SBCL.
+ (defun prompt-for-new-values ()
+ (format *debug-io* "~&New values: ")
+ (list (read *debug-io*)))
+ (defun add-method-restarts (form method)
+ (let ((block (gensym))
+ (tag (gensym)))
+ `(BLOCK ,block
+ (TAGBODY
+ ,tag
+ (RETURN-FROM ,block
+ (RESTART-CASE ,form
+ (METHOD-REDO ()
+ :REPORT (LAMBDA (STREAM) (FORMAT STREAM "Try calling ~S again." ,method))
+ (GO ,tag))
+ (METHOD-RETURN (L)
+ :REPORT (LAMBDA (STREAM) (FORMAT STREAM "Specify return values for ~S call." ,method))
+ :INTERACTIVE (LAMBDA () (PROMPT-FOR-NEW-VALUES))
+ (RETURN-FROM ,block (VALUES-LIST L)))))))))
+ (defun convert-effective-method (efm)
+ (if (consp efm)
+ (if (eq (car efm) 'CALL-METHOD)
+ (let ((method-list (third efm)))
+ (if (or (typep (first method-list) 'method) (rest method-list))
+ ; Reduce the case of multiple methods to a single one.
+ ; Make the call to the next-method explicit.
+ (convert-effective-method
+ `(CALL-METHOD ,(second efm)
+ ((MAKE-METHOD
+ (CALL-METHOD ,(first method-list) ,(rest method-list))))))
+ ; Now the case of at most one method.
+ (if (typep (second efm) 'method)
+ ; Wrap the method call in a RESTART-CASE.
+ (add-method-restarts
+ (cons (convert-effective-method (car efm))
+ (convert-effective-method (cdr efm)))
+ (second efm))
+ ; Normal recursive processing.
+ (cons (convert-effective-method (car efm))
+ (convert-effective-method (cdr efm))))))
+ (cons (convert-effective-method (car efm))
+ (convert-effective-method (cdr efm))))
+ efm))
+ (define-method-combination standard-with-restarts ()
+ ((around (:around))
+ (before (:before))
+ (primary () :required t)
+ (after (:after)))
+ (flet ((call-methods-sequentially (methods)
+ (mapcar #'(lambda (method)
+ `(CALL-METHOD ,method))
+ methods)))
+ (let ((form (if (or before after (rest primary))
+ `(MULTIPLE-VALUE-PROG1
+ (PROGN
+ ,@(call-methods-sequentially before)
+ (CALL-METHOD ,(first primary) ,(rest primary)))
+ ,@(call-methods-sequentially (reverse after)))
+ `(CALL-METHOD ,(first primary)))))
+ (when around
+ (setq form
+ `(CALL-METHOD ,(first around)
+ (,@(rest around) (MAKE-METHOD ,form)))))
+ (convert-effective-method form))))
+ (defgeneric testgf16 (x) (:method-combination standard-with-restarts))
+ (defclass testclass16a () ())
+ (defclass testclass16b (testclass16a) ())
+ (defclass testclass16c (testclass16a) ())
+ (defclass testclass16d (testclass16b testclass16c) ())
+ (defmethod testgf16 ((x testclass16a))
+ (list 'a
+ (not (null (find-restart 'method-redo)))
+ (not (null (find-restart 'method-return)))))
+ (defmethod testgf16 ((x testclass16b))
+ (cons 'b (call-next-method)))
+ (defmethod testgf16 ((x testclass16c))
+ (cons 'c (call-next-method)))
+ (defmethod testgf16 ((x testclass16d))
+ (cons 'd (call-next-method)))
+ (testgf16 (make-instance 'testclass16d))
+
+ Expected: (D B C A T T)
+ Got: ERROR CALL-METHOD outside of a effective method form
+
+ This is a bug because ANSI CL HyperSpec/Body/locmac_call-m__make-method
+ says
+ "The macro call-method invokes the specified method, supplying it with
+ arguments and with definitions for call-next-method and for next-method-p.
+ If the invocation of call-method is lexically inside of a make-method,
+ the arguments are those that were supplied to that method. Otherwise
+ the arguments are those that were supplied to the generic function."
+ and the example uses nothing more than these two cases (as you can see by
+ doing (trace convert-effective-method)).
+
+361: initialize-instance of standard-reader-method ignores :function argument
+ (reported by Bruno Haible)
+ Pass a custom :function argument to initialize-instance of a
+ standard-reader-method instance, but it has no effect.
+ ;; Check that it's possible to define reader methods that do typechecking.
+ (progn
+ (defclass typechecking-reader-method (sb-pcl:standard-reader-method)
+ ())
+ (defmethod initialize-instance ((method typechecking-reader-method) &rest initargs
+ &key slot-definition)
+ (let ((name (sb-pcl:slot-definition-name slot-definition))
+ (type (sb-pcl:slot-definition-type slot-definition)))
+ (apply #'call-next-method method
+ :function #'(lambda (args next-methods)
+ (declare (ignore next-methods))
+ (apply #'(lambda (instance)
+ (let ((value (slot-value instance name)))
+ (unless (typep value type)
+ (error "Slot ~S of ~S is not of type ~S: ~S"
+ name instance type value))
+ value))
+ args))
+ initargs)))
+ (defclass typechecking-reader-class (standard-class)
+ ())
+ (defmethod sb-pcl:validate-superclass ((c1 typechecking-reader-class) (c2 standard-class))
+ t)
+ (defmethod reader-method-class ((class typechecking-reader-class) direct-slot &rest args)
+ (find-class 'typechecking-reader-method))
+ (defclass testclass25 ()
+ ((pair :type (cons symbol (cons symbol null)) :initarg :pair :accessor testclass25-pair))
+ (:metaclass typechecking-reader-class))
+ (macrolet ((succeeds (form)
+ `(not (nth-value 1 (ignore-errors ,form)))))
+ (let ((p (list 'abc 'def))
+ (x (make-instance 'testclass25)))
+ (list (succeeds (make-instance 'testclass25 :pair '(seventeen 17)))
+ (succeeds (setf (testclass25-pair x) p))
+ (succeeds (setf (second p) 456))
+ (succeeds (testclass25-pair x))
+ (succeeds (slot-value x 'pair))))))
+ Expected: (t t t nil t)
+ Got: (t t t t t)
+
+ (inspect (first (sb-pcl:generic-function-methods #'testclass25-pair)))
+ shows that the method was created with a FAST-FUNCTION slot but with a
+ FUNCTION slot of NIL.
+
+362: missing error when a slot-definition is created without a name
+ (reported by Bruno Haible)
+ The MOP says about slot-definition initialization:
+ "The :NAME argument is a slot name. An ERROR is SIGNALled if this argument
+ is not a symbol which can be used as a variable name. An ERROR is SIGNALled
+ if this argument is not supplied."
+ Test case:
+ (make-instance (find-class 'sb-pcl:standard-direct-slot-definition))
+ Expected: ERROR
+ Got: #<SB-MOP:STANDARD-DIRECT-SLOT-DEFINITION NIL>
+
+363: missing error when a slot-definition is created with a wrong documentation object
+ (reported by Bruno Haible)
+ The MOP says about slot-definition initialization:
+ "The :DOCUMENTATION argument is a STRING or NIL. An ERROR is SIGNALled
+ if it is not. This argument default to NIL during initialization."
+ Test case:
+ (make-instance (find-class 'sb-pcl:standard-direct-slot-definition)
+ :name 'foo
+ :documentation 'not-a-string)
+ Expected: ERROR
+ Got: #<SB-MOP:STANDARD-DIRECT-SLOT-DEFINITION FOO>
+
+364: does not support class objects as specializer names
+ (reported by Bruno Haible)
+ According to ANSI CL 7.6.2, class objects are valid specializer names,
+ and "Parameter specializer names are used in macros intended as the
+ user-level interface (defmethod)". DEFMETHOD's syntax section doesn't
+ mention this possibility in the BNF for parameter-specializer-name;
+ however, this appears to be an editorial omission, since the CLHS
+ mentions issue CLASS-OBJECT-SPECIALIZER:AFFIRM as being approved
+ by X3J13. SBCL doesn't support it:
+ (defclass foo () ())
+ (defmethod goo ((x #.(find-class 'foo))) x)
+ Expected: #<STANDARD-METHOD GOO (#<STANDARD-CLASS FOO>)>
+ Got: ERROR "#<STANDARD-CLASS FOO> is not a legal class name."
+
+365: mixin on generic-function subclass
+ (reported by Bruno Haible)
+ a mixin class
+ (defclass prioritized-dispatcher ()
+ ((dependents :type list :initform nil)))
+ on a generic-function subclass:
+ (defclass prioritized-generic-function (prioritized-dispatcher standard-generic-function)
+ ()
+ (:metaclass sb-pcl:funcallable-standard-class))
+ SBCL gives an error on this, telling to define a method on SB-MOP:VALIDATE-SUPERCLASS. If done,
+ (defmethod sb-pcl:validate-superclass ((c1 sb-pcl:funcallable-standard-class)
+ (c2 (eql (find-class 'prioritized-dispatcher))))
+ t)
+ then, however,
+ (defclass prioritized-generic-function (prioritized-dispatcher standard-generic-function)
+ ()
+ (:metaclass sb-pcl:funcallable-standard-class))
+ => debugger invoked on a SIMPLE-ERROR in thread 6687:
+ layout depth conflict: #(#<SB-KERNEL:LAYOUT for T {500E1E9}> ...)
+
+ Further discussion on this: http://thread.gmane.org/gmane.lisp.steel-bank.general/491
+
+366: cannot define two generic functions with user-defined class
+ (reported by Bruno Haible)
+ it is possible to define one generic function class and an instance
+ of it. But attempting to do the same thing again, in the same session,
+ leads to a "Control stack exhausted" error. Test case:
+ (defclass my-generic-function-1 (standard-generic-function)
+ ()
+ (:metaclass sb-pcl:funcallable-standard-class))
+ (defgeneric testgf-1 (x) (:generic-function-class my-generic-function-1)
+ (:method ((x integer)) (cons 'integer nil)))
+ (defclass my-generic-function-2 (standard-generic-function)
+ ()
+ (:metaclass sb-pcl:funcallable-standard-class))
+ (defgeneric testgf-2 (x) (:generic-function-class my-generic-function-2)
+ (:method ((x integer)) (cons 'integer nil)))
+ => SB-KERNEL::CONTROL-STACK-EXHAUSTED
+
+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.
+
+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.
+
+375: MISC.555
+ (compile nil '(lambda (p1)
+ (declare (optimize (speed 1) (safety 2) (debug 2) (space 0))
+ (type keyword p1))
+ (keywordp p1)))
+
+ fails on hairy type check in IR2.
+
+ 1. KEYWORDP is MAYBE-INLINE expanded (before TYPEP-like
+ transformation could eliminate it).
+
+ 2. From the only call of KEYWORDP the type of its argument is
+ derived to be KEYWORD.
+
+ 2. Type check for P1 is generated; it uses KEYWORDP to perform the
+ check, and so references the local function; from the KEYWORDP
+ argument type new CAST to KEYWORD is generated. The compiler
+ loops forever.
+
+377: Memory fault error reporting
+ On those architectures where :C-STACK-IS-CONTROL-STACK is in
+ *FEATURES*, we handle SIG_MEMORY_FAULT (SEGV or BUS) on an altstack,
+ so we cannot handle the signal directly (as in interrupt_handle_now())
+ in the case when the signal comes from some external agent (the user
+ using kill(1), or a fault in some foreign code, for instance). As
+ of sbcl-0.8.20.20, this is fixed by calling
+ arrange_return_to_lisp_function() to a new error-signalling
+ function, but as a result the error reporting is poor: we cannot
+ even tell the user at which address the fault occurred. We should
+ arrange such that arguments can be passed to the function called from
+ arrange_return_to_lisp_function(), but this looked hard to do in
+ general without suffering from memory leaks.
+
+379: TRACE :ENCAPSULATE NIL broken on ppc/darwin
+ See commented-out test-case in debug.impure.lisp.
+
+380: Accessor redefinition fails because of old accessor name
+ When redefining an accessor, SB-PCL::FIX-SLOT-ACCESSORS may try to
+ find the generic function named by the old accessor name using
+ ENSURE-GENERIC-FUNCTION and then remove the old accessor's method in
+ the GF. If the old name does not name a function, or if the old name
+ does not name a generic function, no attempt to find the GF or remove
+ any methods is made.
+
+ However, if an unrelated GF with an incompatible lambda list exists,
+ the class redefinition will fail when SB-PCL::REMOVE-READER-METHOD
+ tries to find and remove a method with an incompatible lambda list
+ from the unrelated generic function.
+
+381: incautious calls to EQUAL in fasl dumping
+ Compiling
+ (frob #(#1=(a #1#)))
+ (frob #(#1=(b #1#)))
+ (frob #(#1=(a #1#)))
+ in sbcl-0.9.0 causes CONTROL-STACK-EXHAUSTED. My (WHN) impression
+ is that this follows from the use of (MAKE-HASH-TABLE :TEST 'EQUAL)
+ to detect sharing, in which case fixing it might require either
+ getting less ambitious about detecting shared list structure, or
+ implementing the moral equivalent of EQUAL hash tables in a
+ cycle-tolerant way.