0.8alpha.0.2:

	Fix for methods on classes with incomplete subclasses (detected
	by KMR/McCLIM compilation)
	... distilled test for it.

diff --git a/src/pcl/dfun.lisp b/src/pcl/dfun.lisp
index 8ae016d..106708d 100644 (file)
--- a/src/pcl/dfun.lisp
+++ b/src/pcl/dfun.lisp
@@ -1411,11 +1411,7 @@ And so, we are saved.
                     (eq (cadr specl) (cadr type)))
                    (class
                     (or (eq (cadr specl) (cadr type))
                     (eq (cadr specl) (cadr type)))
                    (class
                     (or (eq (cadr specl) (cadr type))

-                        (memq (cadr specl)
-                              (if (eq *boot-state* 'complete)
-                                  (class-precedence-list (cadr type))
-                                  (early-class-precedence-list
-                                   (cadr type)))))))))
+                        (memq (cadr specl) (cpl-or-nil (cadr type))))))))

        (values pred pred))))
 
 (defun saut-prototype (specl type)
        (values pred pred))))
 
 (defun saut-prototype (specl type)

@@ -1428,10 +1424,7 @@ And so, we are saved.
                (class-eq   (eq (cadr specl) (class-of (cadr type))))
                (class      (memq (cadr specl)
                                  (let ((class (class-of (cadr type))))
                (class-eq   (eq (cadr specl) (class-of (cadr type))))
                (class      (memq (cadr specl)
                                  (let ((class (class-of (cadr type))))

-                                   (if (eq *boot-state* 'complete)
-                                       (class-precedence-list class)
-                                       (early-class-precedence-list
-                                        class))))))))
+                                   (cpl-or-nil class)))))))

     (values pred pred)))
 
 (defun specializer-applicable-using-type-p (specl type)
     (values pred pred)))
 
 (defun specializer-applicable-using-type-p (specl type)

diff --git a/tests/clos.impure-cload.lisp b/tests/clos.impure-cload.lisp
index cda6eab..d866200 100644 (file)
--- a/tests/clos.impure-cload.lisp
+++ b/tests/clos.impure-cload.lisp
@@ -63,6 +63,13 @@
 (defmethod baz ((x specializer1)) x)
 (assert (typep (baz (make-instance 'specializer1)) 'specializer1))
 
 (defmethod baz ((x specializer1)) x)
 (assert (typep (baz (make-instance 'specializer1)) 'specializer1))
 

+;;; ... and from McCLIM, another test case:
+(defclass specializer1a (specializer2a specializer2b) ())
+(defclass specializer2a () ())
+(defmethod initialize-instance :after
+    ((obj specializer2a) &key &allow-other-keys)
+  (print obj))
+

 ;;; in a similar vein, we should be able to define methods on classes
 ;;; that are effectively unknown to the type system:
 (sb-mop:ensure-class 'unknown-type)
 ;;; in a similar vein, we should be able to define methods on classes
 ;;; that are effectively unknown to the type system:
 (sb-mop:ensure-class 'unknown-type)

diff --git a/version.lisp-expr b/version.lisp-expr
index 22de979..dbf48b2 100644 (file)
--- a/version.lisp-expr
+++ b/version.lisp-expr
@@ -17,4 +17,4 @@
 ;;; checkins which aren't released. (And occasionally for internal
 ;;; versions, especially for internal versions off the main CVS
 ;;; branch, it gets hairier, e.g. "0.pre7.14.flaky4.13".)
 ;;; checkins which aren't released. (And occasionally for internal
 ;;; versions, especially for internal versions off the main CVS
 ;;; branch, it gets hairier, e.g. "0.pre7.14.flaky4.13".)

-"0.8alpha.0.1"
+"0.8alpha.0.2"