Work around http://debbugs.gnu.org/19553

[gnu-emacs-elpa] / company.el

diff --git a/company.el b/company.el
index 8049e374c5e8988200c2143651c17233e1aa36c2..e4cfcdde353a8e3f34f8c2c785670a9ce3de15f0 100644 (file)
--- a/company.el
+++ b/company.el
@@ -5,7 +5,7 @@
 ;; Author: Nikolaj Schumacher
 ;; Maintainer: Dmitry Gutov <dgutov@yandex.ru>
 ;; URL: http://company-mode.github.io/
 ;; Author: Nikolaj Schumacher
 ;; Maintainer: Dmitry Gutov <dgutov@yandex.ru>
 ;; URL: http://company-mode.github.io/

-;; Version: 0.9.0-cvs
+;; Version: 0.8.8-cvs

 ;; Keywords: abbrev, convenience, matching
 ;; Package-Requires: ((emacs "24.1") (cl-lib "0.5"))
 
 ;; Keywords: abbrev, convenience, matching
 ;; Package-Requires: ((emacs "24.1") (cl-lib "0.5"))
 


@@ -58,11 +58,6 @@
 ;; enrich gtags with dabbrev-code results (to emulate local variables).
 ;; To do this, add a list with both back-ends as an element in company-backends.
 ;;
 ;; enrich gtags with dabbrev-code results (to emulate local variables).
 ;; To do this, add a list with both back-ends as an element in company-backends.
 ;;

-;; Known Issues:
-;; When point is at the very end of the buffer, the pseudo-tooltip appears very
-;; wrong, unless company is allowed to temporarily insert a fake newline.
-;; This behavior is enabled by `company-end-of-buffer-workaround'.
-;;

 ;;; Change Log:
 ;;
 ;; See NEWS.md in the repository.
 ;;; Change Log:
 ;;
 ;; See NEWS.md in the repository.


@@ -117,6 +112,10 @@ buffer-local wherever it is set."
     (t (:background "green")))
   "Face used for the selection in the tooltip.")
 
     (t (:background "green")))
   "Face used for the selection in the tooltip.")
 

+(defface company-tooltip-search
+  '((default :inherit company-tooltip-selection))
+  "Face used for the search string in the tooltip.")
+

 (defface company-tooltip-mouse
   '((default :inherit highlight))
   "Face used for the tooltip item under the mouse.")
 (defface company-tooltip-mouse
   '((default :inherit highlight))
   "Face used for the tooltip item under the mouse.")


@@ -341,20 +340,20 @@ The first argument is the command requested from the back-end.  It is one
 of the following:
 
 `prefix': The back-end should return the text to be completed.  It must be
 of the following:
 
 `prefix': The back-end should return the text to be completed.  It must be

-text immediately before point.  Returning nil passes control to the next
-back-end.  The function should return `stop' if it should complete but
-cannot (e.g. if it is in the middle of a string).  Instead of a string,
-the back-end may return a cons where car is the prefix and cdr is used in
-`company-minimum-prefix-length' test.  It must be either number or t, and
-in the latter case the test automatically succeeds.
+text immediately before point.  Returning nil from this command passes
+control to the next back-end.  The function should return `stop' if it
+should complete but cannot (e.g. if it is in the middle of a string).
+Instead of a string, the back-end may return a cons where car is the prefix
+and cdr is used in `company-minimum-prefix-length' test.  It must be either
+number or t, and in the latter case the test automatically succeeds.

 
 `candidates': The second argument is the prefix to be completed.  The
 return value should be a list of candidates that match the prefix.
 
 Non-prefix matches are also supported (candidates that don't start with the
 prefix, but match it in some backend-defined way).  Backends that use this
 
 `candidates': The second argument is the prefix to be completed.  The
 return value should be a list of candidates that match the prefix.
 
 Non-prefix matches are also supported (candidates that don't start with the
 prefix, but match it in some backend-defined way).  Backends that use this

-feature must disable cache (return t to `no-cache') and should also respond
-to `match'.
+feature must disable cache (return t to `no-cache') and might also want to
+respond to `match'.

 
 Optional commands:
 
 
 Optional commands:
 


@@ -385,10 +384,10 @@ be kept if they have different annotations.  For that to work properly,
 backends should store the related information on candidates using text
 properties.
 
 backends should store the related information on candidates using text
 properties.
 

-`match': The second argument is a completion candidate.  Backends that
-provide non-prefix completions should return the position of the end of
-text in the candidate that matches `prefix'.  It will be used when
-rendering the popup.
+`match': The second argument is a completion candidate.  Return the index
+after the end of text matching `prefix' within the candidate string.  It
+will be used when rendering the popup.  This command only makes sense for
+backends that provide non-prefix completion.

 
 `require-match': If this returns t, the user is not allowed to enter
 anything not offered as a candidate.  Use with care!  The default value nil
 
 `require-match': If this returns t, the user is not allowed to enter
 anything not offered as a candidate.  Use with care!  The default value nil


@@ -544,13 +543,19 @@ A character that is part of a valid candidate never triggers auto-completion."
 
 (defcustom company-idle-delay .5
   "The idle delay in seconds until completion starts automatically.
 
 (defcustom company-idle-delay .5
   "The idle delay in seconds until completion starts automatically.

-A value of nil means no idle completion, t means show candidates
-immediately when a prefix of `company-minimum-prefix-length' is reached."
+The prefix still has to satisfy `company-minimum-prefix-length' before that
+happens.  The value of nil means no idle completion."

   :type '(choice (const :tag "never (nil)" nil)
   :type '(choice (const :tag "never (nil)" nil)

-                 (const :tag "immediate (t)" t)
+                 (const :tag "immediate (0)" 0)

                  (number :tag "seconds")))
 
                  (number :tag "seconds")))
 

-(defcustom company-begin-commands '(self-insert-command org-self-insert-command)
+(defcustom company-begin-commands '(self-insert-command
+                                    org-self-insert-command
+                                    orgtbl-self-insert-command
+                                    c-scope-operator
+                                    c-electric-colon
+                                    c-electric-lt-gt
+                                    c-electric-slash)

   "A list of commands after which idle completion is allowed.
 If this is t, it can show completions after any command except a few from a
 pre-defined list.  See `company-idle-delay'.
   "A list of commands after which idle completion is allowed.
 If this is t, it can show completions after any command except a few from a
 pre-defined list.  See `company-idle-delay'.


@@ -559,7 +564,8 @@ Alternatively, any command with a non-nil `company-begin' property is
 treated as if it was on this list."
   :type '(choice (const :tag "Any command" t)
                  (const :tag "Self insert command" '(self-insert-command))
 treated as if it was on this list."
   :type '(choice (const :tag "Any command" t)
                  (const :tag "Self insert command" '(self-insert-command))

-                 (repeat :tag "Commands" function)))
+                 (repeat :tag "Commands" function))
+  :package-version '(company . "0.8.4"))

 
 (defcustom company-continue-commands '(not save-buffer save-some-buffers
                                            save-buffers-kill-terminal
 
 (defcustom company-continue-commands '(not save-buffer save-some-buffers
                                            save-buffers-kill-terminal


@@ -586,10 +592,6 @@ commands in the `company-' namespace, abort completion."
   :type '(choice (const :tag "off" nil)
                  (const :tag "on" t)))
 
   :type '(choice (const :tag "off" nil)
                  (const :tag "on" t)))
 

-(defvar company-end-of-buffer-workaround t
-  "Work around a visualization bug when completing at the end of the buffer.
-The work-around consists of adding a newline.")
-

 (defvar company-async-wait 0.03
   "Pause between checks to see if the value's been set when turning an
 asynchronous call into synchronous.")
 (defvar company-async-wait 0.03
   "Pause between checks to see if the value's been set when turning an
 asynchronous call into synchronous.")


@@ -626,12 +628,8 @@ asynchronous call into synchronous.")
     (define-key keymap "\C-s" 'company-search-candidates)
     (define-key keymap "\C-\M-s" 'company-filter-candidates)
     (dotimes (i 10)
     (define-key keymap "\C-s" 'company-search-candidates)
     (define-key keymap "\C-\M-s" 'company-filter-candidates)
     (dotimes (i 10)

-      (define-key keymap (vector (+ (aref (kbd "M-0") 0) i))
-        `(lambda ()
-           (interactive)
-           (company-complete-number ,(if (zerop i) 10 i)))))
-
-    keymap)
+      (define-key keymap (read-kbd-macro (format "M-%d" i)) 'company-complete-number))
+     keymap)

   "Keymap that is enabled during an active completion.")
 
 (defvar company--disabled-backends nil)
   "Keymap that is enabled during an active completion.")
 
 (defvar company--disabled-backends nil)


@@ -692,6 +690,9 @@ keymap during active completions (`company-active-map'):
   nil company-lighter company-mode-map
   (if company-mode
       (progn
   nil company-lighter company-mode-map
   (if company-mode
       (progn

+        (when (eq company-idle-delay t)
+          (setq company-idle-delay 0)
+          (warn "Setting `company-idle-delay' to t is deprecated.  Set it to 0 instead."))

         (add-hook 'pre-command-hook 'company-pre-command nil t)
         (add-hook 'post-command-hook 'company-post-command nil t)
         (mapc 'company-init-backend company-backends))
         (add-hook 'pre-command-hook 'company-pre-command nil t)
         (add-hook 'post-command-hook 'company-post-command nil t)
         (mapc 'company-init-backend company-backends))


@@ -761,32 +762,31 @@ means that `company-mode' is always turned on except in `message-mode' buffers."
 ;; Hack:
 ;; Emacs calculates the active keymaps before reading the event.  That means we
 ;; cannot change the keymap from a timer.  So we send a bogus command.
 ;; Hack:
 ;; Emacs calculates the active keymaps before reading the event.  That means we
 ;; cannot change the keymap from a timer.  So we send a bogus command.

-;; XXX: Seems not to be needed anymore in Emacs 24.4
+;; XXX: Even in Emacs 24.4, seems to be needed in the terminal.

 (defun company-ignore ()
   (interactive)
   (setq this-command last-command))
 
 (defun company-ignore ()
   (interactive)
   (setq this-command last-command))
 

-(global-set-key '[31415926] 'company-ignore)
+(global-set-key '[company-dummy-event] 'company-ignore)

 
 (defun company-input-noop ()
 
 (defun company-input-noop ()

-  (push 31415926 unread-command-events))
+  (push 'company-dummy-event unread-command-events))

 
 

-(defun company--column (&optional pos)
-  (save-excursion
-    (when pos (goto-char pos))
-    (save-restriction
-      (+ (save-excursion
-           (vertical-motion 0)
-           (narrow-to-region (point) (point-max))
-           (let ((prefix (get-text-property (point) 'line-prefix)))
-             (if prefix (length prefix) 0)))
-         (current-column)))))
+(defun company--posn-col-row (posn)
+  (let ((col (car (posn-col-row posn)))
+        ;; `posn-col-row' doesn't work well with lines of different height.
+        ;; `posn-actual-col-row' doesn't handle multiple-width characters.
+        (row (cdr (posn-actual-col-row posn))))
+    (when (and header-line-format (version< emacs-version "24.3.93.3"))
+      ;; http://debbugs.gnu.org/18384
+      (cl-decf row))
+    (cons (+ col (window-hscroll)) row)))
+
+(defun company--col-row (&optional pos)
+  (company--posn-col-row (posn-at-point pos)))

 
 (defun company--row (&optional pos)
 
 (defun company--row (&optional pos)

-  (save-excursion
-    (when pos (goto-char pos))
-    (count-screen-lines (window-start)
-                        (progn (vertical-motion 0) (point)))))
+  (cdr (company--col-row pos)))

 
 ;;; backends ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
 ;;; backends ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 


@@ -849,7 +849,7 @@ means that `company-mode' is always turned on except in `message-mode' buffers."
         res))))
 
 (defun company-call-backend-raw (&rest args)
         res))))
 
 (defun company-call-backend-raw (&rest args)

-  (condition-case err
+  (condition-case-unless-debug err

       (if (functionp company-backend)
           (apply company-backend args)
         (apply #'company--multi-backend-adapter company-backend args))
       (if (functionp company-backend)
           (apply company-backend args)
         (apply #'company--multi-backend-adapter company-backend args))


@@ -970,8 +970,6 @@ Controlled by `company-auto-complete'.")
 
 (defvar company-timer nil)
 
 
 (defvar company-timer nil)
 

-(defvar-local company-added-newline nil)
-

 (defsubst company-strip-prefix (str)
   (substring str (length company-prefix)))
 
 (defsubst company-strip-prefix (str)
   (substring str (length company-prefix)))
 


@@ -980,8 +978,9 @@ Controlled by `company-auto-complete'.")
   ;; XXX: Return value we check here is subject to change.
   (if (eq (company-call-backend 'ignore-case) 'keep-prefix)
       (insert (company-strip-prefix candidate))
   ;; XXX: Return value we check here is subject to change.
   (if (eq (company-call-backend 'ignore-case) 'keep-prefix)
       (insert (company-strip-prefix candidate))

-    (delete-region (- (point) (length company-prefix)) (point))
-    (insert candidate)))
+    (unless (equal company-prefix candidate)
+      (delete-region (- (point) (length company-prefix)) (point))
+      (insert candidate))))

 
 (defmacro company-with-candidate-inserted (candidate &rest body)
   "Evaluate BODY with CANDIDATE temporarily inserted.
 
 (defmacro company-with-candidate-inserted (candidate &rest body)
   "Evaluate BODY with CANDIDATE temporarily inserted.


@@ -994,7 +993,8 @@ can retrieve meta-data for them."
      (company--insert-candidate ,candidate)
      (unwind-protect
          (progn ,@body)
      (company--insert-candidate ,candidate)
      (unwind-protect
          (progn ,@body)

-       (delete-region company-point (point)))))
+       (delete-region company-point (point))
+       (set-buffer-modified-p modified-p))))

 
 (defun company-explicit-action-p ()
   "Return whether explicit completion action was taken by the user."
 
 (defun company-explicit-action-p ()
   "Return whether explicit completion action was taken by the user."


@@ -1010,7 +1010,7 @@ can retrieve meta-data for them."
     candidate))
 
 (defun company--should-complete ()
     candidate))
 
 (defun company--should-complete ()

-  (and (eq company-idle-delay t)
+  (and (eq company-idle-delay 'now)

        (not (or buffer-read-only overriding-terminal-local-map
                 overriding-local-map))
        ;; Check if in the middle of entering a key combination.
        (not (or buffer-read-only overriding-terminal-local-map
                 overriding-local-map))
        ;; Check if in the middle of entering a key combination.


@@ -1030,7 +1030,7 @@ can retrieve meta-data for them."
 
 (defun company-call-frontends (command)
   (dolist (frontend company-frontends)
 
 (defun company-call-frontends (command)
   (dolist (frontend company-frontends)

-    (condition-case err
+    (condition-case-unless-debug err

         (funcall frontend command)
       (error (error "Company: Front-end %s error \"%s\" on command %s"
                     frontend (error-message-string err) command)))))
         (funcall frontend command)
       (error (error "Company: Front-end %s error \"%s\" on command %s"
                     frontend (error-message-string err) command)))))


@@ -1078,21 +1078,17 @@ can retrieve meta-data for them."
                                          company-selection)))))
     (setq company-selection 0
           company-candidates candidates))
                                          company-selection)))))
     (setq company-selection 0
           company-candidates candidates))

-  ;; Save in cache:
-  (push (cons company-prefix company-candidates) company-candidates-cache)

   ;; Calculate common.
   (let ((completion-ignore-case (company-call-backend 'ignore-case)))
     ;; We want to support non-prefix completion, so filtering is the
     ;; responsibility of each respective backend, not ours.
     ;; On the other hand, we don't want to replace non-prefix input in
   ;; Calculate common.
   (let ((completion-ignore-case (company-call-backend 'ignore-case)))
     ;; We want to support non-prefix completion, so filtering is the
     ;; responsibility of each respective backend, not ours.
     ;; On the other hand, we don't want to replace non-prefix input in

-    ;; `company-complete-common'.
+    ;; `company-complete-common', unless there's only one candidate.

     (setq company-common
           (if (cdr company-candidates)
     (setq company-common
           (if (cdr company-candidates)

-              (let ((common (try-completion company-prefix company-candidates)))
-                (if (eq common t)
-                    ;; Mulple equal strings, probably with different
-                    ;; annotations.
-                    company-prefix
+              (let ((common (try-completion "" company-candidates)))
+                (when (string-prefix-p company-prefix common
+                                       completion-ignore-case)

                   common))
             (car company-candidates)))))
 
                   common))
             (car company-candidates)))))
 


@@ -1109,11 +1105,12 @@ can retrieve meta-data for them."
                                            company-candidates-cache)))
                 (setq candidates (all-completions prefix prev))
                 (cl-return t)))))
                                            company-candidates-cache)))
                 (setq candidates (all-completions prefix prev))
                 (cl-return t)))))

-        ;; no cache match, call back-end
-        (setq candidates
-              (company--process-candidates
-               (company--fetch-candidates prefix))))
-    (setq candidates (company--transform-candidates candidates))
+        (progn
+          ;; No cache match, call the backend.
+          (setq candidates (company--fetch-candidates prefix))
+          ;; Save in cache (without the predicate applied).
+          (push (cons prefix candidates) company-candidates-cache)))
+    (setq candidates (company--process-candidates candidates))

     (when candidates
       (if (or (cdr candidates)
               (not (eq t (compare-strings (car candidates) nil nil
     (when candidates
       (if (or (cdr candidates)
               (not (eq t (compare-strings (car candidates) nil nil


@@ -1138,13 +1135,11 @@ can retrieve meta-data for them."
          (cdr c)
          (lambda (candidates)
            (if (not (and candidates (eq res 'done)))
          (cdr c)
          (lambda (candidates)
            (if (not (and candidates (eq res 'done)))

-               ;; Fetcher called us back right away.
+               ;; There's no completions to display,
+               ;; or the fetcher called us back right away.

                (setq res candidates)
              (setq company-backend backend
                (setq res candidates)
              (setq company-backend backend

-                   company-candidates-cache
-                   (list (cons prefix
-                               (company--process-candidates
-                                candidates))))
+                   company-candidates-cache (list (cons prefix candidates)))

              (company-idle-begin buf win tick pt)))))
       ;; FIXME: Relying on the fact that the callers
       ;; will interpret nil as "do nothing" is shaky.
              (company-idle-begin buf win tick pt)))))
       ;; FIXME: Relying on the fact that the callers
       ;; will interpret nil as "do nothing" is shaky.


@@ -1158,10 +1153,10 @@ can retrieve meta-data for them."
           (company-apply-predicate candidates
                                    company-candidates-predicate)))
   (unless (company-call-backend 'sorted)
           (company-apply-predicate candidates
                                    company-candidates-predicate)))
   (unless (company-call-backend 'sorted)

-    (setq candidates (sort candidates 'string<)))
+    (setq candidates (sort (copy-sequence candidates) 'string<)))

   (when (company-call-backend 'duplicates)
     (company--strip-duplicates candidates))
   (when (company-call-backend 'duplicates)
     (company--strip-duplicates candidates))

-  candidates)
+  (company--transform-candidates candidates))

 
 (defun company--strip-duplicates (candidates)
   (let ((c2 candidates))
 
 (defun company--strip-duplicates (candidates)
   (let ((c2 candidates))


@@ -1188,43 +1183,74 @@ can retrieve meta-data for them."
       (setq c (funcall tr c)))
     c))
 
       (setq c (funcall tr c)))
     c))
 

+(defcustom company-occurrence-weight-function
+  #'company-occurrence-prefer-closest-above
+  "Function to weigh matches in `company-sort-by-occurrence'.
+It's called with three arguments: cursor position, the beginning and the
+end of the match."
+  :type '(choice
+          (const :tag "First above point, then below point"
+                 company-occurrence-prefer-closest-above)
+          (const :tag "Prefer closest in any direction"
+                 company-occurrence-prefer-any-closest)))
+
+(defun company-occurrence-prefer-closest-above (pos match-beg match-end)
+  "Give priority to the matches above point, then those below point."
+  (if (< match-beg pos)
+      (- pos match-end)
+    (- match-beg (window-start))))
+
+(defun company-occurrence-prefer-any-closest (pos _match-beg match-end)
+  "Give priority to the matches closest to the point."
+  (abs (- pos match-end)))
+

 (defun company-sort-by-occurrence (candidates)
   "Sort CANDIDATES according to their occurrences.
 Searches for each in the currently visible part of the current buffer and
 (defun company-sort-by-occurrence (candidates)
   "Sort CANDIDATES according to their occurrences.
 Searches for each in the currently visible part of the current buffer and

-gives priority to the closest ones above point, then closest ones below
-point. The rest of the list is appended unchanged.
+prioritizes the matches according to `company-occurrence-weight-function'.
+The rest of the list is appended unchanged.

 Keywords and function definition names are ignored."
 Keywords and function definition names are ignored."

-  (let* (occurs
+  (let* ((w-start (window-start))
+         (w-end (window-end))
+         (start-point (point))
+         occurs

          (noccurs
          (noccurs

-          (cl-delete-if
-           (lambda (candidate)
-             (when (or
-                    (save-excursion
-                      (progn (forward-char (- (length company-prefix)))
-                             (search-backward candidate (window-start) t)))
-                    (save-excursion
-                      (search-forward candidate (window-end) t)))
-               (let ((beg (match-beginning 0))
-                     (end (match-end 0)))
-                 (when (save-excursion
-                         (goto-char end)
-                         (and (not (memq (get-text-property (point) 'face)
-                                         '(font-lock-function-name-face
-                                           font-lock-keyword-face)))
-                              (let ((prefix (company--prefix-str
-                                             (company-call-backend 'prefix))))
-                                (and (stringp prefix)
-                                     (= (length prefix) (- end beg))))))
-                   (push (cons candidate (if (< beg (point))
-                                             (- (point) end)
-                                           (- beg (window-start))))
-                         occurs)
-                   t))))
-           candidates)))
+          (save-excursion
+            (cl-delete-if
+             (lambda (candidate)
+               (when (catch 'done
+                       (goto-char w-start)
+                       (while (search-forward candidate w-end t)
+                         (when (and (not (eq (point) start-point))
+                                    (save-match-data
+                                      (company--occurrence-predicate)))
+                           (throw 'done t))))
+                 (push
+                  (cons candidate
+                        (funcall company-occurrence-weight-function
+                                 start-point
+                                 (match-beginning 0)
+                                 (match-end 0)))
+                  occurs)
+                 t))
+             candidates))))

     (nconc
      (mapcar #'car (sort occurs (lambda (e1 e2) (<= (cdr e1) (cdr e2)))))
      noccurs)))
 
     (nconc
      (mapcar #'car (sort occurs (lambda (e1 e2) (<= (cdr e1) (cdr e2)))))
      noccurs)))
 

+(defun company--occurrence-predicate ()
+  (let ((beg (match-beginning 0))
+        (end (match-end 0)))
+    (save-excursion
+      (goto-char end)
+      (and (not (memq (get-text-property (1- (point)) 'face)
+                      '(font-lock-function-name-face
+                        font-lock-keyword-face)))
+           (let ((prefix (company--prefix-str
+                          (company-call-backend 'prefix))))
+             (and (stringp prefix)
+                  (= (length prefix) (- end beg))))))))
+

 (defun company-sort-by-backend-importance (candidates)
   "Sort CANDIDATES as two priority groups.
 If `company-backend' is a function, do nothing.  If it's a list, move
 (defun company-sort-by-backend-importance (candidates)
   "Sort CANDIDATES as two priority groups.
 If `company-backend' is a function, do nothing.  If it's a list, move


@@ -1249,24 +1275,23 @@ from the rest of the back-ends in the group, if any, will be left at the end."
        (eq tick (buffer-chars-modified-tick))
        (eq pos (point))
        (when (company-auto-begin)
        (eq tick (buffer-chars-modified-tick))
        (eq pos (point))
        (when (company-auto-begin)

-         (when (version< emacs-version "24.3.50")
-           (company-input-noop))
-         (company-post-command))))
+         (company-input-noop)
+         (let ((this-command 'company-idle-begin))
+           (company-post-command)))))

 
 (defun company-auto-begin ()
   (and company-mode
        (not company-candidates)
 
 (defun company-auto-begin ()
   (and company-mode
        (not company-candidates)

-       (let ((company-idle-delay t))
+       (let ((company-idle-delay 'now))

          (condition-case-unless-debug err
          (condition-case-unless-debug err

-             (company--perform)
+             (progn
+               (company--perform)
+               ;; Return non-nil if active.
+               company-candidates)

            (error (message "Company: An error occurred in auto-begin")
                   (message "%s" (error-message-string err))
                   (company-cancel))
            (error (message "Company: An error occurred in auto-begin")
                   (message "%s" (error-message-string err))
                   (company-cancel))

-           (quit (company-cancel)))))
-  (unless company-candidates
-    (setq company-backend nil))
-  ;; Return non-nil if active.
-  company-candidates)
+           (quit (company-cancel))))))

 
 (defun company-manual-begin ()
   (interactive)
 
 (defun company-manual-begin ()
   (interactive)


@@ -1274,7 +1299,8 @@ from the rest of the back-ends in the group, if any, will be left at the end."
   (setq company--manual-action t)
   (unwind-protect
       (let ((company-minimum-prefix-length 0))
   (setq company--manual-action t)
   (unwind-protect
       (let ((company-minimum-prefix-length 0))

-        (company-auto-begin))
+        (or company-candidates
+            (company-auto-begin)))

     (unless company-candidates
       (setq company--manual-action nil))))
 
     (unless company-candidates
       (setq company--manual-action nil))))
 


@@ -1336,6 +1362,7 @@ from the rest of the back-ends in the group, if any, will be left at the end."
      ((and (or (not (company-require-match-p))
                ;; Don't require match if the new prefix
                ;; doesn't continue the old one, and the latter was a match.
      ((and (or (not (company-require-match-p))
                ;; Don't require match if the new prefix
                ;; doesn't continue the old one, and the latter was a match.

+               (not (stringp new-prefix))

                (<= (length new-prefix) (length company-prefix)))
            (member company-prefix company-candidates))
       ;; Last input was a success,
                (<= (length new-prefix) (length company-prefix)))
            (member company-prefix company-candidates))
       ;; Last input was a success,


@@ -1425,12 +1452,8 @@ from the rest of the back-ends in the group, if any, will be left at the end."
 (defun company--perform ()
   (or (and company-candidates (company--continue))
       (and (company--should-complete) (company--begin-new)))
 (defun company--perform ()
   (or (and company-candidates (company--continue))
       (and (company--should-complete) (company--begin-new)))

-  (when company-candidates
-    (let ((modified (buffer-modified-p)))
-      (when (and company-end-of-buffer-workaround (eobp))
-        (save-excursion (insert "\n"))
-        (setq company-added-newline
-              (or modified (buffer-chars-modified-tick)))))
+  (if (not company-candidates)
+      (setq company-backend nil)

     (setq company-point (point)
           company--point-max (point-max))
     (company-ensure-emulation-alist)
     (setq company-point (point)
           company--point-max (point-max))
     (company-ensure-emulation-alist)


@@ -1438,14 +1461,6 @@ from the rest of the back-ends in the group, if any, will be left at the end."
     (company-call-frontends 'update)))
 
 (defun company-cancel (&optional result)
     (company-call-frontends 'update)))
 
 (defun company-cancel (&optional result)

-  (and company-added-newline
-       (> (point-max) (point-min))
-       (let ((tick (buffer-chars-modified-tick)))
-         (delete-region (1- (point-max)) (point-max))
-         (equal tick company-added-newline))
-       ;; Only set unmodified when tick remained the same since insert,
-       ;; and the buffer wasn't modified before.
-       (set-buffer-modified-p nil))

   (unwind-protect
       (when company-prefix
         (if (stringp result)
   (unwind-protect
       (when company-prefix
         (if (stringp result)


@@ -1454,8 +1469,7 @@ from the rest of the back-ends in the group, if any, will be left at the end."
               (run-hook-with-args 'company-completion-finished-hook result)
               (company-call-backend 'post-completion result))
           (run-hook-with-args 'company-completion-cancelled-hook result)))
               (run-hook-with-args 'company-completion-finished-hook result)
               (company-call-backend 'post-completion result))
           (run-hook-with-args 'company-completion-cancelled-hook result)))

-    (setq company-added-newline nil
-          company-backend nil
+    (setq company-backend nil

           company-prefix nil
           company-candidates nil
           company-candidates-length nil
           company-prefix nil
           company-candidates nil
           company-candidates-length nil


@@ -1490,7 +1504,7 @@ from the rest of the back-ends in the group, if any, will be left at the end."
 
 (defun company-pre-command ()
   (unless (company-keep this-command)
 
 (defun company-pre-command ()
   (unless (company-keep this-command)

-    (condition-case err
+    (condition-case-unless-debug err

         (when company-candidates
           (company-call-frontends 'pre-command)
           (unless (company--should-continue)
         (when company-candidates
           (company-call-frontends 'pre-command)
           (unless (company--should-continue)


@@ -1504,13 +1518,18 @@ from the rest of the back-ends in the group, if any, will be left at the end."
   (company-uninstall-map))
 
 (defun company-post-command ()
   (company-uninstall-map))
 
 (defun company-post-command ()

+  (when (null this-command)
+    ;; Happens when the user presses `C-g' while inside
+    ;; `flyspell-post-command-hook', for example.
+    ;; Or any other `post-command-hook' function that can call `sit-for',
+    ;; or any quittable timer function.
+    (company-abort)
+    (setq this-command 'company-abort))

   (unless (company-keep this-command)
   (unless (company-keep this-command)

-    (condition-case err
+    (condition-case-unless-debug err

         (progn
           (unless (equal (point) company-point)
         (progn
           (unless (equal (point) company-point)

-            (let ((company-idle-delay (and (eq company-idle-delay t)
-                                           (company--should-begin)
-                                           t)))
+            (let (company-idle-delay) ; Against misbehavior while debugging.

               (company--perform)))
           (if company-candidates
               (company-call-frontends 'post-command)
               (company--perform)))
           (if company-candidates
               (company-call-frontends 'post-command)


@@ -1544,15 +1563,16 @@ from the rest of the back-ends in the group, if any, will be left at the end."
 
 ;;; search ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
 ;;; search ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 

-(defvar-local company-search-string nil)
+(defvar-local company-search-string "")

 
 (defvar-local company-search-lighter " Search: \"\"")
 
 
 (defvar-local company-search-lighter " Search: \"\"")
 

-(defvar-local company-search-old-map nil)
+(defvar-local company-search-filtering nil
+  "Non-nil to filter the completion candidates by the search string")

 
 

-(defvar-local company-search-old-selection 0)
+(defvar-local company--search-old-selection 0)

 
 

-(defun company-search (text lines)
+(defun company--search (text lines)

   (let ((quoted (regexp-quote text))
         (i 0))
     (cl-dolist (line lines)
   (let ((quoted (regexp-quote text))
         (i 0))
     (cl-dolist (line lines)


@@ -1560,26 +1580,53 @@ from the rest of the back-ends in the group, if any, will be left at the end."
         (cl-return i))
       (cl-incf i))))
 
         (cl-return i))
       (cl-incf i))))
 

+(defun company-search-keypad ()
+  (interactive)
+  (let* ((name (symbol-name last-command-event))
+         (last-command-event (aref name (1- (length name)))))
+    (company-search-printing-char)))
+

 (defun company-search-printing-char ()
   (interactive)
 (defun company-search-printing-char ()
   (interactive)

-  (company-search-assert-enabled)
-  (setq company-search-string
-        (concat (or company-search-string "") (string last-command-event))
-        company-search-lighter (concat " Search: \"" company-search-string
-                                       "\""))
-  (let ((pos (company-search company-search-string
-                             (nthcdr company-selection company-candidates))))
+  (company--search-assert-enabled)
+  (let ((ss (concat company-search-string (string last-command-event))))
+    (when company-search-filtering
+      (company--search-update-predicate ss))
+    (company--search-update-string ss)))
+
+(defun company--search-update-predicate (&optional ss)
+  (or ss (setq ss company-search-string))
+  (let* ((company-candidates-predicate
+          (when company-search-filtering
+            (lambda (candidate) (string-match ss candidate))))
+         (cc (company-calculate-candidates company-prefix)))
+    (unless cc (error "No match"))
+    (company-update-candidates cc)))
+
+(defun company--search-update-string (new)
+  (let* ((pos (company--search new (nthcdr company-selection company-candidates))))

     (if (null pos)
         (ding)
     (if (null pos)
         (ding)

+      (setq company-search-string new
+            company-search-lighter (format " %s: \"%s\""
+                                           (if company-search-filtering
+                                               "Filter"
+                                             "Search")
+                                           new))

       (company-set-selection (+ company-selection pos) t))))
 
       (company-set-selection (+ company-selection pos) t))))
 

+(defun company--search-assert-input ()
+  (company--search-assert-enabled)
+  (unless (cl-plusp (length company-search-string))
+    (error "Empty search string")))
+

 (defun company-search-repeat-forward ()
   "Repeat the incremental search in completion candidates forward."
   (interactive)
 (defun company-search-repeat-forward ()
   "Repeat the incremental search in completion candidates forward."
   (interactive)

-  (company-search-assert-enabled)
-  (let ((pos (company-search company-search-string
-                             (cdr (nthcdr company-selection
-                                          company-candidates)))))
+  (company--search-assert-input)
+  (let ((pos (company--search company-search-string
+                              (cdr (nthcdr company-selection
+                                           company-candidates)))))

     (if (null pos)
         (ding)
       (company-set-selection (+ company-selection pos 1) t))))
     (if (null pos)
         (ding)
       (company-set-selection (+ company-selection pos 1) t))))


@@ -1587,56 +1634,47 @@ from the rest of the back-ends in the group, if any, will be left at the end."
 (defun company-search-repeat-backward ()
   "Repeat the incremental search in completion candidates backwards."
   (interactive)
 (defun company-search-repeat-backward ()
   "Repeat the incremental search in completion candidates backwards."
   (interactive)

-  (company-search-assert-enabled)
-  (let ((pos (company-search company-search-string
-                             (nthcdr (- company-candidates-length
-                                        company-selection)
-                                     (reverse company-candidates)))))
+  (company--search-assert-input)
+  (let ((pos (company--search company-search-string
+                              (nthcdr (- company-candidates-length
+                                         company-selection)
+                                      (reverse company-candidates)))))

     (if (null pos)
         (ding)
       (company-set-selection (- company-selection pos 1) t))))
 
     (if (null pos)
         (ding)
       (company-set-selection (- company-selection pos 1) t))))
 

-(defun company-create-match-predicate ()
-  (setq company-candidates-predicate
-        `(lambda (candidate)
-           ,(if company-candidates-predicate
-                `(and (string-match ,company-search-string candidate)
-                      (funcall ,company-candidates-predicate
-                               candidate))
-              `(string-match ,company-search-string candidate))))
-  (company-update-candidates
-   (company-apply-predicate company-candidates company-candidates-predicate))
-  ;; Invalidate cache.
-  (setq company-candidates-cache (cons company-prefix company-candidates)))
-
-(defun company-filter-printing-char ()
-  (interactive)
-  (company-search-assert-enabled)
-  (company-search-printing-char)
-  (company-create-match-predicate)
-  (company-call-frontends 'update))
-
-(defun company-search-kill-others ()
-  "Limit the completion candidates to the ones matching the search string."
+(defun company-search-toggle-filtering ()
+  "Toggle `company-search-filtering'."

   (interactive)
   (interactive)

-  (company-search-assert-enabled)
-  (company-create-match-predicate)
-  (company-search-mode 0)
-  (company-call-frontends 'update))
+  (company--search-assert-enabled)
+  (setq company-search-filtering (not company-search-filtering))
+  (let ((ss company-search-string))
+    (company--search-update-predicate ss)
+    (company--search-update-string ss)))

 
 (defun company-search-abort ()
   "Abort searching the completion candidates."
   (interactive)
 
 (defun company-search-abort ()
   "Abort searching the completion candidates."
   (interactive)

-  (company-search-assert-enabled)
-  (company-set-selection company-search-old-selection t)
+  (company--search-assert-enabled)
+  (company--search-update-predicate "")
+  (company-set-selection company--search-old-selection t)

   (company-search-mode 0))
 
 (defun company-search-other-char ()
   (interactive)
   (company-search-mode 0))
 
 (defun company-search-other-char ()
   (interactive)

-  (company-search-assert-enabled)
+  (company--search-assert-enabled)

   (company-search-mode 0)
   (company--unread-last-input))
 
   (company-search-mode 0)
   (company--unread-last-input))
 

+(defun company-search-delete-char ()
+  (interactive)
+  (company--search-assert-enabled)
+  (when (cl-plusp (length company-search-string))
+    (let ((ss (substring company-search-string 0 -1)))
+      (when company-search-filtering
+        (company--search-update-predicate ss))
+      (company--search-update-string ss))))
+

 (defvar company-search-map
   (let ((i 0)
         (keymap (make-keymap)))
 (defvar company-search-map
   (let ((i 0)
         (keymap (make-keymap)))


@@ -1657,18 +1695,22 @@ from the rest of the back-ends in the group, if any, will be left at the end."
     (while (< i 256)
       (define-key keymap (vector i) 'company-search-printing-char)
       (cl-incf i))
     (while (< i 256)
       (define-key keymap (vector i) 'company-search-printing-char)
       (cl-incf i))

+    (dotimes (i 10)
+      (define-key keymap (read (format "[kp-%s]" i)) 'company-search-keypad))

     (let ((meta-map (make-sparse-keymap)))
       (define-key keymap (char-to-string meta-prefix-char) meta-map)
       (define-key keymap [escape] meta-map))
     (define-key keymap (vector meta-prefix-char t) 'company-search-other-char)
     (let ((meta-map (make-sparse-keymap)))
       (define-key keymap (char-to-string meta-prefix-char) meta-map)
       (define-key keymap [escape] meta-map))
     (define-key keymap (vector meta-prefix-char t) 'company-search-other-char)

+    (define-key keymap (kbd "M-n") 'company-select-next)
+    (define-key keymap (kbd "M-p") 'company-select-previous)

     (define-key keymap "\e\e\e" 'company-search-other-char)
     (define-key keymap [escape escape escape] 'company-search-other-char)
     (define-key keymap "\e\e\e" 'company-search-other-char)
     (define-key keymap [escape escape escape] 'company-search-other-char)

-    (define-key keymap (kbd "DEL") 'company-search-other-char)
-
+    (define-key keymap (kbd "DEL") 'company-search-delete-char)
+    (define-key keymap [backspace] 'company-search-delete-char)

     (define-key keymap "\C-g" 'company-search-abort)
     (define-key keymap "\C-s" 'company-search-repeat-forward)
     (define-key keymap "\C-r" 'company-search-repeat-backward)
     (define-key keymap "\C-g" 'company-search-abort)
     (define-key keymap "\C-s" 'company-search-repeat-forward)
     (define-key keymap "\C-r" 'company-search-repeat-backward)

-    (define-key keymap "\C-o" 'company-search-kill-others)
+    (define-key keymap "\C-o" 'company-search-toggle-filtering)

     keymap)
   "Keymap used for incrementally searching the completion candidates.")
 
     keymap)
   "Keymap used for incrementally searching the completion candidates.")
 


@@ -1680,15 +1722,16 @@ Don't start this directly, use `company-search-candidates' or
   (if company-search-mode
       (if (company-manual-begin)
           (progn
   (if company-search-mode
       (if (company-manual-begin)
           (progn

-            (setq company-search-old-selection company-selection)
+            (setq company--search-old-selection company-selection)

             (company-call-frontends 'update))
         (setq company-search-mode nil))
     (kill-local-variable 'company-search-string)
     (kill-local-variable 'company-search-lighter)
             (company-call-frontends 'update))
         (setq company-search-mode nil))
     (kill-local-variable 'company-search-string)
     (kill-local-variable 'company-search-lighter)

-    (kill-local-variable 'company-search-old-selection)
+    (kill-local-variable 'company-search-filtering)
+    (kill-local-variable 'company--search-old-selection)

     (company-enable-overriding-keymap company-active-map)))
 
     (company-enable-overriding-keymap company-active-map)))
 

-(defun company-search-assert-enabled ()
+(defun company--search-assert-enabled ()

   (company-assert-enabled)
   (unless company-search-mode
     (company-uninstall-map)
   (company-assert-enabled)
   (unless company-search-mode
     (company-uninstall-map)


@@ -1701,11 +1744,12 @@ Don't start this directly, use `company-search-candidates' or
 - `company-search-repeat-forward' (\\[company-search-repeat-forward])
 - `company-search-repeat-backward' (\\[company-search-repeat-backward])
 - `company-search-abort' (\\[company-search-abort])
 - `company-search-repeat-forward' (\\[company-search-repeat-forward])
 - `company-search-repeat-backward' (\\[company-search-repeat-backward])
 - `company-search-abort' (\\[company-search-abort])

+- `company-search-delete-char' (\\[company-search-delete-char])

 
 Regular characters are appended to the search string.
 
 
 Regular characters are appended to the search string.
 

-The command `company-search-kill-others' (\\[company-search-kill-others])
-uses the search string to limit the completion candidates."
+The command `company-search-toggle-filtering' (\\[company-search-toggle-filtering])
+uses the search string to filter the completion candidates."

   (interactive)
   (company-search-mode 1)
   (company-enable-overriding-keymap company-search-map))
   (interactive)
   (company-search-mode 1)
   (company-enable-overriding-keymap company-search-map))


@@ -1721,10 +1765,10 @@ uses the search string to limit the completion candidates."
 (defun company-filter-candidates ()
   "Start filtering the completion candidates incrementally.
 This works the same way as `company-search-candidates' immediately
 (defun company-filter-candidates ()
   "Start filtering the completion candidates incrementally.
 This works the same way as `company-search-candidates' immediately

-followed by `company-search-kill-others' after each input."
+followed by `company-search-toggle-filtering'."

   (interactive)
   (company-search-mode 1)
   (interactive)
   (company-search-mode 1)

-  (company-enable-overriding-keymap company-filter-map))
+  (setq company-search-filtering t))

 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 


@@ -1777,14 +1821,7 @@ and invoke the normal binding."
                 (>= evt-row (+ row height)))))))
 
 (defun company--event-col-row (event)
                 (>= evt-row (+ row height)))))))
 
 (defun company--event-col-row (event)

-  (let* ((col-row (posn-actual-col-row (event-start event)))
-         (col (car col-row))
-         (row (cdr col-row)))
-    (cl-incf col (window-hscroll))
-    (and header-line-format
-         (version< "24" emacs-version)
-         (cl-decf row))
-    (cons col row)))
+  (company--posn-col-row (event-start event)))

 
 (defun company-select-mouse (event)
   "Select the candidate picked by the mouse."
 
 (defun company-select-mouse (event)
   "Select the candidate picked by the mouse."


@@ -1835,6 +1872,16 @@ and invoke the normal binding."
       (when company-common
         (company--insert-candidate company-common)))))
 
       (when company-common
         (company--insert-candidate company-common)))))
 

+(defun company-complete-common-or-cycle ()
+  "Insert the common part of all candidates, or select the next one."
+  (interactive)
+  (when (company-manual-begin)
+    (let ((tick (buffer-chars-modified-tick)))
+      (call-interactively 'company-complete-common)
+      (when (eq tick (buffer-chars-modified-tick))
+        (let ((company-selection-wrap-around t))
+          (call-interactively 'company-select-next))))))
+

 (defun company-complete ()
   "Insert the common part of all candidates or the current selection.
 The first time this is called, the common part is inserted, the second
 (defun company-complete ()
   "Insert the common part of all candidates or the current selection.
 The first time this is called, the common part is inserted, the second


@@ -1849,14 +1896,26 @@ inserted."
       (setq this-command 'company-complete-common))))
 
 (defun company-complete-number (n)
       (setq this-command 'company-complete-common))))
 
 (defun company-complete-number (n)

-  "Insert the Nth candidate.
+  "Insert the Nth candidate visible in the tooltip.

 To show the number next to the candidates in some back-ends, enable
 To show the number next to the candidates in some back-ends, enable

-`company-show-numbers'."
+`company-show-numbers'.  When called interactively, uses the last typed
+character, stripping the modifiers.  That character must be a digit."
+  (interactive
+   (list (let* ((type (event-basic-type last-command-event))
+                (char (if (characterp type)
+                          ;; Number on the main row.
+                          type
+                        ;; Keypad number, if bound directly.
+                        (car (last (string-to-list (symbol-name type))))))
+                (n (- char ?0)))
+           (if (zerop n) 10 n))))

   (when (company-manual-begin)
   (when (company-manual-begin)

-    (and (or (< n 1) (> n company-candidates-length))
+    (and (or (< n 1) (> n (- company-candidates-length
+                             company-tooltip-offset)))

          (error "No candidate number %d" n))
     (cl-decf n)
          (error "No candidate number %d" n))
     (cl-decf n)

-    (company-finish (nth n company-candidates))))
+    (company-finish (nth (+ n company-tooltip-offset)
+                         company-candidates))))

 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 


@@ -2078,8 +2137,10 @@ If SHOW-VERSION is non-nil, show the version in the echo area."
 
 (defun company-fill-propertize (value annotation width selected left right)
   (let* ((margin (length left))
 
 (defun company-fill-propertize (value annotation width selected left right)
   (let* ((margin (length left))

-         (common (+ (or (company-call-backend 'match value)
-                        (length company-common)) margin))
+         (common (or (company-call-backend 'match value)
+                     (if company-common
+                         (string-width company-common)
+                       0)))

          (ann-ralign company-tooltip-align-annotations)
          (ann-truncate (< width
                           (+ (length value) (length annotation)
          (ann-ralign company-tooltip-align-annotations)
          (ann-truncate (< width
                           (+ (length value) (length annotation)


@@ -2103,6 +2164,7 @@ If SHOW-VERSION is non-nil, show the version in the echo area."
                                                   (- width (length annotation)))
                           annotation))
                        right)))
                                                   (- width (length annotation)))
                           annotation))
                        right)))

+    (setq common (+ (min common width) margin))

     (setq width (+ width margin (length right)))
 
     (add-text-properties 0 width '(face company-tooltip
     (setq width (+ width margin (length right)))
 
     (add-text-properties 0 width '(face company-tooltip


@@ -2118,17 +2180,13 @@ If SHOW-VERSION is non-nil, show the version in the echo area."
                              mouse-face company-tooltip-mouse)
                            line))
     (when selected
                              mouse-face company-tooltip-mouse)
                            line))
     (when selected

-      (if (and company-search-string
+      (if (and (cl-plusp (length company-search-string))

                (string-match (regexp-quote company-search-string) value
                              (length company-prefix)))
           (let ((beg (+ margin (match-beginning 0)))
                 (end (+ margin (match-end 0))))
                (string-match (regexp-quote company-search-string) value
                              (length company-prefix)))
           (let ((beg (+ margin (match-beginning 0)))
                 (end (+ margin (match-end 0))))

-            (add-text-properties beg end '(face company-tooltip-selection)
-                                 line)
-            (when (< beg common)
-              (add-text-properties beg common
-                                   '(face company-tooltip-common-selection)
-                                   line)))
+            (add-text-properties beg end '(face company-tooltip-search)
+                                 line))

         (add-text-properties 0 width '(face company-tooltip-selection
                                        mouse-face company-tooltip-selection)
                              line)
         (add-text-properties 0 width '(face company-tooltip-selection
                                        mouse-face company-tooltip-selection)
                              line)


@@ -2138,12 +2196,32 @@ If SHOW-VERSION is non-nil, show the version in the echo area."
                              line)))
     line))
 
                              line)))
     line))
 

+(defun company--clean-string (str)
+  (replace-regexp-in-string
+   "\\([^[:graph:] ]\\)\\|\\(\ufeff\\)\\|[[:multibyte:]]"
+   (lambda (match)
+     (cond
+      ((match-beginning 1)
+       ;; FIXME: Better char for 'non-printable'?
+       ;; We shouldn't get any of these, but sometimes we might.
+       "\u2017")
+      ((match-beginning 2)
+       ;; Zero-width non-breakable space.
+       "")
+      ((> (string-width match) 1)
+       (concat
+        (make-string (1- (string-width match)) ?\ufeff)
+        match))
+      (t match)))
+   str))
+

 ;;; replace
 
 (defun company-buffer-lines (beg end)
   (goto-char beg)
 ;;; replace
 
 (defun company-buffer-lines (beg end)
   (goto-char beg)

-  (let (lines)
-    (while (and (= 1 (vertical-motion 1))
+  (let (lines lines-moved)
+    (while (and (not (eobp)) ; http://debbugs.gnu.org/19553
+                (> (setq lines-moved (vertical-motion 1)) 0)

                 (<= (point) end))
       (let ((bound (min end (1- (point)))))
         ;; A visual line can contain several physical lines (e.g. with outline's
                 (<= (point) end))
       (let ((bound (min end (1- (point)))))
         ;; A visual line can contain several physical lines (e.g. with outline's


@@ -2154,6 +2232,10 @@ If SHOW-VERSION is non-nil, show the version in the echo area."
                                   (re-search-forward "$" bound 'move)
                                   (point)))
               lines))
                                   (re-search-forward "$" bound 'move)
                                   (point)))
               lines))

+      ;; One physical line can be displayed as several visual ones as well:
+      ;; add empty strings to the list, to even the count.
+      (dotimes (_ (1- lines-moved))
+        (push "" lines))

       (setq beg (point)))
     (unless (eq beg end)
       (push (buffer-substring beg end) lines))
       (setq beg (point)))
     (unless (eq beg end)
       (push (buffer-substring beg end) lines))


@@ -2169,6 +2251,30 @@ If SHOW-VERSION is non-nil, show the version in the echo area."
       limit
     (length lst)))
 
       limit
     (length lst)))
 

+(defsubst company--window-height ()
+  (if (fboundp 'window-screen-lines)
+      (floor (window-screen-lines))
+    (window-body-height)))
+
+(defun company--window-width ()
+  (let ((ww (window-body-width)))
+    ;; Account for the line continuation column.
+    (when (zerop (cadr (window-fringes)))
+      (cl-decf ww))
+    (unless (or (display-graphic-p)
+                (version< "24.3.1" emacs-version))
+      ;; Emacs 24.3 and earlier included margins
+      ;; in window-width when in TTY.
+      (cl-decf ww
+               (let ((margins (window-margins)))
+                 (+ (or (car margins) 0)
+                    (or (cdr margins) 0)))))
+    (when (and word-wrap
+               (version< emacs-version "24.4.51.5"))
+      ;; http://debbugs.gnu.org/18384
+      (cl-decf ww))
+    ww))
+

 (defun company--replacement-string (lines old column nl &optional align-top)
   (cl-decf column company-tooltip-margin)
 
 (defun company--replacement-string (lines old column nl &optional align-top)
   (cl-decf column company-tooltip-margin)
 


@@ -2193,17 +2299,20 @@ If SHOW-VERSION is non-nil, show the version in the echo area."
     (while old
       (push (company-modify-line (pop old)
                                  (company--offset-line (pop lines) offset)
     (while old
       (push (company-modify-line (pop old)
                                  (company--offset-line (pop lines) offset)

-                                 column) new))
+                                 column)
+            new))

     ;; Append whole new lines.
     (while lines
       (push (concat (company-space-string column)
                     (company--offset-line (pop lines) offset))
             new))
 
     ;; Append whole new lines.
     (while lines
       (push (concat (company-space-string column)
                     (company--offset-line (pop lines) offset))
             new))
 

-    (let ((str (concat (when nl "\n")
+    (let ((str (concat (when nl " ")
+                       "\n"

                        (mapconcat 'identity (nreverse new) "\n")
                        "\n")))
       (font-lock-append-text-property 0 (length str) 'face 'default str)
                        (mapconcat 'identity (nreverse new) "\n")
                        "\n")))
       (font-lock-append-text-property 0 (length str) 'face 'default str)

+      (when nl (put-text-property 0 1 'cursor t str))

       str)))
 
 (defun company--offset-line (line offset)
       str)))
 
 (defun company--offset-line (line offset)


@@ -2213,7 +2322,6 @@ If SHOW-VERSION is non-nil, show the version in the echo area."
 
 (defun company--create-lines (selection limit)
   (let ((len company-candidates-length)
 
 (defun company--create-lines (selection limit)
   (let ((len company-candidates-length)

-        (numbered 99999)

         (window-width (company--window-width))
         lines
         width
         (window-width (company--window-width))
         lines
         width


@@ -2255,9 +2363,12 @@ If SHOW-VERSION is non-nil, show the version in the echo area."
     (dotimes (_ len)
       (let* ((value (pop lines-copy))
              (annotation (company-call-backend 'annotation value)))
     (dotimes (_ len)
       (let* ((value (pop lines-copy))
              (annotation (company-call-backend 'annotation value)))

-        (when (and annotation company-tooltip-align-annotations)
-          ;; `lisp-completion-at-point' adds a space.
-          (setq annotation (comment-string-strip annotation t nil)))
+        (setq value (company--clean-string value))
+        (when annotation
+          (when company-tooltip-align-annotations
+            ;; `lisp-completion-at-point' adds a space.
+            (setq annotation (comment-string-strip annotation t nil)))
+          (setq annotation (company--clean-string annotation)))

         (push (cons value annotation) items)
         (setq width (max (+ (length value)
                             (if (and annotation company-tooltip-align-annotations)
         (push (cons value annotation) items)
         (setq width (max (+ (length value)
                             (if (and annotation company-tooltip-align-annotations)


@@ -2267,16 +2378,13 @@ If SHOW-VERSION is non-nil, show the version in the echo area."
 
     (setq width (min window-width
                      (max company-tooltip-minimum-width
 
     (setq width (min window-width
                      (max company-tooltip-minimum-width

-                          (if (and company-show-numbers
-                                   (< company-tooltip-offset 10))
+                          (if company-show-numbers

                               (+ 2 width)
                             width))))
 
                               (+ 2 width)
                             width))))
 

-    ;; number can make tooltip too long
-    (when company-show-numbers
-      (setq numbered company-tooltip-offset))
-
-    (let ((items (nreverse items)) new)
+    (let ((items (nreverse items))
+          (numbered (if company-show-numbers 0 99999))
+          new)

       (when previous
         (push (company--scrollpos-line previous width) new))
 
       (when previous
         (push (company--scrollpos-line previous width) new))
 


@@ -2326,30 +2434,11 @@ If SHOW-VERSION is non-nil, show the version in the echo area."
 
 ;; show
 
 
 ;; show
 

-(defsubst company--window-inner-height ()
-  (let ((edges (window-inside-edges)))
-    (- (nth 3 edges) (nth 1 edges))))
-
-(defsubst company--window-width ()
-  (let ((ww (window-width)))
-    ;; Account for the line continuation column.
-    (when (zerop (cadr (window-fringes)))
-      (cl-decf ww))
-    (unless (or (display-graphic-p)
-                (version< "24.3.1" emacs-version))
-      ;; Emacs 24.3 and earlier included margins
-      ;; in window-width when in TTY.
-      (cl-decf ww
-               (let ((margins (window-margins)))
-                 (+ (or (car margins) 0)
-                    (or (cdr margins) 0)))))
-    ww))
-

 (defun company--pseudo-tooltip-height ()
   "Calculate the appropriate tooltip height.
 Returns a negative number if the tooltip should be displayed above point."
   (let* ((lines (company--row))
 (defun company--pseudo-tooltip-height ()
   "Calculate the appropriate tooltip height.
 Returns a negative number if the tooltip should be displayed above point."
   (let* ((lines (company--row))

-         (below (- (company--window-inner-height) 1 lines)))
+         (below (- (company--window-height) 1 lines)))

     (if (and (< below (min company-tooltip-minimum company-candidates-length))
              (> lines below))
         (- (max 3 (min company-tooltip-limit lines)))
     (if (and (< below (min company-tooltip-minimum company-candidates-length))
              (> lines below))
         (- (max 3 (min company-tooltip-limit lines)))


@@ -2371,7 +2460,7 @@ Returns a negative number if the tooltip should be displayed above point."
              (end (save-excursion
                     (move-to-window-line (+ row (abs height)))
                     (point)))
              (end (save-excursion
                     (move-to-window-line (+ row (abs height)))
                     (point)))

-             (ov (make-overlay beg end))
+             (ov (make-overlay (if nl beg (1- beg)) end nil t))

              (args (list (mapcar 'company-plainify
                                  (company-buffer-lines beg end))
                          column nl above)))
              (args (list (mapcar 'company-plainify
                                  (company-buffer-lines beg end))
                          column nl above)))


@@ -2380,7 +2469,7 @@ Returns a negative number if the tooltip should be displayed above point."
         (overlay-put ov 'company-replacement-args args)
 
         (let ((lines (company--create-lines selection (abs height))))
         (overlay-put ov 'company-replacement-args args)
 
         (let ((lines (company--create-lines selection (abs height))))

-          (overlay-put ov 'company-after
+          (overlay-put ov 'company-display

                        (apply 'company--replacement-string lines args))
           (overlay-put ov 'company-width (string-width (car lines))))
 
                        (apply 'company--replacement-string lines args))
           (overlay-put ov 'company-width (string-width (car lines))))
 


@@ -2388,17 +2477,17 @@ Returns a negative number if the tooltip should be displayed above point."
         (overlay-put ov 'company-height height)))))
 
 (defun company-pseudo-tooltip-show-at-point (pos column-offset)
         (overlay-put ov 'company-height height)))))
 
 (defun company-pseudo-tooltip-show-at-point (pos column-offset)

-  (let ((row (company--row pos))
-        (col (- (company--column pos) column-offset)))
+  (let* ((col-row (company--col-row pos))
+         (col (- (car col-row) column-offset)))

     (when (< col 0) (setq col 0))
     (when (< col 0) (setq col 0))

-    (company-pseudo-tooltip-show (1+ row) col company-selection)))
+    (company-pseudo-tooltip-show (1+ (cdr col-row)) col company-selection)))

 
 (defun company-pseudo-tooltip-edit (selection)
   (let* ((height (overlay-get company-pseudo-tooltip-overlay 'company-height))
          (lines  (company--create-lines selection (abs height))))
     (overlay-put company-pseudo-tooltip-overlay 'company-width
                  (string-width (car lines)))
 
 (defun company-pseudo-tooltip-edit (selection)
   (let* ((height (overlay-get company-pseudo-tooltip-overlay 'company-height))
          (lines  (company--create-lines selection (abs height))))
     (overlay-put company-pseudo-tooltip-overlay 'company-width
                  (string-width (car lines)))

-    (overlay-put company-pseudo-tooltip-overlay 'company-after
+    (overlay-put company-pseudo-tooltip-overlay 'company-display

                  (apply 'company--replacement-string
                         lines
                         (overlay-get company-pseudo-tooltip-overlay
                  (apply 'company--replacement-string
                         lines
                         (overlay-get company-pseudo-tooltip-overlay


@@ -2412,43 +2501,51 @@ Returns a negative number if the tooltip should be displayed above point."
 (defun company-pseudo-tooltip-hide-temporarily ()
   (when (overlayp company-pseudo-tooltip-overlay)
     (overlay-put company-pseudo-tooltip-overlay 'invisible nil)
 (defun company-pseudo-tooltip-hide-temporarily ()
   (when (overlayp company-pseudo-tooltip-overlay)
     (overlay-put company-pseudo-tooltip-overlay 'invisible nil)

-    (overlay-put company-pseudo-tooltip-overlay 'line-prefix nil)

     (overlay-put company-pseudo-tooltip-overlay 'after-string nil)))
 
 (defun company-pseudo-tooltip-unhide ()
   (when company-pseudo-tooltip-overlay
     (overlay-put company-pseudo-tooltip-overlay 'after-string nil)))
 
 (defun company-pseudo-tooltip-unhide ()
   (when company-pseudo-tooltip-overlay

-    (overlay-put company-pseudo-tooltip-overlay 'invisible t)
-    ;; Beat outline's folding overlays, at least.
-    (overlay-put company-pseudo-tooltip-overlay 'priority 1)
-    ;; No (extra) prefix for the first line.
-    (overlay-put company-pseudo-tooltip-overlay 'line-prefix "")
-    (overlay-put company-pseudo-tooltip-overlay 'after-string
-                 (overlay-get company-pseudo-tooltip-overlay 'company-after))
-    (overlay-put company-pseudo-tooltip-overlay 'window (selected-window))))
+    (let* ((ov company-pseudo-tooltip-overlay)
+           (disp (overlay-get ov 'company-display)))
+      ;; Beat outline's folding overlays, at least.
+      (overlay-put ov 'priority 1)
+      ;; `display' could be better (http://debbugs.gnu.org/18285), but it
+      ;; doesn't work when the overlay is empty, which is what happens at eob.
+      ;; It also seems to interact badly with `cursor'.
+      ;; We deal with priorities by having the overlay start before the newline.
+      (overlay-put ov 'after-string disp)
+      (overlay-put ov 'invisible t)
+      (overlay-put ov 'window (selected-window)))))

 
 (defun company-pseudo-tooltip-guard ()
 
 (defun company-pseudo-tooltip-guard ()

-  (buffer-substring-no-properties
-   (point) (overlay-start company-pseudo-tooltip-overlay)))
+  (cons
+   (save-excursion (beginning-of-visual-line))
+   (let ((ov company-pseudo-tooltip-overlay)
+         (overhang (save-excursion (end-of-visual-line)
+                                   (- (line-end-position) (point)))))
+     (when (>= (overlay-get ov 'company-height) 0)
+       (cons
+        (buffer-substring-no-properties (point) (overlay-start ov))
+        (when (>= overhang 0) overhang))))))

 
 (defun company-pseudo-tooltip-frontend (command)
   "`company-mode' front-end similar to a tooltip but based on overlays."
   (cl-case command
     (pre-command (company-pseudo-tooltip-hide-temporarily))
     (post-command
 
 (defun company-pseudo-tooltip-frontend (command)
   "`company-mode' front-end similar to a tooltip but based on overlays."
   (cl-case command
     (pre-command (company-pseudo-tooltip-hide-temporarily))
     (post-command

-     (let ((old-height (if (overlayp company-pseudo-tooltip-overlay)
-                           (overlay-get company-pseudo-tooltip-overlay
-                                        'company-height)
-                         0))
-           (new-height (company--pseudo-tooltip-height)))
-       (unless (and (>= (* old-height new-height) 0)
-                    (>= (abs old-height) (abs new-height))
-                    (equal (company-pseudo-tooltip-guard)
-                           (overlay-get company-pseudo-tooltip-overlay
-                                        'company-guard)))
-         ;; Redraw needed.
-         (company-pseudo-tooltip-show-at-point (point) (length company-prefix))
-         (overlay-put company-pseudo-tooltip-overlay
-                      'company-guard (company-pseudo-tooltip-guard))))
+     (unless (when (overlayp company-pseudo-tooltip-overlay)
+              (let* ((ov company-pseudo-tooltip-overlay)
+                     (old-height (overlay-get ov 'company-height))
+                     (new-height (company--pseudo-tooltip-height)))
+                (and
+                 (>= (* old-height new-height) 0)
+                 (>= (abs old-height) (abs new-height))
+                 (equal (company-pseudo-tooltip-guard)
+                        (overlay-get ov 'company-guard)))))
+       ;; Redraw needed.
+       (company-pseudo-tooltip-show-at-point (point) (length company-prefix))
+       (overlay-put company-pseudo-tooltip-overlay
+                    'company-guard (company-pseudo-tooltip-guard)))

      (company-pseudo-tooltip-unhide))
     (hide (company-pseudo-tooltip-hide)
           (setq company-tooltip-offset 0))
      (company-pseudo-tooltip-unhide))
     (hide (company-pseudo-tooltip-hide)
           (setq company-tooltip-offset 0))


@@ -2468,8 +2565,6 @@ Returns a negative number if the tooltip should be displayed above point."
 (defun company-preview-show-at-point (pos)
   (company-preview-hide)
 
 (defun company-preview-show-at-point (pos)
   (company-preview-hide)
 

-  (setq company-preview-overlay (make-overlay pos (1+ pos)))
-

   (let ((completion (nth company-selection company-candidates)))
     (setq completion (propertize completion 'face 'company-preview))
     (add-text-properties 0 (length company-common)
   (let ((completion (nth company-selection company-candidates)))
     (setq completion (propertize completion 'face 'company-preview))
     (add-text-properties 0 (length company-common)


@@ -2487,12 +2582,26 @@ Returns a negative number if the tooltip should be displayed above point."
 
     (and (equal pos (point))
          (not (equal completion ""))
 
     (and (equal pos (point))
          (not (equal completion ""))

-         (add-text-properties 0 1 '(cursor t) completion))
-
-    (overlay-put company-preview-overlay 'display
-                 (concat completion (unless (eq pos (point-max))
-                                      (buffer-substring pos (1+ pos)))))
-    (overlay-put company-preview-overlay 'window (selected-window))))
+         (add-text-properties 0 1 '(cursor 1) completion))
+
+    (let* ((beg pos)
+           (pto company-pseudo-tooltip-overlay)
+           (ptf-workaround (and
+                            pto
+                            (char-before pos)
+                            (eq pos (overlay-start pto)))))
+      ;; Try to accomodate for the pseudo-tooltip overlay,
+      ;; which may start at the same position if it's at eol.
+      (when ptf-workaround
+        (cl-decf beg)
+        (setq completion (concat (buffer-substring beg pos) completion)))
+
+      (setq company-preview-overlay (make-overlay beg pos))
+
+      (let ((ov company-preview-overlay))
+        (overlay-put ov (if ptf-workaround 'display 'after-string)
+                     completion)
+        (overlay-put ov 'window (selected-window))))))

 
 (defun company-preview-hide ()
   (when company-preview-overlay
 
 (defun company-preview-hide ()
   (when company-preview-overlay


@@ -2515,8 +2624,8 @@ Returns a negative number if the tooltip should be displayed above point."
 (defun company--show-inline-p ()
   (and (not (cdr company-candidates))
        company-common
 (defun company--show-inline-p ()
   (and (not (cdr company-candidates))
        company-common

-       (string-prefix-p company-prefix company-common
-                        (company-call-backend 'ignore-case))))
+       (or (eq (company-call-backend 'ignore-case) 'keep-prefix)
+           (string-prefix-p company-prefix company-common))))

 
 ;;; echo ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
 ;;; echo ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 


@@ -2545,7 +2654,7 @@ Returns a negative number if the tooltip should be displayed above point."
 
 (defun company-echo-format ()
 
 
 (defun company-echo-format ()
 

-  (let ((limit (window-width (minibuffer-window)))
+  (let ((limit (window-body-width (minibuffer-window)))

         (len -1)
         ;; Roll to selection.
         (candidates (nthcdr company-selection company-candidates))
         (len -1)
         ;; Roll to selection.
         (candidates (nthcdr company-selection company-candidates))


@@ -2575,7 +2684,7 @@ Returns a negative number if the tooltip should be displayed above point."
 
 (defun company-echo-strip-common-format ()
 
 
 (defun company-echo-strip-common-format ()
 

-  (let ((limit (window-width (minibuffer-window)))
+  (let ((limit (window-body-width (minibuffer-window)))

         (len (+ (length company-prefix) 2))
         ;; Roll to selection.
         (candidates (nthcdr company-selection company-candidates))
         (len (+ (length company-prefix) 2))
         ;; Roll to selection.
         (candidates (nthcdr company-selection company-candidates))