;;;; from the "Symbols" chapter:
(defknown get (symbol t &optional t) t (flushable))
+(defknown sb!impl::get2 (symbol t) t (flushable))
+(defknown sb!impl::get3 (symbol t t) t (flushable))
(defknown remprop (symbol t) t)
(defknown symbol-plist (symbol) list (flushable))
(defknown getf (list t &optional t) t (foldable flushable))
(defknown get-properties (list list) (values t t list) (foldable flushable))
(defknown symbol-name (symbol) simple-string (movable foldable flushable))
(defknown make-symbol (string) symbol (flushable))
+(defknown %make-symbol (simple-string) symbol (flushable))
(defknown copy-symbol (symbol &optional t) symbol (flushable))
(defknown gensym (&optional (or string unsigned-byte)) symbol ())
(defknown symbol-package (symbol) (or sb!xc:package null) (flushable))
(defknown unexport (symbols-designator &optional package-designator) (eql t))
(defknown shadowing-import (symbols-designator &optional package-designator)
(eql t))
-(defknown shadow ((or symbol string list) &optional package-designator)
+(defknown shadow ((or symbol character string list) &optional package-designator)
(eql t))
(defknown (use-package unuse-package)
((or list package-designator) &optional package-designator) (eql t))
(defknown * (&rest number) number
(movable foldable flushable explicit-check))
(defknown / (number &rest number) number
- (movable foldable flushable explicit-check))
+ (movable foldable unsafely-flushable explicit-check))
(defknown (1+ 1-) (number) number
(movable foldable flushable explicit-check))
(defknown reverse (sequence) consed-sequence (flushable)
:derive-type (sequence-result-nth-arg 1))
-(defknown nreverse (sequence) sequence ()
- :derive-type #'result-type-first-arg)
+(defknown nreverse (sequence) sequence (important-result)
+ :derive-type #'result-type-first-arg
+ :destroyed-constant-args (nth-constant-nonempty-sequence-args 1))
(defknown make-sequence (type-specifier index
&key
(defknown map-into (sequence callable &rest sequence)
sequence
(call)
- :derive-type #'result-type-first-arg)
+ :derive-type #'result-type-first-arg
+ :destroyed-constant-args (nth-constant-nonempty-sequence-args 1))
;;; returns the result from the predicate...
(defknown some (callable sequence &rest sequence) t
(foldable unsafely-flushable call))
;;; unsafe for :INITIAL-VALUE...
-(defknown reduce (callable
- sequence
- &key
- (:from-end t)
- (:start index)
- (:end sequence-end)
- (:initial-value t)
- (:key callable))
+(defknown reduce (callable sequence &rest t &key (:from-end t) (:start index)
+ (:end sequence-end) (:initial-value t) (:key callable))
t
(foldable flushable call unsafe))
-(defknown fill (sequence t &key (:start index) (:end sequence-end)) sequence
+(defknown fill (sequence t &rest t &key
+ (:start index) (:end sequence-end)) sequence
(unsafe)
- :derive-type #'result-type-first-arg)
+ :derive-type #'result-type-first-arg
+ :destroyed-constant-args (nth-constant-nonempty-sequence-args 1))
-(defknown replace (sequence
- sequence
- &key
- (:start1 index)
- (:end1 sequence-end)
- (:start2 index)
- (:end2 sequence-end))
+(defknown replace (sequence sequence &rest t &key (:start1 index)
+ (:end1 sequence-end) (:start2 index) (:end2 sequence-end))
sequence ()
- :derive-type #'result-type-first-arg)
+ :derive-type #'result-type-first-arg
+ :destroyed-constant-args (nth-constant-nonempty-sequence-args 1))
(defknown remove
- (t sequence &key (:from-end t) (:test callable)
+ (t sequence &rest t &key (:from-end t) (:test callable)
(:test-not callable) (:start index) (:end sequence-end)
(:count sequence-count) (:key callable))
consed-sequence
:derive-type (sequence-result-nth-arg 2))
(defknown substitute
- (t t sequence &key (:from-end t) (:test callable)
+ (t t sequence &rest t &key (:from-end t) (:test callable)
(:test-not callable) (:start index) (:end sequence-end)
(:count sequence-count) (:key callable))
consed-sequence
: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-count) (:key callable))
+ (callable sequence &rest t &key (:from-end t) (:start index)
+ (:end sequence-end) (: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)
- (:count sequence-count) (:key callable))
+ (t callable sequence &rest t &key (:from-end t) (:start index)
+ (:end sequence-end) (:count sequence-count) (:key callable))
consed-sequence
(flushable call)
:derive-type (sequence-result-nth-arg 3))
(defknown delete
- (t sequence &key (:from-end t) (:test callable)
+ (t sequence &rest t &key (:from-end t) (:test callable)
(:test-not callable) (:start index) (:end sequence-end)
(:count sequence-count) (:key callable))
sequence
- (flushable call)
- :derive-type (sequence-result-nth-arg 2))
+ (flushable call important-result)
+ :derive-type (sequence-result-nth-arg 2)
+ :destroyed-constant-args (nth-constant-nonempty-sequence-args 2))
(defknown nsubstitute
- (t t sequence &key (:from-end t) (:test callable)
+ (t t sequence &rest t &key (:from-end t) (:test callable)
(:test-not callable) (:start index) (:end sequence-end)
(:count sequence-count) (:key callable))
sequence
(flushable call)
- :derive-type (sequence-result-nth-arg 3))
+ :derive-type (sequence-result-nth-arg 3)
+ :destroyed-constant-args (nth-constant-nonempty-sequence-args 3))
(defknown (delete-if delete-if-not)
- (callable sequence &key (:from-end t) (:start index) (:end sequence-end)
- (:count sequence-count) (:key callable))
+ (callable sequence &rest t &key (:from-end t) (:start index)
+ (:end sequence-end) (:count sequence-count) (:key callable))
sequence
- (flushable call)
- :derive-type (sequence-result-nth-arg 2))
+ (flushable call important-result)
+ :derive-type (sequence-result-nth-arg 2)
+ :destroyed-constant-args (nth-constant-nonempty-sequence-args 2))
(defknown (nsubstitute-if nsubstitute-if-not)
- (t callable sequence &key (:from-end t) (:start index) (:end sequence-end)
- (:count sequence-count) (:key callable))
+ (t callable sequence &rest t &key (:from-end t) (:start index)
+ (:end sequence-end) (:count sequence-count) (:key callable))
sequence
(flushable call)
- :derive-type (sequence-result-nth-arg 3))
+ :derive-type (sequence-result-nth-arg 3)
+ :destroyed-constant-args (nth-constant-nonempty-sequence-args 3))
(defknown remove-duplicates
- (sequence &key (:test callable) (:test-not callable) (:start index)
+ (sequence &rest t &key (:test callable) (:test-not callable) (:start index)
(:from-end t) (:end sequence-end) (:key callable))
consed-sequence
(unsafely-flushable call)
:derive-type (sequence-result-nth-arg 1))
(defknown delete-duplicates
- (sequence &key (:test callable) (:test-not callable) (:start index)
+ (sequence &rest t &key (:test callable) (:test-not callable) (:start index)
(:from-end t) (:end sequence-end) (:key callable))
sequence
- (unsafely-flushable call)
- :derive-type (sequence-result-nth-arg 1))
+ (unsafely-flushable call important-result)
+ :derive-type (sequence-result-nth-arg 1)
+ :destroyed-constant-args (nth-constant-nonempty-sequence-args 1))
-(defknown find (t sequence &key (:test callable) (:test-not callable)
- (:start index) (:from-end t) (:end sequence-end)
- (:key callable))
+(defknown find (t sequence &rest t &key (:test callable)
+ (:test-not callable) (:start index) (:from-end t)
+ (:end sequence-end) (:key callable))
t
(foldable flushable call))
(defknown (find-if find-if-not)
- (callable sequence &key (:from-end t) (:start index) (:end sequence-end)
- (:key callable))
+ (callable sequence &rest t &key (:from-end t) (:start index)
+ (:end sequence-end) (:key callable))
t
(foldable flushable call))
-(defknown position (t sequence &key (:test callable) (:test-not callable)
- (:start index) (:from-end t) (:end sequence-end)
- (:key callable))
+(defknown position (t sequence &rest t &key (:test callable)
+ (:test-not callable) (:start index) (:from-end t)
+ (:end sequence-end) (:key callable))
(or index null)
(foldable flushable call))
(defknown (position-if position-if-not)
- (callable sequence &key (:from-end t) (:start index) (:end sequence-end)
- (:key callable))
+ (callable sequence &rest t &key (:from-end t) (:start index)
+ (:end sequence-end) (:key callable))
(or index null)
(foldable flushable call))
-(defknown count (t sequence &key (:test callable) (:test-not callable)
- (:start index) (:from-end t) (:end sequence-end)
- (:key callable))
+(defknown count (t sequence &rest t &key
+ (:test callable) (:test-not callable) (:start index)
+ (:from-end t) (:end sequence-end) (:key callable))
index
(foldable flushable call))
(defknown (count-if count-if-not)
- (callable sequence &key (:from-end t) (:start index) (:end sequence-end)
- (:key callable))
+ (callable sequence &rest t &key
+ (:from-end t) (:start index) (:end sequence-end) (:key callable))
index
(foldable flushable call))
(defknown (mismatch search)
- (sequence sequence &key (:from-end t) (:test callable) (:test-not callable)
- (:start1 index) (:end1 sequence-end)
- (:start2 index) (:end2 sequence-end)
- (:key callable))
+ (sequence sequence &rest t &key (:from-end t) (:test callable)
+ (:test-not callable) (:start1 index) (:end1 sequence-end)
+ (:start2 index) (:end2 sequence-end) (:key callable))
(or index null)
(foldable flushable call))
;;; not FLUSHABLE, since vector sort guaranteed in-place...
-(defknown (stable-sort sort) (sequence callable &key (:key callable)) sequence
+(defknown (stable-sort sort) (sequence callable &rest t &key (:key callable))
+ sequence
(call)
- :derive-type (sequence-result-nth-arg 1))
+ :derive-type (sequence-result-nth-arg 1)
+ :destroyed-constant-args (nth-constant-nonempty-sequence-args 1))
+(defknown sb!impl::stable-sort-list (list function function) list
+ (call important-result)
+ :destroyed-constant-args (nth-constant-nonempty-sequence-args 1))
(defknown sb!impl::sort-vector (vector index index function (or function null))
* ; SORT-VECTOR works through side-effect
- (call))
+ (call)
+ :destroyed-constant-args (nth-constant-nonempty-sequence-args 1))
(defknown merge (type-specifier sequence sequence callable
&key (:key callable))
sequence
- (call)
- :derive-type (creation-result-type-specifier-nth-arg 1))
+ (call important-result)
+ :derive-type (creation-result-type-specifier-nth-arg 1)
+ :destroyed-constant-args (nth-constant-nonempty-sequence-args 2 3))
;;; not FLUSHABLE, despite what CMU CL's DEFKNOWN said..
(defknown read-sequence (sequence stream
(defknown nth (unsigned-byte list) t (foldable flushable))
(defknown nthcdr (unsigned-byte list) t (foldable unsafely-flushable))
(defknown last (list &optional unsigned-byte) t (foldable flushable))
+(defknown sb!impl::last1 (list) 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
;;; 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 nconc (&rest t) t ()
+ :destroyed-constant-args (remove-non-constants-and-nils #'butlast))
+(defknown sb!impl::nconc2 (list t) t ()
+ :destroyed-constant-args (remove-non-constants-and-nils #'butlast))
-(defknown nreconc (list t) t ())
+(defknown nreconc (list t) t (important-result)
+ :destroyed-constant-args (nth-constant-nonempty-sequence-args 1))
(defknown butlast (list &optional unsigned-byte) list (flushable))
-(defknown nbutlast (list &optional unsigned-byte) list ())
+(defknown nbutlast (list &optional unsigned-byte) list ()
+ :destroyed-constant-args (nth-constant-nonempty-sequence-args 1))
+
(defknown ldiff (list t) list (flushable))
-(defknown (rplaca rplacd) (cons t) list (unsafe))
+(defknown (rplaca rplacd) (cons t) list (unsafe)
+ :destroyed-constant-args (nth-constant-args 1))
-(defknown (nsubst subst) (t t t &key (:key callable) (:test callable)
- (:test-not callable))
+(defknown subst (t t t &key (:key callable) (:test callable)
+ (:test-not callable))
t (flushable unsafe call))
+(defknown nsubst (t t t &key (:key callable) (:test callable)
+ (:test-not callable))
+ t (unsafe call)
+ :destroyed-constant-args (nth-constant-nonempty-sequence-args 3))
-(defknown (subst-if subst-if-not nsubst-if nsubst-if-not)
+(defknown (subst-if subst-if-not)
(t callable t &key (:key callable))
t (flushable unsafe call))
+(defknown (nsubst-if nsubst-if-not)
+ (t callable t &key (:key callable))
+ t (unsafe call)
+ :destroyed-constant-args (nth-constant-nonempty-sequence-args 3))
-(defknown (sublis nsublis) (list t &key (:key callable) (:test callable)
- (:test-not callable))
+(defknown sublis (list t &key (:key callable) (:test callable)
+ (:test-not callable))
t (flushable unsafe call))
+(defknown nsublis (list t &key (:key callable) (:test callable)
+ (:test-not callable))
+ t (flushable unsafe call)
+ :destroyed-constant-args (nth-constant-nonempty-sequence-args 2))
(defknown member (t list &key (:key callable) (:test callable)
(:test-not callable))
(defknown (nunion nintersection nset-difference nset-exclusive-or)
(list list &key (:key callable) (:test callable) (:test-not callable))
list
- (foldable flushable call))
+ (foldable flushable call important-result)
+ :destroyed-constant-args (nth-constant-nonempty-sequence-args 1 2))
(defknown subsetp
(list list &key (:key callable) (:test callable) (:test-not callable))
(callable list &key (:key callable)) list (foldable flushable call))
(defknown (memq assq) (t list) list (foldable flushable unsafe))
-(defknown delq (t list) list (flushable unsafe))
+(defknown delq (t list) list (flushable unsafe)
+ :destroyed-constant-args (nth-constant-nonempty-sequence-args 2))
\f
;;;; from the "Hash Tables" chapter:
(&key (:test callable) (:size unsigned-byte)
(:rehash-size (or (integer 1) (float (1.0))))
(:rehash-threshold (real 0 1))
- (:weak-p t))
+ (:weakness (member nil :key :value :key-and-value :key-or-value)))
hash-table
(flushable unsafe))
(defknown hash-table-p (t) boolean (movable foldable flushable))
(defknown gethash (t hash-table &optional t) (values t boolean)
(flushable unsafe)) ; not FOLDABLE, since hash table contents can change
-(defknown %puthash (t hash-table t) t (unsafe))
-(defknown remhash (t hash-table) boolean ())
+(defknown sb!impl::gethash2 (t hash-table) (values t boolean)
+ (flushable unsafe)) ; not FOLDABLE, since hash table contents can change
+(defknown sb!impl::gethash3 (t hash-table t) (values t boolean)
+ (flushable unsafe)) ; not FOLDABLE, since hash table contents can change
+(defknown %puthash (t hash-table t) t (unsafe)
+ :destroyed-constant-args (nth-constant-args 2))
+(defknown remhash (t hash-table) boolean ()
+ :destroyed-constant-args (nth-constant-args 2))
(defknown maphash (callable hash-table) null (flushable call))
-(defknown clrhash (hash-table) hash-table ())
+(defknown clrhash (hash-table) hash-table ()
+ :destroyed-constant-args (nth-constant-args 2))
(defknown hash-table-count (hash-table) index (flushable))
(defknown hash-table-rehash-size (hash-table) (or (integer 1) (float (1.0)))
(foldable flushable))
(defknown hash-table-test (hash-table) symbol (foldable flushable))
(defknown sxhash (t) (integer 0 #.sb!xc:most-positive-fixnum)
(#-sb-xc-host foldable flushable))
+(defknown psxhash (t &optional t) (integer 0 #.sb!xc:most-positive-fixnum)
+ (#-sb-xc-host foldable flushable))
\f
;;;; from the "Arrays" chapter
(defknown bit ((array bit) &rest index) bit (foldable flushable))
(defknown sbit ((simple-array bit) &rest index) bit (foldable flushable))
+;;; FIXME: :DESTROYED-CONSTANT-ARGS for these is complicated.
(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 nil)))
(defknown array-has-fill-pointer-p (array) boolean
(movable 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 vector-push (t vector) (or index null) ()
+ :destroyed-constant-args (nth-constant-args 2))
+(defknown vector-push-extend (t vector &optional index) index ()
+ :destroyed-constant-args (nth-constant-args 2))
+(defknown vector-pop (vector) t ()
+ :destroyed-constant-args (nth-constant-args 1))
+
+;;; FIXME: complicated :DESTROYED-CONSTANT-ARGS
+;;; Also, an important-result warning could be provided if the array
+;;; is known to be not expressly adjustable.
(defknown adjust-array
(array (or index list) &key (:element-type type-specifier)
(:initial-element t) (:initial-contents t)
(defknown (nstring-upcase nstring-downcase nstring-capitalize)
(string &key (:start index) (:end sequence-end))
- string ())
+ string ()
+ :destroyed-constant-args (nth-constant-nonempty-sequence-args 1))
(defknown string (string-designator) string
(flushable explicit-check))
(defknown readtablep (t) boolean (movable foldable flushable))
(defknown set-syntax-from-char
- (character character &optional (or readtable null) readtable) (eql t)
+ (character character &optional readtable (or readtable null)) (eql t)
())
(defknown set-macro-character (character callable &optional t readtable)
(defknown write-byte (integer stream) integer
(explicit-check))
+;;; FIXME: complicated :DESTROYED-CONSTANT-ARGS
(defknown format ((or (member nil t) stream string)
(or string function) &rest t)
(or string null)
(defknown load-logical-pathname-translations (string) t ())
(defknown logical-pathname-translations (logical-host-designator) list ())
-(defknown pathname (pathname-designator) pathname (unsafely-flushable))
+(defknown pathname (pathname-designator) pathname ())
(defknown truename (pathname-designator) pathname ())
(defknown parse-namestring
(defknown merge-pathnames
(pathname-designator &optional pathname-designator pathname-version)
pathname
- (unsafely-flushable))
+ ())
(defknown make-pathname
(&key (:defaults pathname-designator)
(defknown %listify-rest-args (t index) list (flushable))
(defknown %more-arg-context (t t) (values t index) (flushable))
(defknown %more-arg (t index) t)
+#!+stack-grows-downward-not-upward
+(defknown %more-kw-arg (t index) (values t t))
(defknown %more-arg-values (t index index) * (flushable))
(defknown %verify-arg-count (index index) (values))
(defknown %arg-count-error (t) nil)
(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 explicit-check))
-(defknown data-vector-set (array index t) t (unsafe explicit-check))
+ (foldable explicit-check always-translatable))
+#!+x86
+(defknown data-vector-ref-with-offset (simple-array index fixnum) t
+ (foldable explicit-check always-translatable))
+(defknown data-vector-set (array index t) t
+ (unsafe explicit-check always-translatable))
+#!+x86
+(defknown data-vector-set-with-offset (array index fixnum t) t
+ (unsafe explicit-check always-translatable))
(defknown hairy-data-vector-ref (array index) t
(foldable explicit-check))
(defknown hairy-data-vector-set (array index t) t (unsafe explicit-check))
+(defknown hairy-data-vector-ref/check-bounds (array index) t
+ (foldable explicit-check))
+(defknown hairy-data-vector-set/check-bounds (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))
(values (simple-array * (*)) index index index)
\f
;;;; SETF inverses
-(defknown %aset (array &rest t) t (unsafe))
-(defknown %set-row-major-aref (array index t) t (unsafe))
-(defknown %rplaca (cons t) t (unsafe))
-(defknown %rplacd (cons t) t (unsafe))
+(defknown %aset (array &rest t) t (unsafe)
+ :destroyed-constant-args (nth-constant-args 1))
+(defknown %set-row-major-aref (array index t) t (unsafe)
+ :destroyed-constant-args (nth-constant-args 1))
+(defknown (%rplaca %rplacd) (cons t) t (unsafe)
+ :destroyed-constant-args (nth-constant-args 1))
(defknown %put (symbol t t) t (unsafe))
-(defknown %setelt (sequence index t) t (unsafe))
-(defknown %svset (simple-vector index t) t (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 %setelt (sequence index t) t (unsafe)
+ :destroyed-constant-args (nth-constant-args 1))
+(defknown %svset (simple-vector index t) t (unsafe)
+ :destroyed-constant-args (nth-constant-args 1))
+(defknown %bitset ((array bit) &rest index) bit (unsafe)
+ :destroyed-constant-args (nth-constant-args 1))
+(defknown %sbitset ((simple-array bit) &rest index) bit (unsafe)
+ :destroyed-constant-args (nth-constant-args 1))
+(defknown %charset (string index character) character (unsafe)
+ :destroyed-constant-args (nth-constant-args 1))
+(defknown %scharset (simple-string index character) character (unsafe)
+ :destroyed-constant-args (nth-constant-args 1))
(defknown %set-symbol-value (symbol t) t (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 %setnth (unsigned-byte list t) t (unsafe))
-(defknown %set-fill-pointer (vector index) index (unsafe))
+(defknown %setnth (unsigned-byte list t) t (unsafe)
+ :destroyed-constant-args (nth-constant-args 2))
+(defknown %set-fill-pointer (vector index) index (unsafe)
+ :destroyed-constant-args (nth-constant-args 1))
\f
;;;; ALIEN and call-out-to-C stuff
(defknown policy-quality (policy symbol) policy-quality
(flushable))
-(defknown (compiler-abort compiler-error) (string &rest t) nil ())
+(defknown compiler-error (t &rest t) nil ())
(defknown (compiler-warn compiler-style-warn) (string &rest t) (values) ())
(defknown (compiler-notify maybe-compiler-notify) ((or string symbol) &rest t)
(values)
())
(defknown style-warn (string &rest t) null ())
-
projects / sbcl.git / blobdiff