[Emacs-diffs] emacs-26 e292c09: Fix #'fun handling inside `labels' (Bug#31792)

[Noam Postavsky]

branch: emacs-26
commit e292c0973cf7a92819d312ea8a828b67e6adf1ab
Author: Noam Postavsky <address@hidden>
Commit: Noam Postavsky <address@hidden>

    Fix #'fun handling inside `labels' (Bug#31792)
    
    * lisp/emacs-lisp/cl.el (labels): Apply the equivalent of the
    cl-labels change from 2015-01-16 "* lisp/emacs-lisp/cl-macs.el: Fix
    last change".
    * test/lisp/emacs-lisp/cl-tests.el (labels-function-quoting): New
    test.
    * lisp/emacs-lisp/cl-macs.el (cl-flet, cl-labels): Improve docstring,
    link to relevant manual page.
    * doc/misc/cl.texi (Function Bindings): Don't imply that function
    cells of symbols are modified by cl-flet.  Don't claim that cl-flet or
    cl-labels affect references of the form (quote FUNC).
---
 doc/misc/cl.texi                 | 23 ++++++++++-------------
 lisp/emacs-lisp/cl-macs.el       | 17 ++++++++++++-----
 lisp/emacs-lisp/cl.el            |  7 +++++--
 test/lisp/emacs-lisp/cl-tests.el | 35 +++++++++++++++++++++++++++++++++++
 4 files changed, 62 insertions(+), 20 deletions(-)

diff --git a/doc/misc/cl.texi b/doc/misc/cl.texi
index bf85b00..553b935 100644
--- a/doc/misc/cl.texi
+++ b/doc/misc/cl.texi
@@ -1299,17 +1299,18 @@ These forms make @code{let}-like bindings to functions 
instead
 of variables.
 
 @defmac cl-flet (address@hidden) address@hidden
-This form establishes @code{let}-style bindings on the function
-cells of symbols rather than on the value cells.  Each @var{binding}
-must be a list of the form @samp{(@var{name} @var{arglist}
address@hidden@dots{})}, which defines a function exactly as if
-it were a @code{cl-defun} form.  The function @var{name} is defined
-accordingly but only within the body of the @code{cl-flet}, hiding any external
-definition if applicable.
+This form establishes @code{let}-style bindings for functions rather
+than values.  Each @var{binding} must be a list of the form
address@hidden(@var{name} @var{arglist} @address@hidden)}.  Within
address@hidden, any reference to the function @var{name} uses the local
+definition instead of the global one.
+
+A ``reference'' to a function name is either a call to that function,
+or a use of its name quoted by @code{function} to be passed on to,
+say, @code{mapcar}.
 
 The bindings are lexical in scope.  This means that all references to
-the named functions must appear physically within the body of the
address@hidden form.
+the named functions must appear physically within @var{forms}.
 
 Functions defined by @code{cl-flet} may use the full Common Lisp
 argument notation supported by @code{cl-defun}; also, the function
@@ -1336,10 +1337,6 @@ functions must appear physically within the body of the
 the functions themselves.  Thus, @code{cl-labels} can define
 local recursive functions, or mutually-recursive sets of functions.
 
-A ``reference'' to a function name is either a call to that
-function, or a use of its name quoted by @code{quote} or
address@hidden to be passed on to, say, @code{mapcar}.
-
 Note that the @file{cl.el} version of this macro behaves slightly
 differently.  @xref{Obsolete Macros}.
 @end defmac
diff --git a/lisp/emacs-lisp/cl-macs.el b/lisp/emacs-lisp/cl-macs.el
index 9c47cea..0854e66 100644
--- a/lisp/emacs-lisp/cl-macs.el
+++ b/lisp/emacs-lisp/cl-macs.el
@@ -1964,13 +1964,16 @@ a `let' form, except that the list of symbols can be 
computed at run-time."
 ;;;###autoload
 (defmacro cl-flet (bindings &rest body)
   "Make local function definitions.
-Like `cl-labels' but the definitions are not recursive.
-Each binding can take the form (FUNC EXP) where
+Each definition can take the form (FUNC EXP) where
 FUNC is the function name, and EXP is an expression that returns the
 function value to which it should be bound, or it can take the more common
 form \(FUNC ARGLIST BODY...) which is a shorthand
 for (FUNC (lambda ARGLIST BODY)).
 
+FUNC is defined only within FORM, not BODY, so you can't write
+recursive function definitions.  Use `cl-labels' for that.  See
+info node `(cl) Function Bindings' for details.
+
 \(fn ((FUNC ARGLIST BODY...) ...) FORM...)"
   (declare (indent 1) (debug ((&rest (cl-defun)) cl-declarations body)))
   (let ((binds ()) (newenv macroexpand-all-environment))
@@ -2012,9 +2015,13 @@ Like `cl-flet' but the definitions can refer to previous 
ones.
 
 ;;;###autoload
 (defmacro cl-labels (bindings &rest body)
-  "Make temporary function bindings.
-The bindings can be recursive and the scoping is lexical, but capturing them
-in closures will only work if `lexical-binding' is in use.
+    "Make local (recursive) function definitions.
+Each definition can take the form (FUNC ARGLIST BODY...) where
+FUNC is the function name, ARGLIST its arguments, and BODY the
+forms of the function body.  FUNC is defined in any BODY, as well
+as FORM, so you can write recursive and mutually recursive
+function definitions.  See info node `(cl) Function Bindings' for
+details.
 
 \(fn ((FUNC ARGLIST BODY...) ...) FORM...)"
   (declare (indent 1) (debug cl-flet))
diff --git a/lisp/emacs-lisp/cl.el b/lisp/emacs-lisp/cl.el
index d53c8e0..f664315 100644
--- a/lisp/emacs-lisp/cl.el
+++ b/lisp/emacs-lisp/cl.el
@@ -466,9 +466,12 @@ rather than relying on `lexical-binding'."
        (push var sets)
        (push (cons (car binding)
                     `(lambda (&rest cl-labels-args)
-                       (cl-list* 'funcall ',var
-                                 cl-labels-args)))
+                       (if (eq (car cl-labels-args) cl--labels-magic)
+                           (list cl--labels-magic ',var)
+                         (cl-list* 'funcall ',var cl-labels-args))))
               newenv)))
+    ;; `lexical-let' adds `cl--function-convert' (which calls
+    ;; `cl--labels-convert') as a macroexpander for `function'.
     (macroexpand-all `(lexical-let ,vars (setq ,@sets) ,@body) newenv)))
 
 ;; Generalized variables are provided by gv.el, but some details are
diff --git a/test/lisp/emacs-lisp/cl-tests.el b/test/lisp/emacs-lisp/cl-tests.el
new file mode 100644
index 0000000..b673822
--- /dev/null
+++ b/test/lisp/emacs-lisp/cl-tests.el
@@ -0,0 +1,35 @@
+;;; cl-tests.el --- tests for emacs-lisp/cl.el  -*- lexical-binding:t -*-
+
+;; Copyright (C) 2018 Free Software Foundation, Inc.
+
+;; This file is part of GNU Emacs.
+
+;; This program 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.
+;;
+;; This program 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 this program.  If not, see `https://www.gnu.org/licenses/'.
+
+;;; Commentary:
+
+;;; Code:
+
+(require 'cl)
+(require 'ert)
+
+
+
+(ert-deftest labels-function-quoting ()
+  "Test that #'foo does the right thing in `labels'." ; Bug#31792.
+  (should (eq (funcall (labels ((foo () t))
+                         #'foo))
+              t)))
+
+;;; cl-tests.el ends here