:name 'y
:allocation :instance))))
(defclass dummy-ctais () ((x :allocation :class)))
+(finalize-inheritance (find-class 'class-to-add-instance-slot))
(assert (equal (mapcar #'slot-definition-allocation
(class-slots (find-class 'class-to-add-instance-slot)))
;; FIXME: is the order really guaranteed?
:name 'y
:allocation :class))))
(defclass dummy-ctacs () ((x :allocation :class)))
+(finalize-inheritance (find-class 'class-to-add-class-slot))
(assert (equal (mapcar #'slot-definition-allocation
(class-slots (find-class 'class-to-add-class-slot)))
'(:class :class)))
;;; (addendum to test for #331: conditions suffered the same problem)
(define-condition condition-bug-331-super () ())
(define-condition condition-bug-331-sub (condition-bug-331-super) ())
-(let ((subs (sb-mop:class-direct-subclasses
+(let ((subs (sb-mop:class-direct-subclasses
(find-class 'condition-bug-331-super))))
(assert (= 1 (length subs)))
(assert (eq (car subs) (find-class 'condition-bug-331-sub))))
(let* ((gf #'slot331a)
(methods (sb-mop:generic-function-methods gf)))
(assert (= (length methods) 1))
- (assert (eq (car methods)
- (find-method #'slot331a nil
+ (assert (eq (car methods)
+ (find-method #'slot331a nil
(list (find-class 'condition-bug-331a))))))
;;; detection of multiple class options in defclass, reported by Bruno Haible
()
(:metaclass funcallable-standard-class))
(make-instance 'bad-funcallable-standard-class))))
-
+\f
+;;; we should be able to make classes with silly names
+(make-instance 'standard-class :name 3)
+(defclass foo () ())
+(reinitialize-instance (find-class 'foo) :name '(a b))
+\f
+;;; classes (including anonymous ones) and eql-specializers should be
+;;; allowed to be specializers.
+(defvar *anonymous-class*
+ (make-instance 'standard-class
+ :direct-superclasses (list (find-class 'standard-object))))
+(defvar *object-of-anonymous-class*
+ (make-instance *anonymous-class*))
+(eval `(defmethod method-on-anonymous-class ((obj ,*anonymous-class*)) 41))
+(assert (eql (method-on-anonymous-class *object-of-anonymous-class*) 41))
+(eval `(defmethod method-on-anonymous-class
+ ((obj ,(intern-eql-specializer *object-of-anonymous-class*)))
+ 42))
+(assert (eql (method-on-anonymous-class *object-of-anonymous-class*) 42))
+\f
+;;; accessors can cause early finalization, which caused confusion in
+;;; the system, leading to uncompileable TYPEP problems.
+(defclass funcallable-class-for-typep ()
+ ((some-slot-with-accessor :accessor some-slot-with-accessor))
+ (:metaclass funcallable-standard-class))
+(compile nil '(lambda (x) (typep x 'funcallable-class-for-typep)))
+\f
+;;; even anonymous classes should be valid types
+(let* ((class1 (make-instance 'standard-class :direct-superclasses (list (find-class 'standard-object))))
+ (class2 (make-instance 'standard-class :direct-superclasses (list class1))))
+ (assert (subtypep class2 class1))
+ (assert (typep (make-instance class2) class1)))
+\f
+;;; ensure-class got its treatment of :metaclass wrong.
+(ensure-class 'better-be-standard-class :direct-superclasses '(standard-object)
+ :metaclass 'standard-class
+ :metaclass 'funcallable-standard-class)
+(assert (eq (class-of (find-class 'better-be-standard-class))
+ (find-class 'standard-class)))
+\f
;;;; success