0.8.16.16:

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

diff --git a/src/compiler/fndb.lisp b/src/compiler/fndb.lisp
index 2b6ba93..309758f 100644 (file)
--- a/src/compiler/fndb.lisp
+++ b/src/compiler/fndb.lisp
@@ -35,15 +35,17 @@
   ;; FIXME: It's actually not clear that COERCE on non-NUMBER types
   ;; is FOLDABLE at all. Check this.
   (movable #-sb-xc-host foldable)
   ;; FIXME: It's actually not clear that COERCE on non-NUMBER types
   ;; is FOLDABLE at all. Check this.
   (movable #-sb-xc-host foldable)

-  :derive-type (result-type-specifier-nth-arg 2))
+  ;; :DERIVE-TYPE RESULT-TYPE-SPEC-NTH-ARG 2 ? Nope... (COERCE 1 'COMPLEX)
+  ;; returns REAL/INTEGER, not COMPLEX.
+  )

 (defknown list-to-vector* (list type-specifier) vector)
 (defknown vector-to-vector* (vector type-specifier) vector)
 
 (defknown type-of (t) t (foldable flushable))
 
 ;;; These can be affected by type definitions, so they're not FOLDABLE.
 (defknown list-to-vector* (list type-specifier) vector)
 (defknown vector-to-vector* (vector type-specifier) vector)
 
 (defknown type-of (t) t (foldable flushable))
 
 ;;; These can be affected by type definitions, so they're not FOLDABLE.

-(defknown (upgraded-complex-part-type upgraded-array-element-type)
-         (type-specifier) type-specifier
+(defknown (upgraded-complex-part-type sb!xc:upgraded-array-element-type)
+         (type-specifier &optional lexenv-designator) type-specifier

   (unsafely-flushable))
 \f
 ;;;; from the "Predicates" chapter:
   (unsafely-flushable))
 \f
 ;;;; from the "Predicates" chapter:

@@ -54,7 +56,7 @@
 ;;; FIXNUMness) might be different between host and target. Perhaps
 ;;; this property should be protected by #-SB-XC-HOST? Perhaps we need
 ;;; 3-stage bootstrapping after all? (Ugh! It's *so* slow already!)
 ;;; FIXNUMness) might be different between host and target. Perhaps
 ;;; this property should be protected by #-SB-XC-HOST? Perhaps we need
 ;;; 3-stage bootstrapping after all? (Ugh! It's *so* slow already!)

-(defknown typep (t type-specifier) t
+(defknown typep (t type-specifier &optional lexenv-designator) t

    ;; Unlike SUBTYPEP or UPGRADED-ARRAY-ELEMENT-TYPE and friends, this
    ;; seems to be FOLDABLE. Like SUBTYPEP, it's affected by type
    ;; definitions, but unlike SUBTYPEP, there should be no way to make
    ;; Unlike SUBTYPEP or UPGRADED-ARRAY-ELEMENT-TYPE and friends, this
    ;; seems to be FOLDABLE. Like SUBTYPEP, it's affected by type
    ;; definitions, but unlike SUBTYPEP, there should be no way to make

@@ -73,7 +75,8 @@
    ;; (UPGRADED-ARRAY-ELEMENT-TYPE and UPGRADED-COMPLEX-PART-TYPE have
    ;; behavior like SUBTYPEP in this respect, not like TYPEP.)
    (foldable))
    ;; (UPGRADED-ARRAY-ELEMENT-TYPE and UPGRADED-COMPLEX-PART-TYPE have
    ;; behavior like SUBTYPEP in this respect, not like TYPEP.)
    (foldable))

-(defknown subtypep (type-specifier type-specifier) (values boolean boolean)
+(defknown subtypep (type-specifier type-specifier &optional lexenv-designator)
+  (values boolean boolean)

   ;; This is not FOLDABLE because its value is affected by type
   ;; definitions.
   ;;
   ;; This is not FOLDABLE because its value is affected by type
   ;; definitions.
   ;;

@@ -93,10 +96,10 @@
 ;;;; classes
 
 (sb!xc:deftype name-for-class () t)
 ;;;; classes
 
 (sb!xc:deftype name-for-class () t)

-(defknown class-name (sb!xc:class) name-for-class (flushable))
-(defknown find-class (name-for-class &optional t lexenv)
-  (or sb!xc:class null) ())
-(defknown class-of (t) sb!xc:class (flushable))
+(defknown classoid-name (classoid) name-for-class (flushable))
+(defknown find-classoid (name-for-class &optional t lexenv-designator)
+  (or classoid null) ())
+(defknown classoid-of (t) classoid (flushable))

 (defknown layout-of (t) layout (flushable))
 (defknown copy-structure (structure-object) structure-object
   (flushable unsafe))
 (defknown layout-of (t) layout (flushable))
 (defknown copy-structure (structure-object) structure-object
   (flushable unsafe))

@@ -105,7 +108,14 @@
 
 ;;; This is not FLUSHABLE, since it's required to signal an error if
 ;;; unbound.
 
 ;;; This is not FLUSHABLE, since it's required to signal an error if
 ;;; unbound.

-(defknown (symbol-value symbol-function) (symbol) t ())
+(defknown (symbol-value) (symbol) t ())
+;;; From CLHS, "If the symbol is globally defined as a macro or a
+;;; special operator, an object of implementation-dependent nature and
+;;; identity is returned. If the symbol is not globally defined as
+;;; either a macro or a special operator, and if the symbol is fbound,
+;;; a function object is returned".  Our objects of
+;;; implementation-dependent nature happen to be functions.
+(defknown (symbol-function) (symbol) function ())

 
 (defknown boundp (symbol) boolean (flushable))
 (defknown fboundp ((or symbol cons)) boolean (unsafely-flushable explicit-check))
 
 (defknown boundp (symbol) boolean (flushable))
 (defknown fboundp ((or symbol cons)) boolean (unsafely-flushable explicit-check))

@@ -121,13 +131,18 @@
 (defknown fmakunbound ((or symbol cons)) (or symbol cons)
   (unsafe explicit-check))
 (defknown (get-setf-method get-setf-method-multiple-value)
 (defknown fmakunbound ((or symbol cons)) (or symbol cons)
   (unsafe explicit-check))
 (defknown (get-setf-method get-setf-method-multiple-value)

-  ((or list symbol) &optional lexenv)
+  ((or list symbol) &optional lexenv-designator)

   (values list list list form form)
   (flushable))
 (defknown apply (callable t &rest t) *) ; ### Last arg must be List...
 (defknown funcall (callable &rest t) *)
 
   (values list list list form form)
   (flushable))
 (defknown apply (callable t &rest t) *) ; ### Last arg must be List...
 (defknown funcall (callable &rest t) *)
 

-(defknown (mapcar maplist mapcan mapcon) (callable list &rest list) list
+(defknown (mapcar maplist) (callable list &rest list) list
+  (call))
+
+;;; According to CLHS the result must be a LIST, but we do not check
+;;; it.
+(defknown (mapcan mapcon) (callable list &rest list) t

   (call))
 
 (defknown (mapc mapl) (callable list &rest list) list (foldable call))
   (call))
 
 (defknown (mapc mapl) (callable list &rest list) list (foldable call))

@@ -140,13 +155,13 @@
 \f
 ;;;; from the "Macros" chapter:
 
 \f
 ;;;; from the "Macros" chapter:
 

-(defknown macro-function (symbol &optional lexenv)
+(defknown macro-function (symbol &optional lexenv-designator)

   (or function null)
   (flushable))
   (or function null)
   (flushable))

-(defknown (macroexpand macroexpand-1) (t &optional lexenv)
+(defknown (macroexpand macroexpand-1) (t &optional lexenv-designator)

   (values form &optional boolean))
 
   (values form &optional boolean))
 

-(defknown compiler-macro-function (t &optional lexenv)
+(defknown compiler-macro-function (t &optional lexenv-designator)

   (or function null)
   (flushable))
 \f
   (or function null)
   (flushable))
 \f

@@ -170,17 +185,14 @@
 \f
 ;;;; from the "Packages" chapter:
 
 \f
 ;;;; from the "Packages" chapter:
 

-(sb!xc:deftype package-designator () '(or stringable sb!xc:package))
-(sb!xc:deftype symbols () '(or list symbol))
-

 (defknown gentemp (&optional string package-designator) symbol)
 
 (defknown gentemp (&optional string package-designator) symbol)
 

-(defknown make-package (stringable &key
-                                  (:use list)
-                                  (:nicknames list)
-                                  ;; ### extensions...
-                                  (:internal-symbols index)
-                                  (:external-symbols index))
+(defknown make-package (string-designator &key
+                                         (:use list)
+                                         (:nicknames list)
+                                         ;; ### extensions...
+                                         (:internal-symbols index)
+                                         (:external-symbols index))

   sb!xc:package)
 (defknown find-package (package-designator) (or sb!xc:package null)
   (flushable))
   sb!xc:package)
 (defknown find-package (package-designator) (or sb!xc:package null)
   (flushable))

@@ -199,15 +211,17 @@
 (defknown find-symbol (string &optional package-designator)
   (values symbol (member :internal :external :inherited nil))
   (flushable))
 (defknown find-symbol (string &optional package-designator)
   (values symbol (member :internal :external :inherited nil))
   (flushable))

-(defknown (export import) (symbols &optional package-designator) (eql t))
+(defknown (export import) (symbols-designator &optional package-designator) 
+  (eql t))

 (defknown unintern (symbol &optional package-designator) boolean)
 (defknown unintern (symbol &optional package-designator) boolean)

-(defknown unexport (symbols &optional package-designator) (eql t))
-(defknown shadowing-import (symbols &optional package-designator) (eql t))
+(defknown unexport (symbols-designator &optional package-designator) (eql t))
+(defknown shadowing-import (symbols-designator &optional package-designator)
+  (eql t))

 (defknown shadow ((or symbol string list) &optional package-designator)
   (eql t))
 (defknown (use-package unuse-package)
   ((or list package-designator) &optional package-designator) (eql t))
 (defknown shadow ((or symbol string list) &optional package-designator)
   (eql t))
 (defknown (use-package unuse-package)
   ((or list package-designator) &optional package-designator) (eql t))

-(defknown find-all-symbols (stringable) list (flushable))
+(defknown find-all-symbols (string-designator) list (flushable))

 \f
 ;;;; from the "Numbers" chapter:
 
 \f
 ;;;; from the "Numbers" chapter:
 

@@ -321,21 +335,21 @@
   (movable foldable flushable explicit-check))
 
 (defknown (ffloor fceiling fround ftruncate)
   (movable foldable flushable explicit-check))
 
 (defknown (ffloor fceiling fround ftruncate)

-  (real &optional real) (values float float)
+  (real &optional real) (values float real)

   (movable foldable flushable explicit-check))
 
 (defknown decode-float (float) (values float float-exponent float)
   (movable foldable flushable explicit-check))
   (movable foldable flushable explicit-check))
 
 (defknown decode-float (float) (values float float-exponent float)
   (movable foldable flushable explicit-check))

-(defknown scale-float (float float-exponent) float
-  (movable foldable flushable explicit-check))
+(defknown scale-float (float integer) float
+  (movable foldable unsafely-flushable explicit-check))

 (defknown float-radix (float) float-radix
 (defknown float-radix (float) float-radix

-  (movable foldable flushable explicit-check))
+  (movable foldable flushable))

 (defknown float-sign (float &optional float) float
   (movable foldable flushable explicit-check))
 (defknown (float-digits float-precision) (float) float-digits
   (movable foldable flushable explicit-check))
 (defknown integer-decode-float (float)
 (defknown float-sign (float &optional float) float
   (movable foldable flushable explicit-check))
 (defknown (float-digits float-precision) (float) float-digits
   (movable foldable flushable explicit-check))
 (defknown integer-decode-float (float)

-         (values integer float-exponent (member -1 1))
+         (values integer float-int-exponent (member -1 1))

          (movable foldable flushable explicit-check))
 
 (defknown complex (real &optional real) number
          (movable foldable flushable explicit-check))
 
 (defknown complex (real &optional real) number

@@ -355,7 +369,7 @@
 
 (defknown lognot (integer) integer (movable foldable flushable explicit-check))
 (defknown logtest (integer integer) boolean (movable foldable flushable))
 
 (defknown lognot (integer) integer (movable foldable flushable explicit-check))
 (defknown logtest (integer integer) boolean (movable foldable flushable))

-(defknown logbitp (bit-index integer) boolean (movable foldable flushable))
+(defknown logbitp (unsigned-byte integer) boolean (movable foldable flushable))

 (defknown ash (integer integer) integer
   (movable foldable flushable explicit-check))
 (defknown (logcount integer-length) (integer) bit-index
 (defknown ash (integer integer) integer
   (movable foldable flushable explicit-check))
 (defknown (logcount integer-length) (integer) bit-index

@@ -378,7 +392,8 @@
   (movable foldable flushable))
 (defknown deposit-field (integer byte-specifier integer) integer
   (movable foldable flushable))
   (movable foldable flushable))
 (defknown deposit-field (integer byte-specifier integer) integer
   (movable foldable flushable))

-(defknown random ((real (0)) &optional random-state) (real 0) ())
+(defknown random ((or (float (0.0)) (integer 1)) &optional random-state)
+  (or (float 0.0) (integer 0)) ())

 (defknown make-random-state (&optional (or (member nil t) random-state))
   random-state (flushable))
 (defknown random-state-p (t) boolean (movable foldable flushable))
 (defknown make-random-state (&optional (or (member nil t) random-state))
   random-state (flushable))
 (defknown random-state-p (t) boolean (movable foldable flushable))

@@ -388,7 +403,7 @@
                           upper-case-p lower-case-p both-case-p alphanumericp)
   (character) boolean (movable foldable flushable))
 
                           upper-case-p lower-case-p both-case-p alphanumericp)
   (character) boolean (movable foldable flushable))
 

-(defknown digit-char-p (character &optional unsigned-byte)
+(defknown digit-char-p (character &optional (integer 2 36))

   (or (integer 0 35) null) (movable foldable flushable))
 
 (defknown (char= char/= char< char> char<= char>= char-equal char-not-equal
   (or (integer 0 35) null) (movable foldable flushable))
 
 (defknown (char= char/= char< char> char<= char>= char-equal char-not-equal

@@ -399,14 +414,14 @@
 (defknown char-code (character) char-code (movable foldable flushable))
 (defknown (char-upcase char-downcase) (character) character
   (movable foldable flushable))
 (defknown char-code (character) char-code (movable foldable flushable))
 (defknown (char-upcase char-downcase) (character) character
   (movable foldable flushable))

-(defknown digit-char (integer &optional integer)
+(defknown digit-char (unsigned-byte &optional (integer 2 36))

   (or character null) (movable foldable flushable))
 (defknown char-int (character) char-code (movable foldable flushable))
 (defknown char-name (character) (or simple-string null)
   (movable foldable flushable))
   (or character null) (movable foldable flushable))
 (defknown char-int (character) char-code (movable foldable flushable))
 (defknown char-name (character) (or simple-string null)
   (movable foldable flushable))

-(defknown name-char (stringable) (or character null)
+(defknown name-char (string-designator) (or character null)

   (movable foldable flushable))
   (movable foldable flushable))

-(defknown code-char (char-code) base-char
+(defknown code-char (char-code) character

   ;; By suppressing constant folding on CODE-CHAR when the
   ;; cross-compiler is running in the cross-compilation host vanilla
   ;; ANSI Common Lisp, we can use CODE-CHAR expressions to delay until
   ;; By suppressing constant folding on CODE-CHAR when the
   ;; cross-compiler is running in the cross-compilation host vanilla
   ;; ANSI Common Lisp, we can use CODE-CHAR expressions to delay until

@@ -425,12 +440,12 @@
   :derive-type (sequence-result-nth-arg 1))
 
 (defknown copy-seq (sequence) consed-sequence (flushable)
   :derive-type (sequence-result-nth-arg 1))
 
 (defknown copy-seq (sequence) consed-sequence (flushable)

-  :derive-type #'result-type-first-arg)
+  :derive-type (sequence-result-nth-arg 1))

 
 (defknown length (sequence) index (foldable flushable))
 
 (defknown reverse (sequence) consed-sequence (flushable)
 
 (defknown length (sequence) index (foldable flushable))
 
 (defknown reverse (sequence) consed-sequence (flushable)

-  :derive-type #'result-type-first-arg)
+  :derive-type (sequence-result-nth-arg 1))

 
 (defknown nreverse (sequence) sequence ()
   :derive-type #'result-type-first-arg)
 
 (defknown nreverse (sequence) sequence ()
   :derive-type #'result-type-first-arg)

@@ -440,11 +455,11 @@
                                        (:initial-element t))
   consed-sequence
   (movable unsafe)
                                        (:initial-element t))
   consed-sequence
   (movable unsafe)

-  :derive-type (result-type-specifier-nth-arg 1))
+  :derive-type (creation-result-type-specifier-nth-arg 1))

 
 (defknown concatenate (type-specifier &rest sequence) consed-sequence
   ()
 
 (defknown concatenate (type-specifier &rest sequence) consed-sequence
   ()

-  :derive-type (result-type-specifier-nth-arg 1))
+  :derive-type (creation-result-type-specifier-nth-arg 1))

 
 (defknown (map %map) (type-specifier callable sequence &rest sequence)
   consed-sequence
 
 (defknown (map %map) (type-specifier callable sequence &rest sequence)
   consed-sequence

@@ -459,6 +474,11 @@
 (defknown %map-to-nil-on-vector (callable vector) null (flushable call))
 (defknown %map-to-nil-on-sequence (callable sequence) null (flushable call))
 
 (defknown %map-to-nil-on-vector (callable vector) null (flushable call))
 (defknown %map-to-nil-on-sequence (callable sequence) null (flushable call))
 

+(defknown map-into (sequence callable &rest sequence)
+  sequence
+  (call)
+  :derive-type #'result-type-first-arg)
+

 ;;; returns the result from the predicate...
 (defknown some (callable sequence &rest sequence) t
   (foldable unsafely-flushable call))
 ;;; returns the result from the predicate...
 (defknown some (callable sequence &rest sequence) t
   (foldable unsafely-flushable call))

@@ -614,12 +634,15 @@
 (defknown (stable-sort sort) (sequence callable &key (:key callable)) sequence
   (call)
   :derive-type (sequence-result-nth-arg 1))
 (defknown (stable-sort sort) (sequence callable &key (:key callable)) sequence
   (call)
   :derive-type (sequence-result-nth-arg 1))

+(defknown sb!impl::sort-vector (vector index index function (or function null))
+  * ; SORT-VECTOR works through side-effect
+  (call))

 
 (defknown merge (type-specifier sequence sequence callable
                                &key (:key callable))
   sequence
   (call)
 
 (defknown merge (type-specifier sequence sequence callable
                                &key (:key callable))
   sequence
   (call)

-  :derive-type (result-type-specifier-nth-arg 1))
+  :derive-type (creation-result-type-specifier-nth-arg 1))

 
 ;;; not FLUSHABLE, despite what CMU CL's DEFKNOWN said..
 (defknown read-sequence (sequence stream
 
 ;;; not FLUSHABLE, despite what CMU CL's DEFKNOWN said..
 (defknown read-sequence (sequence stream

@@ -643,6 +666,9 @@
   t
   (foldable flushable))
 
   t
   (foldable flushable))
 

+;; Correct argument type restrictions for these functions are
+;; complicated, so we just declare them to accept LISTs and suppress
+;; flushing is safe code.

 (defknown (caar cadr cdar cddr
                 caaar caadr cadar caddr cdaar cdadr cddar cdddr
                 caaaar caaadr caadar caaddr cadaar cadadr caddar cadddr
 (defknown (caar cadr cdar cddr
                 caaar caadr cadar caddr cdaar cdadr cddar cdddr
                 caaaar caaadr caadar caaddr cadaar cadadr caddar cadddr

@@ -656,11 +682,11 @@
 
 (defknown tree-equal (t t &key (:test callable) (:test-not callable)) boolean
   (foldable flushable call))
 
 (defknown tree-equal (t t &key (:test callable) (:test-not callable)) boolean
   (foldable flushable call))

-(defknown endp (t) boolean (foldable unsafely-flushable movable))
+(defknown endp (list) boolean (foldable flushable movable))

 (defknown list-length (list) (or index null) (foldable unsafely-flushable))
 (defknown list-length (list) (or index null) (foldable unsafely-flushable))

-(defknown nth (index list) t (foldable flushable))
-(defknown nthcdr (index list) t (foldable unsafely-flushable))
-(defknown last (list &optional index) list (foldable flushable))
+(defknown nth (unsigned-byte list) t (foldable flushable))
+(defknown nthcdr (unsigned-byte list) t (foldable unsafely-flushable))
+(defknown last (list &optional unsigned-byte) t (foldable flushable))

 (defknown list (&rest t) list (movable flushable unsafe))
 (defknown list* (t &rest t) t (movable flushable unsafe))
 (defknown make-list (index &key (:initial-element t)) list
 (defknown list (&rest t) list (movable flushable unsafe))
 (defknown list* (t &rest t) t (movable flushable unsafe))
 (defknown make-list (index &key (:initial-element t)) list

@@ -680,23 +706,23 @@
 ;;; not check it now :-).
 (defknown nconc (&rest t) t ())
 
 ;;; not check it now :-).
 (defknown nconc (&rest t) t ())
 

-(defknown nreconc (list t) list ())
-(defknown butlast (list &optional index) list (flushable))
-(defknown nbutlast (list &optional index) list ())
+(defknown nreconc (list t) t ())
+(defknown butlast (list &optional unsigned-byte) list (flushable))
+(defknown nbutlast (list &optional unsigned-byte) list ())

 (defknown ldiff (list t) list (flushable))
 (defknown (rplaca rplacd) (cons t) list (unsafe))
 
 (defknown (nsubst subst) (t t t &key (:key callable) (:test callable)
                            (:test-not callable))
 (defknown ldiff (list t) list (flushable))
 (defknown (rplaca rplacd) (cons t) list (unsafe))
 
 (defknown (nsubst subst) (t t t &key (:key callable) (:test callable)
                            (:test-not callable))

-  list (flushable unsafe call))
+  t (flushable unsafe call))

 
 (defknown (subst-if subst-if-not nsubst-if nsubst-if-not)
 
 (defknown (subst-if subst-if-not nsubst-if nsubst-if-not)

-         (t t t &key (:key callable))
-  list (flushable unsafe call))
+         (t callable t &key (:key callable))
+  t (flushable unsafe call))

 
 (defknown (sublis nsublis) (list t &key (:key callable) (:test callable)
                                 (:test-not callable))
 
 (defknown (sublis nsublis) (list t &key (:key callable) (:test callable)
                                 (:test-not callable))

-  list (flushable unsafe call))
+  t (flushable unsafe call))

 
 (defknown member (t list &key (:key callable) (:test callable)
                    (:test-not callable))
 
 (defknown member (t list &key (:key callable) (:test callable)
                    (:test-not callable))

@@ -761,7 +787,7 @@
 (defknown hash-table-size (hash-table) index (flushable))
 (defknown hash-table-test (hash-table) symbol (foldable flushable))
 (defknown sxhash (t) (integer 0 #.sb!xc:most-positive-fixnum)
 (defknown hash-table-size (hash-table) index (flushable))
 (defknown hash-table-test (hash-table) symbol (foldable flushable))
 (defknown sxhash (t) (integer 0 #.sb!xc:most-positive-fixnum)

-  (foldable flushable))
+  (#-sb-xc-host foldable flushable))

 \f
 ;;;; from the "Arrays" chapter
 
 \f
 ;;;; from the "Arrays" chapter
 

@@ -778,8 +804,8 @@
 
 (defknown vector (&rest t) simple-vector (flushable unsafe))
 
 
 (defknown vector (&rest t) simple-vector (flushable unsafe))
 

-(defknown aref (array &rest index) t (foldable flushable))
-(defknown row-major-aref (array index) t (foldable flushable))
+(defknown aref (array &rest index) t (foldable))
+(defknown row-major-aref (array index) t (foldable))

 
 (defknown array-element-type (array)
   type-specifier
 
 (defknown array-element-type (array)
   type-specifier

@@ -787,7 +813,7 @@
 (defknown array-rank (array) array-rank (foldable flushable))
 (defknown array-dimension (array array-rank) index (foldable flushable))
 (defknown array-dimensions (array) list (foldable flushable))
 (defknown array-rank (array) array-rank (foldable flushable))
 (defknown array-dimension (array array-rank) index (foldable flushable))
 (defknown array-dimensions (array) list (foldable flushable))

-(defknown array-in-bounds-p (array &rest index) boolean (foldable flushable))
+(defknown array-in-bounds-p (array &rest integer) boolean (foldable flushable))

 (defknown array-row-major-index (array &rest index) array-total-size
   (foldable flushable))
 (defknown array-total-size (array) array-total-size (foldable flushable))
 (defknown array-row-major-index (array &rest index) array-total-size
   (foldable flushable))
 (defknown array-total-size (array) array-total-size (foldable flushable))

@@ -799,16 +825,19 @@
 
 (defknown (bit-and bit-ior bit-xor bit-eqv bit-nand bit-nor bit-andc1 bit-andc2
                   bit-orc1 bit-orc2)
 
 (defknown (bit-and bit-ior bit-xor bit-eqv bit-nand bit-nor bit-andc1 bit-andc2
                   bit-orc1 bit-orc2)

-  ((array bit) (array bit) &optional (or (array bit) (member t)))
+  ((array bit) (array bit) &optional (or (array bit) (member t nil)))

   (array bit)
   (foldable)
   #|:derive-type #'result-type-last-arg|#)
 
   (array bit)
   (foldable)
   #|:derive-type #'result-type-last-arg|#)
 

-(defknown bit-not ((array bit) &optional (or (array bit) (member t)))
+(defknown bit-not ((array bit) &optional (or (array bit) (member t nil)))

   (array bit)
   (foldable)
   #|:derive-type #'result-type-last-arg|#)
 
   (array bit)
   (foldable)
   #|:derive-type #'result-type-last-arg|#)
 

+(defknown bit-vector-= (bit-vector bit-vector) boolean
+  (movable foldable flushable))
+

 (defknown array-has-fill-pointer-p (array) boolean
   (movable foldable flushable))
 (defknown fill-pointer (vector) index (foldable unsafely-flushable))
 (defknown array-has-fill-pointer-p (array) boolean
   (movable foldable flushable))
 (defknown fill-pointer (vector) index (foldable unsafely-flushable))

@@ -818,7 +847,7 @@
 
 (defknown adjust-array
   (array (or index list) &key (:element-type type-specifier)
 
 (defknown adjust-array
   (array (or index list) &key (:element-type type-specifier)

-        (:initial-element t) (:initial-contents list)
+        (:initial-element t) (:initial-contents t)

         (:fill-pointer t) (:displaced-to (or array null))
         (:displaced-index-offset index))
   array (unsafe))
         (:fill-pointer t) (:displaced-to (or array null))
         (:displaced-index-offset index))
   array (unsafe))

@@ -829,10 +858,8 @@
 (defknown char (string index) character (foldable flushable))
 (defknown schar (simple-string index) character (foldable flushable))
 
 (defknown char (string index) character (foldable flushable))
 (defknown schar (simple-string index) character (foldable flushable))
 

-(sb!xc:deftype stringable () '(or character string symbol))
-

 (defknown (string= string-equal)
 (defknown (string= string-equal)

-  (stringable stringable &key (:start1 index) (:end1 sequence-end)
+  (string-designator string-designator &key (:start1 index) (:end1 sequence-end)

              (:start2 index) (:end2 sequence-end))
   boolean
   (foldable flushable))
              (:start2 index) (:end2 sequence-end))
   boolean
   (foldable flushable))

@@ -840,7 +867,7 @@
 (defknown (string< string> string<= string>= string/= string-lessp
                   string-greaterp string-not-lessp string-not-greaterp
                   string-not-equal)
 (defknown (string< string> string<= string>= string/= string-lessp
                   string-greaterp string-not-lessp string-not-greaterp
                   string-not-equal)

-  (stringable stringable &key (:start1 index) (:end1 sequence-end)
+  (string-designator string-designator &key (:start1 index) (:end1 sequence-end)

              (:start2 index) (:end2 sequence-end))
   (or index null)
   (foldable flushable))
              (:start2 index) (:end2 sequence-end))
   (or index null)
   (foldable flushable))

@@ -850,35 +877,35 @@
   simple-string (flushable))
 
 (defknown (string-trim string-left-trim string-right-trim)
   simple-string (flushable))
 
 (defknown (string-trim string-left-trim string-right-trim)

-  (sequence stringable) simple-string (flushable))
+  (sequence string-designator) simple-string (flushable))

 
 (defknown (string-upcase string-downcase string-capitalize)
 
 (defknown (string-upcase string-downcase string-capitalize)

-  (stringable &key (:start index) (:end sequence-end))
+  (string-designator &key (:start index) (:end sequence-end))

   simple-string (flushable))
 
 (defknown (nstring-upcase nstring-downcase nstring-capitalize)
   (string &key (:start index) (:end sequence-end))
   string ())
 
   simple-string (flushable))
 
 (defknown (nstring-upcase nstring-downcase nstring-capitalize)
   (string &key (:start index) (:end sequence-end))
   string ())
 

-(defknown string (stringable) string
+(defknown string (string-designator) string

   (flushable explicit-check))
 \f
 ;;;; internal non-keyword versions of string predicates:
 
 (defknown (string<* string>* string<=* string>=* string/=*)
   (flushable explicit-check))
 \f
 ;;;; internal non-keyword versions of string predicates:
 
 (defknown (string<* string>* string<=* string>=* string/=*)

-  (stringable stringable index sequence-end index sequence-end)
+  (string-designator string-designator index sequence-end index sequence-end)

   (or index null)
   (foldable flushable))
 
 (defknown string=*
   (or index null)
   (foldable flushable))
 
 (defknown string=*

-  (stringable stringable index sequence-end index sequence-end)
+  (string-designator string-designator index sequence-end index sequence-end)

   boolean
   (foldable flushable))
 \f
 ;;;; from the "Eval" chapter:
 
 (defknown eval (t) * (recursive))
   boolean
   (foldable flushable))
 \f
 ;;;; from the "Eval" chapter:
 
 (defknown eval (t) * (recursive))

-(defknown constantp (t &optional lexenv) boolean
+(defknown constantp (t &optional lexenv-designator) boolean

   (foldable flushable))
 \f
 ;;;; from the "Streams" chapter:
   (foldable flushable))
 \f
 ;;;; from the "Streams" chapter:

@@ -888,9 +915,13 @@
 (defknown make-concatenated-stream (&rest stream) stream (unsafely-flushable))
 (defknown make-two-way-stream (stream stream) stream (unsafely-flushable))
 (defknown make-echo-stream (stream stream) stream (flushable))
 (defknown make-concatenated-stream (&rest stream) stream (unsafely-flushable))
 (defknown make-two-way-stream (stream stream) stream (unsafely-flushable))
 (defknown make-echo-stream (stream stream) stream (flushable))

-(defknown make-string-input-stream (string &optional index index) stream
+(defknown make-string-input-stream (string &optional index sequence-end)
+  stream

   (flushable unsafe))
   (flushable unsafe))

-(defknown make-string-output-stream () stream (flushable))
+(defknown make-string-output-stream 
+    (&key (:element-type type-specifier)) 
+    stream 
+  (flushable))

 (defknown get-output-stream-string (stream) simple-string ())
 (defknown streamp (t) boolean (movable foldable flushable))
 (defknown stream-element-type (stream) type-specifier
 (defknown get-output-stream-string (stream) simple-string ())
 (defknown streamp (t) boolean (movable foldable flushable))
 (defknown stream-element-type (stream) type-specifier

@@ -929,22 +960,58 @@
   (character character &optional (or readtable null)) (or callable null)
   ())
 
   (character character &optional (or readtable null)) (or callable null)
   ())
 

+(defknown copy-pprint-dispatch
+  (&optional (or sb!pretty:pprint-dispatch-table null))
+  sb!pretty:pprint-dispatch-table
+  ())
+(defknown pprint-dispatch
+  (t &optional (or sb!pretty:pprint-dispatch-table null))
+  (values callable boolean)
+  ())
+(defknown (pprint-fill pprint-linear)
+  (stream-designator t &optional t t)
+  null
+  ())
+(defknown pprint-tabular
+  (stream-designator t &optional t t unsigned-byte)
+  null
+  ())
+(defknown pprint-indent
+  ((member :block :current) real &optional stream-designator)
+  null
+  ())
+(defknown pprint-newline
+  ((member :linear :fill :miser :mandatory) &optional stream-designator)
+  null
+  ())
+(defknown pprint-tab
+  ((member :line :section :line-relative :section-relative)
+   unsigned-byte unsigned-byte &optional stream-designator)
+  null
+  ())
+(defknown set-pprint-dispatch
+  (type-specifier (or null callable)
+   &optional real sb!pretty:pprint-dispatch-table)
+  null
+  ())
+

 ;;; may return any type due to eof-value...
 (defknown (read read-preserving-whitespace read-char-no-hang read-char)
 ;;; may return any type due to eof-value...
 (defknown (read read-preserving-whitespace read-char-no-hang read-char)

-  (&optional streamlike t t t) t (explicit-check))
+  (&optional stream-designator t t t) t (explicit-check))

 
 

-(defknown read-delimited-list (character &optional streamlike t) t
+(defknown read-delimited-list (character &optional stream-designator t) list

   (explicit-check))
   (explicit-check))

-(defknown read-line (&optional streamlike t t t) (values t boolean)
+(defknown read-line (&optional stream-designator t t t) (values t boolean)

   (explicit-check))
   (explicit-check))

-(defknown unread-char (character &optional streamlike) t
+(defknown unread-char (character &optional stream-designator) t

   (explicit-check))
   (explicit-check))

-(defknown peek-char (&optional (or character (member nil t)) streamlike t t t)
+(defknown peek-char (&optional (or character (member nil t)) 
+                              stream-designator t t t)

   t
   (explicit-check))
   t
   (explicit-check))

-(defknown listen (&optional streamlike) boolean (flushable explicit-check))
+(defknown listen (&optional stream-designator) boolean (flushable explicit-check))

 
 

-(defknown clear-input (&optional stream) null (explicit-check))
+(defknown clear-input (&optional stream-designator) null (explicit-check))

 
 (defknown read-from-string
   (string &optional t t
 
 (defknown read-from-string
   (string &optional t t

@@ -965,7 +1032,7 @@
 
 (defknown write
   (t &key
 
 (defknown write
   (t &key

-     (:stream streamlike)
+     (:stream stream-designator)

      (:escape t)
      (:radix t)
      (:base (integer 2 36))
      (:escape t)
      (:radix t)
      (:base (integer 2 36))

@@ -985,11 +1052,14 @@
   (any explicit-check)
   :derive-type #'result-type-first-arg)
 
   (any explicit-check)
   :derive-type #'result-type-first-arg)
 

-(defknown (prin1 print princ) (t &optional streamlike) t (any explicit-check)
+(defknown (prin1 print princ) (t &optional stream-designator) 
+  t 
+  (any explicit-check)

   :derive-type #'result-type-first-arg)
 
 ;;; xxx-TO-STRING functions are not foldable because they depend on
   :derive-type #'result-type-first-arg)
 
 ;;; xxx-TO-STRING functions are not foldable because they depend on

-;;; the dynamic environment.
+;;; the dynamic environment, the state of the pretty printer dispatch
+;;; table, and probably other run-time factors.

 (defknown write-to-string
   (t &key (:escape t) (:radix t) (:base (integer 2 36)) (:readably t)
      (:circle t) (:pretty t) (:level (or unsigned-byte null))
 (defknown write-to-string
   (t &key (:escape t) (:radix t) (:base (integer 2 36)) (:readably t)
      (:circle t) (:pretty t) (:level (or unsigned-byte null))

@@ -997,28 +1067,29 @@
      (:lines (or unsigned-byte null)) (:right-margin (or unsigned-byte null))
      (:miser-width (or unsigned-byte null)) (:pprint-dispatch t))
   simple-string
      (:lines (or unsigned-byte null)) (:right-margin (or unsigned-byte null))
      (:miser-width (or unsigned-byte null)) (:pprint-dispatch t))
   simple-string

-  (foldable flushable explicit-check))
+  (flushable explicit-check))

 
 (defknown (prin1-to-string princ-to-string) (t) simple-string (flushable))
 
 
 (defknown (prin1-to-string princ-to-string) (t) simple-string (flushable))
 

-(defknown write-char (character &optional streamlike) character
+(defknown write-char (character &optional stream-designator) character

   (explicit-check))
 (defknown (write-string write-line)
   (explicit-check))
 (defknown (write-string write-line)

-  (string &optional streamlike &key (:start index) (:end sequence-end))
+  (string &optional stream-designator &key (:start index) (:end sequence-end))

   string
   (explicit-check))
 
 (defknown (terpri finish-output force-output clear-output)
   string
   (explicit-check))
 
 (defknown (terpri finish-output force-output clear-output)

-  (&optional streamlike) null
+  (&optional stream-designator) null

   (explicit-check))
 
   (explicit-check))
 

-(defknown fresh-line (&optional streamlike) boolean
+(defknown fresh-line (&optional stream-designator) boolean

   (explicit-check))
 
 (defknown write-byte (integer stream) integer
   (explicit-check))
 
   (explicit-check))
 
 (defknown write-byte (integer stream) integer
   (explicit-check))
 

-(defknown format ((or streamlike string) (or string function) &rest t)
+(defknown format ((or (member nil t) stream string) 
+                 (or string function) &rest t)

   (or string null)
   (explicit-check))
 
   (or string null)
   (explicit-check))
 

@@ -1037,9 +1108,10 @@
                           (member nil :host :device
                                   :directory :name
                                   :type :version))
                           (member nil :host :device
                                   :directory :name
                                   :type :version))

-  boolean
+  generalized-boolean

   ())
   ())

-(defknown pathname-match-p (pathname-designator pathname-designator) boolean
+(defknown pathname-match-p (pathname-designator pathname-designator)
+  generalized-boolean

   ())
 (defknown translate-pathname (pathname-designator
                              pathname-designator
   ())
 (defknown translate-pathname (pathname-designator
                              pathname-designator

@@ -1048,7 +1120,8 @@
   ())
 
 (defknown logical-pathname (pathname-designator) logical-pathname ())
   ())
 
 (defknown logical-pathname (pathname-designator) logical-pathname ())

-(defknown translate-logical-pathname (pathname-designator &key) pathname ())
+(defknown translate-logical-pathname (pathname-designator &key) pathname
+  (recursive))

 (defknown load-logical-pathname-translations (string) t ())
 (defknown logical-pathname-translations (logical-host-designator) list ())
 
 (defknown load-logical-pathname-translations (string) t ())
 (defknown logical-pathname-translations (logical-host-designator) list ())
 

@@ -1102,7 +1175,7 @@
   pathname-version (flushable))
 
 (defknown (namestring file-namestring directory-namestring host-namestring)
   pathname-version (flushable))
 
 (defknown (namestring file-namestring directory-namestring host-namestring)

-  (pathname-designator) simple-string
+  (pathname-designator) (or simple-string null)

   (unsafely-flushable))
 
 (defknown enough-namestring (pathname-designator &optional pathname-designator)
   (unsafely-flushable))
 
 (defknown enough-namestring (pathname-designator &optional pathname-designator)

@@ -1119,7 +1192,7 @@
                                           :rename-and-delete :overwrite
                                           :append :supersede nil))
                       (:if-does-not-exist (member :error :create nil))
                                           :rename-and-delete :overwrite
                                           :append :supersede nil))
                       (:if-does-not-exist (member :error :create nil))

-                      (:external-format (member :default)))
+                      (:external-format keyword))

   (or stream null))
 
 (defknown rename-file (pathname-designator filename)
   (or stream null))
 
 (defknown rename-file (pathname-designator filename)

@@ -1148,12 +1221,32 @@
 (defknown directory (pathname-designator &key)
   list ())
 \f
 (defknown directory (pathname-designator &key)
   list ())
 \f

-;;;; from the "Errors" chapter:
-
-(defknown error (t &rest t) nil) ; never returns
-(defknown cerror (string t &rest t) null)
+;;;; from the "Conditions" chapter:
+
+(defknown cell-error-name (cell-error) t)
+(defknown error (t &rest t) nil)
+(defknown cerror (format-control t &rest t) null)
+(defknown invalid-method-error (t format-control &rest t) *) ; FIXME: first arg is METHOD
+(defknown method-combination-error (format-control &rest t) *)
+(defknown signal (t &rest t) null)
+(defknown simple-condition-format-control (condition)
+  format-control)
+(defknown simple-condition-format-arguments (condition)
+  list)

 (defknown warn (t &rest t) null)
 (defknown warn (t &rest t) null)

-(defknown break (&optional t &rest t) null)
+(defknown invoke-debugger (condition) nil)
+(defknown break (&optional format-control &rest t) null)
+(defknown make-condition (type-specifier &rest t) condition)
+(defknown compute-restarts (&optional (or condition null)) list)
+(defknown find-restart (restart-designator &optional (or condition null))
+  (or restart null))
+(defknown invoke-restart (restart-designator &rest t) *)
+(defknown invoke-restart-interactively (restart-designator) *)
+(defknown restart-name (restart) symbol)
+(defknown (abort muffle-warning) (&optional (or condition null)) nil)
+(defknown continue (&optional (or condition null)) null)
+(defknown (store-value use-value) (t &optional (or condition null))
+  null)

 
 ;;; and analogous SBCL extension:
 (defknown bug (t &rest t) nil) ; never returns
 
 ;;; and analogous SBCL extension:
 (defknown bug (t &rest t) nil) ; never returns

@@ -1181,9 +1274,10 @@
    (:block-compile t))
   (values (or pathname null) boolean boolean))
 
    (:block-compile t))
   (values (or pathname null) boolean boolean))
 

-(defknown disassemble (callable &key
-                               (:stream stream)
-                               (:use-labels t))
+;; FIXME: consider making (OR CALLABLE CONS) something like
+;; EXTENDED-FUNCTION-DESIGNATOR
+(defknown disassemble ((or callable cons) &key
+                      (:stream stream) (:use-labels t))

   null)
 
 (defknown fdocumentation (t symbol)
   null)
 
 (defknown fdocumentation (t symbol)

@@ -1193,12 +1287,12 @@
 (defknown describe (t &optional (or stream (member t nil))) (values))
 (defknown inspect (t) (values))
 (defknown room (&optional (member t nil :default)) (values))
 (defknown describe (t &optional (or stream (member t nil))) (values))
 (defknown inspect (t) (values))
 (defknown room (&optional (member t nil :default)) (values))

-(defknown ed (&optional (or symbol cons filename) &key (:init t) (:display t))
+(defknown ed (&optional (or symbol cons filename))

   t)
 (defknown dribble (&optional filename &key (:if-exists t)) (values))
 
   t)
 (defknown dribble (&optional filename &key (:if-exists t)) (values))
 

-(defknown apropos      (stringable &optional package-designator t) (values))
-(defknown apropos-list (stringable &optional package-designator t) list
+(defknown apropos      (string-designator &optional package-designator t) (values))
+(defknown apropos-list (string-designator &optional package-designator t) list

   (flushable))
 
 (defknown get-decoded-time ()
   (flushable))
 
 (defknown get-decoded-time ()

@@ -1285,7 +1379,13 @@
 (defknown %nlx-entry (t) *)
 (defknown %%primitive (t t &rest t) *)
 (defknown %pop-values (t) t)
 (defknown %nlx-entry (t) *)
 (defknown %%primitive (t t &rest t) *)
 (defknown %pop-values (t) t)

+(defknown %nip-values (t t &rest t) (values))

 (defknown %type-check-error (t t) nil)
 (defknown %type-check-error (t t) nil)

+
+;; FIXME: This function does not return, but due to the implementation
+;; of FILTER-LVAR we cannot write it here.
+(defknown %compile-time-type-error (t t t) *)
+

 (defknown %odd-key-args-error () nil)
 (defknown %unknown-key-arg-error (t) nil)
 (defknown (%ldb %mask-field) (bit-index bit-index integer) unsigned-byte
 (defknown %odd-key-args-error () nil)
 (defknown %unknown-key-arg-error (t) nil)
 (defknown (%ldb %mask-field) (bit-index bit-index integer) unsigned-byte

@@ -1295,13 +1395,13 @@
 (defknown %negate (number) number (movable foldable flushable explicit-check))
 (defknown %check-bound (array index fixnum) index (movable foldable flushable))
 (defknown data-vector-ref (simple-array index) t
 (defknown %negate (number) number (movable foldable flushable explicit-check))
 (defknown %check-bound (array index fixnum) index (movable foldable flushable))
 (defknown data-vector-ref (simple-array index) t

-  (foldable flushable explicit-check))
+  (foldable explicit-check))

 (defknown data-vector-set (array index t) t (unsafe explicit-check))
 (defknown hairy-data-vector-ref (array index) t
 (defknown data-vector-set (array index t) t (unsafe explicit-check))
 (defknown hairy-data-vector-ref (array index) t

-  (foldable flushable explicit-check))
+  (foldable explicit-check))

 (defknown hairy-data-vector-set (array index t) t (unsafe explicit-check))
 (defknown hairy-data-vector-set (array index t) t (unsafe explicit-check))

-(defknown sb!kernel:%caller-frame-and-pc () (values t t) (flushable))
-(defknown sb!kernel:%with-array-data (array index (or index null))
+(defknown %caller-frame-and-pc () (values t t) (flushable))
+(defknown %with-array-data (array index (or index null))

   (values (simple-array * (*)) index index index)
   (foldable flushable))
 (defknown %set-symbol-package (symbol t) t (unsafe))
   (values (simple-array * (*)) index index index)
   (foldable flushable))
 (defknown %set-symbol-package (symbol t) t (unsafe))

@@ -1316,8 +1416,26 @@
   (function sequence t index sequence-end function)
   (values t (or index null))
   (call))
   (function sequence t index sequence-end function)
   (values t (or index null))
   (call))

-
-(defknown sb!kernel::arg-count-error (t t t t t t) nil (unsafe))
+(defknown effective-find-position-test (callable callable)
+  function
+  (flushable foldable))
+(defknown effective-find-position-key (callable)
+  function
+  (flushable foldable))
+
+(defknown %check-vector-sequence-bounds (vector index sequence-end)
+  index
+  (unwind))
+;;; FIXME: including this information here is probably necessary to
+;;; get efficient compilation of the inline expansion of
+;;; %FIND-POSITION-IF, so it should maybe be in a more
+;;; compiler-friendly package (SB-INT?)
+(defknown sb!impl::signal-bounding-indices-bad-error
+    (sequence index sequence-end)
+  nil) ; never returns
+  
+
+(defknown arg-count-error (t t t t t t) nil (unsafe))

 \f
 ;;;; SETF inverses
 
 \f
 ;;;; SETF inverses
 

@@ -1328,8 +1446,8 @@
 (defknown %put (symbol t t) t (unsafe))
 (defknown %setelt (sequence index t) t (unsafe))
 (defknown %svset (simple-vector index t) t (unsafe))
 (defknown %put (symbol t t) t (unsafe))
 (defknown %setelt (sequence index t) t (unsafe))
 (defknown %svset (simple-vector index t) t (unsafe))

-(defknown %bitset (bit-vector &rest index) bit (unsafe))
-(defknown %sbitset (simple-bit-vector &rest index) bit (unsafe))
+(defknown %bitset ((array bit) &rest index) bit (unsafe))
+(defknown %sbitset ((simple-array bit) &rest index) bit (unsafe))

 (defknown %charset (string index character) character (unsafe))
 (defknown %scharset (simple-string index character) character (unsafe))
 (defknown %set-symbol-value (symbol t) t (unsafe))
 (defknown %charset (string index character) character (unsafe))
 (defknown %scharset (simple-string index character) character (unsafe))
 (defknown %set-symbol-value (symbol t) t (unsafe))

@@ -1338,10 +1456,41 @@
 (defknown (setf fdocumentation) ((or string null) t symbol)
   (or string null)
   ())
 (defknown (setf fdocumentation) ((or string null) t symbol)
   (or string null)
   ())

-(defknown %setnth (index list t) t (unsafe))
+(defknown %setnth (unsigned-byte list t) t (unsafe))

 (defknown %set-fill-pointer (vector index) index (unsafe))
 \f
 (defknown %set-fill-pointer (vector index) index (unsafe))
 \f

+;;;; ALIEN and call-out-to-C stuff
+
+;;; 'unsafe' attribute because we store the arg on the stack, which is in
+;;; some sense 'passing it upwards'
+(defknown sb!vm::push-word-on-c-stack (system-area-pointer) (values) (unsafe))
+(defknown sb!vm::pop-words-from-c-stack (index) (values) ())
+
+#!+linkage-table
+(defknown foreign-symbol-dataref-address (simple-string)
+  system-area-pointer
+  (movable flushable))
+
+(defknown foreign-symbol-address (simple-string &optional boolean)
+  system-area-pointer
+  (movable flushable))
+
+(defknown foreign-symbol-address-as-integer (simple-string &optional boolean)
+  integer
+  (movable flushable))
+

 ;;;; miscellaneous internal utilities
 
 (defknown %fun-name (function) t (flushable))
 (defknown (setf %fun-name) (t function) t (unsafe))
 ;;;; miscellaneous internal utilities
 
 (defknown %fun-name (function) t (flushable))
 (defknown (setf %fun-name) (t function) t (unsafe))

+
+(defknown policy-quality (policy symbol) policy-quality
+          (flushable))
+
+(defknown (compiler-abort compiler-error) (string &rest t) nil ())
+(defknown (compiler-warn compiler-style-warn) (string &rest t) (values) ())
+(defknown (compiler-notify maybe-compiler-notify) ((or string symbol) &rest t)
+  (values)
+  ())
+(defknown style-warn (string &rest t) null ())
+