0.7.12.12:

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

diff --git a/src/compiler/fndb.lisp b/src/compiler/fndb.lisp
index 6f9eaa7..31f4350 100644 (file)
--- a/src/compiler/fndb.lisp
+++ b/src/compiler/fndb.lisp
@@ -45,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:

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

@@ -75,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.
   ;;

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

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

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

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

@@ -803,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|#)

@@ -882,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:

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