Company complete/preview common and fuzzy filtering

[untoreh]

If I am using a package like orderless or prescient, company-common will never match because company-prefix is not exact, (it would be something like sm-p-rf.
I managed to make company-complete-common work by adding this advice:

;; this function doesn't require all candidates to match, just a subset
(cl-defun my/first-common-prefix (candidates &optional (min-length 2))
  (let ((common (try-completion "" candidates)))
    (if (not (eq "" common))
        common
      (my/first-common-prefix (butlast candidates) min-length))))

(defun my/company-update-first-common (&rest _)
  (setq company-common (my/first-common-prefix company-candidates)))

which is not ideal, because company is still setting its own company-common and overriding it inside company-update-candidates doesn't look possible without replacing the whole func.

Moreover, showing the preview candidate when the prefix is inexact also doesn't work. This is harder to fix because it's unclear how the prefix should be joined with the common completion, should the common completion overwrite the prefix altogether?

[dgutov]

I'm not sure the complete-common action is a good fit for the fuzzy completion backends.

The current behavior completes the common prefix, and that is it.

But suppose you have a fuzzy matching backend, or completion style, etc, where you typed sm-p

and get completions like

small-part-word
smile-pooch-world
smart-cooperation

What do you expect company-complete-common to do? It could, for example, expand input to sm-po.

All three completions above contain an o after p, so they all match it. But now you lost the chance to type a to choose the first option right away.

I suppose can be more optimal strategies: when we discussed this with Stefan Monnier (a while ago), one of the ideas was that the chain of common parts would be returned by the completion function (in the c-a-p-f API), or the completion style. But that never materialized, thus far, so I never wired this approach into company backends.

If you have a particular strategy in mind, I suppose we could try to implement it. Or implement delegation.

Regarding the preview frontend, I don't know how it should behave with non-prefix inputs. That's why we use the pseudo-tooltip backend for those cases. But ideas welcome.

[untoreh]

I would expect complete-common to complete the common prefix among the candidates, indipendently of what I typed (in that case would be just sm), currently it compares the common part against the prefix (which is jargon) so it never completes. For me it is enough to just ignore the prefix, I am not trying to predict some form of similarity among the subwords that the fuzzy algo used to produce the list of candidates...

I think it is enough to delegate setting company-common to a custom function, such that it is possible to modify the value without recomputing.

Previewing could work by overwriting the prefix except the last characther typed, so the preview would have a hole in the middle at the location of the cursor (in case the common part is longer than the prefix). If it is shorter it would just replace the necessary length (without overwriting the whole prefix). Pressing <backspace> would hide the preview.

If there is a common part and you press TAB, the prefix is replaced with the common part; differently from the current behaviour which you can expect to always increase the number of inserted characters, completing the common part of a fuzzy prefix can result in characters being removed from the line.

[dgutov]

(If you reply in the input area under the answer, it will keep discussion in one thread instead of creating new answers.)

I would expect complete-common to complete the common prefix among the candidates, indipendently of what I typed (in that case would be just sm)

Here's how the process could go:

• You type TAB, it changes the input from sm-p to sm. There are now more matches, including those that don't start with 'sm (we're matching fuzzily, after all).
• You type TAB again, and the input changes to to empty, because there is no common prefix in the previous set of matches.

Is that a good workflow for the "complete common" command? Seems doubtful to me. If the matching is fuzzy, the user usually wants to take advantage of the fuzziness, and narrows down through typing more characters. Removing the chars will get in the way of narrowing completions down.

But you can get this behavior locally easily enough rebinding TAB to your own command instead of company-complete-common: pass something else than company-common to company--insert-candidate, and you're good to go. You'll also need to add the name of that command to company-continue-commands.

[dgutov]

Regarding preview, wouldn't the last character look out of place? And having the cursor jump horizontally because of inserted chars sounds potentially annoying.

You can try implementing this and report back. The preview frontend code is largely self-contained, you can start there.