* bug#28557: 26.0.60; Bugs using (:documentation FORM) in closures
@ 2017-09-22 17:30 Gemini Lasswell
2020-05-03 1:32 ` Stefan Kangas
2021-12-21 3:05 ` Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors
0 siblings, 2 replies; 8+ messages in thread
From: Gemini Lasswell @ 2017-09-22 17:30 UTC (permalink / raw)
To: 28557; +Cc: Stefan Monnier
[-- 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
^ permalink raw reply [flat|nested] 8+ messages in thread
* bug#28557: 26.0.60; Bugs using (:documentation FORM) in closures
2017-09-22 17:30 bug#28557: 26.0.60; Bugs using (:documentation FORM) in closures Gemini Lasswell
@ 2020-05-03 1:32 ` Stefan Kangas
2020-05-03 14:52 ` Eli Zaretskii
2021-12-21 3:05 ` Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors
1 sibling, 1 reply; 8+ messages in thread
From: Stefan Kangas @ 2020-05-03 1:32 UTC (permalink / raw)
To: Gemini Lasswell; +Cc: 28557, Stefan Monnier
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
^ permalink raw reply [flat|nested] 8+ messages in thread
* bug#28557: 26.0.60; Bugs using (:documentation FORM) in closures
2020-05-03 1:32 ` Stefan Kangas
@ 2020-05-03 14:52 ` Eli Zaretskii
2020-05-03 19:22 ` Stefan Kangas
0 siblings, 1 reply; 8+ messages in thread
From: Eli Zaretskii @ 2020-05-03 14:52 UTC (permalink / raw)
To: Stefan Kangas; +Cc: 28557, gazally, monnier
> 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.
^ permalink raw reply [flat|nested] 8+ messages in thread
* bug#28557: 26.0.60; Bugs using (:documentation FORM) in closures
2020-05-03 14:52 ` Eli Zaretskii
@ 2020-05-03 19:22 ` Stefan Kangas
2020-05-04 13:47 ` Eli Zaretskii
0 siblings, 1 reply; 8+ messages in thread
From: Stefan Kangas @ 2020-05-03 19:22 UTC (permalink / raw)
To: Eli Zaretskii; +Cc: 28557, gazally, monnier
[-- 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
^ permalink raw reply related [flat|nested] 8+ messages in thread
* bug#28557: 26.0.60; Bugs using (:documentation FORM) in closures
2020-05-03 19:22 ` Stefan Kangas
@ 2020-05-04 13:47 ` Eli Zaretskii
2020-08-04 17:06 ` Stefan Kangas
0 siblings, 1 reply; 8+ messages in thread
From: Eli Zaretskii @ 2020-05-04 13:47 UTC (permalink / raw)
To: Stefan Kangas; +Cc: 28557, gazally, monnier
> 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.
^ permalink raw reply [flat|nested] 8+ messages in thread
* bug#28557: 26.0.60; Bugs using (:documentation FORM) in closures
2020-05-04 13:47 ` Eli Zaretskii
@ 2020-08-04 17:06 ` Stefan Kangas
2020-08-13 1:07 ` Gemini Lasswell
0 siblings, 1 reply; 8+ messages in thread
From: Stefan Kangas @ 2020-08-04 17:06 UTC (permalink / raw)
To: Eli Zaretskii; +Cc: 28557, gazally, monnier
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
^ permalink raw reply [flat|nested] 8+ messages in thread
* bug#28557: 26.0.60; Bugs using (:documentation FORM) in closures
2017-09-22 17:30 bug#28557: 26.0.60; Bugs using (:documentation FORM) in closures Gemini Lasswell
2020-05-03 1:32 ` Stefan Kangas
@ 2021-12-21 3:05 ` Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors
1 sibling, 0 replies; 8+ messages in thread
From: Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors @ 2021-12-21 3:05 UTC (permalink / raw)
To: Gemini Lasswell; +Cc: 28557-done
> 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
^ permalink raw reply [flat|nested] 8+ messages in thread
end of thread, other threads:[~2021-12-21 3:05 UTC | newest]
Thread overview: 8+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2017-09-22 17:30 bug#28557: 26.0.60; Bugs using (:documentation FORM) in closures Gemini Lasswell
2020-05-03 1:32 ` Stefan Kangas
2020-05-03 14:52 ` Eli Zaretskii
2020-05-03 19:22 ` Stefan Kangas
2020-05-04 13:47 ` Eli Zaretskii
2020-08-04 17:06 ` Stefan Kangas
2020-08-13 1:07 ` Gemini Lasswell
2021-12-21 3:05 ` Stefan Monnier via Bug reports for GNU Emacs, the Swiss army knife of text editors
Code repositories for project(s) associated with this public inbox
https://git.savannah.gnu.org/cgit/emacs.git
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).