A customizable variable is either (i) a variable whose property
list contains a non-nil `standard-value' or `custom-autoload'
property, or (ii) an alias for another customizable variable."
- (declare (side-effect-free t))
+ (declare (type (function (symbol) t))
+ (side-effect-free t))
(when (symbolp variable)
(setq variable (indirect-variable variable))
(or (get variable 'standard-value)
:risky t
:version "28.1")
-(defconst comp-known-type-specifiers
+(defconst comp-primitive-type-specifiers
`(
;; Functions we can trust not to be redefined, or, if redefined,
;; to expose the same type. The vast majority of these are
(assq (function (t list) list))
(atan (function (number &optional number) float))
(atom (function (t) boolean))
- (bignump (function (t) boolean))
(bobp (function () boolean))
(bolp (function () boolean))
(bool-vector-count-consecutive
(bool-vector-p (function (t) boolean))
(bool-vector-subsetp (function (bool-vector bool-vector) boolean))
(boundp (function (symbol) boolean))
- (buffer-end (function ((or number marker)) integer))
(buffer-file-name (function (&optional buffer) (or string null)))
(buffer-list (function (&optional frame) list))
(buffer-local-variables (function (&optional buffer) list))
(copy-sequence (function (sequence) sequence))
(copysign (function (float float) float))
(cos (function (number) float))
- (count-lines
- (function ((or integer marker) (or integer marker) &optional t) integer))
(current-buffer (function () buffer))
(current-global-map (function () cons))
(current-indentation (function () integer))
(current-time-zone (function (&optional (or number list)
(or symbol string cons integer))
cons))
- (custom-variable-p (function (symbol) t))
(decode-char (function (cons t) (or fixnum null)))
(decode-time (function (&optional (or number list)
(or symbol string cons integer)
cons))
(default-boundp (function (symbol) boolean))
(default-value (function (symbol) t))
- (degrees-to-radians (function (number) float))
(documentation
(function ((or function symbol subr) &optional t) (or null string)))
(downcase (function ((or fixnum string)) (or fixnum string)))
(eql (function (t t) boolean))
(equal (function (t t) boolean))
(error-message-string (function (list) string))
- (eventp (function (t) boolean))
(exp (function (number) float))
(expt (function (number number) number))
(fboundp (function (symbol) boolean))
(file-readable-p (function (string) boolean))
(file-symlink-p (function (string) (or boolean string)))
(file-writable-p (function (string) boolean))
- (fixnump (function (t) boolean))
(float (function (number) float))
(float-time (function (&optional (or number list)) float))
(floatp (function (t) boolean))
(function (&optional (or buffer string) (or symbol (integer 0 0)))
(or null window)))
(get-file-buffer (function (string) (or null buffer)))
- (get-largest-window (function (&optional t t t) (or window null)))
- (get-lru-window (function (&optional t t t) (or window null)))
- (getenv (function (string &optional frame) (or null string)))
(gethash (function (t hash-table &optional t) t))
(hash-table-count (function (hash-table) integer))
(hash-table-p (function (t) boolean))
(identity (function (t) t))
- (ignore (function (&rest t) null))
- (int-to-string (function (number) string))
(integer-or-marker-p (function (t) boolean))
(integerp (function (t) boolean))
- (interactive-p (function () boolean))
(intern-soft (function ((or string symbol) &optional (or obarray vector))
symbol))
(invocation-directory (function () string))
(keymap-parent (function (cons) (or cons null)))
(keymapp (function (t) boolean))
(keywordp (function (t) boolean))
- (last (function (list &optional integer) list))
- (lax-plist-get (function (list t) t))
(ldexp (function (number integer) float))
(length (function (t) (integer 0 *)))
(length< (function (sequence fixnum) boolean))
(local-variable-p (function (symbol &optional buffer) boolean))
(locale-info (function ((member codeset days months paper)) (or null string)))
(log (function (number number) float))
- (log10 (function (number) float))
(logand (function (&rest (or integer marker)) integer))
(logb (function (number) integer))
(logcount (function (integer) integer))
(lognot (function (integer) integer))
(logxor (function (&rest (or integer marker)) integer))
;; (lsh (function ((integer ,most-negative-fixnum *) integer) integer)) ?
- (lsh (function (integer integer) integer))
(make-byte-code
(function ((or fixnum list) string vector integer &optional string t
&rest t)
(make-marker (function () marker))
(make-string (function (integer fixnum &optional t) string))
(make-symbol (function (string) symbol))
- (mark (function (&optional t) (or integer null)))
(mark-marker (function () marker))
(marker-buffer (function (marker) (or buffer null)))
(markerp (function (t) boolean))
(max (function ((or number marker) &rest (or number marker)) number))
(max-char (function (&optional t) fixnum))
(member (function (t list) list))
- (memory-limit (function () integer))
(memq (function (t list) list))
(memql (function (t list) list))
(min (function ((or number marker) &rest (or number marker)) number))
(mod
(function ((or number marker) (or number marker))
(or (integer 0 *) (float 0 *))))
- (mouse-movement-p (function (t) boolean))
(multibyte-char-to-unibyte (function (fixnum) fixnum))
(natnump (function (t) boolean))
(next-window (function (&optional window t t) window))
(number-or-marker-p (function (t) boolean))
(number-to-string (function (number) string))
(numberp (function (t) boolean))
- (one-window-p (function (&optional t t) boolean))
(overlayp (function (t) boolean))
- (parse-colon-path (function (string) list))
(plist-get (function (list t &optional t) t))
(plist-member (function (list t &optional t) list))
(point (function () integer))
(processp (function (t) boolean))
(proper-list-p (function (t) (or fixnum null)))
(propertize (function (string &rest t) string))
- (radians-to-degrees (function (number) float))
(rassoc (function (t list) list))
(rassq (function (t list) list))
(read-from-string (function (string &optional integer integer) cons))
(recent-keys (function (&optional (or cons null)) vector))
(recursion-depth (function () integer))
- (regexp-opt (function (list) string))
(regexp-quote (function (string) string))
(region-beginning (function () integer))
(region-end (function () integer))
(upcase (function ((or fixnum string)) (or fixnum string)))
(user-full-name (function (&optional integer) (or string null)))
(user-login-name (function (&optional integer) (or string null)))
- (user-original-login-name (function (&optional integer) (or string null)))
(user-real-login-name (function () string))
(user-real-uid (function () integer))
(user-uid (function () integer))
(window-live-p (function (t) boolean))
(window-valid-p (function (t) boolean))
(windowp (function (t) boolean))
- (zerop (function (number) boolean))
- ;; Type hints
- (comp-hint-fixnum (function (t) fixnum))
- (comp-hint-cons (function (t) cons))
;; Non returning functions
(throw (function (t t) nil))
- (error (function (string &rest t) nil))
(signal (function (symbol t) nil)))
"Alist used for type propagation.")
and cdr is a symbol, either `inferred' or `declared'. If the symbol is
`inferred', the type specifier is automatically inferred from the code
itself by the native compiler; if it is `declared', the type specifier
-comes from `comp-known-type-specifiers' or the function type declaration
+comes from `comp-primitive-type-specifiers' or the function type declaration
itself."
(let ((kind 'declared)
type-spec)
- (when-let ((res (assoc function comp-known-type-specifiers)))
+ (when-let ((res (assoc function comp-primitive-type-specifiers)))
;; Declared primitive
(setf type-spec (cadr res)))
(let ((f (and (symbolp function)
;; are assumed just to be true. Use with extreme caution...
(defun comp-hint-fixnum (x)
- (declare (gv-setter (lambda (val) `(setf ,x ,val))))
+ (declare (type (function (t) fixnum))
+ (gv-setter (lambda (val) `(setf ,x ,val))))
x)
(defun comp-hint-cons (x)
- (declare (gv-setter (lambda (val) `(setf ,x ,val))))
+ (declare (type (function (t) cons))
+ (gv-setter (lambda (val) `(setf ,x ,val))))
x)
\f
"Return the \"far end\" position of the buffer, in direction ARG.
If ARG is positive, that's the end of the buffer.
Otherwise, that's the beginning of the buffer."
- (declare (side-effect-free error-free))
+ (declare (type (function ((or number marker)) integer))
+ (side-effect-free error-free))
(if (> arg 0) (point-max) (point-min)))
(defun end-of-defun (&optional arg interactive)
(concat (car parens)
(mapconcat \\='regexp-quote strings \"\\\\|\")
(cdr parens))))"
- (declare (pure t) (side-effect-free t))
+ (declare (type (function (list) string))
+ (pure t) (side-effect-free t))
(save-match-data
;; Recurse on the sorted list.
(let* ((max-lisp-eval-depth 10000)
Otherwise, this function searches `process-environment' for
VARIABLE. If it is not found there, then it continues the search
in the environment list of the selected frame."
- (declare (side-effect-free t))
+ (declare (type (function (string &optional frame) (or null string)))
+ (side-effect-free t))
(interactive (list (read-envvar-name "Get environment variable: " t)))
(let ((value (getenv-internal (if (multibyte-string-p variable)
(encode-coding-string
resulting list of directory names. For an empty path element (i.e.,
a leading or trailing separator, or two adjacent separators), return
nil (meaning `default-directory') as the associated list element."
+ (declare (type (function (string) list)))
(when (stringp search-path)
(let ((spath (substitute-env-vars search-path))
(double-slash-special-p
When IGNORE-INVISIBLE-LINES is non-nil, invisible lines are not
included in the count."
- (declare (side-effect-free t))
+ (declare (type (function ((or integer marker) (or integer marker) &optional t)
+ integer))
+ (side-effect-free t))
(save-excursion
(save-restriction
(narrow-to-region start end)
If you are using this in an editing command, you are most likely making
a mistake; see the documentation of `set-mark'."
- (declare (side-effect-free t))
+ (declare (type (function (&optional t) (or integer null)))
+ (side-effect-free t))
(if (or force (not transient-mark-mode) mark-active mark-even-if-inactive)
(marker-position (mark-marker))
(signal 'mark-inactive nil)))
(defun lax-plist-get (plist prop)
"Extract a value from a property list, comparing with `equal'."
- (declare (pure t) (side-effect-free t) (obsolete plist-get "29.1"))
+ (declare (type (function (list t) t))
+ (pure t) (side-effect-free t) (obsolete plist-get "29.1"))
(plist-get plist prop #'equal))
(defun lax-plist-put (plist prop val)
Also see `always'."
;; Not declared `side-effect-free' because we don't want calls to it
;; elided; see `byte-compile-ignore'.
- (declare (pure t) (completion ignore))
+ (declare (type (function (&rest t) null))
+ (pure t) (completion ignore))
(interactive)
nil)
To alter the look of the displayed error messages, you can use
the `command-error-function' variable."
- (declare (advertised-calling-convention (string &rest args) "23.1"))
+ (declare (type (function (string &rest t) nil))
+ (advertised-calling-convention (string &rest args) "23.1"))
(signal 'error (list (apply #'format-message args))))
(defun user-error (format &rest args)
"Return t if NUMBER is zero."
;; Used to be in C, but it's pointless since (= 0 n) is faster anyway because
;; = has a byte-code.
- (declare (pure t) (side-effect-free t)
+ (declare (type (function (number) boolean))
+ (pure t) (side-effect-free t)
(compiler-macro (lambda (_) `(= 0 ,number))))
(= 0 number))
(defun fixnump (object)
"Return t if OBJECT is a fixnum."
- (declare (side-effect-free error-free))
+ (declare (type (function (t) boolean))
+ (side-effect-free error-free))
(and (integerp object)
(<= most-negative-fixnum object most-positive-fixnum)))
(defun bignump (object)
"Return t if OBJECT is a bignum."
- (declare (side-effect-free error-free))
+ (declare (type (function (t) boolean))
+ (side-effect-free error-free))
(and (integerp object) (not (fixnump object))))
(defun lsh (value count)
to use `ash' instead, unless COUNT could ever be negative, and
if, when COUNT is negative, your program really needs the special
treatment of negative COUNT provided by this function."
- (declare (compiler-macro
+ (declare (type (function (integer integer) integer))
+ (compiler-macro
(lambda (form)
(macroexp-warn-and-return
(format-message "avoid `lsh'; use `ash' instead")
If LIST is nil, return nil.
If N is non-nil, return the Nth-to-last link of LIST.
If N is bigger than the length of LIST, return LIST."
- (declare (pure t) (side-effect-free t)) ; pure up to mutation
+ (declare (type (function (list &optional integer) list))
+ (pure t) (side-effect-free t)) ; pure up to mutation
(if n
(and (>= n 0)
(let ((m (safe-length list)))
(defun eventp (object)
"Return non-nil if OBJECT is an input event or event object."
- (declare (pure t) (side-effect-free error-free))
+ (declare (type (function (t) boolean))
+ (pure t) (side-effect-free error-free))
(or (integerp object)
(and (if (consp object)
(setq object (car object))
(defsubst mouse-movement-p (object)
"Return non-nil if OBJECT is a mouse movement event."
- (declare (side-effect-free error-free))
+ (declare (type (function (t) boolean))
+ (side-effect-free error-free))
(eq (car-safe object) 'mouse-movement))
(defun mouse-event-p (object)
(defun log10 (x)
"Return (log X 10), the log base 10 of X."
- (declare (side-effect-free t) (obsolete log "24.4"))
+ (declare (type (function (number) float))
+ (side-effect-free t) (obsolete log "24.4"))
(log x 10))
(set-advertised-calling-convention
(defun memory-limit ()
"Return an estimate of Emacs virtual memory usage, divided by 1024."
- (declare (side-effect-free error-free))
+ (declare (type (function () integer))
+ (side-effect-free error-free))
(let ((default-directory temporary-file-directory))
(or (cdr (assq 'vsize (process-attributes (emacs-pid)))) 0)))
`commandp'."
;; Kept around for now. See discussion at:
;; https://lists.gnu.org/r/emacs-devel/2020-08/msg00564.html
- (declare (obsolete called-interactively-p "23.2")
+ (declare (type (function () boolean))
+ (obsolete called-interactively-p "23.2")
(side-effect-free error-free))
(called-interactively-p 'interactive))
Any other value of ALL-FRAMES means consider all windows on the
selected frame and no others."
- (declare (side-effect-free error-free))
+ (declare (type (function (&optional t t t) (or window null)))
+ (side-effect-free error-free))
(let ((windows (window-list-1 nil 'nomini all-frames))
best-window best-time second-best-window second-best-time time)
(dolist (window windows)
Any other value of ALL-FRAMES means consider all windows on the
selected frame and no others."
- (declare (side-effect-free error-free))
+ (declare (type (function (&optional t t t) (or window null)))
+ (side-effect-free error-free))
(let ((best-size 0)
best-window size)
(dolist (window (window-list-1 nil 'nomini all-frames))
Anything else means consider all windows on the selected frame
and no others."
- (declare (side-effect-free error-free))
+ (declare (type (function (&optional t t) boolean))
+ (side-effect-free error-free))
(let ((base-window (selected-window)))
(if (and nomini (eq base-window (minibuffer-window)))
(setq base-window (next-window base-window)))
projects / emacs.git / commitdiff