Merge commit '7c14dedc79bf0c6eaad5bf50b80ea80dd721afdc' from company

Conflicts:
	packages/company/company-pysmell.el

diff --combined packages/company/NEWS.md
index 97dc2849d558b0c962c407523293201f987a355a,af8ea70cbfd183c0ff1d1c6f10d8dad8dd06fe5e..af8ea70cbfd183c0ff1d1c6f10d8dad8dd06fe5e
--- 1/packages/company/NEWS.md
--- 2/NEWS.md
+++ b/packages/company/NEWS.md
@@@ -1,5 -1,21 +1,21 @@@
  # History of user-visible changes
  
+ ## 2014-07-01 (0.8.1)
+ 
+ * `company-require-match` is not in effect when the new input doesn't continue
+   the previous prefix, and that prefix was a match.
+ * The meaning of `company-begin-commands` value t has slightly changed.
+ * New transformer, `company-sort-by-backend-importance`.
+ * When grouped back-ends are used, the back-end of the current candidate is
+   indicated in the mode-line, enclosed in angle brackets.
+ * New user option `company-gtags-insert-arguments`, t by default.
+ * `company-css` knows about CSS3.
+ * `company-gtags` supports `meta` and `annotation`.
+ * User option `company-dabbrev-code-other-buffers` can have a new value: `code`.
+ * New user option `company-tooltip-flip-when-above`.
+ * `company-clang` uses the standard header search paths by default.
+ * `C-h` is bound to `company-show-doc-buffer` (like `f1`).
+ 
  ## 2014-04-19 (0.8.0)
  
  * `company-capf` is included in `company-backends` in any supported Emacs

diff --combined packages/company/company-capf.el
index be7292ab7ee2ab065ea48efd5482a895e14dc054,cc075df2017e0e04c675ad324763a7c6a4ef026a..cc075df2017e0e04c675ad324763a7c6a4ef026a
--- 1/packages/company/company-capf.el
--- 2/company-capf.el
+++ b/packages/company/company-capf.el
@@@ -25,10 -25,10 +25,10 @@@
  
  ;;; Code:
  
+ (require 'company)
  (require 'cl-lib)
  
- (defvar company--capf-data nil)
- (make-variable-buffer-local 'company--capf-data)
+ (defvar-local company--capf-data nil)
  
  (defun company--capf-clear-data (&optional _ignore)
    (setq company--capf-data nil)

diff --combined packages/company/company-clang.el
index 4f0f3189eb45e4db3c6e9d86f50817b79bb1dee8,a1a32512509ff5065c49f69a8db69118771df8ea..a1a32512509ff5065c49f69a8db69118771df8ea
--- 1/packages/company/company-clang.el
--- 2/company-clang.el
+++ b/packages/company/company-clang.el
@@@ -61,7 -61,9 +61,9 @@@ or automatically through a custom `comp
    "Major modes which clang may complete.")
  
  (defcustom company-clang-insert-arguments t
-   "When non-nil, insert function arguments as a template after completion.")
+   "When non-nil, insert function arguments as a template after completion."
+   :type 'boolean
+   :package-version '(company . "0.8.0"))
  
  ;; prefix ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  
@@@ -145,9 -147,9 +147,9 @@@
    (let ((meta (company-clang--meta candidate)))
      (cond
       ((null meta) nil)
-      ((string-match ":" meta)
-       (substring meta (match-beginning 0)))
-      ((string-match "\\((.*)\\'\\)" meta)
+      ((string-match "[^:]:[^:]" meta)
+       (substring meta (1+ (match-beginning 0))))
+      ((string-match "\\((.*)[ a-z]*\\'\\)" meta)
        (match-string 1 meta)))))
  
  (defun company-clang--strip-formatting (text)
@@@ -217,14 -219,14 +219,14 @@@
                    t))))))
  
  (defsubst company-clang--build-complete-args (pos)
-   (append '("-cc1" "-fsyntax-only" "-code-completion-macros")
+   (append '("-fsyntax-only" "-Xclang" "-code-completion-macros")
            (unless (company-clang--auto-save-p)
              (list "-x" (company-clang--lang-option)))
            company-clang-arguments
            (when (stringp company-clang--prefix)
              (list "-include" (expand-file-name company-clang--prefix)))
-           '("-code-completion-at")
-           (list (company-clang--build-location pos))
+           (list "-Xclang" (format "-code-completion-at=%s"
+                                   (company-clang--build-location pos)))
            (list (if (company-clang--auto-save-p) buffer-file-name "-"))))
  
  (defun company-clang--candidates (prefix callback)
@@@ -316,9 -318,9 +318,9 @@@ passed via standard input.
      (post-completion (let ((anno (company-clang--annotation arg)))
                         (when (and company-clang-insert-arguments anno)
                           (insert anno)
-                          (if (string-match ":" anno)
+                          (if (string-match "\\`:[^:]" anno)
                               (company-clang-objc-templatify anno)
-                           (company-template-c-like-templatify anno)))))))
+                            (company-template-c-like-templatify anno)))))))
  
  (provide 'company-clang)
  ;;; company-clang.el ends here

diff --combined packages/company/company-css.el
index c4154c2ec4efa85847d4d289c0e354cc22c0b8d5,b8bd639c188985fad6e39c9112bb096f48048615..b8bd639c188985fad6e39c9112bb096f48048615
--- 1/packages/company/company-css.el
--- 2/company-css.el
+++ b/packages/company/company-css.el
@@@ -1,6 -1,6 +1,6 @@@
- ;;; company-css.el --- company-mode completion back-end for css-mode
+ ;;; company-css.el --- company-mode completion back-end for css-mode  -*- lexical-binding: t -*-
  
- ;; Copyright (C) 2009, 2011  Free Software Foundation, Inc.
+ ;; Copyright (C) 2009, 2011, 2014  Free Software Foundation, Inc.
  
  ;; Author: Nikolaj Schumacher
  
@@@ -32,7 -32,8 +32,8 @@@
       "center-right" "right" "far-right" "right-side" "behind" "leftwards"
       "rightwards")
      ("background" background-color background-image background-repeat
-      background-attachment background-position)
+      background-attachment background-position
+      background-clip background-origin background-size)
      ("background-attachment" "scroll" "fixed")
      ("background-color" color "transparent")
      ("background-image" uri "none")
@@@ -85,13 -86,14 +86,14 @@@
      ("elevation" angle "below" "level" "above" "higher" "lower")
      ("empty-cells" "show" "hide")
      ("float" "left" "right" "none")
-     ("font" font-style font-variant font-weight font-size "/" line-height
+     ("font" font-style font-weight font-size "/" line-height
       font-family "caption" "icon" "menu" "message-box" "small-caption"
-      "status-bar")
+      "status-bar" "normal" "small-caps"
+      ;; CSS3
+      font-stretch)
      ("font-family" family-name generic-family)
      ("font-size" absolute-size relative-size length percentage)
      ("font-style" "normal" "italic" "oblique")
-     ("font-variant" "normal" "small-caps")
      ("font-weight" "normal" "bold" "bolder" "lighter" "100" "200" "300" "400"
       "500" "600" "700" "800" "900")
      ("height" length percentage "auto")
@@@ -118,7 -120,9 +120,9 @@@
      ("outline-color" color "invert")
      ("outline-style" border-style)
      ("outline-width" border-width)
-     ("overflow" "visible" "hidden" "scroll" "auto")
+     ("overflow" "visible" "hidden" "scroll" "auto"
+      ;; CSS3:
+      "no-display" "no-content")
      ("padding" padding-width)
      ("padding-bottom" padding-width)
      ("padding-left" padding-width)
@@@ -146,7 -150,6 +150,6 @@@
      ("stress" number)
      ("table-layout" "auto" "fixed")
      ("text-align" "left" "right" "center" "justify")
-     ("text-decoration" "none" "underline" "overline" "line-through" "blink")
      ("text-indent" length percentage)
      ("text-transform" "capitalize" "uppercase" "lowercase" "none")
      ("top" length percentage "auto")
@@@ -162,14 -165,137 +165,137 @@@
      ("widows" integer)
      ("width" length percentage "auto")
      ("word-spacing" "normal" length)
-     ("z-index" "auto" integer))
+     ("z-index" "auto" integer)
+     ;; CSS3
+     ("align-content" align-stretch "space-between" "space-around")
+     ("align-items" align-stretch "baseline")
+     ("align-self" align-items "auto")
+     ("animation" animation-name animation-duration animation-timing-function
+      animation-delay animation-iteration-count animation-direction
+      animation-fill-mode)
+     ("animation-delay" time)
+     ("animation-direction" "normal" "reverse" "alternate" "alternate-reverse")
+     ("animation-duration" time)
+     ("animation-fill-mode" "none" "forwards" "backwards" "both")
+     ("animation-iteration-count" integer "infinite")
+     ("animation-name" "none")
+     ("animation-play-state" "paused" "running")
+     ("animation-timing-function" transition-timing-function
+      "step-start" "step-end" "steps(,)")
+     ("backface-visibility" "visible" "hidden")
+     ("background-clip" background-origin)
+     ("background-origin" "border-box" "padding-box" "content-box")
+     ("background-size" length percentage "auto" "cover" "contain")
+     ("border-image" border-image-outset border-image-repeat border-image-source
+      border-image-slice border-image-width)
+     ("border-image-outset" length)
+     ("border-image-repeat" "stretch" "repeat" "round" "space")
+     ("border-image-source" uri "none")
+     ("border-image-slice" length)
+     ("border-image-width" length percentage)
+     ("border-radius" length)
+     ("border-top-left-radius" length)
+     ("border-top-right-radius" length)
+     ("border-bottom-left-radius" length)
+     ("border-bottom-right-radius" length)
+     ("box-decoration-break" "slice" "clone")
+     ("box-shadow" length color)
+     ("box-sizing" "content-box" "border-box")
+     ("break-after" "auto" "always" "avoid" "left" "right" "page" "column"
+      "avoid-page" "avoid-column")
+     ("break-before" break-after)
+     ("break-inside" "avoid" "auto")
+     ("columns" column-width column-count)
+     ("column-count" integer)
+     ("column-fill" "auto" "balance")
+     ("column-gap" length "normal")
+     ("column-rule" column-rule-width column-rule-style column-rule-color)
+     ("column-rule-color" color)
+     ("column-rule-style" border-style)
+     ("column-rule-width" border-width)
+     ("column-span" "all" "none")
+     ("column-width" length "auto")
+     ("filter" url "blur()" "brightness()" "contrast()" "drop-shadow()"
+      "grayscale()" "hue-rotate()" "invert()" "opacity()" "saturate()" "sepia()")
+     ("flex" flex-grow flex-shrink flex-basis)
+     ("flex-basis" percentage length "auto")
+     ("flex-direction" "row" "row-reverse" "column" "column-reverse")
+     ("flex-flow" flex-direction flex-wrap)
+     ("flex-grow" number)
+     ("flex-shrink" number)
+     ("flex-wrap" "nowrap" "wrap" "wrap-reverse")
+     ("font-feature-setting" normal string number)
+     ("font-kerning" "auto" "normal" "none")
+     ("font-language-override" "normal" string)
+     ("font-size-adjust" "none" number)
+     ("font-stretch" "normal" "ultra-condensed" "extra-condensed" "condensed"
+      "semi-condensed" "semi-expanded" "expanded" "extra-expanded" "ultra-expanded")
+     ("font-synthesis" "none" "weight" "style")
+     ("font-variant" font-variant-alternates font-variant-caps
+      font-variant-east-asian font-variant-ligatures font-variant-numeric
+      font-variant-position)
+     ("font-variant-alternates" "normal" "historical-forms" "stylistic()"
+      "styleset()" "character-variant()" "swash()" "ornaments()" "annotation()")
+     ("font-variant-caps" "normal" "small-caps" "all-small-caps" "petite-caps"
+      "all-petite-caps" "unicase" "titling-caps")
+     ("font-variant-east-asian" "jis78" "jis83" "jis90" "jis04" "simplified"
+      "traditional" "full-width" "proportional-width" "ruby")
+     ("font-variant-ligatures" "normal" "none" "common-ligatures"
+      "no-common-ligatures" "discretionary-ligatures" "no-discretionary-ligatures"
+      "historical-ligatures" "no-historical-ligatures" "contextual" "no-contextual")
+     ("font-variant-numeric" "normal" "ordinal" "slashed-zero"
+      "lining-nums" "oldstyle-nums" "proportional-nums" "tabular-nums"
+      "diagonal-fractions" "stacked-fractions")
+     ("font-variant-position" "normal" "sub" "super")
+     ("hyphens" "none" "manual" "auto")
+     ("justify-content" align-common "space-between" "space-around")
+     ("line-break" "auto" "loose" "normal" "strict")
+     ("marquee-direction" "forward" "reverse")
+     ("marquee-play-count" integer "infinite")
+     ("marquee-speed" "slow" "normal" "fast")
+     ("marquee-style" "scroll" "slide" "alternate")
+     ("opacity" number)
+     ("order" number)
+     ("outline-offset" length)
+     ("overflow-x" overflow)
+     ("overflow-y" overflow)
+     ("overflow-style" "auto" "marquee-line" "marquee-block")
+     ("overflow-wrap" "normal" "break-word")
+     ("perspective" "none" length)
+     ("perspective-origin" percentage length "left" "center" "right" "top" "bottom")
+     ("resize" "none" "both" "horizontal" "vertical")
+     ("tab-size" integer length)
+     ("text-align-last" "auto" "start" "end" "left" "right" "center" "justify")
+     ("text-decoration" text-decoration-color text-decoration-line text-decoration-style)
+     ("text-decoration-color" color)
+     ("text-decoration-line" "none" "underline" "overline" "line-through" "blink")
+     ("text-decoration-style" "solid" "double" "dotted" "dashed" "wavy")
+     ("text-overflow" "clip" "ellipsis")
+     ("text-shadow" color length)
+     ("text-underline-position" "auto" "under" "left" "right")
+     ("transform" "matrix(,,,,,)" "translate(,)" "translateX()" "translateY()"
+      "scale()" "scaleX()" "scaleY()" "rotate()" "skewX()" "skewY()" "none")
+     ("transform-origin" perspective-origin)
+     ("transform-style" "flat" "preserve-3d")
+     ("transition" transition-property transition-duration
+      transition-timing-function transition-delay)
+     ("transition-delay" time)
+     ("transition-duration" time)
+     ("transition-timing-function"
+      "ease" "linear" "ease-in" "ease-out" "ease-in-out" "cubic-bezier(,,,)")
+     ("transition-property" "none" "all" identifier)
+     ("word-wrap" overflow-wrap)
+     ("word-break" "normal" "break-all" "keep-all"))
    "A list of CSS properties and their possible values.")
  
  (defconst company-css-value-classes
    '((absolute-size "xx-small" "x-small" "small" "medium" "large" "x-large"
                     "xx-large")
+     (align-common "flex-start" "flex-end" "center")
+     (align-stretch align-common "stretch")
      (border-style "none" "hidden" "dotted" "dashed" "solid" "double" "groove"
                    "ridge" "inset" "outset")
+     (border-width "thick" "medium" "thin")
      (color "aqua" "black" "blue" "fuchsia" "gray" "green" "lime" "maroon" "navy"
             "olive" "orange" "purple" "red" "silver" "teal" "white" "yellow")
      (counter "counter(,)")
@@@ -194,7 -320,10 +320,10 @@@
      "li" "link" "map" "menu" "meta" "noframes" "noscript" "object" "ol"
      "optgroup" "option" "p" "param" "pre" "q" "s" "samp" "script" "select"
      "small" "span" "strike" "strong" "style" "sub" "sup" "table" "tbody" "td"
-     "textarea" "tfoot" "th" "thead" "title" "tr" "tt" "u" "ul" "var")
+     "textarea" "tfoot" "th" "thead" "title" "tr" "tt" "u" "ul" "var"
+     ;; HTML5
+     "section" "article" "aside" "header" "footer" "nav" "figure" "figcaption"
+     "time" "mark" "main")
    "A list of HTML tags for use in CSS completion.")
  
  (defconst company-css-pseudo-classes
@@@ -213,8 -342,8 +342,8 @@@
                (dolist (child (or (cdr (assoc value company-css-value-classes))
                                   (company-css-property-values
                                    (symbol-name value))))
-                 (add-to-list 'results child))
-             (add-to-list 'results value)))
+                 (push child results))
+             (push value results)))
          (setq results (sort results 'string<))
          (puthash attribute results company-css-property-cache)
          results)))

diff --combined packages/company/company-dabbrev-code.el
index 1039e4a66d192e511bc5e989f3067b564d4a0c6f,371d90843d61b77bf2ba82ce3455e3cfedcdcae5..371d90843d61b77bf2ba82ce3455e3cfedcdcae5
--- 1/packages/company/company-dabbrev-code.el
--- 2/company-dabbrev-code.el
+++ b/packages/company/company-dabbrev-code.el
@@@ -1,6 -1,6 +1,6 @@@
- ;;; company-dabbrev-code.el --- dabbrev-like company-mode back-end for code
+ ;;; company-dabbrev-code.el --- dabbrev-like company-mode back-end for code  -*- lexical-binding: t -*-
  
- ;; Copyright (C) 2009, 2011  Free Software Foundation, Inc.
+ ;; Copyright (C) 2009, 2011, 2014  Free Software Foundation, Inc.
  
  ;; Author: Nikolaj Schumacher
  
@@@ -34,25 -34,26 +34,26 @@@
    :group 'company)
  
  (defcustom company-dabbrev-code-modes
-   '(asm-mode batch-file-mode c++-mode c-mode cperl-mode csharp-mode css-mode
-     emacs-lisp-mode erlang-mode f90-mode fortran-mode haskell-mode java-mode
-     javascript-mode jde-mode js2-mode lisp-mode lua-mode objc-mode perl-mode
-     php-mode prog-mode python-mode ruby-mode scheme-mode shell-script-mode)
+   '(prog-mode
+     batch-file-mode csharp-mode css-mode erlang-mode haskell-mode jde-mode
+     lua-mode python-mode)
    "Modes that use `company-dabbrev-code'.
- In all these modes `company-dabbrev-code' will complete only symbols, not text
- in comments or strings.  In other modes `company-dabbrev-code' will pass control
- to other back-ends \(e.g. `company-dabbrev'\).
- Value t means complete in all modes."
+ In all these modes (and their derivatives) `company-dabbrev-code' will
+ complete only symbols, not text in comments or strings.  In other modes
+ `company-dabbrev-code' will pass control to other back-ends
+ \(e.g. `company-dabbrev'\).  Value t means complete in all modes."
    :type '(choice (repeat (symbol :tag "Major mode"))
                   (const tag "All modes" t)))
  
  (defcustom company-dabbrev-code-other-buffers t
    "Determines whether `company-dabbrev-code' should search other buffers.
  If `all', search all other buffers.  If t, search buffers with the same
- major mode.
+ major mode.  If `code', search all buffers with major modes in
+ `company-dabbrev-code-modes', or derived from one of them.
  See also `company-dabbrev-code-time-limit'."
    :type '(choice (const :tag "Off" nil)
                   (const :tag "Same major mode" t)
+                  (const :tag "Code major modes" code)
                   (const :tag "All" all)))
  
  (defcustom company-dabbrev-code-time-limit .1
@@@ -83,7 -84,7 +84,7 @@@ comments or strings.
    (cl-case command
      (interactive (company-begin-backend 'company-dabbrev-code))
      (prefix (and (or (eq t company-dabbrev-code-modes)
-                      (apply 'derived-mode-p company-dabbrev-code-modes))
+                      (apply #'derived-mode-p company-dabbrev-code-modes))
                   (or company-dabbrev-code-everywhere
                       (not (company-in-string-or-comment)))
                   (or (company-grab-symbol) 'stop)))
@@@ -91,7 -92,11 +92,11 @@@
                    (company-dabbrev--search
                     (company-dabbrev-code--make-regexp arg)
                     company-dabbrev-code-time-limit
-                    company-dabbrev-code-other-buffers t)))
+                    (pcase company-dabbrev-code-other-buffers
+                      (`t (list major-mode))
+                      (`code company-dabbrev-code-modes)
+                      (`all `all))
+                    t)))
      (ignore-case company-dabbrev-code-ignore-case)
      (duplicates t)))
  

diff --combined packages/company/company-dabbrev.el
index 401fcc9181f5391ebcdae07f20b37aedfdc78b0d,ef63d90780ec317950961ddfb3159e713f868c9e..ef63d90780ec317950961ddfb3159e713f868c9e
--- 1/packages/company/company-dabbrev.el
--- 2/company-dabbrev.el
+++ b/packages/company/company-dabbrev.el
@@@ -1,6 -1,6 +1,6 @@@
- ;;; company-dabbrev.el --- dabbrev-like company-mode completion back-end
+ ;;; company-dabbrev.el --- dabbrev-like company-mode completion back-end  -*- lexical-binding: t -*-
  
- ;; Copyright (C) 2009, 2011  Free Software Foundation, Inc.
+ ;; Copyright (C) 2009, 2011, 2014  Free Software Foundation, Inc.
  
  ;; Author: Nikolaj Schumacher
  
@@@ -64,7 -64,8 +64,8 @@@ If you set this value to nil, you may a
  `company-dabbrev-ignore-case' to any value other than `keep-prefix'.")
  
  (defcustom company-dabbrev-minimum-length (1+ company-minimum-prefix-length)
-   "The minimum length for the string to be included.")
+   "The minimum length for the string to be included."
+   :type 'integer)
  
  (defmacro company-dabrev--time-limit-while (test start limit &rest body)
    (declare (indent 3) (debug t))
@@@ -108,19 -109,19 +109,19 @@@
              (push match symbols))))
        symbols)))
  
- (defun company-dabbrev--search (regexp &optional limit other-buffers
+ (defun company-dabbrev--search (regexp &optional limit other-buffer-modes
                                  ignore-comments)
    (let* ((start (current-time))
           (symbols (company-dabbrev--search-buffer regexp (point) nil start limit
                                                    ignore-comments)))
-     (when other-buffers
+     (when other-buffer-modes
        (cl-dolist (buffer (delq (current-buffer) (buffer-list)))
-         (and (or (eq other-buffers 'all)
-                  (eq (buffer-local-value 'major-mode buffer) major-mode))
-              (with-current-buffer buffer
-                (setq symbols
-                      (company-dabbrev--search-buffer regexp nil symbols start
-                                                      limit ignore-comments))))
+         (with-current-buffer buffer
+           (when (or (eq other-buffer-modes 'all)
+                     (apply #'derived-mode-p other-buffer-modes))
+             (setq symbols
+                   (company-dabbrev--search-buffer regexp nil symbols start
+                                                   limit ignore-comments))))
          (and limit
               (> (float-time (time-since start)) limit)
               (cl-return))))
@@@ -135,8 -136,10 +136,10 @@@
      (prefix (company-grab-word))
      (candidates
       (let ((words (company-dabbrev--search (company-dabbrev--make-regexp arg)
-                                          company-dabbrev-time-limit
-                                          company-dabbrev-other-buffers))
+                                            company-dabbrev-time-limit
+                                            (pcase company-dabbrev-other-buffers
+                                              (`t (list major-mode))
+                                              (`all `all))))
             (downcase-p (if (eq company-dabbrev-downcase 'case-replace)
                             case-replace
                           company-dabbrev-downcase)))

diff --combined packages/company/company-eclim.el
index 0eaf38228675de1d41467a7a2e32c986f2197037,1f1beae9604e73c87d499044c04dab1cbb7f8bb4..1f1beae9604e73c87d499044c04dab1cbb7f8bb4
--- 1/packages/company/company-eclim.el
--- 2/company-eclim.el
+++ b/packages/company/company-eclim.el
@@@ -60,11 -60,9 +60,9 @@@ eclim can only complete correctly when 
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  
- (defvar company-eclim--project-dir 'unknown)
- (make-variable-buffer-local 'company-eclim--project-dir)
+ (defvar-local company-eclim--project-dir 'unknown)
  
- (defvar company-eclim--project-name nil)
- (make-variable-buffer-local 'company-eclim--project-name)
+ (defvar-local company-eclim--project-name nil)
  
  (declare-function json-read "json")
  (defvar json-array-type)

diff --combined packages/company/company-etags.el
index 8634103fe9f346df1c15819dd3294f93bec90e36,c7ba60870c48761034c1b40ff6f76f257cff9461..c7ba60870c48761034c1b40ff6f76f257cff9461
--- 1/packages/company/company-etags.el
--- 2/company-etags.el
+++ b/packages/company/company-etags.el
@@@ -42,13 -42,13 +42,13 @@@ buffer automatically.
  
  (defcustom company-etags-ignore-case nil
    "Non-nil to ignore case in completion candidates."
-   :type 'boolean)
+   :type 'boolean
+   :package-version '(company . "0.7.3"))
  
  (defvar company-etags-modes '(prog-mode c-mode objc-mode c++-mode java-mode
                                jde-mode pascal-mode perl-mode python-mode))
  
- (defvar company-etags-buffer-table 'unknown)
- (make-variable-buffer-local 'company-etags-buffer-table)
+ (defvar-local company-etags-buffer-table 'unknown)
  
  (defun company-etags-find-table ()
    (let ((file (locate-dominating-file (or buffer-file-name

diff --combined packages/company/company-files.el
index a839f799ee5cafe6ab3a167f50baeb628d9de174,3dc4d867f8b67fb925e68a05fd6e65dc5b54bd36..3dc4d867f8b67fb925e68a05fd6e65dc5b54bd36
--- 1/packages/company/company-files.el
--- 2/company-files.el
+++ b/packages/company/company-files.el
@@@ -59,17 -59,19 +59,19 @@@
  (defun company-files-complete (prefix)
    (let* ((dir (file-name-directory prefix))
           (file (file-name-nondirectory prefix))
-          candidates)
+          candidates directories)
      (unless (equal dir (car company-files-completion-cache))
        (dolist (file (company-files-directory-files dir file))
          (setq file (concat dir file))
          (push file candidates)
          (when (file-directory-p file)
-           ;; Add one level of children.
-           (dolist (child (company-files-directory-files file ""))
-             (push (concat file
-                           (unless (eq (aref file (1- (length file))) ?/) "/")
-                           child) candidates))))
+           (push file directories)))
+       (dolist (directory (reverse directories))
+         ;; Add one level of children.
+         (dolist (child (company-files-directory-files directory ""))
+           (push (concat directory
+                         (unless (eq (aref directory (1- (length directory))) ?/) "/")
+                         child) candidates)))
        (setq company-files-completion-cache (cons dir (nreverse candidates))))
      (all-completions prefix
                       (cdr company-files-completion-cache))))

diff --combined packages/company/company-gtags.el
index 0ae98d7d62e0d66a33327c27a816398b980056de,d2f1e78ebb0a9ea80b21c8b97dbe78543067fecf..d2f1e78ebb0a9ea80b21c8b97dbe78543067fecf
--- 1/packages/company/company-gtags.el
--- 2/company-gtags.el
+++ b/packages/company/company-gtags.el
@@@ -1,6 -1,6 +1,6 @@@
  ;;; company-gtags.el --- company-mode completion back-end for GNU Global
  
- ;; Copyright (C) 2009-2011  Free Software Foundation, Inc.
+ ;; Copyright (C) 2009-2011, 2014  Free Software Foundation, Inc.
  
  ;; Author: Nikolaj Schumacher
  
@@@ -41,8 -41,12 +41,12 @@@
    'company-gtags-gnu-global-program-name
    'company-gtags-executable "earlier")
  
- (defvar company-gtags--tags-available-p 'unknown)
- (make-variable-buffer-local 'company-gtags--tags-available-p)
+ (defcustom company-gtags-insert-arguments t
+   "When non-nil, insert function arguments as a template after completion."
+   :type 'boolean
+   :package-version '(company . "0.8.1"))
+ 
+ (defvar-local company-gtags--tags-available-p 'unknown)
  
  (defvar company-gtags-modes '(c-mode c++-mode jde-mode java-mode php-mode))
  
@@@ -52,24 -56,32 +56,32 @@@
              (locate-dominating-file buffer-file-name "GTAGS"))
      company-gtags--tags-available-p))
  
- (defun company-gtags-fetch-tags (prefix)
+ (defun company-gtags--fetch-tags (prefix)
    (with-temp-buffer
      (let (tags)
        (when (= 0 (call-process company-gtags-executable nil
-                                (list (current-buffer) nil) nil "-c" prefix))
-         (goto-char (point-min))
-         (split-string (buffer-string) "\n" t)))))
- 
- (defun company-gtags-location (tag)
-   (with-temp-buffer
-     (when (= 0 (call-process company-gtags-executable nil
-                              (list (current-buffer) nil) nil "-x" tag))
+                                (list (current-buffer) nil) nil "-xGq" (concat "^" prefix)))
          (goto-char (point-min))
-         (when (looking-at (concat (regexp-quote tag)
-                                   "[ \t]+\\([[:digit:]]+\\)"
-                                   "[ \t]+\\([^ \t]+\\)"))
-           (cons (expand-file-name (match-string 2))
-                 (string-to-number (match-string 1)))))))
+         (cl-loop while
+                  (re-search-forward (concat
+                                      "^"
+                                      "\\([^ ]*\\)" ;; completion
+                                      "[ \t]+\\([[:digit:]]+\\)" ;; linum
+                                      "[ \t]+\\([^ \t]+\\)" ;; file
+                                      "[ \t]+\\(.*\\)" ;; definition
+                                      "$"
+                                      ) nil t)
+                  collect
+                  (propertize (match-string 1)
+                              'meta (match-string 4)
+                              'location (cons (expand-file-name (match-string 3))
+                                              (string-to-number (match-string 2)))
+                              ))))))
+ 
+ (defun company-gtags--annotation (arg)
+   (let ((meta (get-text-property 0 'meta arg)))
+     (when (string-match (concat arg "\\((.*)\\).*") meta)
+       (match-string 1 meta))))
  
  ;;;###autoload
  (defun company-gtags (command &optional arg &rest ignored)
@@@ -82,9 -94,16 +94,16 @@@
                   (not (company-in-string-or-comment))
                   (company-gtags--tags-available-p)
                   (or (company-grab-symbol) 'stop)))
-     (candidates (company-gtags-fetch-tags arg))
+     (candidates (company-gtags--fetch-tags arg))
      (sorted t)
-     (location (company-gtags-location arg))))
+     (duplicates t)
+     (annotation (company-gtags--annotation arg))
+     (meta (get-text-property 0 'meta arg))
+     (location (get-text-property 0 'location arg))
+     (post-completion (let ((anno (company-gtags--annotation arg)))
+                        (when (and company-gtags-insert-arguments anno)
+                          (insert anno)
+                          (company-template-c-like-templatify anno))))))
  
  (provide 'company-gtags)
  ;;; company-gtags.el ends here

diff --combined packages/company/company-keywords.el
index c700af769bee7b235ae94f2dfa160092d6e5cdb7,f426c06ad758e8a97ff6f63f81ca09e86bb8cc38..f426c06ad758e8a97ff6f63f81ca09e86bb8cc38
--- 1/packages/company/company-keywords.el
--- 2/company-keywords.el
+++ b/packages/company/company-keywords.el
@@@ -210,6 -210,7 +210,7 @@@
      ;; aliases
      (js2-mode . javascript-mode)
      (espresso-mode . javascript-mode)
+     (js-mode . javascript-mode)
      (cperl-mode . perl-mode)
      (jde-mode . java-mode))
    "Alist mapping major-modes to sorted keywords for `company-keywords'.")

diff --combined packages/company/company-pysmell.el
index 2f22bf0f53d5d1501d27220b4260f7eb65220952,8a69e76907ad58fa4d3956e7bb0e3ab1ce99346d..8a69e76907ad58fa4d3956e7bb0e3ab1ce99346d
--- 1/packages/company/company-pysmell.el
--- 2/company-pysmell.el
+++ b/packages/company/company-pysmell.el
@@@ -28,10 -28,10 +28,10 @@@
  ;;; Code:
  
  (if t (require 'pysmell))               ;Don't load during compilation.
+ (require 'company)
  (require 'cl-lib)
  
- (defvar company-pysmell--available-p 'unknown)
- (make-variable-buffer-local 'company-pysmell--available-p)
+ (defvar-local company-pysmell--available-p 'unknown)
  
  (defun company-pysmell--available-p ()
    (if (eq company-pysmell--available-p 'unknown)

diff --combined packages/company/company-semantic.el
index 110d4fd8946adf0bb26994609bc0fca324067700,6c020a30f70ba4eaed2730b0d1c1ea4549ca716e..6c020a30f70ba4eaed2730b0d1c1ea4549ca716e
--- 1/packages/company/company-semantic.el
--- 2/company-semantic.el
+++ b/packages/company/company-semantic.el
@@@ -49,9 -49,8 +49,8 @@@
  
  (defvar company-semantic-modes '(c-mode c++-mode jde-mode java-mode))
  
- (defvar company-semantic--current-tags nil
+ (defvar-local company-semantic--current-tags nil
    "Tags for the current context.")
- (make-variable-buffer-local 'company-semantic--current-tags)
  
  (defun company-semantic-documentation-for-tag (tag)
    (when (semantic-tag-buffer tag)

diff --combined packages/company/company-template.el
index d689183b97099b202174fcf5551bc669c578213b,576b246ecdd8db682932e6aa745394e0212b21a6..576b246ecdd8db682932e6aa745394e0212b21a6
--- 1/packages/company/company-template.el
--- 2/company-template.el
+++ b/packages/company/company-template.el
@@@ -35,8 -35,7 +35,7 @@@
      (define-key keymap (kbd "TAB") 'company-template-forward-field)
      keymap))
  
- (defvar company-template--buffer-templates nil)
- (make-variable-buffer-local 'company-template--buffer-templates)
+ (defvar-local company-template--buffer-templates nil)
  
  ;; interactive ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  

diff --combined packages/company/company-tests.el
index abd970423e110c6ca898e554d22edd7f1fa942fe,14b18bc4d29ea503f8f648bcc0572485feaae518..14b18bc4d29ea503f8f648bcc0572485feaae518
--- 1/packages/company/company-tests.el
--- 2/company-tests.el
+++ b/packages/company/company-tests.el
@@@ -99,6 -99,22 +99,22 @@@
                     (candidates '("c" "d")))))))
      (should (equal (company-call-backend 'candidates "z") '("a" "b" "c" "d")))))
  
+ (ert-deftest company-multi-backend-filters-backends-by-prefix ()
+   (let ((company-backend
+          (list (lambda (command &optional arg &rest ignore)
+                  (cl-case command
+                    (prefix (cons "z" t))
+                    (candidates '("a" "b"))))
+                (lambda (command &optional arg &rest ignore)
+                  (cl-case command
+                    (prefix "t")
+                    (candidates '("c" "d"))))
+                (lambda (command &optional arg &rest ignore)
+                  (cl-case command
+                    (prefix "z")
+                    (candidates '("e" "f")))))))
+     (should (equal (company-call-backend 'candidates "z") '("a" "b" "e" "f")))))
+ 
  (ert-deftest company-multi-backend-remembers-candidate-backend ()
    (let ((company-backend
           (list (lambda (command &optional arg)
@@@ -183,6 -199,7 +199,7 @@@
      (insert "ab")
      (company-mode)
      (let (company-frontends
+           (company-minimum-prefix-length 2)
            (company-require-match 'company-explicit-action-p)
            (company-backends
             (list (lambda (command &optional arg)
@@@ -191,11 -208,35 +208,35 @@@
                       (candidates '("abc" "abd")))))))
        (company-idle-begin (current-buffer) (selected-window)
                            (buffer-chars-modified-tick) (point))
+       (should (eq 2 company-candidates-length))
        (let ((last-command-event ?e))
          (company-call 'self-insert-command 1))
        (should (eq nil company-candidates-length))
        (should (eq 4 (point))))))
  
+ (ert-deftest company-dont-require-match-if-old-prefix-ended-and-was-a-match ()
+   (with-temp-buffer
+     (insert "ab")
+     (company-mode)
+     (let (company-frontends
+           (company-require-match 'company-explicit-action-p)
+           (company-backends
+            (list (lambda (command &optional arg)
+                    (cl-case command
+                      (prefix (company-grab-word))
+                      (candidates '("abc" "ab" "abd"))
+                      (sorted t))))))
+       (let (this-command)
+         (company-complete))
+       (let ((last-command-event ?e))
+         (company-call 'self-insert-command 1))
+       (should (eq 3 company-candidates-length))
+       (should (eq 3 (point)))
+       (let ((last-command-event ? ))
+         (company-call 'self-insert-command 1))
+       (should (null company-candidates-length))
+       (should (eq 4 (point))))))
+ 
  (ert-deftest company-should-complete-whitelist ()
    (with-temp-buffer
      (insert "ab")
@@@ -265,6 -306,7 +306,7 @@@
      (let (company-frontends
            (company-auto-complete 'company-explicit-action-p)
            (company-auto-complete-chars '(? ))
+           (company-minimum-prefix-length 2)
            (company-backends
             (list (lambda (command &optional arg)
                     (cl-case command
@@@ -376,6 -418,24 +418,24 @@@
          (should (string= (overlay-get ov 'company-after)
                           "  123 \nc 45  c\nddd\n")))))))
  
+ (ert-deftest company-pseudo-tooltip-edit-updates-width ()
+   :tags '(interactive)
+   (with-temp-buffer
+     (set-window-buffer nil (current-buffer))
+     (let ((company-candidates-length 5)
+           (company-candidates '("123" "45" "67" "89" "1011"))
+           (company-backend 'ignore)
+           (company-tooltip-limit 4)
+           (company-tooltip-offset-display 'scrollbar))
+       (company-pseudo-tooltip-show (company--row)
+                                    (company--column)
+                                    0)
+       (should (eq (overlay-get company-pseudo-tooltip-overlay 'company-width)
+                   6))
+       (company-pseudo-tooltip-edit 4)
+       (should (eq (overlay-get company-pseudo-tooltip-overlay 'company-width)
+                   7)))))
+ 
  (ert-deftest company-preview-show-with-annotations ()
    :tags '(interactive)
    (with-temp-buffer
@@@ -548,6 -608,7 +608,7 @@@
    (with-temp-buffer
      (company-mode)
      (let (company-frontends
+           company-transformers
            (company-backends (list 'company-async-backend)))
        (company-manual-begin)
        (should (equal "foo" company-prefix))
@@@ -557,6 -618,7 +618,7 @@@
    (with-temp-buffer
      (company-mode)
      (let (company-frontends
+           company-transformers
            (company-backends (list 'company-async-backend)))
        (company-idle-begin (current-buffer) (selected-window)
                            (buffer-chars-modified-tick) (point))
@@@ -575,7 -637,6 +637,6 @@@
        (should (null company-candidates))
        (insert "a")
        (sleep-for 0.1)
-       (should (null company-prefix))
        (should (null company-candidates)))))
  
  (ert-deftest company-idle-begin-async-allows-immediate-callbacks ()

diff --combined packages/company/company-xcode.el
index 7a985aaedc2e183bb419a1dc41b7391378738e61,91ae60b85e17904402d6ffc7d27d0848b2a40330..91ae60b85e17904402d6ffc7d27d0848b2a40330
--- 1/packages/company/company-xcode.el
--- 2/company-xcode.el
+++ b/packages/company/company-xcode.el
@@@ -62,8 -62,7 +62,7 @@@ valid in most contexts.
                (const "Structure") (const "Type") (const "Union")
                (const "Variable") (const "Function")))
  
- (defvar company-xcode-project 'unknown)
- (make-variable-buffer-local 'company-xcode-project)
+ (defvar-local company-xcode-project 'unknown)
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  

diff --combined packages/company/company-yasnippet.el
index 4730b211b7989e09d2639155a511b1154d79ccf6,741a160086707a5ed25c4681a63f0c7bd4488c02..741a160086707a5ed25c4681a63f0c7bd4488c02
--- 1/packages/company/company-yasnippet.el
--- 2/company-yasnippet.el
+++ b/packages/company/company-yasnippet.el
@@@ -82,7 -82,10 +82,10 @@@ shadow back-ends that come after it.  R
       ;; How many trigger keys start with non-symbol characters anyway?
       (and yas-minor-mode
            (company-grab-symbol)))
-     (annotation (concat " -> " (get-text-property 0 'yas-annotation arg)))
+     (annotation
+      (concat
+       (unless company-tooltip-align-annotations " -> ")
+       (get-text-property 0 'yas-annotation arg)))
      (candidates (company-yasnippet--candidates arg))
      (post-completion
       (let ((template (get-text-property 0 'yas-template arg)))

diff --combined packages/company/company.el
index 632b7dc64de6b179e7de1628e9f789f2e789dec1,5d8562a3052d6cae5a14adeb01cde84dfecc8bef..5d8562a3052d6cae5a14adeb01cde84dfecc8bef
--- 1/packages/company/company.el
--- 2/company.el
+++ b/packages/company/company.el
@@@ -5,7 -5,7 +5,7 @@@
  ;; Author: Nikolaj Schumacher
  ;; Maintainer: Dmitry Gutov <dgutov@yandex.ru>
  ;; URL: http://company-mode.github.io/
- ;; Version: 0.8.0
+ ;; Version: 0.8.1
  ;; Keywords: abbrev, convenience, matching
  ;; Package-Requires: ((emacs "24.1") (cl-lib "0.5"))
  
@@@ -81,6 -81,19 +81,19 @@@
  (add-to-list 'debug-ignored-errors "^Cannot complete at point$")
  (add-to-list 'debug-ignored-errors "^No other back-end$")
  
+ ;;; Compatibility
+ (eval-and-compile
+   ;; `defvar-local' for Emacs 24.2 and below
+   (unless (fboundp 'defvar-local)
+     (defmacro defvar-local (var val &optional docstring)
+       "Define VAR as a buffer-local variable with default value VAL.
+ Like `defvar' but additionally marks the variable as being automatically
+ buffer-local wherever it is set."
+       (declare (debug defvar) (doc-string 3))
+       `(progn
+          (defvar ,var ,val ,docstring)
+          (make-variable-buffer-local ',var)))))
+ 
  (defgroup company nil
    "Extensible inline text completion mechanism"
    :group 'abbrev
@@@ -236,7 -249,7 +249,7 @@@ The visualized data is stored in `compa
                           (function :tag "custom function" nil))))
  
  (defcustom company-tooltip-limit 10
-   "The maximum number of candidates in the tooltip"
+   "The maximum number of candidates in the tooltip."
    :type 'integer)
  
  (defcustom company-tooltip-minimum 6
@@@ -247,7 -260,8 +260,8 @@@ If this many lines are not available, p
  (defcustom company-tooltip-minimum-width 0
    "The minimum width of the tooltip's inner area.
  This doesn't include the margins and the scroll bar."
-   :type 'integer)
+   :type 'integer
+   :package-version '(company . "0.8.0"))
  
  (defcustom company-tooltip-margin 1
    "Width of margin columns to show around the toolip."
@@@ -262,7 -276,13 +276,13 @@@
  
  (defcustom company-tooltip-align-annotations nil
    "When non-nil, align annotations to the right tooltip border."
-   :type 'boolean)
+   :type 'boolean
+   :package-version '(company . "0.7.1"))
+ 
+ (defcustom company-tooltip-flip-when-above nil
+   "Whether to flip the tooltip when it's above the current line."
+   :type 'boolean
+   :package-version '(company . "0.8.1"))
  
  (defvar company-safe-backends
    '((company-abbrev . "Abbrev")
@@@ -309,6 -329,11 +329,11 @@@
                                company-oddmuse company-files company-dabbrev)
    "The list of active back-ends (completion engines).
  
+ Only one back-end is used at a time.  The choice depends on the order of
+ the items in this list, and on the values they return in response to the
+ `prefix' command (see below).  But a back-end can also be a \"grouped\"
+ one (see below).
+ 
  `company-begin-backend' can be used to start a specific back-end,
  `company-other-backend' will skip to the next matching back-end in the list.
  
@@@ -319,7 -344,7 +344,7 @@@ 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,
+ 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.
@@@ -432,6 -457,8 +457,8 @@@ Each function gets called with the retu
    :type '(choice
            (const :tag "None" nil)
            (const :tag "Sort by occurrence" (company-sort-by-occurrence))
+           (const :tag "Sort by back-end importance"
+                  (company-sort-by-backend-importance))
            (repeat :tag "User defined" (function))))
  
  (defcustom company-completion-started-hook nil
@@@ -462,7 -489,8 +489,8 @@@ back-end, consider using the `post-comp
    "If enabled, cancel a manually started completion when the prefix gets
  shorter than both `company-minimum-prefix-length' and the length of the
  prefix it was started from."
-   :type 'boolean)
+   :type 'boolean
+   :package-version '(company . "0.8.0"))
  
  (defcustom company-require-match 'company-explicit-action-p
    "If enabled, disallow non-matching input.
@@@ -525,8 -553,8 +553,8 @@@ immediately when a prefix of `company-m
  
  (defcustom company-begin-commands '(self-insert-command org-self-insert-command)
    "A list of commands after which idle completion is allowed.
- If this is t, it can show completions after any command.  See
- `company-idle-delay'.
+ If this is t, it can show completions after any command except a few from a
+ pre-defined list.  See `company-idle-delay'.
  
  Alternatively, any command with a non-nil `company-begin' property is
  treated as if it was on this list."
@@@ -594,12 -622,15 +622,15 @@@ asynchronous call into synchronous."
      (define-key keymap [tab] 'company-complete-common)
      (define-key keymap (kbd "TAB") 'company-complete-common)
      (define-key keymap (kbd "<f1>") 'company-show-doc-buffer)
+     (define-key keymap (kbd "C-h") 'company-show-doc-buffer)
      (define-key keymap "\C-w" 'company-show-location)
      (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 ,i))))
+         `(lambda ()
+            (interactive)
+            (company-complete-number ,(if (zerop i) 10 i)))))
  
      keymap)
    "Keymap that is enabled during an active completion.")
@@@ -632,8 -663,7 +663,7 @@@
  
  (defvar company-default-lighter " company")
  
- (defvar company-lighter company-default-lighter)
- (make-variable-buffer-local 'company-lighter)
+ (defvar-local company-lighter company-default-lighter)
  
  ;;;###autoload
  (define-minor-mode company-mode
@@@ -707,8 -737,7 +737,7 @@@ means that `company-mode' is always tur
  
  ;;; keymaps ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  
- (defvar company-my-keymap nil)
- (make-variable-buffer-local 'company-my-keymap)
+ (defvar-local company-my-keymap nil)
  
  (defvar company-emulation-alist '((t . nil)))
  
@@@ -762,8 -791,7 +791,7 @@@
  
  ;;; backends ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  
- (defvar company-backend nil)
- (make-variable-buffer-local 'company-backend)
+ (defvar-local company-backend nil)
  
  (defun company-grab (regexp &optional expression limit)
    (when (looking-back regexp limit)
@@@ -858,7 -886,8 +886,8 @@@
  
  (defun company--multi-backend-adapter-candidates (backends prefix)
    (let ((pairs (cl-loop for backend in (cdr backends)
-                         when (equal (funcall backend 'prefix)
+                         when (equal (company--prefix-str
+                                      (funcall backend 'prefix))
                                      prefix)
                          collect (cons (funcall backend 'candidates prefix)
                                        (let ((b backend))
@@@ -867,7 -896,7 +896,7 @@@
                                             (lambda (str)
                                               (propertize str 'company-backend b))
                                             candidates)))))))
-     (when (equal (funcall (car backends) 'prefix) prefix)
+     (when (equal (company--prefix-str (funcall (car backends) 'prefix)) prefix)
        ;; Small perf optimization: don't tag the candidates received
        ;; from the first backend in the group.
        (push (cons (funcall (car backends) 'candidates prefix)
@@@ -906,53 -935,43 +935,43 @@@
                                (setcar cell (funcall mapper res))
                                (funcall finisher)))))))))))))
  
+ (defun company--prefix-str (prefix)
+   (or (car-safe prefix) prefix))
+ 
  ;;; completion mechanism ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  
- (defvar company-prefix nil)
- (make-variable-buffer-local 'company-prefix)
+ (defvar-local company-prefix nil)
  
- (defvar company-candidates nil)
- (make-variable-buffer-local 'company-candidates)
+ (defvar-local company-candidates nil)
  
- (defvar company-candidates-length nil)
- (make-variable-buffer-local 'company-candidates-length)
+ (defvar-local company-candidates-length nil)
  
- (defvar company-candidates-cache nil)
- (make-variable-buffer-local 'company-candidates-cache)
+ (defvar-local company-candidates-cache nil)
  
- (defvar company-candidates-predicate nil)
- (make-variable-buffer-local 'company-candidates-predicate)
+ (defvar-local company-candidates-predicate nil)
  
- (defvar company-common nil)
- (make-variable-buffer-local 'company-common)
+ (defvar-local company-common nil)
  
- (defvar company-selection 0)
- (make-variable-buffer-local 'company-selection)
+ (defvar-local company-selection 0)
  
- (defvar company-selection-changed nil)
- (make-variable-buffer-local 'company-selection-changed)
+ (defvar-local company-selection-changed nil)
  
- (defvar company--manual-action nil
+ (defvar-local company--manual-action nil
    "Non-nil, if manual completion took place.")
- (make-variable-buffer-local 'company--manual-action)
  
- (defvar company--manual-prefix nil)
- (make-variable-buffer-local 'company--manual-prefix)
+ (defvar-local company--manual-prefix nil)
  
  (defvar company--auto-completion nil
    "Non-nil when current candidate is being inserted automatically.
  Controlled by `company-auto-complete'.")
  
- (defvar company--point-max nil)
- (make-variable-buffer-local 'company--point-max)
+ (defvar-local company--point-max nil)
  
- (defvar company-point nil)
- (make-variable-buffer-local 'company-point)
+ (defvar-local company-point nil)
  
  (defvar company-timer nil)
  
- (defvar company-added-newline nil)
- (make-variable-buffer-local 'company-added-newline)
+ (defvar-local company-added-newline nil)
  
  (defsubst company-strip-prefix (str)
    (substring str (length company-prefix)))
@@@ -992,15 -1011,12 +1011,12 @@@ can retrieve meta-data for them.
      candidate))
  
  (defun company--should-complete ()
-   (and (not (or buffer-read-only overriding-terminal-local-map
+   (and (eq company-idle-delay t)
+        (not (or buffer-read-only overriding-terminal-local-map
                  overriding-local-map))
         ;; Check if in the middle of entering a key combination.
         (or (equal (this-command-keys-vector) [])
             (not (keymapp (key-binding (this-command-keys-vector)))))
-        (eq company-idle-delay t)
-        (or (eq t company-begin-commands)
-            (memq this-command company-begin-commands)
-            (and (symbolp this-command) (get this-command 'company-begin)))
         (not (and transient-mark-mode mark-active))))
  
  (defun company--should-continue ()
@@@ -1010,7 -1026,8 +1026,8 @@@
            (not (memq this-command (cdr company-continue-commands)))
          (or (memq this-command company-begin-commands)
              (memq this-command company-continue-commands)
-             (string-match-p "\\`company-" (symbol-name this-command))))))
+             (and (symbolp this-command)
+                  (string-match-p "\\`company-" (symbol-name this-command)))))))
  
  (defun company-call-frontends (command)
    (dolist (frontend company-frontends)
@@@ -1025,10 -1042,20 +1042,20 @@@
              (mod selection company-candidates-length)
            (max 0 (min (1- company-candidates-length) selection))))
    (when (or force-update (not (equal selection company-selection)))
+     (company--update-group-lighter (nth selection company-candidates))
      (setq company-selection selection
            company-selection-changed t)
      (company-call-frontends 'update)))
  
+ (defun company--update-group-lighter (candidate)
+   (when (listp company-backend)
+     (let ((backend (or (get-text-property 0 'company-backend candidate)
+                        (car company-backend))))
+       (when (and backend (symbolp backend))
+         (let ((name (replace-regexp-in-string "company-\\|-company" ""
+                                               (symbol-name backend))))
+           (setq company-lighter (format " company-<%s>" name)))))))
+ 
  (defun company-apply-predicate (candidates predicate)
    (let (new)
      (dolist (c candidates)
@@@ -1112,7 -1139,7 +1139,7 @@@
           (cdr c)
           (lambda (candidates)
             (if (not (and candidates (eq res 'done)))
-                ;; Fetcher called us right back.
+                ;; Fetcher called us back right away.
                 (setq res candidates)
               (setq company-backend backend
                     company-candidates-cache
@@@ -1174,7 -1201,7 +1201,7 @@@ Keywords and function definition names 
             (lambda (candidate)
               (when (or
                      (save-excursion
-                       (progn (forward-line 0)
+                       (progn (forward-char (- (length company-prefix)))
                               (search-backward candidate (window-start) t)))
                      (save-excursion
                        (search-forward candidate (window-end) t)))
@@@ -1185,8 -1212,8 +1212,8 @@@
                           (and (not (memq (get-text-property (point) 'face)
                                           '(font-lock-function-name-face
                                             font-lock-keyword-face)))
-                               (let* ((prefix (company-call-backend 'prefix))
-                                      (prefix (or (car-safe prefix) prefix)))
+                               (let ((prefix (company--prefix-str
+                                              (company-call-backend 'prefix))))
                                  (and (stringp prefix)
                                       (= (length prefix) (- end beg))))))
                     (push (cons candidate (if (< beg (point))
@@@ -1199,6 -1226,24 +1226,24 @@@
       (mapcar #'car (sort occurs (lambda (e1 e2) (<= (cdr e1) (cdr e2)))))
       noccurs)))
  
+ (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
+ candidates from back-ends before keyword `:with' to the front.  Candidates
+ from the rest of the back-ends in the group, if any, will be left at the end."
+   (if (functionp company-backend)
+       candidates
+     (let ((low-priority (cdr (memq :with company-backend))))
+       (if (null low-priority)
+           candidates
+         (sort candidates
+               (lambda (c1 c2)
+                 (and
+                  (let ((b2 (get-text-property 0 'company-backend c2)))
+                    (and b2 (memq b2 low-priority)))
+                  (let ((b1 (get-text-property 0 'company-backend c1)))
+                    (or (not b1) (not (memq b1 low-priority)))))))))))
+ 
  (defun company-idle-begin (buf win tick pos)
    (and (eq buf (current-buffer))
         (eq win (selected-window))
@@@ -1212,10 -1257,9 +1257,9 @@@
  (defun company-auto-begin ()
    (and company-mode
         (not company-candidates)
-        (let ((company-idle-delay t)
-              (company-begin-commands t))
+        (let ((company-idle-delay t))
           (condition-case-unless-debug err
-              (company-begin)
+              (company--perform)
             (error (message "Company: An error occurred in auto-begin")
                    (message "%s" (error-message-string err))
                    (company-cancel))
@@@ -1280,7 -1324,7 +1324,7 @@@
                                  company-point)
                company-prefix)))
  
- (defun company--continue-failed ()
+ (defun company--continue-failed (new-prefix)
    (let ((input (buffer-substring-no-properties (point) company-point)))
      (cond
       ((company-auto-complete-p input)
@@@ -1290,19 -1334,25 +1334,25 @@@
          (let ((company--auto-completion t))
            (company-complete-selection))
          nil))
+      ((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.
+                (<= (length new-prefix) (length company-prefix)))
+            (member company-prefix company-candidates))
+       ;; Last input was a success,
+       ;; but we're treating it as an abort + input anyway,
+       ;; like the `unique' case below.
+       (company-cancel 'non-unique))
       ((company-require-match-p)
-       ;; wrong incremental input, but required match
+       ;; Wrong incremental input, but required match.
        (delete-char (- (length input)))
        (ding)
        (message "Matching input is required")
        company-candidates)
-      ((equal company-prefix (car company-candidates))
-       ;; last input was actually success
-       (company-cancel company-prefix))
       (t (company-cancel)))))
  
  (defun company--good-prefix-p (prefix)
-   (and (stringp (or (car-safe prefix) prefix)) ;excludes 'stop
+   (and (stringp (company--prefix-str prefix)) ;excludes 'stop
         (or (eq (cdr-safe prefix) t)
             (let ((len (or (cdr-safe prefix) (length prefix))))
               (if company--manual-prefix
@@@ -1318,14 -1368,17 +1368,17 @@@
      (setq company-candidates-cache nil))
    (let* ((new-prefix (company-call-backend 'prefix))
           (c (when (and (company--good-prefix-p new-prefix)
-                        (setq new-prefix (or (car-safe new-prefix) new-prefix))
+                        (setq new-prefix (company--prefix-str new-prefix))
                         (= (- (point) (length new-prefix))
                            (- company-point (length company-prefix))))
                (company-calculate-candidates new-prefix))))
      (cond
       ((eq c t)
        ;; t means complete/unique.
-       (company-cancel new-prefix))
+       ;; Handle it like completion was aborted, to differentiate from user
+       ;; calling one of Company's commands to insert the candidate,
+       ;; not to trigger template expansion, etc.
+       (company-cancel 'unique))
       ((consp c)
        ;; incremental match
        (setq company-prefix new-prefix)
@@@ -1333,7 -1386,7 +1386,7 @@@
        c)
       ((not (company--incremental-p))
        (company-cancel))
-      (t (company--continue-failed)))))
+      (t (company--continue-failed new-prefix)))))
  
  (defun company--begin-new ()
    (let (prefix c)
@@@ -1352,25 -1405,25 +1405,25 @@@
                (company--multi-backend-adapter backend 'prefix)))
        (when prefix
          (when (company--good-prefix-p prefix)
-           (setq prefix (or (car-safe prefix) prefix)
+           (setq company-prefix (company--prefix-str prefix)
                  company-backend backend
-                 c (company-calculate-candidates prefix))
+                 c (company-calculate-candidates company-prefix))
            ;; t means complete/unique.  We don't start, so no hooks.
            (if (not (consp c))
                (when company--manual-action
                  (message "No completion found"))
-             (setq company-prefix prefix)
              (when company--manual-action
                (setq company--manual-prefix prefix))
-             (when (symbolp backend)
-               (setq company-lighter (concat " " (symbol-name backend))))
+             (if (symbolp backend)
+                 (setq company-lighter (concat " " (symbol-name backend)))
+               (company--update-group-lighter (car c)))
              (company-update-candidates c)
              (run-hook-with-args 'company-completion-started-hook
                                  (company-explicit-action-p))
              (company-call-frontends 'show)))
          (cl-return c)))))
  
- (defun company-begin ()
+ (defun company--perform ()
    (or (and company-candidates (company--continue))
        (and (company--should-complete) (company--begin-new)))
    (when company-candidates
@@@ -1394,47 -1447,44 +1447,44 @@@
         ;; Only set unmodified when tick remained the same since insert,
         ;; and the buffer wasn't modified before.
         (set-buffer-modified-p nil))
-   (when company-prefix
-     (if (stringp result)
-         (progn
-           (company-call-backend 'pre-completion 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
-         company-prefix nil
-         company-candidates nil
-         company-candidates-length nil
-         company-candidates-cache nil
-         company-candidates-predicate nil
-         company-common nil
-         company-selection 0
-         company-selection-changed nil
-         company--manual-action nil
-         company--manual-prefix nil
-         company-lighter company-default-lighter
-         company--point-max nil
-         company-point nil)
-   (when company-timer
-     (cancel-timer company-timer))
-   (company-search-mode 0)
-   (company-call-frontends 'hide)
-   (company-enable-overriding-keymap nil)
+   (unwind-protect
+       (when company-prefix
+         (if (stringp result)
+             (progn
+               (company-call-backend 'pre-completion 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
+           company-prefix nil
+           company-candidates nil
+           company-candidates-length nil
+           company-candidates-cache nil
+           company-candidates-predicate nil
+           company-common nil
+           company-selection 0
+           company-selection-changed nil
+           company--manual-action nil
+           company--manual-prefix nil
+           company-lighter company-default-lighter
+           company--point-max nil
+           company-point nil)
+     (when company-timer
+       (cancel-timer company-timer))
+     (company-search-mode 0)
+     (company-call-frontends 'hide)
+     (company-enable-overriding-keymap nil))
    ;; Make return value explicit.
    nil)
  
  (defun company-abort ()
    (interactive)
-   (company-cancel t)
-   ;; Don't start again, unless started manually.
-   (setq company-point (point)))
+   (company-cancel 'abort))
  
  (defun company-finish (result)
    (company--insert-candidate result)
-   (company-cancel result)
-   ;; Don't start again, unless started manually.
-   (setq company-point (point)))
+   (company-cancel result))
  
  (defsubst company-keep (command)
    (and (symbolp command) (get command 'company-keep)))
@@@ -1459,13 -1509,14 +1509,14 @@@
      (condition-case err
          (progn
            (unless (equal (point) company-point)
-             (company-begin))
+             (let ((company-idle-delay (and (eq company-idle-delay t)
+                                            (company--should-begin)
+                                            t)))
+               (company--perform)))
            (if company-candidates
                (company-call-frontends 'post-command)
              (and (numberp company-idle-delay)
-                  (or (eq t company-begin-commands)
-                      (memq this-command company-begin-commands))
-                  (not (equal (point) company-point))
+                  (company--should-begin)
                   (setq company-timer
                         (run-with-timer company-idle-delay nil
                                         'company-idle-begin
@@@ -1476,19 -1527,31 +1527,31 @@@
               (company-cancel))))
    (company-install-map))
  
+ (defvar company--begin-inhibit-commands '(company-abort
+                                           company-complete-mouse
+                                           company-complete
+                                           company-complete-common
+                                           company-complete-selection
+                                           company-complete-number)
+   "List of commands after which idle completion is (still) disabled when
+ `company-begin-commands' is t.")
+ 
+ (defun company--should-begin ()
+   (if (eq t company-begin-commands)
+       (not (memq this-command company--begin-inhibit-commands))
+     (or
+      (memq this-command company-begin-commands)
+      (and (symbolp this-command) (get this-command 'company-begin)))))
+ 
  ;;; search ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  
- (defvar company-search-string nil)
- (make-variable-buffer-local 'company-search-string)
+ (defvar-local company-search-string nil)
  
- (defvar company-search-lighter " Search: \"\"")
- (make-variable-buffer-local 'company-search-lighter)
+ (defvar-local company-search-lighter " Search: \"\"")
  
- (defvar company-search-old-map nil)
- (make-variable-buffer-local 'company-search-old-map)
+ (defvar-local company-search-old-map nil)
  
- (defvar company-search-old-selection 0)
- (make-variable-buffer-local 'company-search-old-selection)
+ (defvar-local company-search-old-selection 0)
  
  (defun company-search (text lines)
    (let ((quoted (regexp-quote text))
@@@ -1504,9 -1567,9 +1567,9 @@@
    (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))))
+                              (nthcdr company-selection company-candidates))))
      (if (null pos)
          (ding)
        (company-set-selection (+ company-selection pos) t))))
@@@ -1516,8 -1579,8 +1579,8 @@@
    (interactive)
    (company-search-assert-enabled)
    (let ((pos (company-search company-search-string
-                               (cdr (nthcdr company-selection
-                                            company-candidates)))))
+                              (cdr (nthcdr company-selection
+                                           company-candidates)))))
      (if (null pos)
          (ding)
        (company-set-selection (+ company-selection pos 1) t))))
@@@ -1527,9 -1590,9 +1590,9 @@@
    (interactive)
    (company-search-assert-enabled)
    (let ((pos (company-search company-search-string
-                               (nthcdr (- company-candidates-length
-                                          company-selection)
-                                       (reverse company-candidates)))))
+                              (nthcdr (- company-candidates-length
+                                         company-selection)
+                                      (reverse company-candidates)))))
      (if (null pos)
          (ding)
        (company-set-selection (- company-selection pos 1) t))))
@@@ -1600,7 -1663,8 +1663,8 @@@
        (define-key keymap [escape] meta-map))
      (define-key keymap (vector meta-prefix-char t) '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 [escape escape escape] 'company-search-other-char)
+     (define-key keymap (kbd "DEL") 'company-search-other-char)
  
      (define-key keymap "\C-g" 'company-search-abort)
      (define-key keymap "\C-s" 'company-search-repeat-forward)
@@@ -1790,7 -1854,7 +1854,7 @@@ inserted.
  To show the number next to the candidates in some back-ends, enable
  `company-show-numbers'."
    (when (company-manual-begin)
-     (and (< n 1) (> n company-candidates-length)
+     (and (or (< n 1) (> n company-candidates-length))
           (error "No candidate number %d" n))
      (cl-decf n)
      (company-finish (nth n company-candidates))))
@@@ -1828,8 -1892,7 +1892,7 @@@
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  
- (defvar company-last-metadata nil)
- (make-variable-buffer-local 'company-last-metadata)
+ (defvar-local company-last-metadata nil)
  
  (defun company-fetch-metadata ()
    (let ((selected (nth company-selection company-candidates)))
@@@ -1904,8 -1967,7 +1967,7 @@@
  
  ;;; package functions ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  
- (defvar company-callback nil)
- (make-variable-buffer-local 'company-callback)
+ (defvar-local company-callback nil)
  
  (defun company-remove-callback (&optional ignored)
    (remove-hook 'company-completion-finished-hook company-callback t)
@@@ -1943,13 -2005,13 +2005,13 @@@ Example: \(company-begin-with '\(\"foo\
      (company-begin-backend
       (lambda (command &optional arg &rest ignored)
         (pcase command
-         (`prefix
-          (when (equal (point) (marker-position begin-marker))
-            (buffer-substring (- (point) (or prefix-length 0)) (point))))
-         (`candidates
-          (all-completions arg candidates))
-         (`require-match
-          require-match)))
+          (`prefix
+           (when (equal (point) (marker-position begin-marker))
+             (buffer-substring (- (point) (or prefix-length 0)) (point))))
+          (`candidates
+           (all-completions arg candidates))
+          (`require-match
+           require-match)))
       callback)))
  
  (defun company-version (&optional show-version)
@@@ -1966,11 -2028,9 +2028,9 @@@ If SHOW-VERSION is non-nil, show the ve
  
  ;;; pseudo-tooltip ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  
- (defvar company-pseudo-tooltip-overlay nil)
- (make-variable-buffer-local 'company-pseudo-tooltip-overlay)
+ (defvar-local company-pseudo-tooltip-overlay nil)
  
- (defvar company-tooltip-offset 0)
- (make-variable-buffer-local 'company-tooltip-offset)
+ (defvar-local company-tooltip-offset 0)
  
  (defun company-tooltip--lines-update-offset (selection num-lines limit)
    (cl-decf limit 2)
@@@ -2113,6 -2173,9 +2173,9 @@@
  (defun company--replacement-string (lines old column nl &optional align-top)
    (cl-decf column company-tooltip-margin)
  
+   (when (and align-top company-tooltip-flip-when-above)
+     (setq lines (reverse lines)))
+ 
    (let ((width (length (car lines)))
          (remaining-cols (- (+ (company--window-width) (window-hscroll))
                             column)))
@@@ -2260,7 -2323,7 +2323,7 @@@
    (propertize (concat (company-space-string company-tooltip-margin)
                        (company-safe-substring text 0 width)
                        (company-space-string company-tooltip-margin))
-    'face 'company-tooltip))
+               'face 'company-tooltip))
  
  ;; show
  
@@@ -2269,16 -2332,19 +2332,19 @@@
      (- (nth 3 edges) (nth 1 edges))))
  
  (defsubst company--window-width ()
-   (- (window-width)
-      (cond
-       ((display-graphic-p) 0)
-       ;; Account for the line continuation column.
-       ((version< "24.3.1" emacs-version) 1)
+   (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.
-       (t (1+ (let ((margins (window-margins)))
-                (+ (or (car margins) 0)
-                   (or (cdr margins) 0))))))))
+       (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.
@@@ -2328,10 -2394,13 +2394,13 @@@ Returns a negative number if the toolti
      (company-pseudo-tooltip-show (1+ row) col company-selection)))
  
  (defun company-pseudo-tooltip-edit (selection)
-   (let ((height (overlay-get company-pseudo-tooltip-overlay 'company-height)))
+   (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
                   (apply 'company--replacement-string
-                         (company--create-lines selection (abs height))
+                         lines
                          (overlay-get company-pseudo-tooltip-overlay
                                       'company-replacement-args)))))
  
@@@ -2395,8 -2464,7 +2464,7 @@@
  
  ;;; overlay ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  
- (defvar company-preview-overlay nil)
- (make-variable-buffer-local 'company-preview-overlay)
+ (defvar-local company-preview-overlay nil)
  
  (defun company-preview-show-at-point (pos)
    (company-preview-hide)
@@@ -2453,8 -2521,7 +2521,7 @@@
  
  ;;; echo ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  
- (defvar company-echo-last-msg nil)
- (make-variable-buffer-local 'company-echo-last-msg)
+ (defvar-local company-echo-last-msg nil)
  
  (defvar company-echo-timer nil)