(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
;;;; 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))
;;; 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 %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))
(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
(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 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
;;; 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 (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)
- (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))
- list (flushable unsafe call))
+ t (flushable unsafe call))
(defknown member (t list &key (:key callable) (:test callable)
(:test-not callable))
(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
(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 (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))
(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
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)
(: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)
(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 %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
- (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))
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