0.7.13.pcl-class.1

[sbcl.git] / src / compiler / typetran.lisp

diff --git a/src/compiler/typetran.lisp b/src/compiler/typetran.lisp
index ad9986e..06f0de1 100644 (file)
--- a/src/compiler/typetran.lisp
+++ b/src/compiler/typetran.lisp
@@ -72,6 +72,8 @@
           nil)
          ((csubtypep otype type)
           t)
+          ((eq type *empty-type*)
+           nil)
          (t
           (give-up-ir1-transform)))))
 
@@ -97,10 +99,10 @@
 
 ;;; If FIND-CLASS is called on a constant class, locate the CLASS-CELL
 ;;; at load time.
-(deftransform find-class ((name) ((constant-arg symbol)) *)
+(deftransform find-classoid ((name) ((constant-arg symbol)) *)
   (let* ((name (continuation-value name))
-        (cell (find-class-cell name)))
-    `(or (class-cell-class ',cell)
+        (cell (find-classoid-cell name)))
+    `(or (classoid-cell-classoid ',cell)
         (error "class not yet defined: ~S" name))))
 \f
 ;;;; standard type predicates, i.e. those defined in package COMMON-LISP,
@@ -274,6 +276,11 @@
                                            `(typep ,n-obj ',x))
                                          (rest spec))))))))))
 
+(defun source-transform-negation-typep (object type)
+  (declare (type negation-type type))
+  (let ((spec (type-specifier (negation-type-type type))))
+    `(not (typep ,object ',spec))))
+
 ;;; Do source transformation for TYPEP of a known union type. If a
 ;;; union type contains LIST, then we pull that out and make it into a
 ;;; single LISTP call. Note that if SYMBOL is in the union, then LIST
@@ -388,7 +395,7 @@
   (aver (constant-continuation-p spec))
   (let* ((spec (continuation-value spec))
         (class (specifier-type spec))
-        (name (sb!xc:class-name class))
+        (name (classoid-name class))
         (otype (continuation-type object))
         (layout (let ((res (info :type :compiler-layout name)))
                   (if (and res (not (layout-invalid res)))
@@ -401,7 +408,7 @@
       ((csubtypep otype class)
        t)
       ;; If not properly named, error.
-      ((not (and name (eq (sb!xc:find-class name) class)))
+      ((not (and name (eq (find-classoid name) class)))
        (compiler-error "can't compile TYPEP of anonymous or undefined ~
                        class:~%  ~S"
                       class))
@@ -419,8 +426,8 @@
             (t
              (values '(lambda (x) (declare (ignore x)) t) 'layout-of)))
         (cond
-          ((and (eq (class-state class) :sealed) layout
-                (not (class-subclasses class)))
+          ((and (eq (classoid-state class) :sealed) layout
+                (not (classoid-subclasses class)))
            ;; Sealed and has no subclasses.
            (let ((n-layout (gensym)))
              `(and (,pred object)
@@ -429,7 +436,7 @@
                              `((when (layout-invalid ,n-layout)
                                  (%layout-invalid-error object ',layout))))
                      (eq ,n-layout ',layout)))))
-          ((and (typep class 'basic-structure-class) layout)
+          ((and (typep class 'basic-structure-classoid) layout)
            ;; structure type tests; hierarchical layout depths
            (let ((depthoid (layout-depthoid layout))
                  (n-layout (gensym)))
@@ -467,9 +474,9 @@
           (t
            (/noshow "default case -- ,PRED and CLASS-CELL-TYPEP")
            `(and (,pred object)
-                 (class-cell-typep (,get-layout object)
-                                   ',(find-class-cell name)
-                                   object)))))))))
+                 (classoid-cell-typep (,get-layout object)
+                                      ',(find-classoid-cell name)
+                                      object)))))))))
 
 ;;; If the specifier argument is a quoted constant, then we consider
 ;;; converting into a simple predicate or other stuff. If the type is
@@ -503,6 +510,8 @@
            (typecase type
              (hairy-type
               (source-transform-hairy-typep object type))
+             (negation-type
+              (source-transform-negation-typep object type))
              (union-type
               (source-transform-union-typep object type))
              (intersection-type
@@ -517,7 +526,7 @@
            (typecase type
              (numeric-type
               (source-transform-numeric-typep object type))
-             (sb!xc:class
+             (classoid
               `(%instance-typep ,object ,spec))
              (array-type
               (source-transform-array-typep object type))
@@ -529,7 +538,7 @@
 \f
 ;;;; coercion
 
-(deftransform coerce ((x type) (* *) *)
+(deftransform coerce ((x type) (* *) * :node node)
   (unless (constant-continuation-p type)
     (give-up-ir1-transform))
   (let ((tspec (ir1-transform-specifier-type (continuation-value type))))
@@ -544,8 +553,12 @@
             ;; FIXME: #!+long-float (t ,(error "LONG-FLOAT case needed"))
             ((csubtypep tspec (specifier-type 'float))
              '(%single-float x))
-            ((csubtypep tspec (specifier-type 'simple-vector))
-             '(coerce-to-simple-vector x))
+            ((and (csubtypep tspec (specifier-type 'simple-vector))
+                  (policy node (< safety 3)))
+             `(if (simple-vector-p x)
+                  x
+                  (replace (make-array (length x)) x)))
+            ;; FIXME: other VECTOR types?
             (t
              (give-up-ir1-transform)))))))