0.pre8.103:

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

diff --git a/src/compiler/fndb.lisp b/src/compiler/fndb.lisp
index 703fdb3..113cb1d 100644 (file)
--- a/src/compiler/fndb.lisp
+++ b/src/compiler/fndb.lisp
@@ -35,20 +35,18 @@
   ;; 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))
-(defknown list-to-simple-string* (list) simple-string)
-(defknown list-to-bit-vector* (list) bit-vector)
-(defknown list-to-vector* (list type) vector)
-(defknown list-to-simple-vector* (list) simple-vector)
-(defknown vector-to-vector* (vector type) vector)
-(defknown vector-to-simple-string* (vector) vector)
+  ;; :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 (upgraded-complex-part-type upgraded-array-element-type)
 
 (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
-  (flushable))
+         (type-specifier &optional lexenv-designator) type-specifier
+  (unsafely-flushable))

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

@@ -58,8 +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
-  (flushable
+(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

@@ -77,14 +74,15 @@
    ;;
    ;; (UPGRADED-ARRAY-ELEMENT-TYPE and UPGRADED-COMPLEX-PART-TYPE have
    ;; behavior like SUBTYPEP in this respect, not like TYPEP.)
    ;;
    ;; (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) 
+   (foldable))
+(defknown subtypep (type-specifier type-specifier &optional lexenv-designator)
+  (values boolean boolean)

   ;; This is not FOLDABLE because its value is affected by type
   ;; definitions.
   ;;
   ;; FIXME: Is it OK to fold this when the types have already been
   ;; defined? Does the code inherited from CMU CL already do this?
   ;; This is not FOLDABLE because its value is affected by type
   ;; definitions.
   ;;
   ;; FIXME: Is it OK to fold this when the types have already been
   ;; defined? Does the code inherited from CMU CL already do this?

-  (flushable)) 
+  (unsafely-flushable))

 
 (defknown (null symbolp atom consp listp numberp integerp rationalp floatp
                complexp characterp stringp bit-vector-p vectorp
 
 (defknown (null symbolp atom consp listp numberp integerp rationalp floatp
                complexp characterp stringp bit-vector-p vectorp

@@ -98,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))

@@ -110,13 +108,20 @@
 
 ;;; 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 boundp (symbol) boolean (flushable))

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

 (defknown special-operator-p (symbol) t
   ;; The set of special operators never changes.
 (defknown special-operator-p (symbol) t
   ;; The set of special operators never changes.

-  (movable foldable flushable)) 
+  (movable foldable flushable))

 (defknown set (symbol t) t (unsafe)
   :derive-type #'result-type-last-arg)
 (defknown fdefinition ((or symbol cons)) function (unsafe explicit-check))
 (defknown set (symbol t) t (unsafe)
   :derive-type #'result-type-last-arg)
 (defknown fdefinition ((or symbol cons)) function (unsafe explicit-check))

@@ -126,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))

@@ -141,17 +151,17 @@
 ;;; it into VALUES. VALUES is not foldable, since MV constants are
 ;;; represented by a call to VALUES.
 (defknown values (&rest t) * (movable flushable unsafe))
 ;;; it into VALUES. VALUES is not foldable, since MV constants are
 ;;; represented by a call to VALUES.
 (defknown values (&rest t) * (movable flushable unsafe))

-(defknown values-list (list) * (movable foldable flushable))
+(defknown values-list (list) * (movable foldable unsafely-flushable))

 \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

@@ -178,7 +188,6 @@
 (sb!xc:deftype package-designator () '(or stringable sb!xc:package))
 (sb!xc:deftype symbols () '(or list symbol))
 
 (sb!xc:deftype package-designator () '(or stringable sb!xc:package))
 (sb!xc:deftype symbols () '(or list symbol))
 

-;;; Should allow a package name, I think, tho CLtL II doesn't say so...

 (defknown gentemp (&optional string package-designator) symbol)
 
 (defknown make-package (stringable &key
 (defknown gentemp (&optional string package-designator) symbol)
 
 (defknown make-package (stringable &key

@@ -191,13 +200,13 @@
 (defknown find-package (package-designator) (or sb!xc:package null)
   (flushable))
 (defknown package-name (package-designator) (or simple-string null)
 (defknown find-package (package-designator) (or sb!xc:package null)
   (flushable))
 (defknown package-name (package-designator) (or simple-string null)

-  (flushable))
-(defknown package-nicknames (package-designator) list (flushable))
+  (unsafely-flushable))
+(defknown package-nicknames (package-designator) list (unsafely-flushable))

 (defknown rename-package (package-designator package-designator &optional list)
   sb!xc:package)
 (defknown rename-package (package-designator package-designator &optional list)
   sb!xc:package)

-(defknown package-use-list (package-designator) list (flushable))
-(defknown package-used-by-list (package-designator) list (flushable))
-(defknown package-shadowing-symbols (package-designator) list (flushable))
+(defknown package-use-list (package-designator) list (unsafely-flushable))
+(defknown package-used-by-list (package-designator) list (unsafely-flushable))
+(defknown package-shadowing-symbols (package-designator) list (unsafely-flushable))

 (defknown list-all-packages () list (flushable))
 (defknown intern (string &optional package-designator)
   (values symbol (member :internal :external :inherited nil))
 (defknown list-all-packages () list (flushable))
 (defknown intern (string &optional package-designator)
   (values symbol (member :internal :external :inherited nil))

@@ -249,12 +258,12 @@
 (defknown lcm (&rest integer) unsigned-byte
   (movable foldable flushable explicit-check))
 
 (defknown lcm (&rest integer) unsigned-byte
   (movable foldable flushable explicit-check))
 

-#!-sb-propagate-fun-type
+#+sb-xc-host ; (See CROSS-FLOAT-INFINITY-KLUDGE.)

 (defknown exp (number) irrational
   (movable foldable flushable explicit-check recursive)
   :derive-type #'result-type-float-contagion)
 
 (defknown exp (number) irrational
   (movable foldable flushable explicit-check recursive)
   :derive-type #'result-type-float-contagion)
 

-#!+sb-propagate-fun-type
+#-sb-xc-host ; (See CROSS-FLOAT-INFINITY-KLUDGE.)

 (defknown exp (number) irrational
   (movable foldable flushable explicit-check recursive))
 
 (defknown exp (number) irrational
   (movable foldable flushable explicit-check recursive))
 

@@ -272,7 +281,7 @@
 (defknown cis (real) (complex float)
   (movable foldable flushable explicit-check))
 
 (defknown cis (real) (complex float)
   (movable foldable flushable explicit-check))
 

-#!-sb-propagate-fun-type
+#+sb-xc-host ; (See CROSS-FLOAT-INFINITY-KLUDGE.)

 (progn
 (defknown (sin cos) (number)
   (or (float -1.0 1.0) (complex float))
 (progn
 (defknown (sin cos) (number)
   (or (float -1.0 1.0) (complex float))

@@ -281,7 +290,7 @@
 
 (defknown atan
   (number &optional real) irrational
 
 (defknown atan
   (number &optional real) irrational

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

   :derive-type #'result-type-float-contagion)
 
 (defknown (tan sinh cosh tanh asinh)
   :derive-type #'result-type-float-contagion)
 
 (defknown (tan sinh cosh tanh asinh)

@@ -289,7 +298,7 @@
   :derive-type #'result-type-float-contagion)
 ) ; PROGN
 
   :derive-type #'result-type-float-contagion)
 ) ; PROGN
 

-#!+sb-propagate-fun-type
+#-sb-xc-host ; (See CROSS-FLOAT-INFINITY-KLUDGE.)

 (progn
 (defknown (sin cos) (number)
   (or (float -1.0 1.0) (complex float))
 (progn
 (defknown (sin cos) (number)
   (or (float -1.0 1.0) (complex float))

@@ -297,7 +306,7 @@
 
 (defknown atan
   (number &optional real) irrational
 
 (defknown atan
   (number &optional real) irrational

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

 
 (defknown (tan sinh cosh tanh asinh)
   (number) irrational (movable foldable flushable explicit-check recursive))
 
 (defknown (tan sinh cosh tanh asinh)
   (number) irrational (movable foldable flushable explicit-check recursive))

@@ -394,18 +403,18 @@
                           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
                 char-lessp char-greaterp char-not-greaterp char-not-lessp)
   (character &rest character) boolean (movable foldable flushable))
 
   (or (integer 0 35) null) (movable foldable flushable))
 
 (defknown (char= char/= char< char> char<= char>= char-equal char-not-equal
                 char-lessp char-greaterp char-not-greaterp char-not-lessp)
   (character &rest character) boolean (movable foldable flushable))
 

-(defknown character (t) character (movable foldable flushable))
+(defknown character (t) character (movable foldable unsafely-flushable))

 (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)
   (or character null) (movable foldable flushable))
 (defknown char-int (character) char-code (movable foldable flushable))
 (defknown char-name (character) (or simple-string null)

@@ -424,19 +433,19 @@
 \f
 ;;;; from the "Sequences" chapter:
 
 \f
 ;;;; from the "Sequences" chapter:
 

-(defknown elt (sequence index) t (foldable flushable))
+(defknown elt (sequence index) t (foldable unsafely-flushable))

 
 (defknown subseq (sequence index &optional sequence-end) consed-sequence
   (flushable)
   :derive-type (sequence-result-nth-arg 1))
 
 (defknown copy-seq (sequence) consed-sequence (flushable)
 
 (defknown subseq (sequence index &optional sequence-end) 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)

@@ -445,16 +454,16 @@
                                        &key
                                        (:initial-element t))
   consed-sequence
                                        &key
                                        (:initial-element t))
   consed-sequence

-  (movable flushable unsafe)
+  (movable unsafe)

   :derive-type (result-type-specifier-nth-arg 1))
 
 (defknown concatenate (type-specifier &rest sequence) consed-sequence
   :derive-type (result-type-specifier-nth-arg 1))
 
 (defknown concatenate (type-specifier &rest sequence) consed-sequence

-  (flushable)
+  ()

   :derive-type (result-type-specifier-nth-arg 1))
 
 (defknown (map %map) (type-specifier callable sequence &rest sequence)
   consed-sequence
   :derive-type (result-type-specifier-nth-arg 1))
 
 (defknown (map %map) (type-specifier callable sequence &rest sequence)
   consed-sequence

-  (flushable call)
+  (call)

 ; :DERIVE-TYPE 'TYPE-SPEC-ARG1 ? Nope... (MAP NIL ...) returns NULL, not NIL.
   )
 (defknown %map-to-list-arity-1 (callable sequence) list (flushable call))
 ; :DERIVE-TYPE 'TYPE-SPEC-ARG1 ? Nope... (MAP NIL ...) returns NULL, not NIL.
   )
 (defknown %map-to-list-arity-1 (callable sequence) list (flushable call))

@@ -465,12 +474,17 @@
 (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
 ;;; returns the result from the predicate...
 (defknown some (callable sequence &rest sequence) t

-  (foldable flushable call))
+  (foldable unsafely-flushable call))

 
 (defknown (every notany notevery) (callable sequence &rest sequence) boolean
 
 (defknown (every notany notevery) (callable sequence &rest sequence) boolean

-  (foldable flushable call))
+  (foldable unsafely-flushable call))

 
 ;;; unsafe for :INITIAL-VALUE...
 (defknown reduce (callable
 
 ;;; unsafe for :INITIAL-VALUE...
 (defknown reduce (callable

@@ -501,7 +515,7 @@
 (defknown remove
   (t sequence &key (:from-end t) (:test callable)
      (:test-not callable) (:start index) (:end sequence-end)
 (defknown remove
   (t sequence &key (:from-end t) (:test callable)
      (:test-not callable) (:start index) (:end sequence-end)

-     (:count sequence-end) (:key callable))
+     (:count sequence-count) (:key callable))

   consed-sequence
   (flushable call)
   :derive-type (sequence-result-nth-arg 2))
   consed-sequence
   (flushable call)
   :derive-type (sequence-result-nth-arg 2))

@@ -509,21 +523,21 @@
 (defknown substitute
   (t t sequence &key (:from-end t) (:test callable)
      (:test-not callable) (:start index) (:end sequence-end)
 (defknown substitute
   (t t sequence &key (:from-end t) (:test callable)
      (:test-not callable) (:start index) (:end sequence-end)

-     (:count sequence-end) (:key callable))
+     (:count sequence-count) (:key callable))

   consed-sequence
   (flushable call)
   :derive-type (sequence-result-nth-arg 3))
 
 (defknown (remove-if remove-if-not)
   (callable sequence &key (:from-end t) (:start index) (:end sequence-end)
   consed-sequence
   (flushable call)
   :derive-type (sequence-result-nth-arg 3))
 
 (defknown (remove-if remove-if-not)
   (callable sequence &key (:from-end t) (:start index) (:end sequence-end)

-           (:count sequence-end) (:key callable))
+           (:count sequence-count) (:key callable))

   consed-sequence
   (flushable call)
   :derive-type (sequence-result-nth-arg 2))
 
 (defknown (substitute-if substitute-if-not)
   (t callable sequence &key (:from-end t) (:start index) (:end sequence-end)
   consed-sequence
   (flushable call)
   :derive-type (sequence-result-nth-arg 2))
 
 (defknown (substitute-if substitute-if-not)
   (t callable sequence &key (:from-end t) (:start index) (:end sequence-end)

-     (:count sequence-end) (:key callable))
+     (:count sequence-count) (:key callable))

   consed-sequence
   (flushable call)
   :derive-type (sequence-result-nth-arg 3))
   consed-sequence
   (flushable call)
   :derive-type (sequence-result-nth-arg 3))

@@ -531,7 +545,7 @@
 (defknown delete
   (t sequence &key (:from-end t) (:test callable)
      (:test-not callable) (:start index) (:end sequence-end)
 (defknown delete
   (t sequence &key (:from-end t) (:test callable)
      (:test-not callable) (:start index) (:end sequence-end)

-     (:count sequence-end) (:key callable))
+     (:count sequence-count) (:key callable))

   sequence
   (flushable call)
   :derive-type (sequence-result-nth-arg 2))
   sequence
   (flushable call)
   :derive-type (sequence-result-nth-arg 2))

@@ -539,21 +553,21 @@
 (defknown nsubstitute
   (t t sequence &key (:from-end t) (:test callable)
      (:test-not callable) (:start index) (:end sequence-end)
 (defknown nsubstitute
   (t t sequence &key (:from-end t) (:test callable)
      (:test-not callable) (:start index) (:end sequence-end)

-     (:count sequence-end) (:key callable))
+     (:count sequence-count) (:key callable))

   sequence
   (flushable call)
   :derive-type (sequence-result-nth-arg 3))
 
 (defknown (delete-if delete-if-not)
   (callable sequence &key (:from-end t) (:start index) (:end sequence-end)
   sequence
   (flushable call)
   :derive-type (sequence-result-nth-arg 3))
 
 (defknown (delete-if delete-if-not)
   (callable sequence &key (:from-end t) (:start index) (:end sequence-end)

-           (:count sequence-end) (:key callable))
+           (:count sequence-count) (:key callable))

   sequence
   (flushable call)
   :derive-type (sequence-result-nth-arg 2))
 
 (defknown (nsubstitute-if nsubstitute-if-not)
   (t callable sequence &key (:from-end t) (:start index) (:end sequence-end)
   sequence
   (flushable call)
   :derive-type (sequence-result-nth-arg 2))
 
 (defknown (nsubstitute-if nsubstitute-if-not)
   (t callable sequence &key (:from-end t) (:start index) (:end sequence-end)

-     (:count sequence-end) (:key callable))
+     (:count sequence-count) (:key callable))

   sequence
   (flushable call)
   :derive-type (sequence-result-nth-arg 3))
   sequence
   (flushable call)
   :derive-type (sequence-result-nth-arg 3))

@@ -562,14 +576,14 @@
   (sequence &key (:test callable) (:test-not callable) (:start index)
            (:from-end t) (:end sequence-end) (:key callable))
   consed-sequence
   (sequence &key (:test callable) (:test-not callable) (:start index)
            (:from-end t) (:end sequence-end) (:key callable))
   consed-sequence

-  (flushable call)
+  (unsafely-flushable call)

   :derive-type (sequence-result-nth-arg 1))
 
 (defknown delete-duplicates
   (sequence &key (:test callable) (:test-not callable) (:start index)
            (:from-end t) (:end sequence-end) (:key callable))
   sequence
   :derive-type (sequence-result-nth-arg 1))
 
 (defknown delete-duplicates
   (sequence &key (:test callable) (:test-not callable) (:start index)
            (:from-end t) (:end sequence-end) (:key callable))
   sequence

-  (flushable call)
+  (unsafely-flushable call)

   :derive-type (sequence-result-nth-arg 1))
 
 (defknown find (t sequence &key (:test callable) (:test-not callable)
   :derive-type (sequence-result-nth-arg 1))
 
 (defknown find (t sequence &key (:test callable) (:test-not callable)

@@ -620,11 +634,13 @@
 (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)) vector
+  (call))

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

-  (flushable call)
+  (call)

   :derive-type (result-type-specifier-nth-arg 1))
 
 ;;; not FLUSHABLE, despite what CMU CL's DEFKNOWN said..
   :derive-type (result-type-specifier-nth-arg 1))
 
 ;;; not FLUSHABLE, despite what CMU CL's DEFKNOWN said..

@@ -644,23 +660,31 @@
   :derive-type (sequence-result-nth-arg 1))
 \f
 ;;;; from the "Manipulating List Structure" chapter:
   :derive-type (sequence-result-nth-arg 1))
 \f
 ;;;; from the "Manipulating List Structure" chapter:

-(defknown (car cdr caar cadr cdar cddr
-              caaar caadr cadar caddr cdaar cdadr cddar cdddr
-              caaaar caaadr caadar caaddr cadaar cadadr caddar cadddr
-              cdaaar cdaadr cdadar cdaddr cddaar cddadr cdddar cddddr
-              first second third fourth fifth sixth seventh eighth ninth tenth
-              rest)
+(defknown (car cdr first rest)

   (list)
   t
   (foldable flushable))
 
   (list)
   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
+                cdaaar cdaadr cdadar cdaddr cddaar cddadr cdddar cddddr
+                second third fourth fifth sixth seventh eighth ninth tenth)
+  (list)
+  t
+  (foldable unsafely-flushable))
+

 (defknown cons (t t) cons (movable flushable unsafe))
 
 (defknown tree-equal (t t &key (:test callable) (:test-not callable)) boolean
   (foldable flushable call))
 (defknown cons (t t) cons (movable flushable unsafe))
 
 (defknown tree-equal (t t &key (:test callable) (:test-not callable)) boolean
   (foldable flushable call))

-(defknown endp (t) boolean (foldable flushable movable))
-(defknown list-length (list) (or index null) (foldable flushable))
-(defknown (nth nthcdr) (index list) t (foldable flushable))
+(defknown endp (list) boolean (foldable flushable movable))
+(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 list (&rest t) list (movable flushable unsafe))
 (defknown list* (t &rest t) t (movable flushable unsafe))
 (defknown last (list &optional index) list (foldable flushable))
 (defknown list (&rest t) list (movable flushable unsafe))
 (defknown list* (t &rest t) t (movable flushable unsafe))

@@ -668,14 +692,19 @@
   (movable flushable unsafe))
 
 ;;; All but last must be of type LIST, but there seems to be no way to
   (movable flushable unsafe))
 
 ;;; All but last must be of type LIST, but there seems to be no way to

-;;; express that in this syntax..
+;;; express that in this syntax.

 (defknown append (&rest t) t (flushable))
 
 (defknown copy-list (list) list (flushable))
 (defknown copy-alist (list) list (flushable))
 (defknown copy-tree (t) t (flushable recursive))
 (defknown revappend (list t) t (flushable))
 (defknown append (&rest t) t (flushable))
 
 (defknown copy-list (list) list (flushable))
 (defknown copy-alist (list) list (flushable))
 (defknown copy-tree (t) t (flushable recursive))
 (defknown revappend (list t) t (flushable))

-(defknown nconc (&rest list) list ())
+
+;;; All but last must be of type LIST, but there seems to be no way to
+;;; express that in this syntax. The result must be LIST, but we do
+;;; 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) list ())
 (defknown butlast (list &optional index) list (flushable))
 (defknown nbutlast (list &optional index) list ())

@@ -756,7 +785,7 @@
   (foldable flushable))
 (defknown hash-table-size (hash-table) index (flushable))
 (defknown hash-table-test (hash-table) symbol (foldable flushable))
   (foldable flushable))
 (defknown hash-table-size (hash-table) index (flushable))
 (defknown hash-table-test (hash-table) symbol (foldable flushable))

-(defknown sxhash (t) (integer 0 #.sb!vm:*target-most-positive-fixnum*)
+(defknown sxhash (t) (integer 0 #.sb!xc:most-positive-fixnum)

   (foldable flushable))
 \f
 ;;;; from the "Arrays" chapter
   (foldable flushable))
 \f
 ;;;; from the "Arrays" chapter

@@ -774,8 +803,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

@@ -783,7 +812,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))

@@ -795,26 +824,29 @@
 
 (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 array-has-fill-pointer-p (array) boolean
   (movable foldable flushable))

-(defknown fill-pointer (vector) index (foldable flushable))
+(defknown fill-pointer (vector) index (foldable unsafely-flushable))

 (defknown vector-push (t vector) (or index null) ())
 (defknown vector-push-extend (t vector &optional index) index ())
 (defknown vector-pop (vector) t ())
 
 (defknown adjust-array
   (array (or index list) &key (:element-type type-specifier)
 (defknown vector-push (t vector) (or index null) ())
 (defknown vector-push-extend (t vector &optional index) index ())
 (defknown vector-pop (vector) t ())
 
 (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))

@@ -874,15 +906,15 @@
 ;;;; from the "Eval" chapter:
 
 (defknown eval (t) * (recursive))
 ;;;; 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:
 
 (defknown make-synonym-stream (symbol) stream (flushable))
   (foldable flushable))
 \f
 ;;;; from the "Streams" chapter:
 
 (defknown make-synonym-stream (symbol) stream (flushable))

-(defknown make-broadcast-stream (&rest stream) stream (flushable))
-(defknown make-concatenated-stream (&rest stream) stream (flushable))
-(defknown make-two-way-stream (stream stream) stream (flushable))
+(defknown make-broadcast-stream (&rest stream) stream (unsafely-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
   (flushable unsafe))
 (defknown make-echo-stream (stream stream) stream (flushable))
 (defknown make-string-input-stream (string &optional index index) stream
   (flushable unsafe))

@@ -922,14 +954,14 @@
   (character character callable &optional readtable) function
   (unsafe))
 (defknown get-dispatch-macro-character
   (character character callable &optional readtable) function
   (unsafe))
 (defknown get-dispatch-macro-character

-  (character character &optional (or readtable null)) callable
-  (flushable))
+  (character character &optional (or readtable null)) (or callable null)
+  ())

 
 ;;; 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))
 
 
 ;;; 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))
 

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

   (explicit-check))
 (defknown read-line (&optional streamlike t t t) (values t boolean)
   (explicit-check))
   (explicit-check))
 (defknown read-line (&optional streamlike t t t) (values t boolean)
   (explicit-check))

@@ -1025,7 +1057,8 @@
 
 ;;; (No pathname functions are FOLDABLE because they all potentially
 ;;; depend on *DEFAULT-PATHNAME-DEFAULTS*, e.g. to provide a default
 
 ;;; (No pathname functions are FOLDABLE because they all potentially
 ;;; depend on *DEFAULT-PATHNAME-DEFAULTS*, e.g. to provide a default

-;;; host when parsing a namestring.)
+;;; host when parsing a namestring. They are not FLUSHABLE because
+;;; parsing of a PATHNAME-DESIGNATOR might signal an error.)

 
 (defknown wild-pathname-p (pathname-designator
                           &optional
 
 (defknown wild-pathname-p (pathname-designator
                           &optional

@@ -1033,21 +1066,22 @@
                                   :directory :name
                                   :type :version))
   boolean
                                   :directory :name
                                   :type :version))
   boolean

-  (flushable))
+  ())

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

-  (flushable))
+  ())

 (defknown translate-pathname (pathname-designator
                              pathname-designator
                              pathname-designator &key)
   pathname
 (defknown translate-pathname (pathname-designator
                              pathname-designator
                              pathname-designator &key)
   pathname

-  (flushable))
+  ())

 
 (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 ())
 

-(defknown pathname (pathname-designator) pathname (flushable))
+(defknown pathname (pathname-designator) pathname (unsafely-flushable))

 (defknown truename (pathname-designator) pathname ())
 
 (defknown parse-namestring
 (defknown truename (pathname-designator) pathname ())
 
 (defknown parse-namestring

@@ -1064,7 +1098,7 @@
 (defknown merge-pathnames
   (pathname-designator &optional pathname-designator pathname-version)
   pathname
 (defknown merge-pathnames
   (pathname-designator &optional pathname-designator pathname-version)
   pathname

-  (flushable))
+  (unsafely-flushable))

 
 (defknown make-pathname
  (&key (:defaults pathname-designator)
 
 (defknown make-pathname
  (&key (:defaults pathname-designator)

@@ -1074,7 +1108,7 @@
        (:name (or pathname-name string (member :wild)))
        (:type (or pathname-type string (member :wild)))
        (:version pathname-version) (:case (member :local :common)))
        (:name (or pathname-name string (member :wild)))
        (:type (or pathname-type string (member :wild)))
        (:version pathname-version) (:case (member :local :common)))

-  pathname (flushable))
+  pathname (unsafely-flushable))

 
 (defknown pathnamep (t) boolean (movable flushable))
 
 
 (defknown pathnamep (t) boolean (movable flushable))
 

@@ -1098,11 +1132,11 @@
 
 (defknown (namestring file-namestring directory-namestring host-namestring)
   (pathname-designator) simple-string
 
 (defknown (namestring file-namestring directory-namestring host-namestring)
   (pathname-designator) simple-string

-  (flushable))
+  (unsafely-flushable))

 
 (defknown enough-namestring (pathname-designator &optional pathname-designator)
   simple-string
 
 (defknown enough-namestring (pathname-designator &optional pathname-designator)
   simple-string

-  (flushable))
+  (unsafely-flushable))

 
 (defknown user-homedir-pathname (&optional t) pathname (flushable))
 
 
 (defknown user-homedir-pathname (&optional t) pathname (flushable))
 

@@ -1114,22 +1148,27 @@
                                           :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
+                       ;; FIXME: This is logically (MEMBER :DEFAULT),
+                       ;; but as a workaround for bug 244, we don't
+                       ;; declare it (to keep the compiler from trusting
+                       ;; the declaration unchecked).
+                       t))

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

-(defknown probe-file (pathname-designator) (or pathname null) (flushable))
+(defknown probe-file (pathname-designator) (or pathname null) ())

 (defknown file-write-date (pathname-designator) (or unsigned-byte null)
 (defknown file-write-date (pathname-designator) (or unsigned-byte null)

-  (flushable))
+  ())

 (defknown file-author (pathname-designator) (or simple-string null)
 (defknown file-author (pathname-designator) (or simple-string null)

-  (flushable))
+  ())

 
 (defknown file-position (stream &optional
                                (or unsigned-byte (member :start :end)))
   (or unsigned-byte (member t nil)))
 
 (defknown file-position (stream &optional
                                (or unsigned-byte (member :start :end)))
   (or unsigned-byte (member t nil)))

-(defknown file-length (stream) (or unsigned-byte null) (flushable))
+(defknown file-length (stream) (or unsigned-byte null) (unsafely-flushable))

 
 (defknown load
   ((or filename stream)
 
 (defknown load
   ((or filename stream)

@@ -1137,22 +1176,25 @@
    (:verbose t)
    (:print t)
    (:if-does-not-exist (member :error :create nil))
    (:verbose t)
    (:print t)
    (:if-does-not-exist (member :error :create nil))

-   ;; FIXME: ANSI specifies an :EXTERNAL-FORMAT keyword too.
-   )
+   (:external-format
+    ;; FIXME: This is logically (MEMBER :DEFAULT), but as a workaround
+    ;; for bug 244, we don't declare it (to keep the compiler from
+    ;; trusting the declaration unchecked).
+    t))

   t)
 
   t)
 

-(defknown directory (pathname-designator &key
-                                        (:check-for-subdirs t)
-                                        (:all t)
-                                        (:follow-links t))
-  list (flushable))
+(defknown directory (pathname-designator &key)
+  list ())

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

-(defknown error (t &rest t) nil) ; never returns...
+(defknown error (t &rest t) nil) ; never returns

 (defknown cerror (string t &rest t) null)
 (defknown warn (t &rest t) null)
 (defknown break (&optional t &rest t) null)
 (defknown cerror (string t &rest t) null)
 (defknown warn (t &rest t) null)
 (defknown break (&optional t &rest t) null)

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

 \f
 ;;;; from the "Miscellaneous" Chapter:
 
 \f
 ;;;; from the "Miscellaneous" Chapter:
 

@@ -1174,13 +1216,13 @@
 
    ;; extensions
    (:trace-file t)
 
    ;; extensions
    (:trace-file t)

-   (:block-compile t)
-   (:byte-compile (member t nil :maybe)))
+   (:block-compile t))

   (values (or pathname null) boolean boolean))
 
   (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)

@@ -1243,6 +1285,17 @@
 (defknown constantly (t) function (movable flushable))
 (defknown complement (function) function (movable flushable))
 \f
 (defknown constantly (t) function (movable flushable))
 (defknown complement (function) function (movable flushable))
 \f

+;;;; miscellaneous extensions
+
+(defknown get-bytes-consed () unsigned-byte (flushable))
+
+;;; PCOUNTERs
+(defknown incf-pcounter (pcounter unsigned-byte) pcounter)
+(defknown pcounter->integer (pcounter) unsigned-byte)
+(defknown %incf-pcounter-or-fixnum ((or pcounter fixnum) unsigned-byte)
+  (or pcounter fixnum))
+(defknown pcounter-or-fixnum->integer ((or pcounter fixnum)) unsigned-byte)
+\f

 ;;;; magical compiler frobs
 
 ;;; We can't fold this in general because of SATISFIES. There is a
 ;;;; magical compiler frobs
 
 ;;; We can't fold this in general because of SATISFIES. There is a

@@ -1259,8 +1312,8 @@
 (defknown %more-arg-context (t t) (values t index) (flushable))
 (defknown %more-arg (t index) t)
 (defknown %more-arg-values (t index index) * (flushable))
 (defknown %more-arg-context (t t) (values t index) (flushable))
 (defknown %more-arg (t index) t)
 (defknown %more-arg-values (t index index) * (flushable))

-(defknown %verify-argument-count (index index) (values))
-(defknown %argument-count-error (t) nil)
+(defknown %verify-arg-count (index index) (values))
+(defknown %arg-count-error (t) nil)

 (defknown %unknown-values () *)
 (defknown %catch (t t) t)
 (defknown %unwind-protect (t t) t)
 (defknown %unknown-values () *)
 (defknown %catch (t t) t)
 (defknown %unwind-protect (t t) t)

@@ -1272,8 +1325,8 @@
 (defknown %%primitive (t t &rest t) *)
 (defknown %pop-values (t) t)
 (defknown %type-check-error (t t) nil)
 (defknown %%primitive (t t &rest t) *)
 (defknown %pop-values (t) t)
 (defknown %type-check-error (t t) nil)

-(defknown %odd-key-arguments-error () nil)
-(defknown %unknown-key-argument-error (t) nil)
+(defknown %odd-key-args-error () nil)
+(defknown %unknown-key-arg-error (t) nil)

 (defknown (%ldb %mask-field) (bit-index bit-index integer) unsigned-byte
   (movable foldable flushable explicit-check))
 (defknown (%dpb %deposit-field) (integer bit-index bit-index integer) integer
 (defknown (%ldb %mask-field) (bit-index bit-index integer) unsigned-byte
   (movable foldable flushable explicit-check))
 (defknown (%dpb %deposit-field) (integer bit-index bit-index integer) integer

@@ -1281,27 +1334,47 @@
 (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))

-(defknown %coerce-name-to-function ((or symbol cons)) function (flushable))
-(defknown %coerce-callable-to-function (callable) function (flushable))
-
-;;; Structure slot accessors or setters are magically "known" to be
-;;; these functions, although the var remains the Slot-Accessor
-;;; describing the actual function called.
-;;;
-;;; FIXME: It would be nice to make structure slot accessors be
-;;; ordinary functions.
-(defknown %slot-accessor (t) t (flushable))
-(defknown %slot-setter (t t) t (unsafe))
+(defknown %coerce-name-to-fun ((or symbol cons)) function (flushable))
+(defknown %coerce-callable-to-fun (callable) function (flushable))
+(defknown failed-%with-array-data (t t t) nil)
+(defknown %find-position
+  (t sequence t index sequence-end function function)
+  (values t (or index null))
+  (flushable call))
+(defknown (%find-position-if %find-position-if-not)
+  (function sequence t index sequence-end function)
+  (values t (or index null))
+  (call))
+(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
 

@@ -1312,12 +1385,12 @@
 (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))

-(defknown fset (symbol function) function (unsafe))
+(defknown (setf symbol-function) (function symbol) function (unsafe))

 (defknown %set-symbol-plist (symbol t) t (unsafe))
 (defknown (setf fdocumentation) ((or string null) t symbol)
   (or string null)
 (defknown %set-symbol-plist (symbol t) t (unsafe))
 (defknown (setf fdocumentation) ((or string null) t symbol)
   (or string null)

@@ -1325,18 +1398,10 @@
 (defknown %setnth (index list t) t (unsafe))
 (defknown %set-fill-pointer (vector index) index (unsafe))
 \f
 (defknown %setnth (index list t) t (unsafe))
 (defknown %set-fill-pointer (vector index) index (unsafe))
 \f

-;;;; internal type predicates
+;;;; miscellaneous internal utilities

 
 

-;;; Simple TYPEP uses that don't have any standard predicate are
-;;; translated into non-standard unary predicates.
-(defknown (fixnump bignump ratiop short-float-p single-float-p double-float-p
-          long-float-p base-char-p %standard-char-p %instancep
-          array-header-p)
-  (t) boolean (movable foldable flushable))
-\f
-;;;; miscellaneous "sub-primitives"
+(defknown %fun-name (function) t (flushable))
+(defknown (setf %fun-name) (t function) t (unsafe))

 
 

-(defknown %sp-string-compare
-  (simple-string index index simple-string index index)
-  (or index null)
-  (foldable flushable))
+(defknown policy-quality (policy symbol) policy-quality
+          (flushable))