X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcode%2Fclass.lisp;h=c9f2271327b1c3125c499a2d51af883d2d3f1504;hb=b8f63d9b4e978bec3bfc1f4fc471e5ed946781fd;hp=b296f48863b53eaff25423637afadfe36ba831e0;hpb=5eb97830eca716fef626c6e12429c99c9b97e3c8;p=sbcl.git

diff --git a/src/code/class.lisp b/src/code/class.lisp
index b296f48..c9f2271 100644
--- a/src/code/class.lisp
+++ b/src/code/class.lisp
@@ -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 @@
 
 ;;;; 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))
 
 ;;;; PCL stuff
@@ -1052,10 +1052,8 @@
      :inherits (sequence mutable-sequence mutable-collection
 		generic-sequence collection))
     (cons
-     ;; MNA: cons compound-type patch
-     ;; FIXIT :all commented out
-     ; :translation cons
      :codes (#.sb!vm:list-pointer-type)
+     :translation cons
      :inherits (list sequence
 		mutable-sequence mutable-collection
 		generic-sequence collection))