mirror of
https://github.com/masscollaborationlabs/emacs.git
synced 2025-07-11 06:30:51 +00:00
f2bccae22b
Change `function` so that when evaluating #'(lambda ...) we return an object of type `interpreted-function` rather than a list starting with one of `lambda` or `closure`. The new type reuses the existing PVEC_CLOSURE (nee PVEC_COMPILED) tag and tries to align the corresponding elements: - the arglist, the docstring, and the interactive-form go in the same slots as for byte-code functions. - the body of the function goes in the slot used for the bytecode string. - the lexical context goes in the slot used for the constants of bytecoded functions. The first point above means that `help-function-arglist`, `documentation`, and `interactive-form`s don't need to distinguish interpreted and bytecode functions any more. Main benefits of the change: - We can now reliably distinguish a list from a function value. - `cl-defmethod` can dispatch on `interactive-function` and `closure`. Dispatch on `function` also works now for interpreted functions but still won't work for functions represented as lists or as symbols, of course. - Function values are now self-evaluating. That was alrready the case when byte-compiled, but not when interpreted since (eval '(closure ...)) signals a void-function error. That also avoids false-positive warnings about "don't quote your lambdas" when doing things like `(mapcar ',func ...)`. * src/eval.c (Fmake_interpreted_closure): New function. (Ffunction): Use it and change calling convention of `Vinternal_make_interpreted_closure_function`. (FUNCTIONP, Fcommandp, eval_sub, funcall_general, funcall_lambda) (Ffunc_arity, lambda_arity): Simplify. (funcall_lambda): Adjust to new representation. (syms_of_eval): `defsubr` the new function. Remove definition of `Qclosure`. * lisp/emacs-lisp/cconv.el (cconv-make-interpreted-closure): Change calling convention and use `make-interpreted-closure`. * src/data.c (Fcl_type_of): Distinguish `byte-code-function`s from `interpreted-function`s. (Fclosurep, finterpreted_function_p): New functions. (Fbyte_code_function_p): Don't be confused by `interpreted-function`s. (Finteractive_form, Fcommand_modes): Simplify. (syms_of_data): Define new type symbols and `defsubr` the two new functions. * lisp/emacs-lisp/cl-print.el (cl-print-object) <interpreted-function>: New method. * lisp/emacs-lisp/oclosure.el (oclosure): Refine the parent to be `closure`. (oclosure--fix-type, oclosure-type): Simplify. (oclosure--copy, oclosure--get, oclosure--set): Adjust to new representation. * src/callint.c (Fcall_interactively): Adjust to new representation. * src/lread.c (bytecode_from_rev_list): * lisp/simple.el (function-documentation): * lisp/help.el (help-function-arglist): Remove the old `closure` case and adjust the byte-code case so it handles `interpreted-function`s. * lisp/emacs-lisp/cl-preloaded.el (closure): New type. (byte-code-function): Add it as a parent. (interpreted-function): Adjust parent (the type itself was already added earlier by accident). * lisp/emacs-lisp/bytecomp.el (byte-compile--reify-function): Adjust to new representation. (byte-compile): Use `interpreted-function-p`. * lisp/emacs-lisp/byte-opt.el (byte-compile-inline-expand): Adjust to new representation. (side-effect-free-fns): Add `interpreted-function-p` and `closurep`. * src/profiler.c (trace_hash, ffunction_equal): Simplify. * lisp/profiler.el (profiler-function-equal): Simplify. * lisp/emacs-lisp/nadvice.el (advice--interactive-form-1): Use `interpreted-function-p`; adjust to new representation; and take advantage of the fact that function values are now self-evaluating. * lisp/emacs-lisp/lisp-mode.el (closure): Remove `lisp-indent-function` property. * lisp/emacs-lisp/disass.el (disassemble-internal): Adjust to new representation. * lisp/emacs-lisp/edebug.el (edebug--strip-instrumentation): Use `interpreted-function-p`. * lisp/emacs-lisp/comp-common.el (comp-known-type-specifiers): Add `closurep` and `interpreted-function-p`. * test/lisp/help-fns-tests.el (help-fns-test-lisp-defun): Adjust to more precise type info in `describe-function`. * test/lisp/erc/resources/erc-d/erc-d-tests.el (erc-d--render-entries): Use `interpreted-function-p`. * test/lisp/emacs-lisp/macroexp-resources/vk.el (vk-f4, vk-f5): Don't hardcode function values. * doc/lispref/functions.texi (Anonymous Functions): Don't suggest that function values are lists. Reword "self-quoting" to reflect the fact that #' doesn't return the exact same object. Update examples with the new shape of the return value. * doc/lispref/variables.texi (Lexical Binding): * doc/lispref/lists.texi (Rearrangement): * doc/lispref/control.texi (Handling Errors): Update examples to reflect new representation of function values.
132 lines
4.1 KiB
EmacsLisp
132 lines
4.1 KiB
EmacsLisp
;;; vk.el --- test code for macroexp-tests -*- lexical-binding: t -*-
|
|
|
|
;; Copyright (C) 2021-2024 Free Software Foundation, Inc.
|
|
|
|
;; This file is part of GNU Emacs.
|
|
|
|
;; GNU Emacs is free software: you can redistribute it and/or modify
|
|
;; it under the terms of the GNU General Public License as published by
|
|
;; the Free Software Foundation, either version 3 of the License, or
|
|
;; (at your option) any later version.
|
|
|
|
;; GNU Emacs is distributed in the hope that it will be useful,
|
|
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
;; GNU General Public License for more details.
|
|
|
|
;; You should have received a copy of the GNU General Public License
|
|
;; along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
;;; Code:
|
|
|
|
(require 'macroexp)
|
|
|
|
(defmacro vk-variable-kind (var)
|
|
(if (macroexp--dynamic-variable-p var) ''dyn ''lex))
|
|
|
|
(defvar vk-a 1)
|
|
(defvar vk-b 2)
|
|
(defvar vk-c)
|
|
|
|
(defun vk-f1 (x)
|
|
(defvar vk-u1)
|
|
(let ((vk-a 10)
|
|
(vk-b 20)
|
|
(vk-c 30)
|
|
(vk-u1 40)
|
|
(y 50))
|
|
(ignore vk-a vk-b vk-c vk-u1 x y)
|
|
(list
|
|
(vk-variable-kind vk-a) ; dyn
|
|
(vk-variable-kind vk-b) ; dyn
|
|
(vk-variable-kind vk-c) ; dyn
|
|
(vk-variable-kind vk-u1) ; dyn
|
|
(vk-variable-kind x) ; lex
|
|
(vk-variable-kind y)))) ; lex
|
|
|
|
(eval-and-compile
|
|
(defvar vk-u2)
|
|
(defun vk-f2 (x)
|
|
(defvar vk-v2)
|
|
(let ((vk-u2 11)
|
|
(vk-v2 12)
|
|
(y 13))
|
|
(ignore vk-u2 vk-v2 x y)
|
|
(list
|
|
(vk-variable-kind vk-u2) ; dyn
|
|
(vk-variable-kind vk-v2) ; dyn
|
|
(vk-variable-kind x) ; lex
|
|
(vk-variable-kind y))))) ; lex
|
|
|
|
(eval-when-compile
|
|
(defvar vk-u3)
|
|
(defun vk-f3 (x)
|
|
(defvar vk-v3)
|
|
(let ((vk-a 23)
|
|
(vk-b 24)
|
|
(vk-u3 25)
|
|
(vk-v3 26)
|
|
(y 27))
|
|
(ignore vk-a vk-b vk-u3 vk-v3 x y)
|
|
(list
|
|
(vk-variable-kind vk-a) ; dyn
|
|
(vk-variable-kind vk-b) ; dyn
|
|
(vk-variable-kind vk-u3) ; dyn
|
|
(vk-variable-kind vk-v3) ; dyn
|
|
(vk-variable-kind x) ; lex
|
|
(vk-variable-kind y))))) ; lex
|
|
|
|
(defconst vk-val3 (eval-when-compile (vk-f3 0)))
|
|
|
|
(defconst vk-f4 (eval '(lambda (x)
|
|
(defvar vk-v4)
|
|
(let ((vk-v4 31)
|
|
(y 32))
|
|
(ignore vk-v4 x y)
|
|
(list
|
|
(vk-variable-kind vk-a) ; dyn
|
|
(vk-variable-kind vk-b) ; dyn
|
|
(vk-variable-kind vk-v4) ; dyn
|
|
(vk-variable-kind x) ; dyn
|
|
(vk-variable-kind y)))) ; dyn
|
|
nil))
|
|
|
|
(defconst vk-f5 (eval '(lambda (x)
|
|
(defvar vk-v5)
|
|
(let ((vk-v5 41)
|
|
(y 42))
|
|
(ignore vk-v5 x y)
|
|
(list
|
|
(vk-variable-kind vk-a) ; dyn
|
|
(vk-variable-kind vk-b) ; dyn
|
|
(vk-variable-kind vk-v5) ; dyn
|
|
(vk-variable-kind x) ; lex
|
|
(vk-variable-kind y)))) ; lex
|
|
t))
|
|
|
|
(defun vk-f6 ()
|
|
(eval '(progn
|
|
(defvar vk-v6)
|
|
(let ((vk-v6 51)
|
|
(y 52))
|
|
(ignore vk-v6 y)
|
|
(list
|
|
(vk-variable-kind vk-a) ; dyn
|
|
(vk-variable-kind vk-b) ; dyn
|
|
(vk-variable-kind vk-v6) ; dyn
|
|
(vk-variable-kind vk-y)))))) ; dyn
|
|
|
|
(defun vk-f7 ()
|
|
(eval '(progn
|
|
(defvar vk-v7)
|
|
(let ((vk-v7 51)
|
|
(y 52))
|
|
(ignore vk-v7 y)
|
|
(list
|
|
(vk-variable-kind vk-a) ; dyn
|
|
(vk-variable-kind vk-b) ; dyn
|
|
(vk-variable-kind vk-v7) ; dyn
|
|
(vk-variable-kind vk-y)))) ; lex
|
|
t))
|
|
|
|
(provide 'vk)
|