0.6.10.13:

[sbcl.git] / src / code / class.lisp

diff --git a/src/code/class.lisp b/src/code/class.lisp
index 403860f..c9f2271 100644 (file)
--- a/src/code/class.lisp
+++ b/src/code/class.lisp
@@ -339,7 +339,7 @@
     (unless name
       (compiler-error "can't dump anonymous LAYOUT: ~S" layout))
     ;; Since LAYOUT refers to a class which refers back to the LAYOUT,
-    ;; we have to do this in two stages, a la the TREE-WITH-PARENT
+    ;; we have to do this in two stages, like the TREE-WITH-PARENT
     ;; example in the MAKE-LOAD-FORM entry in the ANSI spec.
     (values
      ;; "creation" form (which actually doesn't create a new LAYOUT if
@@ -464,9 +464,9 @@
         (class-layout (class-layout class))
         (subclasses (class-subclasses class)))
 
-    ;; Attempting to register ourselves with a temporary cookie is
-    ;; almost certainly a programmer error. (I should know, I did it.)
-    ;; -- WHN 19990927
+    ;; Attempting to register ourselves with a temporary undefined
+    ;; class placeholder is almost certainly a programmer error. (I
+    ;; should know, I did it.) -- WHN 19990927
     (assert (not (undefined-class-p class)))
 
     ;; This assertion dates from classic CMU CL. The rationale is
@@ -638,7 +638,7 @@
 ;;; always of the desired class. The second result is any existing
 ;;; LAYOUT for this name.
 (defun insured-find-class (name predicate constructor)
-  (declare (function predicate constructor))
+  (declare (type function predicate constructor))
   (let* ((old (sb!xc:find-class name nil))
         (res (if (and old (funcall predicate old))
                  old
@@ -660,16 +660,16 @@
 \f
 ;;;; CLASS type operations
 
-(define-type-class sb!xc:class)
+(!define-type-class sb!xc:class)
 
 ;;; Simple methods for TYPE= and SUBTYPEP should never be called when
 ;;; the two classes are equal, since there are EQ checks in those
 ;;; operations.
-(define-type-method (sb!xc:class :simple-=) (type1 type2)
+(!define-type-method (sb!xc:class :simple-=) (type1 type2)
   (assert (not (eq type1 type2)))
   (values nil t))
 
-(define-type-method (sb!xc:class :simple-subtypep) (class1 class2)
+(!define-type-method (sb!xc:class :simple-subtypep) (class1 class2)
   (assert (not (eq class1 class2)))
   (let ((subclasses (class-subclasses class2)))
     (if (and subclasses (gethash class1 subclasses))
@@ -697,7 +697,7 @@
 ;;; they are structure classes, since a subclass of both might be
 ;;; defined. If either class is sealed, we can eliminate this
 ;;; possibility.
-(define-type-method (sb!xc:class :simple-intersection) (class1 class2)
+(!define-type-method (sb!xc:class :simple-intersection) (class1 class2)
   (declare (type sb!xc:class class1 class2))
   (cond ((eq class1 class2) class1)
        ((let ((subclasses (class-subclasses class2)))
@@ -716,7 +716,7 @@
        (t
         (values class1 nil))))
 
-(define-type-method (sb!xc:class :unparse) (type)
+(!define-type-method (sb!xc:class :unparse) (type)
   (class-proper-name type))
 \f
 ;;;; PCL stuff
@@ -1053,6 +1053,7 @@
                generic-sequence collection))
     (cons
      :codes (#.sb!vm:list-pointer-type)
+     :translation cons
      :inherits (list sequence
                mutable-sequence mutable-collection
                generic-sequence collection))