0.7.12.39:

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

diff --git a/src/code/early-type.lisp b/src/code/early-type.lisp
index 2eea097..ae5dbd6 100644 (file)
--- a/src/code/early-type.lisp
+++ b/src/code/early-type.lisp
@@ -24,7 +24,7 @@
 (defstruct (hairy-type (:include ctype
                                 (class-info (type-class-or-lose 'hairy))
                                 (enumerable t)
-                                (might-contain-other-types? t))
+                                (might-contain-other-types-p t))
                       (:copier nil)
                       #!+cmu (:pure nil))
   ;; the Common Lisp type-specifier of the type we represent
@@ -38,6 +38,18 @@
 (defstruct (unknown-type (:include hairy-type)
                         (:copier nil)))
 
+(defstruct (negation-type (:include ctype
+                                   (class-info (type-class-or-lose 'negation))
+                                   ;; FIXME: is this right?  It's
+                                   ;; what they had before, anyway
+                                   (enumerable t)
+                                   (might-contain-other-types-p t))
+                         (:copier nil)
+                         #!+cmu (:pure nil))
+  (type (missing-arg) :type ctype))
+
+(!define-type-class negation)
+
 ;;; ARGS-TYPE objects are used both to represent VALUES types and
 ;;; to represent FUNCTION types.
 (defstruct (args-type (:include ctype)
@@ -58,7 +70,9 @@
 (defstruct (values-type
            (:include args-type
                      (class-info (type-class-or-lose 'values)))
+            (:constructor %make-values-type)
            (:copier nil)))
+(define-cached-synonym make-values-type)
 
 (!define-type-class values)
 
@@ -207,6 +221,7 @@
 ;;; things such as SIMPLE-STRING.
 (defstruct (array-type (:include ctype
                                 (class-info (type-class-or-lose 'array)))
+                       (:constructor %make-array-type)
                       (:copier nil))
   ;; the dimensions of the array, or * if unspecified. If a dimension
   ;; is unspecified, it is *.
@@ -217,6 +232,7 @@
   (element-type (missing-arg) :type ctype)
   ;; the element type as it is specialized in this implementation
   (specialized-element-type *wild-type* :type ctype))
+(define-cached-synonym make-array-type)
 
 ;;; A MEMBER-TYPE represent a use of the MEMBER type specifier. We
 ;;; bother with this at this level because MEMBER types are fairly
@@ -232,7 +248,7 @@
 ;;; A COMPOUND-TYPE is a type defined out of a set of types, the
 ;;; common parent of UNION-TYPE and INTERSECTION-TYPE.
 (defstruct (compound-type (:include ctype
-                                   (might-contain-other-types? t))
+                                   (might-contain-other-types-p t))
                          (:constructor nil)
                          (:copier nil))
   (types nil :type list :read-only t))
@@ -248,6 +264,7 @@
                                 (class-info (type-class-or-lose 'union)))
                       (:constructor %make-union-type (enumerable types))
                       (:copier nil)))
+(define-cached-synonym make-union-type)
 
 ;;; An INTERSECTION-TYPE represents a use of the AND type specifier
 ;;; which we couldn't canonicalize to something simpler. Canonical form:
@@ -309,7 +326,7 @@
                                 (logand (sxhash x) #x3FF))
               :hash-bits 10
               :init-wrapper !cold-init-forms)
-             ((orig eq))
+             ((orig equal-but-no-car-recursion))
   (let ((u (uncross orig)))
     (or (info :type :builtin u)
        (let ((spec (type-expand u)))
@@ -359,6 +376,12 @@
       (error "VALUES type illegal in this context:~%  ~S" x))
     res))
 
+(defun single-value-specifier-type (x)
+  (let ((res (specifier-type x)))
+    (if (eq res *wild-type*)
+        *universal-type*
+        res)))
+
 ;;; Similar to MACROEXPAND, but expands DEFTYPEs. We don't bother
 ;;; returning a second value.
 (defun type-expand (form)