master 4afafa03704: Try and avoid hardcoding lists of function types

[Stefan Monnier]

branch: master
commit 4afafa03704aab0c21e4cb4f028256ecead5f795
Author: Stefan Monnier <monnier@iro.umontreal.ca>
Commit: Stefan Monnier <monnier@iro.umontreal.ca>

    Try and avoid hardcoding lists of function types
    
    * lisp/bind-key.el (bind-key--get-binding-description):
    Show docstrings for compiled functions also.  Don't hardcode knowledge
    about various particular kinds of functions.
    
    * lisp/emacs-lisp/bytecomp.el (display-call-tree): Remove special
    support for functions with a `byte-code` body since we never generate
    that nowadays.  Don't hardcode knowledge
    about various particular kinds of functions.
---
 lisp/bind-key.el            | 42 +++++++++++++++++++-----------------------
 lisp/emacs-lisp/bytecomp.el | 15 +++------------
 2 files changed, 22 insertions(+), 35 deletions(-)

diff --git a/lisp/bind-key.el b/lisp/bind-key.el
index 378ad69b2bc..1e59c75566a 100644
--- a/lisp/bind-key.el
+++ b/lisp/bind-key.el
@@ -453,31 +453,27 @@ other modes.  See `override-global-mode'."
   (macroexp-progn (bind-keys-form args 'override-global-map)))
 
 (defun bind-key--get-binding-description (elem)
-  (cond
-   ((listp elem)
+  (let (doc)
     (cond
-     ((memq (car elem) '(lambda function))
-      (if (and bind-key-describe-special-forms
-               (stringp (nth 2 elem)))
-          (nth 2 elem)
-        "#<lambda>"))
-     ((eq 'closure (car elem))
-      (if (and bind-key-describe-special-forms
-               (stringp (nth 3 elem)))
-          (nth 3 elem)
-        "#<closure>"))
-     ((eq 'keymap (car elem))
-      "#<keymap>")
+     ((symbolp elem)
+      (cond
+       ((and bind-key-describe-special-forms (keymapp elem)
+             ;; FIXME: Is this really ever better than the symbol-name?
+             ;; FIXME: `variable-documentation' describe what's in
+             ;; elem's `symbol-value', whereas `elem' here stands for
+             ;; its `symbol-function'.
+             (stringp (setq doc (get elem 'variable-documentation))))
+        doc)
+       (t elem)))
+     ((and bind-key-describe-special-forms (functionp elem)
+           (stringp (setq doc (documentation elem))))
+      doc) ;;FIXME: Keep only the first line?
+     ((consp elem)
+      (if (symbolp (car elem))
+          (format "#<%s>" (car elem))
+        elem))
      (t
-      elem)))
-   ;; must be a symbol, non-symbol keymap case covered above
-   ((and bind-key-describe-special-forms (keymapp elem))
-    (let ((doc (get elem 'variable-documentation)))
-      (if (stringp doc) doc elem)))
-   ((symbolp elem)
-    elem)
-   (t
-    "#<byte-compiled lambda>")))
+      (format "#<%s>" (type-of elem))))))
 
 (defun bind-key--compare-keybindings (l r)
   (let* ((regex bind-key-segregation-regexp)
diff --git a/lisp/emacs-lisp/bytecomp.el b/lisp/emacs-lisp/bytecomp.el
index cf0e6d600dd..7af568cfe34 100644
--- a/lisp/emacs-lisp/bytecomp.el
+++ b/lisp/emacs-lisp/bytecomp.el
@@ -5536,23 +5536,14 @@ invoked interactively."
                 (if (null f)
                     " <top level>";; shouldn't insert nil then, actually -sk
                   " <not defined>"))
-               ((subrp (setq f (symbol-function f)))
-                " <subr>")
-               ((symbolp f)
+               ((symbolp (setq f (symbol-function f))) ;; An alias.
                 (format " ==> %s" f))
-               ((byte-code-function-p f)
-                "<compiled function>")
                ((not (consp f))
-                "<malformed function>")
+                (format " <%s>" (type-of f)))
                ((eq 'macro (car f))
-                (if (or (compiled-function-p (cdr f))
-                        ;; FIXME: Can this still happen?
-                        (assq 'byte-code (cdr (cdr (cdr f)))))
+                (if (compiled-function-p (cdr f))
                     " <compiled macro>"
                   " <macro>"))
-               ((assq 'byte-code (cdr (cdr f)))
-                ;; FIXME: Can this still happen?
-                "<compiled lambda>")
                ((eq 'lambda (car f))
                 "<function>")
                (t "???"))