Corfu popupinfo and Eldoc show different documentation. How can I unify them or trigger popupinfo manually?

[fark0860]

First, thank you for Corfu. It is an excellent plugin and I really enjoy using it.

Problem

When editing Emacs Lisp, I notice that:

• corfu-popupinfo shows rich documentation for the symbol at point.

• eldoc and eldoc-box show a different, usually much shorter, documentation string

I would like both systems (popupinfo and eldoc) to use the same source of documentation if possible.

What I want to achieve

I would prefer one of the following:

• Option A: Manually trigger the Corfu popupinfo window

I would like to bind a key to show popupinfo on demand (currently it only works in corfu's completion menu).
Is there a supported way to do this?

• Option B: Make Eldoc (or eldoc-box) use the same documentation that popupinfo receives

If manual triggering is not possible or not recommended, I would like Eldoc to show the exact same documentation that Corfu popupinfo shows for the symbol at point.

Is there a way to make Eldoc use the same backend or the same documentation function that Corfu's popupinfo uses?

Some Pictures of the issue

eldoc (with eldoc-box) shows minimal/no documentation

but popupinfo does show me what I want

-Eldocs
In other languages too popup info's documentation is richer

-Popupinfo's

If there is an intended architecture for integrating Corfu documentation with Eldoc (or vice-versa), I would appreciate pointers.

Thanks in advance for any advice or recommended configuration.

[minad]

Hi!

Option A: Manually trigger the Corfu popupinfo window

The popupinfo can be triggered manually via the command corfu-popupinfo-documentation, but only from a completion, while the Corfu popup is displayed. Not for an arbitrary symbol at point if you meant that.

Option B: Make Eldoc (or eldoc-box) use the same documentation that popupinfo receives
If

This question depends on the backend.

There are multiple sources of documentation. The backend can add to eldoc-documentation-functions. Capfs can provide documentation via the metadata functions :company-doc-buffer (full documentation buffer, used by corfu-popupinfo-mode) and :company-docsig (used by corfu-echo-mode). Usually Eldoc information is short since it is supposed to be shown in the echo area, so it is more likely that backends provide the same information for :company-docsig and Eldoc.

I am not aware of an existing mechanism to synchronize these documentation sources, but of course this can be done with some Elisp hacking, creating some adapters.

[jdtsmith]

Check this related comment and function from elisp-mode.el:

;; FIXME: Support for Company brings in features which straddle eldoc.
;; We should consolidate this, so that major modes can provide all that
;; data all at once:
;; - a function to extract "the reference at point" (may be more complex
;;     than a mere string, to distinguish various namespaces).
;; - a function to jump to such a reference.
;; - a function to show the signature/interface of such a reference.
;; - a function to build a help-buffer about that reference.
;; FIXME: Those functions should also be used by the normal completion code in
;; the *Completions* buffer.

(defun elisp--company-doc-buffer (str)
  (let ((symbol (intern-soft str)))
    ;; FIXME: we really don't want to "display-buffer and then undo it".
    (save-window-excursion
      ;; Make sure we don't display it in another frame, otherwise
      ;; save-window-excursion won't be able to undo it.
      (let ((display-buffer-overriding-action
             '(nil . ((inhibit-switch-frame . t)))))
        (ignore-errors
          (cond
           ((fboundp symbol) (describe-function symbol))
           ((boundp symbol) (describe-variable symbol))
           ((featurep symbol) (describe-package symbol))
           ((facep symbol) (describe-face symbol))
           (t (signal 'user-error nil)))
          (help-buffer))))))

So emacs-lisp-mode is just doing (e.g.) describe-function on the completion candidate, and corfu picks up the text inserted into that buffer and displays it. It would be straightforward to make an eldoc function which does the same, e.g.:

(defun my/elisp-docs (cb &rest r)
  (when-let ((sym (symbol-at-point))
             (buf (elisp--company-doc-buffer (symbol-name sym))))
    (funcall cb (with-current-buffer buf (buffer-string)) '(:thing "ELDOCS") )))

(add-to-list (make-local-variable 'eldoc-documentation-functions) 'my/elisp-docs)

Then eldoc-box will show all this (TMI IMO!).

[fark0860]

Hi!

Your my/elisp-docs function is very helpful and works great—it gives full docs for functions and variables in Emacs Lisp exactly like C-h f/C-h v.
Much better than my shoddy implementation.

In Python (using python-lsp-server + Corfu + popupinfo), I notice that LSP provides documentation for things like print, numpy, plt.plot, etc but not for keywords like def and import (whose doc do show up in the Corfu popup).

Do you know where the source for those keyword docs is coming from? Is it generated by Corfu, Cape, or something built into Emacs itself? I’m trying to understand how to replicate that in Eldoc or Eldoc-box.

Thanks!

[jdtsmith]

You can always look for the :company-doc-buffer function. For example, for eglot, it is:

       :company-doc-buffer
       (lambda (proxy)
         (let* ((resolved
                 (ensure-resolved (get-text-property 0 'eglot--lsp-item proxy)))
                (documentation
                 (plist-get resolved :documentation))
                (formatted (and documentation
                                (eglot--format-markup documentation))))
           (when formatted
             (with-current-buffer (get-buffer-create " *eglot doc*")
               (erase-buffer)
               (insert formatted)
               (current-buffer)))))

I suppose if you wanted a generic way to do this, you could make a version which automatically discovers the completion doc-buffer function. Something like:

(defun my/elisp-docs (cb &rest r)
  (when-let ((sym (symbol-at-point))
             (doc-buffer-func
              (plist-get (nthcdr 3 (run-hook-with-args-until-success
                                    'completion-at-point-functions))
                         :company-doc-buffer))
             (buf (funcall doc-buffer-func (symbol-name sym))))
    (funcall cb (with-current-buffer buf (buffer-string)) '(:thing "ELDOC") )))

(add-to-list (make-local-variable 'eldoc-documentation-functions) 'my/elisp-docs)

[fark0860]

Issue solved

Thanks for the help. The function you suggested works, but it still didn’t show documentation for Python keywords like def, import, etc.
Running popupinfo in debugger mode showed that the candidate carried an eglot--lsp-item plist, which confirms that the documentation shown in corfu-popupinfo really comes directly from the LSP completion item.

After further investigation,I think I now understand the behaviour: the Python LSP server provides different documentation sources for completion and hover. Completion items often contain small snippets of documentation (which popupinfo displays), but the server does not return hover documentation for Python keywords.
This is consistent in other editors (Neovim, VS Code), and they show the same behaviour, so it appears intentional.

Given this, my configuration is fine and robust. The missing hover documentation for keywords is simply how the LSP server behaves, and since I don’t actually need keyword hover docs, I’ll close the issue.

Thanks again for your time and patience — I’m new to Emacs and Elisp, and this really helped.