0.7.10.15:

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

diff --git a/src/code/target-type.lisp b/src/code/target-type.lisp
index d08becc..d024ace 100644 (file)
--- a/src/code/target-type.lisp
+++ b/src/code/target-type.lisp
@@ -13,17 +13,6 @@
 
 (!begin-collecting-cold-init-forms)
 \f
-;;; Just call %TYPEP.
-;;;
-;;; Note that when cross-compiling, SB!XC:TYPEP is interpreted as
-;;; 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.)
-(defun typep (object type)
-  #!+sb-doc
-  "Return T iff OBJECT is of type TYPE."
-  (%typep object type))
-
 ;;; If TYPE is a type that we can do a compile-time test on, then
 ;;; return whether the object is of that type as the first value and
 ;;; second value true. Otherwise return NIL, NIL.
@@ -92,7 +81,26 @@
          (let ((predicate-name (second hairy-spec)))
            (declare (type symbol predicate-name)) ; by ANSI spec of SATISFIES
            (if (fboundp predicate-name)
-               (values (not (null (funcall predicate-name obj))) t)
+               (let* (;; "Is OBJ of the SATISFIES type?" represented
+                      ;; as a generalized boolean.
+                      ;;
+                      ;; (Why IGNORE-ERRORS? This code is used to try to
+                      ;; check type relationships at compile time. 
+                      ;; Passing only-slightly-twisted types like
+                      ;; (AND INTEGER (SATISFIES ODDP)) into the
+                      ;; rather-significantly-twisted type dispatch
+                      ;; system can easily give rise to oddities like
+                      ;; calling predicates like ODDP on values they
+                      ;; don't like. (E.g. on OBJ=#\NEWLINE when the
+                      ;; above type is tested for TYPE= against
+                      ;; STANDARD-CHAR, represented as a
+                      ;; MEMBER-TYPE.) In such cases, NIL seems to be
+                      ;; an appropriate answer to "is OBJ of the
+                      ;; SATISFIES type?")
+                      (gbool (ignore-errors (funcall predicate-name obj)))
+                      ;; RAW coerced to a pure BOOLEAN value
+                      (bool (not (not gbool))))
+                 (values bool t))
                (values nil nil)))))))))
 \f
 ;;; Return the layout for an object. This is the basic operation for
@@ -117,7 +125,7 @@
           ;; time), we need to suppress a DEFTRANSFORM.. -- WHN 19991004
           (declare (notinline sb!xc:find-class))
           (class-layout (sb!xc:find-class 'null))))
-       (t (svref *built-in-class-codes* (get-type x)))))
+       (t (svref *built-in-class-codes* (widetag-of x)))))
 
 #!-sb-fluid (declaim (inline sb!xc:class-of))
 (defun sb!xc:class-of (object)
@@ -128,7 +136,7 @@
 
 ;;; Pull the type specifier out of a function object.
 (defun extract-fun-type (fun)
-  (specifier-type (%fun-type (%closure-function fun))))
+  (specifier-type (%simple-fun-type (%closure-fun fun))))
 \f
 ;;;; miscellaneous interfaces
 
@@ -146,10 +154,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.
+;;; This is 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))