0.8.1.9:

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

diff --git a/src/compiler/fndb.lisp b/src/compiler/fndb.lisp
index 9e0fa6a..e394ac4 100644 (file)
--- a/src/compiler/fndb.lisp
+++ b/src/compiler/fndb.lisp
@@ -44,7 +44,7 @@
 (defknown type-of (t) t (foldable flushable))
 
 ;;; These can be affected by type definitions, so they're not FOLDABLE.
 (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 (upgraded-complex-part-type sb!xc:upgraded-array-element-type)

          (type-specifier &optional lexenv-designator) type-specifier
   (unsafely-flushable))
 \f
          (type-specifier &optional lexenv-designator) type-specifier
   (unsafely-flushable))
 \f

@@ -96,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-designator)
-  (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))

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

@@ -130,7 +137,12 @@
 (defknown apply (callable t &rest t) *) ; ### Last arg must be List...
 (defknown funcall (callable &rest t) *)
 
 (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))

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

@@ -617,7 +634,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
+(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
   (call))
 
 (defknown merge (type-specifier sequence sequence callable

@@ -648,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

@@ -661,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 nth (index list) t (foldable flushable))
 (defknown nthcdr (index list) t (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 last (list &optional index) 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

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

-(defknown nreconc (list t) list ())
+(defknown nreconc (list t) t ())

 (defknown butlast (list &optional index) list (flushable))
 (defknown nbutlast (list &optional index) list ())
 (defknown ldiff (list t) list (flushable))
 (defknown butlast (list &optional index) list (flushable))
 (defknown nbutlast (list &optional index) list ())
 (defknown ldiff (list t) list (flushable))

@@ -693,15 +714,15 @@
 
 (defknown (nsubst subst) (t t t &key (:key callable) (:test callable)
                            (:test-not callable))
 
 (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))

@@ -783,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

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

@@ -938,7 +962,7 @@
 (defknown (read read-preserving-whitespace read-char-no-hang read-char)
   (&optional streamlike t t t) t (explicit-check))
 
 (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))

@@ -1042,9 +1066,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

@@ -1108,7 +1133,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)

@@ -1187,9 +1212,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)

@@ -1292,6 +1318,11 @@
 (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)

+
+;; FIXME: This function does not return, but due to the implementation
+;; of FILTER-CONTINUATION 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

@@ -1301,10 +1332,10 @@
 (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 %caller-frame-and-pc () (values t t) (flushable))
 (defknown %with-array-data (array index (or index null))
 (defknown hairy-data-vector-set (array index t) t (unsafe explicit-check))
 (defknown %caller-frame-and-pc () (values t t) (flushable))
 (defknown %with-array-data (array index (or index null))

@@ -1329,6 +1360,17 @@
   function
   (flushable foldable))
 
   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
 
 (defknown arg-count-error (t t t t t t) nil (unsafe))
 \f

@@ -1341,8 +1383,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))