mirrors/emacs
1
Fork 0
mirror of git://git.sv.gnu.org/emacs.git synced 2025-12-15 18:40:39 -08:00
Code Issues Projects Releases Wiki Activity
emacs/test/lisp/help-fns-tests.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

197 lines
7.1 KiB
EmacsLisp
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

;;; help-fns-tests.el --- tests for help-fns.el -*- lexical-binding: t -*-
;; Copyright (C) 2014-2024 Free Software Foundation, Inc.
;; Maintainer: emacs-devel@gnu.org
;; 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/>.
;;; Commentary:
;;; Code:
(require 'ert)
(require 'help-fns)
(require 'subr-x)
(autoload 'help-fns-test--macro "foo" nil nil t)
;;; Several tests for describe-function
(defun help-fns-tests--describe-function (func)
"Helper function for `describe-function' tests.
FUNC is the function to describe, a symbol.
Return first line of the output of (describe-function-1 FUNC)."
(let ((string (with-output-to-string
(describe-function-1 func))))
(string-match "\\(.+\\)\n" string)
(match-string-no-properties 1 string)))
(ert-deftest help-fns-test-bug17410 ()
"Test for https://debbugs.gnu.org/17410 ."
(let ((regexp "autoloaded Lisp macro")
(result (help-fns-tests--describe-function 'help-fns-test--macro)))
(should (string-match regexp result))))
(ert-deftest help-fns-test-built-in ()
(let ((regexp "a primitive-function in .C source code")
(result (help-fns-tests--describe-function 'mapcar)))
(should (string-match regexp result))))
(ert-deftest help-fns-test-interactive-built-in ()
(let ((regexp "an interactive primitive-function in .C source code")
(result (help-fns-tests--describe-function 're-search-forward)))
(should (string-match regexp result))))
(ert-deftest help-fns-test-lisp-macro ()
(let ((regexp "a Lisp macro in .+subr\\.el")
(result (help-fns-tests--describe-function 'when)))
(should (string-match regexp result))))
(ert-deftest help-fns-test-lisp-defun ()
(let ((regexp "a \\([^ ]+\\) in .+subr\\.el")
(result (help-fns-tests--describe-function 'last)))
(should (string-match regexp result))
(should (member (match-string 1 result)
'("subr-native-elisp" "byte-code-function")))))
(ert-deftest help-fns-test-lisp-defsubst ()
(let ((regexp "a byte-code-function in .+subr\\.el")
(result (help-fns-tests--describe-function 'posn-window)))
(should (string-match regexp result))))
(ert-deftest help-fns-test-alias-to-defun ()
(let ((regexp "an alias for .set-file-modes. in .+subr\\.el")
(result (help-fns-tests--describe-function 'chmod)))
(should (string-match regexp result))))
(ert-deftest help-fns-test-bug23887 ()
"Test for https://debbugs.gnu.org/23887 ."
(let ((regexp "an alias for .re-search-forward. in .+subr\\.el")
(result (help-fns-tests--describe-function 'search-forward-regexp)))
(should (string-match regexp result))))
(ert-deftest help-fns-test-dangling-alias ()
"Make sure we don't burp on bogus aliases."
(let ((f (make-symbol "bogus-alias")))
(define-obsolete-function-alias f 'help-fns-test--undefined-function "past")
(describe-symbol f)))
;;; Test describe-function over functions with funny names
(defun abc\\\[universal-argument\]b\`c\'d\\e\"f (x)
"A function with a funny name.
\(fn XYZZY)"
x)
(defun defgh\\\[universal-argument\]b\`c\'d\\e\"f (x)
"Another function with a funny name."
x)
(ert-deftest help-fns-test-funny-names ()
"Test for help with functions with funny names."
(describe-function 'abc\\\[universal-argument\]b\`c\'d\\e\"f)
(with-current-buffer "*Help*"
(goto-char (point-min))
(should (search-forward
"(abc\\\\\\[universal-argument\\]b\\`c\\'d\\\\e\\\"f XYZZY)")))
(describe-function 'defgh\\\[universal-argument\]b\`c\'d\\e\"f)
(with-current-buffer "*Help*"
(goto-char (point-min))
(should (search-forward
"(defgh\\\\\\[universal-argument\\]b\\`c\\'d\\\\e\\\"f X)"))))
;;; Test for describe-symbol
(ert-deftest help-fns-test-describe-symbol ()
"Test the `describe-symbol' function."
;; 'describe-symbol' would originally signal an error for
;; 'font-lock-comment-face'.
(describe-symbol 'font-lock-comment-face)
(with-current-buffer "*Help*"
(should (> (point-max) 1))
(goto-char (point-min))
(should (looking-at "^font-lock-comment-face is "))))
(defvar foo-test-map)
(defvar help-fns-test--describe-keymap-foo)
;;; Tests for describe-keymap
(defvar-keymap help-fns-test-map
"a" 'test-cmd-a
"b" 'test-cmd-b
"c" 'test-cmd-c)
(ert-deftest help-fns-test-find-keymap-name ()
(should (equal (help-fns-find-keymap-name lisp-mode-map) 'lisp-mode-map))
;; Follow aliasing.
(unwind-protect
(progn
(defvaralias 'foo-test-map 'lisp-mode-map)
(should (equal (help-fns-find-keymap-name foo-test-map) 'lisp-mode-map)))
(makunbound 'foo-test-map)))
(ert-deftest help-fns-test-describe-keymap/symbol ()
(describe-keymap 'help-fns-test-map)
(with-current-buffer "*Help*"
(should (looking-at "^help-fns-test-map is"))
(should (re-search-forward (rx word-start "a" word-end
(+ blank)
word-start "test-cmd-a" word-end)
nil t))))
(ert-deftest help-fns-test-describe-keymap/value ()
(describe-keymap help-fns-test-map)
(with-current-buffer "*Help*"
(should (looking-at "\nKey"))))
(ert-deftest help-fns-test-describe-keymap/not-keymap ()
(should-error (describe-keymap nil))
(should-error (describe-keymap emacs-version))
(should-error (describe-keymap 'some-undefined-variable-foobar)))
(ert-deftest help-fns-test-describe-keymap/let-bound ()
(let ((foobar help-fns-test-map))
(describe-keymap foobar)
(with-current-buffer "*Help*"
(should (looking-at "\nKey")))))
(ert-deftest help-fns-test-describe-keymap/dynamically-bound-no-file ()
(setq help-fns-test--describe-keymap-foo help-fns-test-map)
(describe-keymap 'help-fns-test--describe-keymap-foo)
(with-current-buffer "*Help*"
(should (looking-at "^help-fns-test--describe-keymap-foo is"))))
;;; Tests for find-lisp-object-file-name
(ert-deftest help-fns-test-bug24697-function-search ()
(should-not (find-lisp-object-file-name 'tab-width 1)))
(ert-deftest help-fns-test-bug24697-non-internal-variable ()
(let ((help-fns--test-var (make-symbol "help-fns--test-var")))
;; simulate an internal variable
(put help-fns--test-var 'variable-documentation 1)
(should-not (find-lisp-object-file-name help-fns--test-var 'defface))
(should-not (find-lisp-object-file-name help-fns--test-var 1))))
(ert-deftest help-fns--analyze-function-recursive ()
(defalias 'help-fns--a 'help-fns--b)
(should (equal (help-fns--analyze-function 'help-fns--a)
'(help-fns--a help-fns--b t help-fns--b))))
;;; help-fns-tests.el ends here
Reference in a new issue View git blame Copy permalink