Integration with package Breadcrumb

[nemethf]

I had a discussion with @sebastianpoeplau regarding a bug he reported against Eglot, which led me here. Although I do not use consult-imenu, it seems to me consult-imenu could take advantage of the text-properties provided by breadcrumb on top of the normal imenu interface.

class Foo {
  void bar() {}
};

Eglot/breadcrumb sets the imenu--index-alist for the file above to this:

((#("Foo" 0 3 (breadcrumb-region (1 . 31) breadcrumb-kind "Class"))
  (#("bar" 0 3 (breadcrumb-region (15 . 28) breadcrumb-kind "Method"))
   . 15)))

What do you think?

[minad]

@nemethf I am not sure if we should add special support to consult-imenu. The command supports the entirety of the Imenu data structure, but does not support extensions beyond that. I wonder why Breadcrumb modifies the Imenu - doesn't it only use Imenu to obtain the nesting of the current location? Sebastian also stated in the bug report that he considers the imenu and consult-imenu behavior in its current form correct. It is not completely clear to me what you want to achieve or what you mean by "taking advantage". Should consult-imenu display additional information or behave differently?

EDIT: I just looked at the Eglot source and the breadcrumb properties actually come from Eglot. Why is it not possible for Eglot to create a compatible Imenu data structure where top level entries are duplicated such that they can be jumped to independently?

[nemethf]

First, there is the breadcrumb-kind property, which consult could show somehow. And it could also highlight the complete region of the item not just the first line in its preview.

I think Sebastian's original idea was exactly what you suggest to duplicate the top level entries, but that does not really help to overcome the shortcomings of the menu-bar version of imenu. The way I understand it, João (the author of breadcrumb and eglot) thinks the imenu api is kind of broken and it is too much effort to fix it. But with the additional text properties a new API can emerge, which other packages can use.

I think this analogous how emacs's completion-extra-properties defines some extra properties to completion items like :annotation-function, but company adds its own properties (e.g., :company-docsig), which now consult and other completion frameworks have started using as well.

---

If consult provides a completing-read-function, then I think an enriched M-x imenu RET can be achieved with breadcrumb-jump, which is better than breadcrumb-jump and imenu, but it may lead to a better interface if consult-imenu directly reads the extra text-properties.

[minad]

I think Sebastian's original idea was exactly what you suggest to duplicate the top level entries, but that does not really help to overcome the shortcomings of the menu-bar version of imenu. The way I understand it, João (the author of breadcrumb and eglot) thinks the imenu api is kind of broken and it is too much effort to fix it. But with the additional text properties a new API can emerge, which other packages can use.

I think one can duplicate the entries with different names, e.g., Foo (top) and Foo. This should work with the menu bar, imenu and consult-imenu. However this solution is a bit ugly. João also suggested to improve the Imenu data structure. One could even go so far and introduce a new incompatible data structure, which makes sense given the current limitations regarding inner and leaf nodes. The imenu command and the menu bar should also support the new format.

[nemethf]

At any rate, I just wanted to draw you attention this eglot/breadcrumb feature. If you think other packages should adapt to consult-imenu (and the current imenu data structure) or someone should reform imenu, that is perfectly understandable.

[sebastianpoeplau]

It also seems possible to construct a data structure that works with imenu as before (i.e., without a way to jump to container symbols, but no regressions either) and presents full information in consult-imenu - that's what I get with servers triggering eglot--imenu-SymbolInformation, e.g., pylsp. I think the trick is that it puts the entry for the symbol behind the entry for the container:

;; imenu--index-alist, trimmed manually and without text properties
(("Function" (("sync_tree" ("path_key" . 20862))
              ("sync_tree" . 18754))))

The Python code that it represents contains something like this:

def sync_tree(...):
    ...

    def path_key(...):
        ...

    ...

[theFool32]

Hi, I also want consult-imenu to work with Breadcrumb. I hack consult-imenu--compute and consult-imenu--flatten to deal with the format of eglot-imenu. I am not familiar with elisp and the overall code is PoC. I try it with python/pyright and it works. Just paste it here for anyone who interested.

(defun consult-imenu--create-key-name-eglot (prefix item types)
  "Create a key-name with optional prefix and type annotations."
  (let* ((name (copy-sequence (car item)))
         (name-type (get-text-property 0 'breadcrumb-kind name))
         (type (assoc name-type types))
         (pos (consult-imenu--normalize (or (car (get-text-property 0 'breadcrumb-region name)) (cdr item))))
         (key-name (concat (when prefix (concat prefix " ")) name)))

    (when type
      (add-face-text-property (if prefix (1+ (length prefix)) 0) (length key-name)
                              (nth 2 type) 'append key-name)

      (setq key-name (concat (car type) " " key-name))
      (put-text-property 0 (length (car type)) 'consult--type (nth 1 type) key-name))

    (list (cons key-name pos))))


(defun consult-imenu--flatten-eglot (prefix face list types)
  "Flatten imenu LIST.
PREFIX is prepended in front of all items.
FACE is the item face.
TYPES is the mode-specific types configuration."
  (mapcan
   (lambda (item)
     (if (and (consp item) (stringp (car item)) (integer-or-marker-p (cdr item)))
         (consult-imenu--create-key-name-eglot prefix item types)

       (progn
         (append
          (consult-imenu--create-key-name-eglot prefix item types)

          (let* ((name (concat (car item)))
                 (next-prefix (if prefix (concat prefix "/" name) name)))
            (add-face-text-property 0 (length name)
                                    'consult-imenu-prefix 'append name)

            (consult-imenu--flatten-eglot next-prefix face (cdr item) types))))))
   list))

(with-eval-after-load 'consult-imenu
  (setq consult-imenu-config '((python-ts-mode :types
                                               ((?c "Class"    font-lock-type-face)
                                                (?C "Constant"    font-lock-constant-face)
                                                (?f "Function"  font-lock-function-name-face)
                                                (?m "Method"  font-lock-function-name-face)
                                                (?v "Variable"  font-lock-variable-name-face)))))

  ;;  HACK: for `breadcrumb' and `eglot'
  (defun consult-imenu--compute ()
    "Compute imenu candidates."
    (consult--forbid-minibuffer)
    (let* ((imenu-use-markers t)
           ;; Generate imenu, see `imenu--make-index-alist'.
           (items (imenu--truncate-items
                   (save-excursion
                     (without-restriction
                       (funcall imenu-create-index-function)))))
           (config (cdr (seq-find (lambda (x) (derived-mode-p (car x))) consult-imenu-config))))
      ;; Fix toplevel items, e.g., emacs-lisp-mode toplevel items are functions
      (when-let (toplevel (plist-get config :toplevel))
        (let ((tops (seq-remove (lambda (x) (listp (cdr x))) items))
              (rest (seq-filter (lambda (x) (listp (cdr x))) items)))
          (setq items (nconc rest (and tops (list (cons toplevel tops)))))))
      ;; Apply our flattening in order to ease searching the imenu.
      (let ((fn (if (and (boundp 'eglot--managed-mode) eglot--managed-mode) #'consult-imenu--flatten-eglot #'consult-imenu--flatten)))
        (funcall fn
                 nil nil items
                 (mapcar (pcase-lambda (`(,x ,y ,z)) (list y x z))
                         (plist-get config :types)))))))