0.7.12.12:

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

diff --git a/src/compiler/fndb.lisp b/src/compiler/fndb.lisp
index dbdc0a5..31f4350 100644 (file)
--- a/src/compiler/fndb.lisp
+++ b/src/compiler/fndb.lisp
@@ -35,7 +35,9 @@
   ;; 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 list-to-vector* (list type-specifier) vector)
 (defknown vector-to-vector* (vector type-specifier) vector)
 

@@ -43,7 +45,7 @@
 
 ;;; These can be affected by type definitions, so they're not FOLDABLE.
 (defknown (upgraded-complex-part-type upgraded-array-element-type)
 
 ;;; 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
+         (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.
   ;;

@@ -94,7 +97,7 @@
 
 (sb!xc:deftype name-for-class () t)
 (defknown class-name (sb!xc:class) name-for-class (flushable))
 
 (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)
+(defknown find-class (name-for-class &optional t lexenv-designator)

   (or sb!xc:class null) ())
 (defknown class-of (t) sb!xc:class (flushable))
 (defknown layout-of (t) layout (flushable))
   (or sb!xc:class null) ())
 (defknown class-of (t) sb!xc:class (flushable))
 (defknown layout-of (t) layout (flushable))

@@ -121,13 +124,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 +148,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

@@ -388,7 +396,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,7 +407,7 @@
 (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)

@@ -425,12 +433,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)

@@ -614,6 +622,8 @@
 (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))
 
 (defknown merge (type-specifier sequence sequence callable
                                &key (:key callable))

@@ -643,6 +653,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

@@ -667,14 +680,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 ())

@@ -782,7 +800,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))

@@ -794,12 +812,12 @@
 
 (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|#)

@@ -813,7 +831,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))

@@ -873,7 +891,7 @@
 ;;;; 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:
   (foldable flushable))
 \f
 ;;;; from the "Streams" chapter:

@@ -1043,7 +1061,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 ())
 

@@ -1295,8 +1314,8 @@
 (defknown hairy-data-vector-ref (array index) t
   (foldable flushable explicit-check))
 (defknown hairy-data-vector-set (array index t) t (unsafe explicit-check))
 (defknown hairy-data-vector-ref (array index) t
   (foldable flushable 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))

@@ -1311,8 +1330,15 @@
   (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 effective-find-position-test (callable callable)
+  function
+  (flushable foldable))
+(defknown effective-find-position-key (callable)
+  function
+  (flushable foldable))
+

 
 

-(defknown sb!kernel::arg-count-error (t t t t t t) nil (unsafe))
+(defknown arg-count-error (t t t t t t) nil (unsafe))

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

@@ -1323,8 +1349,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))

@@ -1340,3 +1366,6 @@
 
 (defknown %fun-name (function) t (flushable))
 (defknown (setf %fun-name) (t function) t (unsafe))
 
 (defknown %fun-name (function) t (flushable))
 (defknown (setf %fun-name) (t function) t (unsafe))

+
+(defknown policy-quality (policy symbol) policy-quality
+          (flushable))