emacs/test/lisp/emacs-lisp/macroexp-resources/vk.el
Stefan Monnier f2bccae22b Use a dedicated type to represent interpreted-function values
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.
2024-04-28 11:58:12 -04:00

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)