bug#28557: 26.0.60; Bugs using (:documentation FORM) in closures

bug#28557: 26.0.60; Bugs using (:documentation FORM) in closures

[Gemini Lasswell]

[-- Attachment #1: Type: text/plain, Size: 466 bytes --]

Since Emacs 25, docstrings can be constructed using
(:documentation FORM) in closures, when lexical-binding is on. This
isn't documented except in NEWS. Bug #24773 is about Edebug specs
which have not been updated to recognize :documentation. I'd like to
fix it, so I started trying to figure out which macros accept
:documentation forms so I would know which Edebug specs to update, and
that effort turned into a collection of tests for the feature, see
attached:


[-- Attachment #2: cconv-tests.el --]
[-- Type: text/plain, Size: 7872 bytes --]

;;; cconv-tests.el --- Tests for cconv.el functionality  -*- lexical-binding: t; -*-

;; Copyright (C) 2017 Free Software Foundation, Inc.

;; Author: Gemini Lasswell

;; 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 'cl-lib)

(ert-deftest cconv-tests-lambda-:documentation ()
  "Docstring for lambda can be specified with :documentation."
  (let ((fun (lambda ()
               (:documentation (concat "lambda" " documentation"))
               'lambda-result)))
    (should (string= (documentation fun) "lambda documentation"))
    (should (eq (funcall fun) 'lambda-result))))

(ert-deftest cconv-tests-pcase-lambda-:documentation ()
  "Docstring for pcase-lambda can be specified with :documentation."
  (let ((fun (pcase-lambda (`(,a ,b))
               (:documentation (concat "pcase-lambda" " documentation"))
               (list b a))))
    (should (string= (documentation fun) "pcase-lambda documentation"))
    (should (equal '(2 1) (funcall fun '(1 2))))))

(defun cconv-tests-defun ()
  (:documentation (concat "defun" " documentation"))
  'defun-result)
(ert-deftest cconv-tests-defun-:documentation ()
  "Docstring for defun can be specified with :documentation."
  (should (string= (documentation 'cconv-tests-defun)
                   "defun documentation"))
  (should (eq (cconv-tests-defun) 'defun-result)))

(cl-defun cconv-tests-cl-defun ()
  (:documentation (concat "cl-defun" " documentation"))
  'cl-defun-result)
(ert-deftest cconv-tests-cl-defun-:documentation ()
  "Docstring for cl-defun can be specified with :documentation."
  (should (string= (documentation 'cconv-tests-cl-defun)
                   "cl-defun documentation"))
  (should (eq (cconv-tests-cl-defun) 'cl-defun-result)))

(defmacro cconv-tests-defmacro ()
  (:documentation (concat "defmacro" " documentation"))
  '(quote defmacro-result))
(ert-deftest cconv-tests-defmacro-:documentation ()
  "Docstring for defmacro can be specified with :documentation."
  (should (string= (documentation 'cconv-tests-defmacro)
                   "defmacro documentation"))
  (should (eq (cconv-tests-defmacro) 'defmacro-result)))

(cl-defmacro cconv-tests-cl-defmacro ()
  (:documentation (concat "cl-defmacro" " documentation"))
  '(quote cl-defmacro-result))
(ert-deftest cconv-tests-cl-defmacro-:documentation ()
  "Docstring for cl-defmacro can be specified with :documentation."
  (should (string= (documentation 'cconv-tests-cl-defmacro)
                   "cl-defmacro documentation"))
  (should (eq (cconv-tests-cl-defmacro) 'cl-defmacro-result)))

(cl-iter-defun cconv-tests-cl-iter-defun ()
  (:documentation (concat "cl-iter-defun" " documentation"))
  (iter-yield 'cl-iter-defun-result))
(ert-deftest cconv-tests-cl-iter-defun-:documentation ()
  "Docstring for cl-iter-defun can be specified with :documentation."
  (should (string= (documentation 'cconv-tests-cl-iter-defun)
                   "cl-iter-defun documentation"))
  (should (eq (iter-next (cconv-tests-cl-iter-defun))
              'cl-iter-defun-result)))

(iter-defun cconv-tests-iter-defun ()
  (:documentation (concat "iter-defun" " documentation"))
  (iter-yield 'iter-defun-result))
(ert-deftest cconv-tests-iter-defun-:documentation ()
  "Docstring for iter-defun can be specified with :documentation."
  (should (string= (documentation 'cconv-tests-iter-defun)
                   "iter-defun documentation"))
  (should (eq (iter-next (cconv-tests-iter-defun)) 'iter-defun-result)))

(ert-deftest cconv-tests-iter-lambda-:documentation ()
  "Docstring for iter-lambda can be specified with :documentation."
  (let ((iter-fun
         (iter-lambda ()
           (:documentation (concat "iter-lambda" " documentation"))
           (iter-yield 'iter-lambda-result))))
    (should (string= (documentation iter-fun) "iter-lambda documentation"))
    (should (eq (iter-next (funcall iter-fun)) 'iter-lambda-result))))

(ert-deftest cconv-tests-cl-function-:documentation ()
  "Docstring for cl-function can be specified with :documentation."
  (let ((fun (cl-function (lambda (&key arg)
                            (:documentation (concat "cl-function"
                                                    " documentation"))
                            (list arg 'cl-function-result)))))
    (should (string= (documentation fun) "cl-function documentation"))
    (should (equal (funcall fun :arg t) '(t cl-function-result)))))

(ert-deftest cconv-tests-function-:documentation ()
  "Docstring for lambda inside function can be specified with :documentation."
  (let ((fun #'(lambda (arg)
                 (:documentation (concat "function" " documentation"))
                 (list arg 'function-result))))
    (should (string= (documentation fun) "function documentation"))
    (should (equal (funcall fun t) '(t function-result)))))

(fmakunbound 'cconv-tests-cl-defgeneric)
(setplist 'cconv-tests-cl-defgeneric nil)
(cl-defgeneric cconv-tests-cl-defgeneric (n)
  (:documentation (concat "cl-defgeneric" " documentation")))
(cl-defmethod cconv-tests-cl-defgeneric ((n integer))
  (:documentation (concat "cl-defmethod" " documentation"))
  (+ 1 n))
(ert-deftest cconv-tests-cl-defgeneric-:documentation ()
  "Docstring for cl-defgeneric can be specified with :documentation."
  (let ((descr (describe-function 'cconv-tests-cl-defgeneric)))
    (set-text-properties 0 (length descr) nil descr)
    (should (string-match-p "cl-defgeneric documentation" descr))
    (should (string-match-p "cl-defmethod documentation" descr)))
  (should (= 11 (cconv-tests-cl-defgeneric 10))))

(fmakunbound 'cconv-tests-cl-defgeneric-literal)
(setplist 'cconv-tests-cl-defgeneric-literal nil)
(cl-defgeneric cconv-tests-cl-defgeneric-literal (n)
  (:documentation "cl-defgeneric-literal documentation"))
(cl-defmethod cconv-tests-cl-defgeneric-literal ((n integer))
  (:documentation "cl-defmethod-literal documentation")
  (+ 1 n))
(ert-deftest cconv-tests-cl-defgeneric-literal-:documentation ()
  "Docstring for cl-defgeneric can be specified with :documentation."
  (let ((descr (describe-function 'cconv-tests-cl-defgeneric-literal)))
    (set-text-properties 0 (length descr) nil descr)
    (should (string-match-p "cl-defgeneric-literal documentation" descr))
    (should (string-match-p "cl-defmethod-literal documentation" descr)))
  (should (= 11 (cconv-tests-cl-defgeneric-literal 10))))

(defsubst cconv-tests-defsubst ()
  (:documentation (concat "defsubst" " documentation"))
  'defsubst-result)
(ert-deftest cconv-tests-defsubst-:documentation ()
  "Docstring for defsubst can be specified with :documentation."
  (should (string= (documentation 'cconv-tests-defsubst)
                   "defsubst documentation"))
  (should (eq (cconv-tests-defsubst) 'defsubst-result)))

(cl-defsubst cconv-tests-cl-defsubst ()
  (:documentation (concat "cl-defsubst" " documentation"))
  'cl-defsubst-result)
(ert-deftest cconv-tests-cl-defsubst-:documentation ()
  "Docstring for cl-defsubst can be specified with :documentation."
  (should (string= (documentation 'cconv-tests-cl-defsubst)
                   "cl-defsubst documentation"))
  (should (eq (cconv-tests-cl-defsubst) 'cl-defsubst-result)))

(provide 'cconv-tests)
;;; cconv-tests.el ends here

[-- Attachment #3: Type: text/plain, Size: 1069 bytes --]


While doing this I found these bugs:

1. A lambda wrapped by cl-function with a :documentation form will
not get a docstring and the :documentation form will be left in the
body of the closure.

2. In code run interactively, a :documentation form in cl-defmacro or
defmacro will work correctly. However if you byte-compile that code,
the byte-compiler stops with the following error message:
    Symbol’s function definition is void: internal-make-closure

3. A :documentation form in cl-defgeneric only works if its argument
is a string literal. In cl-defmethod, it works whether the argument is
a string literal or an expression.

4. A :documentation form works in cl-iter-defun and iter-defun, but
not in iter-lambda.

Stefan, here's a list of macros in which it appears to me that
(:documentation FORM) is supposed to work. Is this correct? Am I
missing any?

lambda
pcase-lambda
defun
defmacro
cl-defun
cl-defmacro
iter-defun
cl-iter-defun
iter-lambda
function
cl-function
cl-defgeneric
cl-defmethod
defsubst
cl-defsubst

bug#28557: 26.0.60; Bugs using (:documentation FORM) in closures

[Stefan Kangas]

Gemini Lasswell <gazally@runbox.com> writes:

> Since Emacs 25, docstrings can be constructed using
> (:documentation FORM) in closures, when lexical-binding is on. This
> isn't documented except in NEWS. Bug #24773 is about Edebug specs
> which have not been updated to recognize :documentation. I'd like to
> fix it, so I started trying to figure out which macros accept
> :documentation forms so I would know which Edebug specs to update, and
> that effort turned into a collection of tests for the feature, see
> attached:

There is a long list of tests here, but it seems like none of this was
ever committed to master.  Should it be?

> While doing this I found these bugs:
>
> 1. A lambda wrapped by cl-function with a :documentation form will
> not get a docstring and the :documentation form will be left in the
> body of the closure.
>
> 2. In code run interactively, a :documentation form in cl-defmacro or
> defmacro will work correctly. However if you byte-compile that code,
> the byte-compiler stops with the following error message:
>     Symbol’s function definition is void: internal-make-closure
>
> 3. A :documentation form in cl-defgeneric only works if its argument
> is a string literal. In cl-defmethod, it works whether the argument is
> a string literal or an expression.
>
> 4. A :documentation form works in cl-iter-defun and iter-defun, but
> not in iter-lambda.
>
> Stefan, here's a list of macros in which it appears to me that
> (:documentation FORM) is supposed to work. Is this correct? Am I
> missing any?
>
> lambda
> pcase-lambda
> defun
> defmacro
> cl-defun
> cl-defmacro
> iter-defun
> cl-iter-defun
> iter-lambda
> function
> cl-function
> cl-defgeneric
> cl-defmethod
> defsubst
> cl-defsubst

Does anyone know the answers to the above questions?

Best regards,
Stefan Kangas

bug#28557: 26.0.60; Bugs using (:documentation FORM) in closures

[Eli Zaretskii]

> From: Stefan Kangas <stefan@marxist.se>
> Date: Sun, 03 May 2020 03:32:50 +0200
> Cc: 28557@debbugs.gnu.org, Stefan Monnier <monnier@IRO.UMontreal.CA>
> 
> There is a long list of tests here, but it seems like none of this was
> ever committed to master.  Should it be?

Why not?  Tests are always good and can never break anything in Emacs.

bug#28557: 26.0.60; Bugs using (:documentation FORM) in closures

[Stefan Kangas]

[-- Attachment #1: Type: text/plain, Size: 624 bytes --]

Eli Zaretskii <eliz@gnu.org> writes:

>> There is a long list of tests here, but it seems like none of this was
>> ever committed to master.  Should it be?
>
> Why not?  Tests are always good and can never break anything in Emacs.

OK.  However, we only got a .el file by Gemini Lasswell, not a patch.

Is there any reason not to commit this in his name like in the
attached patch?

I have made only very minor changes in the attached patch to mark
three tests as ':expected-result :failed' and comment out the two
tests where the byte-compiler fails.  I also wrote a ChangeLog entry.

Thanks.

Best regards,
Stefan Kangas


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: 0001-Add-new-cconv-tests-Bug-28557.patch --]
[-- Type: text/x-diff, Size: 8985 bytes --]

From daa65afc86c07ee38c792911a6056eb30d34cd5c Mon Sep 17 00:00:00 2001
From: Gemini Lasswell <gazally@runbox.com>
Date: Sun, 3 May 2020 21:15:14 +0200
Subject: [PATCH] Add new cconv-tests (Bug#28557)

* test/lisp/emacs-lisp/cconv-tests.el
(top-level): Add two commented out tests which the byte-compiler
can't handle.
(cconv-tests-lambda-:documentation)
(cconv-tests-pcase-lambda-:documentation)
(cconv-tests-defun-:documentation)
(cconv-tests-cl-defun-:documentation)
(cconv-tests-cl-iter-defun-:documentation)
(cconv-tests-iter-defun-:documentation)
(cconv-tests-function-:documentation)
(cconv-tests-cl-defgeneric-literal-:documentation)
(cconv-tests-defsubst-:documentation)
(cconv-tests-cl-defsubst-:documentation): New tests.
(cconv-tests-iter-lambda-:documentation)
(cconv-tests-cl-function-:documentation)
(cconv-tests-cl-defgeneric-:documentation): New failing tests.
---
 test/lisp/emacs-lisp/cconv-tests.el | 156 ++++++++++++++++++++++++++++
 1 file changed, 156 insertions(+)

diff --git a/test/lisp/emacs-lisp/cconv-tests.el b/test/lisp/emacs-lisp/cconv-tests.el
index c8d46541ad..390714590f 100644
--- a/test/lisp/emacs-lisp/cconv-tests.el
+++ b/test/lisp/emacs-lisp/cconv-tests.el
@@ -2,6 +2,8 @@
 
 ;; Copyright (C) 2018-2020 Free Software Foundation, Inc.
 
+;; Author: Gemini Lasswell <gazally@runbox.com>
+
 ;; This file is part of GNU Emacs.
 
 ;; GNU Emacs is free software: you can redistribute it and/or modify
@@ -20,6 +22,160 @@
 ;;; Commentary:
 
 (require 'ert)
+(require 'cl-lib)
+
+(ert-deftest cconv-tests-lambda-:documentation ()
+  "Docstring for lambda can be specified with :documentation."
+  (let ((fun (lambda ()
+               (:documentation (concat "lambda" " documentation"))
+               'lambda-result)))
+    (should (string= (documentation fun) "lambda documentation"))
+    (should (eq (funcall fun) 'lambda-result))))
+
+(ert-deftest cconv-tests-pcase-lambda-:documentation ()
+  "Docstring for pcase-lambda can be specified with :documentation."
+  (let ((fun (pcase-lambda (`(,a ,b))
+               (:documentation (concat "pcase-lambda" " documentation"))
+               (list b a))))
+    (should (string= (documentation fun) "pcase-lambda documentation"))
+    (should (equal '(2 1) (funcall fun '(1 2))))))
+
+(defun cconv-tests-defun ()
+  (:documentation (concat "defun" " documentation"))
+  'defun-result)
+(ert-deftest cconv-tests-defun-:documentation ()
+  "Docstring for defun can be specified with :documentation."
+  (should (string= (documentation 'cconv-tests-defun)
+                   "defun documentation"))
+  (should (eq (cconv-tests-defun) 'defun-result)))
+
+(cl-defun cconv-tests-cl-defun ()
+  (:documentation (concat "cl-defun" " documentation"))
+  'cl-defun-result)
+(ert-deftest cconv-tests-cl-defun-:documentation ()
+  "Docstring for cl-defun can be specified with :documentation."
+  (should (string= (documentation 'cconv-tests-cl-defun)
+                   "cl-defun documentation"))
+  (should (eq (cconv-tests-cl-defun) 'cl-defun-result)))
+
+;; FIXME: The byte-complier croaks on this.  See Bug#28557.
+;; (defmacro cconv-tests-defmacro ()
+;;   (:documentation (concat "defmacro" " documentation"))
+;;   '(quote defmacro-result))
+;; (ert-deftest cconv-tests-defmacro-:documentation ()
+;;   "Docstring for defmacro can be specified with :documentation."
+;;   (should (string= (documentation 'cconv-tests-defmacro)
+;;                    "defmacro documentation"))
+;;   (should (eq (cconv-tests-defmacro) 'defmacro-result)))
+
+;; FIXME: The byte-complier croaks on this.  See Bug#28557.
+;; (cl-defmacro cconv-tests-cl-defmacro ()
+;;   (:documentation (concat "cl-defmacro" " documentation"))
+;;   '(quote cl-defmacro-result))
+;; (ert-deftest cconv-tests-cl-defmacro-:documentation ()
+;;   "Docstring for cl-defmacro can be specified with :documentation."
+;;   (should (string= (documentation 'cconv-tests-cl-defmacro)
+;;                    "cl-defmacro documentation"))
+;;   (should (eq (cconv-tests-cl-defmacro) 'cl-defmacro-result)))
+
+(cl-iter-defun cconv-tests-cl-iter-defun ()
+  (:documentation (concat "cl-iter-defun" " documentation"))
+  (iter-yield 'cl-iter-defun-result))
+(ert-deftest cconv-tests-cl-iter-defun-:documentation ()
+  "Docstring for cl-iter-defun can be specified with :documentation."
+  (should (string= (documentation 'cconv-tests-cl-iter-defun)
+                   "cl-iter-defun documentation"))
+  (should (eq (iter-next (cconv-tests-cl-iter-defun))
+              'cl-iter-defun-result)))
+
+(iter-defun cconv-tests-iter-defun ()
+  (:documentation (concat "iter-defun" " documentation"))
+  (iter-yield 'iter-defun-result))
+(ert-deftest cconv-tests-iter-defun-:documentation ()
+  "Docstring for iter-defun can be specified with :documentation."
+  (should (string= (documentation 'cconv-tests-iter-defun)
+                   "iter-defun documentation"))
+  (should (eq (iter-next (cconv-tests-iter-defun)) 'iter-defun-result)))
+
+(ert-deftest cconv-tests-iter-lambda-:documentation ()
+  "Docstring for iter-lambda can be specified with :documentation."
+  ;; FIXME: See Bug#28557.
+  :expected-result :failed
+  (let ((iter-fun
+         (iter-lambda ()
+           (:documentation (concat "iter-lambda" " documentation"))
+           (iter-yield 'iter-lambda-result))))
+    (should (string= (documentation iter-fun) "iter-lambda documentation"))
+    (should (eq (iter-next (funcall iter-fun)) 'iter-lambda-result))))
+
+(ert-deftest cconv-tests-cl-function-:documentation ()
+  "Docstring for cl-function can be specified with :documentation."
+  ;; FIXME: See Bug#28557.
+  :expected-result :failed
+  (let ((fun (cl-function (lambda (&key arg)
+                            (:documentation (concat "cl-function"
+                                                    " documentation"))
+                            (list arg 'cl-function-result)))))
+    (should (string= (documentation fun) "cl-function documentation"))
+    (should (equal (funcall fun :arg t) '(t cl-function-result)))))
+
+(ert-deftest cconv-tests-function-:documentation ()
+  "Docstring for lambda inside function can be specified with :documentation."
+  (let ((fun #'(lambda (arg)
+                 (:documentation (concat "function" " documentation"))
+                 (list arg 'function-result))))
+    (should (string= (documentation fun) "function documentation"))
+    (should (equal (funcall fun t) '(t function-result)))))
+
+(fmakunbound 'cconv-tests-cl-defgeneric)
+(setplist 'cconv-tests-cl-defgeneric nil)
+(cl-defgeneric cconv-tests-cl-defgeneric (n)
+  (:documentation (concat "cl-defgeneric" " documentation")))
+(cl-defmethod cconv-tests-cl-defgeneric ((n integer))
+  (:documentation (concat "cl-defmethod" " documentation"))
+  (+ 1 n))
+(ert-deftest cconv-tests-cl-defgeneric-:documentation ()
+  "Docstring for cl-defgeneric can be specified with :documentation."
+  ;; FIXME: See Bug#28557.
+  :expected-result :failed
+  (let ((descr (describe-function 'cconv-tests-cl-defgeneric)))
+    (set-text-properties 0 (length descr) nil descr)
+    (should (string-match-p "cl-defgeneric documentation" descr))
+    (should (string-match-p "cl-defmethod documentation" descr)))
+  (should (= 11 (cconv-tests-cl-defgeneric 10))))
+
+(fmakunbound 'cconv-tests-cl-defgeneric-literal)
+(setplist 'cconv-tests-cl-defgeneric-literal nil)
+(cl-defgeneric cconv-tests-cl-defgeneric-literal (n)
+  (:documentation "cl-defgeneric-literal documentation"))
+(cl-defmethod cconv-tests-cl-defgeneric-literal ((n integer))
+  (:documentation "cl-defmethod-literal documentation")
+  (+ 1 n))
+(ert-deftest cconv-tests-cl-defgeneric-literal-:documentation ()
+  "Docstring for cl-defgeneric can be specified with :documentation."
+  (let ((descr (describe-function 'cconv-tests-cl-defgeneric-literal)))
+    (set-text-properties 0 (length descr) nil descr)
+    (should (string-match-p "cl-defgeneric-literal documentation" descr))
+    (should (string-match-p "cl-defmethod-literal documentation" descr)))
+  (should (= 11 (cconv-tests-cl-defgeneric-literal 10))))
+
+(defsubst cconv-tests-defsubst ()
+  (:documentation (concat "defsubst" " documentation"))
+  'defsubst-result)
+(ert-deftest cconv-tests-defsubst-:documentation ()
+  "Docstring for defsubst can be specified with :documentation."
+  (should (string= (documentation 'cconv-tests-defsubst)
+                   "defsubst documentation"))
+  (should (eq (cconv-tests-defsubst) 'defsubst-result)))
+
+(cl-defsubst cconv-tests-cl-defsubst ()
+  (:documentation (concat "cl-defsubst" " documentation"))
+  'cl-defsubst-result)
+(ert-deftest cconv-tests-cl-defsubst-:documentation ()
+  "Docstring for cl-defsubst can be specified with :documentation."
+  (should (string= (documentation 'cconv-tests-cl-defsubst)
+                   "cl-defsubst documentation"))
+  (should (eq (cconv-tests-cl-defsubst) 'cl-defsubst-result)))
 
 (ert-deftest cconv-convert-lambda-lifted ()
   "Bug#30872."
-- 
2.26.2

bug#28557: 26.0.60; Bugs using (:documentation FORM) in closures

[Eli Zaretskii]

> From: Stefan Kangas <stefan@marxist.se>
> Cc: 28557@debbugs.gnu.org,  gazally@runbox.com,  monnier@IRO.UMontreal.CA
> Date: Sun, 03 May 2020 21:22:58 +0200
> 
> > Why not?  Tests are always good and can never break anything in Emacs.
> 
> OK.  However, we only got a .el file by Gemini Lasswell, not a patch.
> 
> Is there any reason not to commit this in his name like in the
> attached patch?

I don't see why not, provided that Gemini Lasswell agrees.

bug#28557: 26.0.60; Bugs using (:documentation FORM) in closures

[Stefan Kangas]

Eli Zaretskii <eliz@gnu.org> writes:

>> From: Stefan Kangas <stefan@marxist.se>
>> Cc: 28557@debbugs.gnu.org,  gazally@runbox.com,  monnier@IRO.UMontreal.CA
>> Date: Sun, 03 May 2020 21:22:58 +0200
>>
>> > Why not?  Tests are always good and can never break anything in Emacs.
>>
>> OK.  However, we only got a .el file by Gemini Lasswell, not a patch.
>>
>> Is there any reason not to commit this in his name like in the
>> attached patch?
>
> I don't see why not, provided that Gemini Lasswell agrees.

No reply within 13 weeks so I committed the tests in my name with credit
to Gemini Lasswell.

The bugs here still needs to be fixed though.

Best regards,
Stefan Kangas

bug#28557: 26.0.60; Bugs using (:documentation FORM) in closures

[Gemini Lasswell]

Stefan Kangas writes:
>> I don't see why not, provided that Gemini Lasswell agrees.
>
> No reply within 13 weeks so I committed the tests in my name with credit
> to Gemini Lasswell.

Sorry I missed this 13 weeks ago.  Thanks for committing the tests.

bug#28557: 26.0.60; Bugs using (:documentation FORM) in closures

[Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors]

> Stefan, here's a list of macros in which it appears to me that
> (:documentation FORM) is supposed to work. Is this correct?
> Am I missing any?

I don't know.  The cl-generic.el case is debatable (not sure how
important it use for it to support computed docstrings), but in any case
I think I fixed those cases now.  Thanks.

Note that I did not upgrade the Edebug specs accordingly :-(


        Stefan