0.6.10:

[sbcl.git] / src / code / target-type.lisp

diff --git a/src/code/target-type.lisp b/src/code/target-type.lisp
index 1e24030..1494806 100644 (file)
--- a/src/code/target-type.lisp
+++ b/src/code/target-type.lisp
@@ -19,11 +19,6 @@
 ;;; a test that the host Lisp object OBJECT translates to a target SBCL
 ;;; type TYPE. (This behavior is needed e.g. to test for the validity of
 ;;; numeric subtype bounds read when cross-compiling.)
-;;;
-;;; KLUDGE: In classic CMU CL this was wrapped in a (DECLAIM (START-BLOCK
-;;; TYPEP %TYPEP CLASS-CELL-TYPEP)) to make calls efficient. Once I straighten
-;;; out bootstrapping and cross-compiling issues it'd likely be a good idea to
-;;; do this again. -- WHN 19990413
 (defun typep (object type)
   #!+sb-doc
   "Return T iff OBJECT is of type TYPE."
@@ -44,7 +39,8 @@
         named-type
         member-type
         array-type
-        sb!xc:built-in-class)
+        sb!xc:built-in-class
+        cons-type)
      (values (%typep obj type) t))
     (sb!xc:class
      (if (if (csubtypep type (specifier-type 'funcallable-instance))
@@ -146,8 +142,8 @@
 \f
 ;;;; miscellaneous interfaces
 
-;;; Clear memoization of all type system operations that can be altered by
-;;; type definition/redefinition.
+;;; Clear memoization of all type system operations that can be
+;;; altered by type definition/redefinition.
 (defun clear-type-caches ()
   (when *type-system-initialized*
     (dolist (sym '(values-specifier-type-cache-clear
@@ -160,9 +156,10 @@
       (funcall (symbol-function sym))))
   (values))
 
-;;; Like TYPE-OF, only we return a CTYPE structure instead of a type specifier,
-;;; and we try to return the type most useful for type checking, rather than
-;;; trying to come up with the one that the user might find most informative.
+;;; Like TYPE-OF, only we return a CTYPE structure instead of a type
+;;; specifier, and we try to return the type most useful for type
+;;; checking, rather than trying to come up with the one that the user
+;;; might find most informative.
 (declaim (ftype (function (t) ctype) ctype-of))
 (defun-cached (ctype-of
               :hash-function (lambda (x) (logand (sxhash x) #x1FF))
@@ -201,6 +198,8 @@
                        :complexp (not (typep x 'simple-array))
                        :element-type etype
                        :specialized-element-type etype)))
+    (cons
+     (make-cons-type *universal-type* *universal-type*))
     (t
      (sb!xc:class-of x))))