Reimplement module functions

Instead of a lambda, create a new type containing all data required to
call the function, and support it in the evaluator.  Because this type
now also needs to store the function documentation, it is too big for
Lisp_Misc; use a pseudovector instead.  That also has the nice benefit
that we don't have to add special support to the garbage collector.

Since the new type is user-visible, give it a predicate.

Now we can easily support 'help-function-args' and 'func-arity'; add
unit tests for these.

* src/lisp.h (allocate_module_function, MODULE_FUNCTIONP)
(XMODULE_FUNCTION): New pseudovector type 'module function'.

* src/eval.c (FUNCTIONP): Also treat module functions as functions.
(funcall_lambda, Ffuncall, eval_sub): Add support for calling module
functions.
(Ffunc_arity): Add support for detecting the arity of module
functions.

* src/emacs-module.c (module_make_function): Adapt to new structure.
Return module function object directly instead of wrapping it in a
lambda; remove FIXME.
(funcall_module): New function to call module functions.  Replaces
`internal--module-call' and is called directly from eval.c.
(syms_of_module): Remove internal helper function, which is no longer
needed.
(module_function_arity): New helper function.

* src/data.c (Ftype_of): Adapt to new implementation.
(Fmodule_function_p, syms_of_data): New user-visible function.  Now
that module functions are first-class objects, they deserve a
predicate.  Define it even if not compiled with --enable-modules so
that Lisp code doesn't have to check for the function's existence.

* src/doc.c (Fdocumentation): Support module functions.

* src/print.c (print_object): Adapt to new implementation.

* src/alloc.c (mark_object): Specialized garbage collector support is
no longer needed.

* lisp/help.el (help-function-arglist): Support module functions.
While there, simplify the arity calculation by using `func-arity',
which does the right thing for all kinds of functions.

* test/data/emacs-module/mod-test.c: Amend docstring so we can test
the argument list.

* test/src/emacs-module-tests.el (mod-test-sum-docstring): Adapt to
new docstring.
(mod-test-non-local-exit-signal-test): Because `internal--module-call'
is gone, the backtrace has changed and no longer leaks the
implementation.
(module--func-arity): New test for `func-arity'.
(module--help-function-arglist): New test for `help-function-arglist'.

1 files changed, 27 insertions, 24 deletions

diff --git a/test/src/emacs-module-tests.el b/test/src/emacs-module-tests.el
index 0f4bfae00a2..5e78aebf7c3 100644
--- a/test/src/emacs-module-tests.el
+++ b/test/src/emacs-module-tests.el
@@ -57,33 +57,22 @@
                 :type 'overflow-error))
 
 (ert-deftest mod-test-sum-docstring ()
-  (should (string= (documentation 'mod-test-sum) "Return A + B")))
+  (should (string= (documentation 'mod-test-sum) "Return A + B\n\n(fn a b)")))
 
 (ert-deftest module-function-object ()
   "Extract and test the implementation of a module function.
 This test needs to be changed whenever the implementation
 changes."
   (let ((func (symbol-function #'mod-test-sum)))
-    (should (consp func))
-    (should (equal (length func) 4))
-    (should (equal (nth 0 func) 'lambda))
-    (should (equal (nth 1 func) '(&rest args)))
-    (should (equal (nth 2 func) "Return A + B"))
-    (let ((body (nth 3 func)))
-      (should (consp body))
-      (should (equal (length body) 4))
-      (should (equal (nth 0 body) #'apply))
-      (should (equal (nth 1 body) '#'internal--module-call))
-      (should (equal (nth 3 body) 'args))
-      (let ((obj (nth 2 body)))
-        (should (equal (type-of obj) 'module-function))
-        (should (string-match-p
-                 (rx "#<module function "
-                     (or "Fmod_test_sum"
-                         (and "at 0x" (+ hex-digit)))
-                     (? " from " (* nonl) "mod-test" (* nonl) )
-                     ">")
-                 (prin1-to-string obj)))))))
+    (should (module-function-p func))
+    (should (equal (type-of func) 'module-function))
+    (should (string-match-p
+             (rx bos "#<module function "
+                 (or "Fmod_test_sum"
+                     (and "at 0x" (+ hex-digit)))
+                 (? " from " (* nonl) "mod-test" (* nonl) )
+                 ">" eos)
+             (prin1-to-string func)))))
 
 ;;
 ;; Non-local exists (throw, signal).
@@ -101,9 +90,7 @@ changes."
        (mod-test-signal)))
     (should (equal debugger-args '(error (error . 56))))
     (should (string-match-p
-             (rx bol "  internal--module-call(" (+ nonl) ?\) ?\n
-                 "  apply(internal--module-call " (+ nonl) ?\) ?\n
-                 "  mod-test-signal()" eol)
+             (rx bol "  mod-test-signal()" eol)
              backtrace))))
 
 (ert-deftest mod-test-non-local-exit-throw-test ()
@@ -172,3 +159,19 @@ changes."
 
         (should (eq (mod-test-vector-fill v-test e) t))
         (should (eq (mod-test-vector-eq v-test e) eq-ref))))))
+
+(ert-deftest module--func-arity ()
+  (should (equal (func-arity #'mod-test-return-t) '(1 . 1)))
+  (should (equal (func-arity #'mod-test-sum) '(2 . 2))))
+
+(ert-deftest module--help-function-arglist ()
+  (should (equal (help-function-arglist #'mod-test-return-t :preserve-names)
+                 '(arg1)))
+  (should (equal (help-function-arglist #'mod-test-return-t)
+                 '(arg1)))
+  (should (equal (help-function-arglist #'mod-test-sum :preserve-names)
+                 '(a b)))
+  (should (equal (help-function-arglist #'mod-test-sum)
+                 '(arg1 arg2))))
+
+;;; emacs-module-tests.el ends here