jcs-elpa / company-fuzzy Goto Github PK

View Code? Open in Web Editor NEW

117.0 3.0 8.0 7.29 MB

Fuzzy matching for `company-mode'

License: GNU General Public License v3.0

Emacs Lisp 98.67% Makefile 1.33%

auto-complete ycmd emacs

company-fuzzy's People

Contributors

Stargazers

Watchers

Forkers

emacsmirror blade6570 jxl-info tex-info jcs-pr dvzubarev windymelt kostafey

company-fuzzy's Issues

Yasnippet offers candidates for every prefix

I have added it to company-fuzzy-history-backends as suggested, but I still get every available snippet pop up as an option for every key that I type, regardless of prefix.

Is there any way to have it only fuzzy match the snippet description instead?

Using company-fuzzy with merged backends

I have backends defined this way in company-mode.

((company-bbdb :with company-yasnippet company-dabbrev-code)
 (company-semantic :with company-yasnippet company-dabbrev-code)
 (company-cmake :with company-yasnippet company-dabbrev-code)
 (company-capf :with company-yasnippet company-dabbrev-code)
 (company-files :with company-yasnippet company-dabbrev-code)
 (company-dabbrev-code company-gtags company-etags company-keywords :with company-yasnippet)
 (company-oddmuse :with company-yasnippet company-dabbrev-code)
 (company-dabbrev :with company-yasnippet company-dabbrev-code))

It looks like when using these backends with company-fuzzy, company-fuzzy doesn't know what to do with the :with keyword and chokes upon trying to complete. e.g. Nothing shows/completes with :with.

Not sure what the best way to handle it in company-fuzzy since company-fuzzy tries to do a completion on all backends. Maybe an extract and pull out the :with backends into the same list.

e.g.

(company-capf :with company-yasnippet company-dabbrev-code)
(company-files :with company-yasnippet company-dabbrev-code)

becomes

(company-capf company-files company-yasnippet company-dabbrev-code)

internally.

Merge function I use:

  (defun merge-backend-with-company-backends (backend-to-merge)
    "Merges a backend with every backend in company-backends.
BACKEND-TO_MERGE will only be merged if it's not already in the current backend.

Merging `company-yasnippet' to `company-capf' will yield
'\(company-capf :with company-yasnippet\)."
    (setq company-backends
          (mapcar (lambda (backend)
                    (cond
                     ((and (listp backend)
                           (member backend-to-merge backend))
                      backend)
                     (:else
                      (append (if (consp backend)
                                  backend
                                (list backend))
                              (if (and (listp backend)
                                       (member :with backend))
                                  `(,backend-to-merge)
                                `(:with ,backend-to-merge))))))
                  company-backends)))

Thanks for the interesting package!

Adding yasnippet as a backend, doesn't complete when calling company-complete-selection

I have something like this bound to RET on the company-active-map.

(defun j-company-expand-yasnippet-or-return ()
      "Expand yas template or call RET normally.

If `yasnippet' expansion in progress, always complete selection."
      (interactive)
      (cond
       ;; `yasnippet' expansion in progress.
       ((yas-current-field)
        (call-interactively #'company-complete-selection))
       ;; Check the type of the candidate.
       ((and company-active-map
             company-selection-changed
             (car company-candidates) ;; Making sure there are candidates.
             (let ((candidate (nth company-selection
                                   company-candidates)))
               (or
                ;; This might work for `eglot'.
                ;; (get-text-property 0 :label candidate)
                ;; `company-lsp'
                (get-text-property 0 'lsp-completion-item candidate)
                ;; `company-sourcekit'
                (get-text-property 0 'sourcetext candidate)
                ;; `yasnippet'
                (get-text-property 0 'yas-template candidate))))
        (call-interactively #'company-complete-selection))
       (:default
        (when company-selection-changed
          (company-complete-selection))
        (let ((company-active-map))
          (call-interactively (key-binding (kbd "RET")))))))

Without company-fuzzy, if I'm on a snippet expansion in the company-mode popup/auto complete menu, pressing RET calls company-complete-selection which then expands the snippet.

For example, in a C file.

if| popup shows with if yasnippet selection -> press ENTER

Result:

if (/cursor/) {
}

When I pair the same setup with company-fuzzy.

Result:

if/cursor/

If I then, press TAB after that, snippet expands normally.

The incorrect result returned by company-fuzzy.

I use this package with the following configuration:

(use-package flx)
;; ;; https://github.com/jcs-elpa/company-fuzzy
(use-package company-fuzzy
  :hook (company-mode . company-fuzzy-mode)
  :init
  (setq company-fuzzy-sorting-backend 'flx
        company-fuzzy-prefix-on-top nil
        ;; company-fuzzy-trigger-symbols '("." "->" "<" "\"" "'" "@")
	)
  )

Now, I use the self-made english-wordlist to do some test as follows:

$ ug 'iso.*ph' ~/Public/repo/github.com/hongyi-zhao/english-wordlist.git/american-english-exhaustive
anisophyllous
anisophylly
antisophism
antisophist
antisophistic
antisophistication
antisophistry
cardisophistical
diisopropyl fluorophosphate
disodium hydrogen phosphate
disodium phosphate
eisoptrophobia
isocamphor
isocamphoric
isocephalic
isocephalism
isocephalous
isocephaly
isochlorophyll
isochlorophyllin
isodiaphere
isodiapheres
isodimorphic
isodimorphism
isodimorphism's
isodimorphisms
isodimorphous
isoflurophate
isograph
isographic
isographical
isographically
isograph's
isographs
isography
isokeraunographic
isokeraunophonic
isomeromorphism
isometrograph
isomorph
isomorphic
isomorphically
isomorphism
isomorphism's
isomorphisms
isomorphous
isomorph's
isomorphs
isomorphy
isoneph
isonephelic
isophanal
isophane
isophasal
isophenal
isophene
isophenomenal
isophenous
isophone
isophone's
isophones
isophoria
isophorone
isophot
isophotal
isophote
isophote's
isophotes
isophotic line
isophthalic
isophthalic acid
isophthalyl
isophyllia
isophyllous
isophylly
isopodimorphous
isopsephic
isopsephism
isosulphide
isosulphocyanate
isosulphocyanic
isotrimorphic
isotrimorphism
isotrimorphous
misophobia
misosopher
misosophist
misosophy
trisodium phosphate
unisomorphic

But, in Emacs, when I'm typing isoph, only a few completed candidates are listed, as shown below:

Any hints for this problem?

See company-mode/company-mode#1380 (comment) for the related discussion.

Regards,
Zhao

Company: frontend company-pseudo-tooltip-unless-just-one-frontend error "Invalid regexp: "Trailing backslash"" on command post-command

Backtrace:
Debugger entered--Lisp error: (invalid-regexp "Trailing backslash") string-match(#("\\" 0 1 (fontified t org-category "bug")) #(" \\C-ch <dabbrev-code> 1 " 0 1 (face (company-tooltip-selection company-tooltip-selection company-tooltip) mouse-face (company-tooltip-mouse)) 1 2 (face (company-tooltip-selection company-tooltip-common-selection company-tooltip-selection company-tooltip) mouse-face (company-tooltip-mouse)) 2 6 (face (company-tooltip-selection company-tooltip-selection company-tooltip) mouse-face (company-tooltip-mouse)) 6 21 (face (company-tooltip-annotation-selection company-tooltip-selection company-tooltip) mouse-face (company-tooltip-mouse)) 21 34 (face (company-tooltip-selection company-tooltip) mouse-face (company-tooltip-mouse))) nil) company-fuzzy--company-fill-propertize(#f(compiled-function (value annotation width selected left right) #<bytecode 0x1561d47cbde9>) "\\C-ch" " <dabbrev-code>" 30 t " " " 1 ") apply(company-fuzzy--company-fill-propertize #f(compiled-function (value annotation width selected left right) #<bytecode 0x1561d47cbde9>) ("\\C-ch" " <dabbrev-code>" 30 t " " " 1 ")) company-fill-propertize("\\C-ch" " <dabbrev-code>" 30 t " " " 1 ") company--create-lines(0 10) company-pseudo-tooltip-show(2 2 0) company-pseudo-tooltip-show-at-point(16 1) company-pseudo-tooltip-frontend(post-command) company-pseudo-tooltip-unless-just-one-frontend(post-command) company-call-frontends(post-command) company-post-command() company-idle-begin(#<buffer bug.org> #<window 3 on bug.org> 158 16) apply(company-idle-begin (#<buffer bug.org> #<window 3 on bug.org> 158 16)) timer-event-handler([t 24417 49290 773636 nil company-idle-begin (#<buffer bug.org> #<window 3 on bug.org> 158 16) nil 162000])

I used the company-fuzzy-mode on any org file. If I start typing with \ then it throws this error.

### My company setup:

(use-package company
:ensure t
:config
(setq company-minimum-prefix-length 1
;; company delay until suggestions are shown
;;company-idle-delay 0.1
company-tooltip-align-annotations t
company-idle-delay 0
;; weight by frequency
company-transformers '(company-sort-by-occurrence))
(global-set-key (kbd "C-") 'company-manual-begin)
(define-key company-active-map (kbd "C-n") 'company-select-next)
(define-key company-active-map (kbd "C-p") 'company-select-previous)
;;(define-key company-active-map (kbd "TAB") 'company-complete-selection)
;;(define-key company-active-map (kbd "") 'company-complete-selection)
(define-key company-active-map (kbd "RET") 'company-complete-common)
;;(define-key company-active-map (kbd "") nil)
;;(define-key company-active-map (kbd "RET") nil)
(global-company-mode)
)

Ignores candidates that do not match prefix

I'm using flx-rs as the sorting backend.

For some reason, only candidates that have a prefix matching the entered string are shown. This is with the etags backend.

This means that if I have foo-bar in TAGS and write fba, foo-bar is suggested, but not when I write bar.

My config so far is:

(require 'company)
(require 'company-fuzzy)
(setq company-fuzzy-sorting-backend 'flx-rs)
(setq company-fuzzy-prefix-on-top nil)

(defun my-mode-hook ()
  (setq-local completion-styles '(substring)) ;; Try to not discard candidates.
  (setq-local company-backends '(company-etags))
  (company-mode 1)
  (company-fuzzy-mode 1)
)

Any suggestion?

`company-eclim-auto-save` is disarded by current version of company.

You told the following setting here:

company-eclim-auto-save nil ; Stop eclim auto save.

But I find nothing about this variable by searching the company-mode's source code of its git master version:

werner@X10DAi:~/.emacs.d/straight/repos/company-mode$ git log -1
commit 1fd1b363eee68e4cdcf0e610005c0bdbf9940604 (HEAD -> master, origin/master, origin/HEAD)
Author: Dmitry Gutov <[email protected]>
Date:   Sat Jun 19 00:05:40 2021 +0300

    Edit the docstring
    
    #1118

werner@X10DAi:~/.emacs.d/straight/repos/company-mode$ rg -uu -- 'company-eclim-auto-save'
werner@X10DAi:~/.emacs.d/straight/repos/company-mode$

So, I'm afraid that this variable has been discarded now.

Company-complete doesn't complete when inside of string

Found strange behaviour when trying to complete inside string with global-company-fuzzy-mode turned-on.
Open scratch buffer and start new string with " "buf<-complete here"

My company backends config quite simple (company-files company-yasnippet company-dabbrev)

Is there some kind of workaround or smth?

Link to configuration in the readme doesn't work

https://github.com/jcs-emacs/jcs-emacs/blob/master/.emacs.jcs/jcs-plugin.el results in a 404.

Error running with doom emacs

When enabling this minor mode in a buffer in Doom emacs, I get this message when company tries to pull up suggestions:

Company: frontend company-pseudo-tooltip-frontend error "Company: backend company-fuzzy-all-other-backends error "Wrong type argument: numberp, nil" with args (pre-render config_data nil)" on command post-command

Let me know what else you want me to do to help diagnose, I am a little new to emacs

Identify exact candidate with different source.

Currently once the source are being defined; the loop will stop immediately to save more runtime. But no way to identify which source is currently each candidate is using. 😕 So..

If I have hello-world in two company sources. For example, capf and dabbrev. Currently it will only return one of them by which source have the former position in backend list.

Solution 1: Let them search though whole list and list them all out. More runtime is cost.

Appropriate hook to enable after changing backends

This is more a help request, but I feel comfortable making it because it should have general appeal.

I have (set-company-backend! 'prog-mode [backends]) in my config. It's a Doom function that adds to backends when changing major modes.

I have tried enabling company-fuzzy with company-mode-hook, the major mode change hook, and even advising set-company-backends.

I can get a final result where the backends seem to be set correctly for fuzzy, but no autocompletion occurs. Disabling then reenabling company-mode doesn't fix it, but doing so for company-fuzzy does.

On startup, when I expect autocompletion and none occurs, company-backends is ((:separate company-capf company-yasnippet) company-fuzzy-all-other-backends). After restarting, it is only (company-fuzzy-all-other-backends)

Any suggestions for how best to enable fuzzy?

company-diag is obscured when using company-fuzzy

When using company-fuzzy, it seems to remove a lot of valuable information in company-diag.

When debugging, it's useful to know which backends are enabled. Here is what it looks like without company-fuzzy:

It would be nice to maintain the functionality of company-diag while still using company-fuzzy

company-keywords backend is not working after recent update

company-keywords backend is not working after the update.

company-keywords doesn't show up at all.

current package-version - company-fuzzy-20201020-1552

emacs-version - 27.1

company-version - 0.9.13 - package-version = company-20201004.735

Update :

Can confirm that it is working until this commit - 2f70e6f
I have tested it using quelpa.

(use-package company-fuzzy
  :quelpa
  (company-fuzzy
   :fetcher github
   :repo "jcs-elpa/company-fuzzy"
   :commit "2f70e6fe78c45d0cbbb22b1d994f90aa9c78553b"
   )
  :init
  (setq company-fuzzy-sorting-backend 'flx)
  (setq company-fuzzy-prefix-ontop nil)
  (with-eval-after-load 'company
    (global-company-fuzzy-mode t)))

I just tested it with jenkinsfile-mode
https://github.com/john2x/jenkinsfile-mode/blob/65bf3925852c35c6bd499978f08f83c1193f4347/jenkinsfile-mode.el#L299

Order is not respected when variable starts with @ (ruby-mode)

Here an example:

value on company-fuzzy--backends:

(company-capf company-dabbrev-code company-ruby-backend company-rspec-backend)

enabling company-fyzzy-mode disables semantic completion with eglot

Hi, I'm interested in fuzzy completions with company, and your package seems to be great. However I have several problems with it.

In particular, I use eglot a.k.a. Emacs polyglot, an LSP client. Without company-fyzzy-mode after I type ap-> I can see these semantic completions provided by clangd language server:

When company-fuzzy-mode is enabled, there's no completions in that case.

When trying to complete manually with company-complete I get this message:

Company: backend company-fuzzy-all-other-backends error "Wrong type argument: stringp, nil" with args (candidates )

Args out of range in doom-emacs until company-fuzzy-mode mode reloaded

Hello, I am trying to use company-fuzzy with doom-emacs (with emacs 27.1). I have set (global-company-fuzzy-mode 1) is my init.el but completion fails with the message.

Args out of range: "", 0, -1
Quit

However, if I disable company-fuzzy-mode and then re-enable it, it seems to behave itself. Here is a stack trace:

Debugger entered--Lisp error: (args-out-of-range "" 0 -1)
  apply(debug error (args-out-of-range "" 0 -1))
  edebug(error (args-out-of-range "" 0 -1))
  signal(args-out-of-range ("" 0 -1))
  edebug-signal(args-out-of-range ("" 0 -1))
  substring("" 0 -1)
  company-fuzzy--sort-prefix-ontop(nil)
  company-fuzzy--sort-candidates(nil)
  company--transform-candidates(nil)
  company--postprocess-candidates(nil)
  company-calculate-candidates("fd" nil)
  company--begin-new()
  company--perform()
  company-auto-begin()
  (edebug-after (edebug-before 22) 23 (company-auto-begin))
  (if (edebug-after (edebug-before 22) 23 (company-auto-begin)) (progn (edebug-after (edebug-before 24) 30 (when (edebug-after (edebug-before 25) 27 (version< (edebug-after 0 26 emacs-version) "24.3.50")) (edebug-after (edebug-before 28) 29 (company-input-noop)))) (edebug-after (edebug-before 31) 34 (let ((this-command 'company-idle-begin)) (edebug-after (edebug-before 32) 33 (company-post-command))))))
  (when (edebug-after (edebug-before 22) 23 (company-auto-begin)) (edebug-after (edebug-before 24) 30 (when (edebug-after (edebug-before 25) 27 (version< (edebug-after 0 26 emacs-version) "24.3.50")) (edebug-after (edebug-before 28) 29 (company-input-noop)))) (edebug-after (edebug-before 31) 34 (let ((this-command 'company-idle-begin)) (edebug-after (edebug-before 32) 33 (company-post-command)))))
  (edebug-after (edebug-before 21) 35 (when (edebug-after (edebug-before 22) 23 (company-auto-begin)) (edebug-after (edebug-before 24) 30 (when (edebug-after (edebug-before 25) 27 (version< (edebug-after 0 26 emacs-version) "24.3.50")) (edebug-after (edebug-before 28) 29 (company-input-noop)))) (edebug-after (edebug-before 31) 34 (let ((this-command 'company-idle-begin)) (edebug-after (edebug-before 32) 33 (company-post-command))))))
  (and (edebug-after (edebug-before 1) 5 (eq (edebug-after 0 2 buf) (edebug-after (edebug-before 3) 4 (current-buffer)))) (edebug-after (edebug-before 6) 10 (eq (edebug-after 0 7 win) (edebug-after (edebug-before 8) 9 (selected-window)))) (edebug-after (edebug-before 11) 15 (eq (edebug-after 0 12 tick) (edebug-after (edebug-before 13) 14 (buffer-chars-modified-tick)))) (edebug-after (edebug-before 16) 20 (eq (edebug-after 0 17 pos) (edebug-after (edebug-before 18) 19 (point)))) (edebug-after (edebug-before 21) 35 (when (edebug-after (edebug-before 22) 23 (company-auto-begin)) (edebug-after (edebug-before 24) 30 (when (edebug-after (edebug-before 25) 27 (version< (edebug-after 0 26 emacs-version) "24.3.50")) (edebug-after (edebug-before 28) 29 (company-input-noop)))) (edebug-after (edebug-before 31) 34 (let ((this-command 'company-idle-begin)) (edebug-after (edebug-before 32) 33 (company-post-command)))))))
  (edebug-after (edebug-before 0) 36 (and (edebug-after (edebug-before 1) 5 (eq (edebug-after 0 2 buf) (edebug-after (edebug-before 3) 4 (current-buffer)))) (edebug-after (edebug-before 6) 10 (eq (edebug-after 0 7 win) (edebug-after (edebug-before 8) 9 (selected-window)))) (edebug-after (edebug-before 11) 15 (eq (edebug-after 0 12 tick) (edebug-after (edebug-before 13) 14 (buffer-chars-modified-tick)))) (edebug-after (edebug-before 16) 20 (eq (edebug-after 0 17 pos) (edebug-after (edebug-before 18) 19 (point)))) (edebug-after (edebug-before 21) 35 (when (edebug-after (edebug-before 22) 23 (company-auto-begin)) (edebug-after (edebug-before 24) 30 (when (edebug-after (edebug-before 25) 27 (version< ... "24.3.50")) (edebug-after (edebug-before 28) 29 (company-input-noop)))) (edebug-after (edebug-before 31) 34 (let ((this-command ...)) (edebug-after (edebug-before 32) 33 (company-post-command))))))))
  (closure ((pos . 1609) (tick . 5353) (win . #<window 37 on config.el>) (buf . #<buffer config.el>) t) nil (edebug-after (edebug-before 0) 36 (and (edebug-after (edebug-before 1) 5 (eq (edebug-after 0 2 buf) (edebug-after (edebug-before 3) 4 (current-buffer)))) (edebug-after (edebug-before 6) 10 (eq (edebug-after 0 7 win) (edebug-after (edebug-before 8) 9 (selected-window)))) (edebug-after (edebug-before 11) 15 (eq (edebug-after 0 12 tick) (edebug-after (edebug-before 13) 14 (buffer-chars-modified-tick)))) (edebug-after (edebug-before 16) 20 (eq (edebug-after 0 17 pos) (edebug-after (edebug-before 18) 19 (point)))) (edebug-after (edebug-before 21) 35 (when (edebug-after (edebug-before 22) 23 (company-auto-begin)) (edebug-after (edebug-before 24) 30 (when (edebug-after ... 27 ...) (edebug-after ... 29 ...))) (edebug-after (edebug-before 31) 34 (let (...) (edebug-after ... 33 ...))))))))()
  edebug-default-enter(company-idle-begin (#<buffer config.el> #<window 37 on config.el> 5353 1609) (closure ((pos . 1609) (tick . 5353) (win . #<window 37 on config.el>) (buf . #<buffer config.el>) t) nil (edebug-after (edebug-before 0) 36 (and (edebug-after (edebug-before 1) 5 (eq (edebug-after 0 2 buf) (edebug-after (edebug-before 3) 4 (current-buffer)))) (edebug-after (edebug-before 6) 10 (eq (edebug-after 0 7 win) (edebug-after (edebug-before 8) 9 (selected-window)))) (edebug-after (edebug-before 11) 15 (eq (edebug-after 0 12 tick) (edebug-after (edebug-before 13) 14 (buffer-chars-modified-tick)))) (edebug-after (edebug-before 16) 20 (eq (edebug-after 0 17 pos) (edebug-after (edebug-before 18) 19 (point)))) (edebug-after (edebug-before 21) 35 (when (edebug-after (edebug-before 22) 23 (company-auto-begin)) (edebug-after (edebug-before 24) 30 (when ... ...)) (edebug-after (edebug-before 31) 34 (let ... ...))))))))
  edebug-default-enter(company-idle-begin (#<buffer config.el> #<window 37 on config.el> 5353 1609) (closure ((pos . 1609) (tick . 5353) (win . #<window 37 on config.el>) (buf . #<buffer config.el>) t) nil (edebug-after (edebug-before 0) 36 (and (edebug-after (edebug-before 1) 5 (eq (edebug-after 0 2 buf) (edebug-after (edebug-before 3) 4 (current-buffer)))) (edebug-after (edebug-before 6) 10 (eq (edebug-after 0 7 win) (edebug-after (edebug-before 8) 9 (selected-window)))) (edebug-after (edebug-before 11) 15 (eq (edebug-after 0 12 tick) (edebug-after (edebug-before 13) 14 (buffer-chars-modified-tick)))) (edebug-after (edebug-before 16) 20 (eq (edebug-after 0 17 pos) (edebug-after (edebug-before 18) 19 (point)))) (edebug-after (edebug-before 21) 35 (when (edebug-after (edebug-before 22) 23 (company-auto-begin)) (edebug-after (edebug-before 24) 30 (when ... ...)) (edebug-after (edebug-before 31) 34 (let ... ...))))))))
  edebug-enter(company-idle-begin (#<buffer config.el> #<window 37 on config.el> 5353 1609) (closure ((pos . 1609) (tick . 5353) (win . #<window 37 on config.el>) (buf . #<buffer config.el>) t) nil (edebug-after (edebug-before 0) 36 (and (edebug-after (edebug-before 1) 5 (eq (edebug-after 0 2 buf) (edebug-after (edebug-before 3) 4 (current-buffer)))) (edebug-after (edebug-before 6) 10 (eq (edebug-after 0 7 win) (edebug-after (edebug-before 8) 9 (selected-window)))) (edebug-after (edebug-before 11) 15 (eq (edebug-after 0 12 tick) (edebug-after (edebug-before 13) 14 (buffer-chars-modified-tick)))) (edebug-after (edebug-before 16) 20 (eq (edebug-after 0 17 pos) (edebug-after (edebug-before 18) 19 (point)))) (edebug-after (edebug-before 21) 35 (when (edebug-after (edebug-before 22) 23 (company-auto-begin)) (edebug-after (edebug-before 24) 30 (when ... ...)) (edebug-after (edebug-before 31) 34 (let ... ...))))))))
  (closure (t) (buf win tick pos) (edebug-enter 'company-idle-begin (list buf win tick pos) #'(lambda nil (edebug-after (edebug-before 0) 36 (and (edebug-after ... 5 ...) (edebug-after ... 10 ...) (edebug-after ... 15 ...) (edebug-after ... 20 ...) (edebug-after ... 35 ...))))))(#<buffer config.el> #<window 37 on config.el> 5353 1609)
  apply((closure (t) (buf win tick pos) (edebug-enter 'company-idle-begin (list buf win tick pos) #'(lambda nil (edebug-after (edebug-before 0) 36 (and (edebug-after ... 5 ...) (edebug-after ... 10 ...) (edebug-after ... 15 ...) (edebug-after ... 20 ...) (edebug-after ... 35 ...)))))) (#<buffer config.el> #<window 37 on config.el> 5353 1609))
  company-idle-begin(#<buffer config.el> #<window 37 on config.el> 5353 1609)
  apply(company-idle-begin (#<buffer config.el> #<window 37 on config.el> 5353 1609))
  timer-event-handler([t 24411 24162 57086 nil company-idle-begin (#<buffer config.el> #<window 37 on config.el> 5353 1609) nil 300000])
  recursive-edit()
  #f(compiled-function (arg-mode) #<bytecode 0x1584458ab2a5>)(before)
  transient--edebug--recursive-edit(#f(compiled-function (arg-mode) #<bytecode 0x1584458ab2a5>) before)
  apply(transient--edebug--recursive-edit #f(compiled-function (arg-mode) #<bytecode 0x1584458ab2a5>) before)
  edebug--recursive-edit(before)
  edebug--display-1(nil 0 before)
  edebug--display(nil 0 before)
  edebug-debugger(0 before nil)
  edebug-before(0)
  (edebug-after (edebug-before 0) 36 (and (edebug-after (edebug-before 1) 5 (eq (edebug-after 0 2 buf) (edebug-after (edebug-before 3) 4 (current-buffer)))) (edebug-after (edebug-before 6) 10 (eq (edebug-after 0 7 win) (edebug-after (edebug-before 8) 9 (selected-window)))) (edebug-after (edebug-before 11) 15 (eq (edebug-after 0 12 tick) (edebug-after (edebug-before 13) 14 (buffer-chars-modified-tick)))) (edebug-after (edebug-before 16) 20 (eq (edebug-after 0 17 pos) (edebug-after (edebug-before 18) 19 (point)))) (edebug-after (edebug-before 21) 35 (when (edebug-after (edebug-before 22) 23 (company-auto-begin)) (edebug-after (edebug-before 24) 30 (when (edebug-after (edebug-before 25) 27 (version< ... "24.3.50")) (edebug-after (edebug-before 28) 29 (company-input-noop)))) (edebug-after (edebug-before 31) 34 (let ((this-command ...)) (edebug-after (edebug-before 32) 33 (company-post-command))))))))
  (closure ((pos . 1608) (tick . 4959) (win . #<window 37 on config.el>) (buf . #<buffer config.el>) t) nil (edebug-after (edebug-before 0) 36 (and (edebug-after (edebug-before 1) 5 (eq (edebug-after 0 2 buf) (edebug-after (edebug-before 3) 4 (current-buffer)))) (edebug-after (edebug-before 6) 10 (eq (edebug-after 0 7 win) (edebug-after (edebug-before 8) 9 (selected-window)))) (edebug-after (edebug-before 11) 15 (eq (edebug-after 0 12 tick) (edebug-after (edebug-before 13) 14 (buffer-chars-modified-tick)))) (edebug-after (edebug-before 16) 20 (eq (edebug-after 0 17 pos) (edebug-after (edebug-before 18) 19 (point)))) (edebug-after (edebug-before 21) 35 (when (edebug-after (edebug-before 22) 23 (company-auto-begin)) (edebug-after (edebug-before 24) 30 (when (edebug-after ... 27 ...) (edebug-after ... 29 ...))) (edebug-after (edebug-before 31) 34 (let (...) (edebug-after ... 33 ...))))))))()
  edebug-default-enter(company-idle-begin (#<buffer config.el> #<window 37 on config.el> 4959 1608) (closure ((pos . 1608) (tick . 4959) (win . #<window 37 on config.el>) (buf . #<buffer config.el>) t) nil (edebug-after (edebug-before 0) 36 (and (edebug-after (edebug-before 1) 5 (eq (edebug-after 0 2 buf) (edebug-after (edebug-before 3) 4 (current-buffer)))) (edebug-after (edebug-before 6) 10 (eq (edebug-after 0 7 win) (edebug-after (edebug-before 8) 9 (selected-window)))) (edebug-after (edebug-before 11) 15 (eq (edebug-after 0 12 tick) (edebug-after (edebug-before 13) 14 (buffer-chars-modified-tick)))) (edebug-after (edebug-before 16) 20 (eq (edebug-after 0 17 pos) (edebug-after (edebug-before 18) 19 (point)))) (edebug-after (edebug-before 21) 35 (when (edebug-after (edebug-before 22) 23 (company-auto-begin)) (edebug-after (edebug-before 24) 30 (when ... ...)) (edebug-after (edebug-before 31) 34 (let ... ...))))))))
  edebug-default-enter(company-idle-begin (#<buffer config.el> #<window 37 on config.el> 4959 1608) (closure ((pos . 1608) (tick . 4959) (win . #<window 37 on config.el>) (buf . #<buffer config.el>) t) nil (edebug-after (edebug-before 0) 36 (and (edebug-after (edebug-before 1) 5 (eq (edebug-after 0 2 buf) (edebug-after (edebug-before 3) 4 (current-buffer)))) (edebug-after (edebug-before 6) 10 (eq (edebug-after 0 7 win) (edebug-after (edebug-before 8) 9 (selected-window)))) (edebug-after (edebug-before 11) 15 (eq (edebug-after 0 12 tick) (edebug-after (edebug-before 13) 14 (buffer-chars-modified-tick)))) (edebug-after (edebug-before 16) 20 (eq (edebug-after 0 17 pos) (edebug-after (edebug-before 18) 19 (point)))) (edebug-after (edebug-before 21) 35 (when (edebug-after (edebug-before 22) 23 (company-auto-begin)) (edebug-after (edebug-before 24) 30 (when ... ...)) (edebug-after (edebug-before 31) 34 (let ... ...))))))))
  edebug-enter(company-idle-begin (#<buffer config.el> #<window 37 on config.el> 4959 1608) (closure ((pos . 1608) (tick . 4959) (win . #<window 37 on config.el>) (buf . #<buffer config.el>) t) nil (edebug-after (edebug-before 0) 36 (and (edebug-after (edebug-before 1) 5 (eq (edebug-after 0 2 buf) (edebug-after (edebug-before 3) 4 (current-buffer)))) (edebug-after (edebug-before 6) 10 (eq (edebug-after 0 7 win) (edebug-after (edebug-before 8) 9 (selected-window)))) (edebug-after (edebug-before 11) 15 (eq (edebug-after 0 12 tick) (edebug-after (edebug-before 13) 14 (buffer-chars-modified-tick)))) (edebug-after (edebug-before 16) 20 (eq (edebug-after 0 17 pos) (edebug-after (edebug-before 18) 19 (point)))) (edebug-after (edebug-before 21) 35 (when (edebug-after (edebug-before 22) 23 (company-auto-begin)) (edebug-after (edebug-before 24) 30 (when ... ...)) (edebug-after (edebug-before 31) 34 (let ... ...))))))))
  (closure (t) (buf win tick pos) (edebug-enter 'company-idle-begin (list buf win tick pos) #'(lambda nil (edebug-after (edebug-before 0) 36 (and (edebug-after ... 5 ...) (edebug-after ... 10 ...) (edebug-after ... 15 ...) (edebug-after ... 20 ...) (edebug-after ... 35 ...))))))(#<buffer config.el> #<window 37 on config.el> 4959 1608)
  apply((closure (t) (buf win tick pos) (edebug-enter 'company-idle-begin (list buf win tick pos) #'(lambda nil (edebug-after (edebug-before 0) 36 (and (edebug-after ... 5 ...) (edebug-after ... 10 ...) (edebug-after ... 15 ...) (edebug-after ... 20 ...) (edebug-after ... 35 ...)))))) (#<buffer config.el> #<window 37 on config.el> 4959 1608))
  company-idle-begin(#<buffer config.el> #<window 37 on config.el> 4959 1608)
  apply(company-idle-begin (#<buffer config.el> #<window 37 on config.el> 4959 1608))
  timer-event-handler([t 24411 24133 377123 nil company-idle-begin (#<buffer config.el> #<window 37 on config.el> 4959 1608) nil 400000])
  recursive-edit()
  debug(debug)
  debug--implement-debug-on-entry(#<buffer config.el> #<window 37 on config.el> 1613 1405)
  apply(debug--implement-debug-on-entry (#<buffer config.el> #<window 37 on config.el> 1613 1405))
* company-idle-begin(#<buffer config.el> #<window 37 on config.el> 1613 1405)
  apply(company-idle-begin (#<buffer config.el> #<window 37 on config.el> 1613 1405))
  timer-event-handler([t 24411 24006 265357 nil company-idle-begin (#<buffer config.el> #<window 37 on config.el> 1613 1405) nil 100000])

This suggests that the problem is somewhere with sorting the prefix on top. If I (setq company-fuzzy-prefix-ontop nil) I no longer get the error, but candidates are not searched fuzzily (until I disable and re-enable the mode).

wrong-type-argument stringp after recent changes

This error occurs on python code, e.g.

l = []
l.ap|

I use company-capf with lsp-pyright.
backtrace:

Debugger entered--Lisp error: (wrong-type-argument stringp ("ap" . t))
  split-string(("ap" . t) "")
  company-fuzzy--pre-render(#("append" 0 1 (face (completions-first-difference) match-data (0 2 0 1 1 2) lsp-completion-prefix "ap" lsp-completion-markers (687 #<marker (moves after insertion) at 689 in ngramdict.py>) lsp-completion-start-point 687 lsp-sort-text "09.9999.append" lsp-completion-item #<hash-table equal 5/6 0x1567a3ae0f61>) 1 6 (match-data (0 2 0 1 1 2) lsp-completion-prefix "ap" lsp-completion-markers (687 #<marker (moves after insertion) at 689 in ngramdict.py>) lsp-completion-start-point 687 lsp-sort-text "09.9999.append" lsp-completion-item #<hash-table equal 5/6 0x1567a3ae0f61>)) nil)
  company-fuzzy-all-other-backends(pre-render #("append" 0 1 (face (completions-first-difference) match-data (0 2 0 1 1 2) lsp-completion-prefix "ap" lsp-completion-markers (687 #<marker (moves after insertion) at 689 in ngramdict.py>) lsp-completion-start-point 687 lsp-sort-text "09.9999.append" lsp-completion-item #<hash-table equal 5/6 0x1567a3ae0f61>) 1 6 (match-data (0 2 0 1 1 2) lsp-completion-prefix "ap" lsp-completion-markers (687 #<marker (moves after insertion) at 689 in ngramdict.py>) lsp-completion-start-point 687 lsp-sort-text "09.9999.append" lsp-completion-item #<hash-table equal 5/6 0x1567a3ae0f61>)) nil)
  apply(company-fuzzy-all-other-backends (pre-render #("append" 0 1 (face (completions-first-difference) match-data (0 2 0 1 1 2) lsp-completion-prefix "ap" lsp-completion-markers (687 #<marker (moves after insertion) at 689 in ngramdict.py>) lsp-completion-start-point 687 lsp-sort-text "09.9999.append" lsp-completion-item #<hash-table equal 5/6 0x1567a3ae0f61>) 1 6 (match-data (0 2 0 1 1 2) lsp-completion-prefix "ap" lsp-completion-markers (687 #<marker (moves after insertion) at 689 in ngramdict.py>) lsp-completion-start-point 687 lsp-sort-text "09.9999.append" lsp-completion-item #<hash-table equal 5/6 0x1567a3ae0f61>)) nil))
  company-call-backend-raw(pre-render #("append" 0 1 (face (completions-first-difference) match-data (0 2 0 1 1 2) lsp-completion-prefix "ap" lsp-completion-markers (687 #<marker (moves after insertion) at 689 in ngramdict.py>) lsp-completion-start-point 687 lsp-sort-text "09.9999.append" lsp-completion-item #<hash-table equal 5/6 0x1567a3ae0f61>) 1 6 (match-data (0 2 0 1 1 2) lsp-completion-prefix "ap" lsp-completion-markers (687 #<marker (moves after insertion) at 689 in ngramdict.py>) lsp-completion-start-point 687 lsp-sort-text "09.9999.append" lsp-completion-item #<hash-table equal 5/6 0x1567a3ae0f61>)) nil)
  company--force-sync(company-call-backend-raw (pre-render #("append" 0 1 (face (completions-first-difference) match-data (0 2 0 1 1 2) lsp-completion-prefix "ap" lsp-completion-markers (687 #<marker (moves after insertion) at 689 in ngramdict.py>) lsp-completion-start-point 687 lsp-sort-text "09.9999.append" lsp-completion-item #<hash-table equal 5/6 0x1567a3ae0f61>) 1 6 (match-data (0 2 0 1 1 2) lsp-completion-prefix "ap" lsp-completion-markers (687 #<marker (moves after insertion) at 689 in ngramdict.py>) lsp-completion-start-point 687 lsp-sort-text "09.9999.append" lsp-completion-item #<hash-table equal 5/6 0x1567a3ae0f61>)) nil) company-fuzzy-all-other-backends)
  company-call-backend(pre-render #("append" 0 1 (face (completions-first-difference) match-data (0 2 0 1 1 2) lsp-completion-prefix "ap" lsp-completion-markers (687 #<marker (moves after insertion) at 689 in ngramdict.py>) lsp-completion-start-point 687 lsp-sort-text "09.9999.append" lsp-completion-item #<hash-table equal 5/6 0x1567a3ae0f61>) 1 6 (match-data (0 2 0 1 1 2) lsp-completion-prefix "ap" lsp-completion-markers (687 #<marker (moves after insertion) at 689 in ngramdict.py>) lsp-completion-start-point 687 lsp-sort-text "09.9999.append" lsp-completion-item #<hash-table equal 5/6 0x1567a3ae0f61>)) nil)
  company--pre-render(#("append" 0 1 (face (completions-first-difference) match-data (0 2 0 1 1 2) lsp-completion-prefix "ap" lsp-completion-markers (687 #<marker (moves after insertion) at 689 in ngramdict.py>) lsp-completion-start-point 687 lsp-sort-text "09.9999.append" lsp-completion-item #<hash-table equal 5/6 0x1567a3ae0f61>) 1 6 (match-data (0 2 0 1 1 2) lsp-completion-prefix "ap" lsp-completion-markers (687 #<marker (moves after insertion) at 689 in ngramdict.py>) lsp-completion-start-point 687 lsp-sort-text "09.9999.append" lsp-completion-item #<hash-table equal 5/6 0x1567a3ae0f61>)))
  company-fill-propertize(#("append" 0 1 (face (completions-first-difference) match-data (0 2 0 1 1 2) lsp-completion-prefix "ap" lsp-completion-markers (687 #<marker (moves after insertion) at 689 in ngramdict.py>) lsp-completion-start-point 687 lsp-sort-text "09.9999.append" lsp-completion-item #<hash-table equal 5/6 0x1567a3ae0f61>) 1 6 (match-data (0 2 0 1 1 2) lsp-completion-prefix "ap" lsp-completion-markers (687 #<marker (moves after insertion) at 689 in ngramdict.py>) lsp-completion-start-point 687 lsp-sort-text "09.9999.append" lsp-completion-item #<hash-table equal 5/6 0x1567a3ae0f61>)) #("(Method) <capf>" 8 15 (face company-fuzzy-annotation-face)) 22 t #("  " 0 1 (display (image :file "/home/denin/.emacs.d/.local/straight/build-28.0.50..." :type svg :width 16 :height 16 :ascent center :background "#c8c6dd")) 1 2 (display (space :width (2)))) " ")
  company--create-lines(0 14)
  company-pseudo-tooltip-show(25 9 0)
  company-pseudo-tooltip-show-at-point(689 2)
  #<subr company-pseudo-tooltip-frontend>(post-command)
  apply(#<subr company-pseudo-tooltip-frontend> post-command)
  company-pseudo-tooltip-frontend(post-command)
  company-call-frontends(post-command)
  company-post-command()
  company-idle-begin(#<buffer ngramdict.py> #<window 3 on ngramdict.py> 1745 689)
  apply(company-idle-begin (#<buffer ngramdict.py> #<window 3 on ngramdict.py> 1745 689))
  timer-event-handler([t 25092 21038 912764 nil company-idle-begin (#<buffer ngramdict.py> #<window 3 on ngramdict.py> 1745 689) nil 542000])

I've found that this error is introduced in a commit a004ae1
I was trying to manually call (company-capf 'prefix) and in my case it returns not a string but a cons ("ap" . t). It seems that cons is unexpected.

[Feature Request] fuzzy scoring and sort function

Currently company-fuzzy doesn't have a fuzzy sorting function(at least I can't find it in source). Would you like to add a fuzzy sorting function?

There's an elisp fuzzy scoring package flx and there's company-flx. You can also have a look at my fuz.el, a fuzzy scoring function powered by Rust.

Report special case for company backend

This thread is a special thread to let other users to report the company backends that isn't working properly with this package. Please report any company backend that isn't working properly with this package.

These backends are special backends that have to implemented individually.

🔍 Backends must take it's own prefix

[2020-10-14] company-files - You will just need to call (company-files 'prefix) to get the correct prefix.

🔍 Backends parse prefix with no strong connection between `candidates` and `prefix` commands

[2019-08-05] company-yasnippet - It returns candidates only when it parse prefix successfully on it's own. Passing prefix to args wouldn't work all the time. (Resolved, see below)

🔍 Unresolved (not working)

[2020-09-24] company-lsp (deprecated) - Somehow doesn't work wit this package. Need more investigations. (Resolved, see below)

Here is list of confirmed normal cases. That said, you don't have to do any special implementation to these backends. And do NOT add it to company-fuzzy-history-backends list.

🔍 Normal (working properly)

Unknown `company` source,

This issue was fix in 41f6d04. The problem was because of capf source is dynamic allocation during completion, hence I couldn't get the correct result. Yet fix this by having to record down a copy of the candidates during the completion.

Cons: More memory to manage in O(n) time and space complexity.