diff --git a/lsp-inline-completion.el b/lsp-inline-completion.el
new file mode 100644
index 00000000000..fffda85bb12
--- /dev/null
+++ b/lsp-inline-completion.el
@@ -0,0 +1,550 @@
+;;; lsp-inline-completion.el --- LSP mode -*- lexical-binding: t; -*-
+
+;; Copyright (C) 2020-2024 emacs-lsp maintainers
+
+;; Author: Rodrigo Kassick
+;; Keywords: languages
+;; Package-Requires: ((emacs "27.1") (dash "2.18.0") (spinner "1.7.3"))
+;; Version: 9.0.1
+
+;; URL: https://github.com/emacs-lsp/lsp-mode
+;; This program is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Inline Completions support
+;; Specification here https://microsoft.github.io/language-server-protocol/specifications/lsp/3.18/specification/#textDocument_inlineCompletion
+
+;;; Code:
+
+(require 'lsp-protocol)
+(require 'dash)
+(require 'cl-lib)
+(require 'fringe)
+
+(if (version< emacs-version "29.1")
+ ;; Undo macro probably introduced in 29.1
+ (defmacro lsp-inline-completion--with-undo-amalgamate (&rest body)
+ "Like `progn' but perform BODY with amalgamated undo barriers.
+
+This allows multiple operations to be undone in a single step.
+When undo is disabled this behaves like `progn'."
+ (declare (indent 0) (debug t))
+ (let ((handle (make-symbol "--change-group-handle--")))
+ `(let ((,handle (prepare-change-group))
+ ;; Don't truncate any undo data in the middle of this,
+ ;; otherwise Emacs might truncate part of the resulting
+ ;; undo step: we want to mimic the behavior we'd get if the
+ ;; undo-boundaries were never added in the first place.
+ (undo-outer-limit nil)
+ (undo-limit most-positive-fixnum)
+ (undo-strong-limit most-positive-fixnum))
+ (unwind-protect
+ (progn
+ (activate-change-group ,handle)
+ ,@body)
+ (progn
+ (accept-change-group ,handle)
+ (undo-amalgamate-change-group ,handle))))))
+ (defalias 'lsp-inline-completion--with-undo-amalgamate 'with-undo-amalgamate))
+
+(defun lsp-inline-completion--params (implicit &optional identifier position)
+ "Returns a InlineCompletionParams instance"
+ (lsp-make-inline-completion-params
+ :textDocument (or identifier (lsp--text-document-identifier))
+ :position (or position (lsp--cur-position))
+ :context (lsp-make-inline-completion-context
+ :triggerKind (if implicit
+ lsp/inline-completion-trigger-automatic
+ lsp/inline-completion-trigger-invoked))))
+
+(defun lsp-inline-completion--parse-items (response)
+ "Parses the reponse from the server and returns a list of
+InlineCompletionItem objects"
+
+ (pcase response
+ ;; Server responded with a completion list
+ ((lsp-interface InlineCompletionList :items)
+ (seq-into items 'list))
+
+ ;; Server responded with a sequence of completion items
+ ((pred (lambda (i)
+ (and (sequencep i)
+ (lsp-inline-completion-item? (elt i 0)))))
+ (seq-into response 'list))
+
+ ;; A sequence means multiple server may have responded. Iterate over them and normalize
+ ((pred sequencep)
+ (let ((item-seq (cl-map 'list #'lsp-inline-completion--parse-items response)))
+ (apply 'seq-concatenate `(list ,@item-seq))))))
+
+;;;;;; Default UI -- overlay
+
+;;;###autoload
+(defvar lsp-inline-completion-active-map
+ (let ((map (make-sparse-keymap)))
+ ;; accept
+ (define-key map (kbd "C-<return>") #'lsp-inline-completion-accept)
+ (define-key map [mouse-1] #'lsp-inline-completion-accept-on-click)
+ ;; navigate
+ (define-key map (kbd "C-n") #'lsp-inline-completion-next)
+ (define-key map (kbd "C-p") #'lsp-inline-completion-prev)
+ ;; cancel
+ (define-key map (kbd "C-g") #'lsp-inline-completion-cancel)
+ (define-key map (kbd "<escape>") #'lsp-inline-completion-cancel)
+ (define-key map (kbd "C-c C-k") #'lsp-inline-completion-cancel)
+ ;; useful -- recenter without loosing the completion
+ (define-key map (kbd "C-l") #'recenter-top-bottom)
+ ;; ignore
+ (define-key map [down-mouse-1] #'ignore)
+ (define-key map [up-mouse-1] #'ignore)
+ (define-key map [mouse-movement] #'ignore)
+ ;; Any event outside of the map, cancel and use it
+ (define-key map [t] #'lsp-inline-completion-cancel-with-input)
+ map)
+ "Keymap active when showing inline code suggestions")
+
+;;;###autoload
+(defface lsp-inline-completion-overlay-face
+ '((t :inherit shadow))
+ "Face for the inline code suggestions overlay."
+ :group 'lsp-mode)
+
+;; Local Buffer State
+
+(defvar-local lsp-inline-completion--items nil "The completions provided by the server")
+(defvar-local lsp-inline-completion--current nil "The current suggestion to be displayed")
+(defvar-local lsp-inline-completion--overlay nil "The overlay displaying code suggestions")
+(defvar-local lsp-inline-completion--start-point nil "The point where the completion started")
+
+(defcustom lsp-before-inline-completion-hook nil
+ "Hooks run before starting code suggestions"
+ :type 'hook
+ :group 'lsp-mode)
+
+(defcustom lsp-after-inline-completion-hook nil
+ "Hooks executed after asking for code suggestions."
+ :type 'hook
+ :group 'lsp-mode)
+
+(defcustom lsp-inline-completion-accepted-hook nil
+ "Hooks executed after accepting a code suggestion. The hooks receive the
+text range that was updated by the completion"
+ :type 'hook
+ :group 'lsp-mode)
+
+(defcustom lsp-inline-completion-cancelled-hook nil
+ "Hooks executed after cancelling the completion UI"
+ :type 'hook
+ :group 'lsp-mode)
+
+(defcustom lsp-inline-completion-before-show-hook nil
+ "Hooks executed before showing a suggestion."
+ :type 'hook
+ :group 'lsp-mode)
+
+(defcustom lsp-inline-completion-shown-hook nil
+ "Hooks executed after showing a suggestion."
+ :type 'hook
+ :group 'lsp-mode)
+
+(defcustom lsp-inline-completion-overlay-priority 9000
+ "The priority of the overlay."
+ :type '(choice (const :tag "No Priority" nil)
+ (integer :tag "Simple, Overriding Priority")
+ (cons :tag "Composite"
+ (choice (integer :tag "Primary")
+ (const :tag "Primary Unset" nil))
+ (integer :tag "Secondary")))
+ :group 'lsp-mode)
+
+(defsubst lsp-inline-completion--overlay-visible ()
+ "Return whether the `overlay' is avaiable."
+ (and (overlayp lsp-inline-completion--overlay)
+ (overlay-buffer lsp-inline-completion--overlay)))
+
+(defun lsp-inline-completion--clear-overlay ()
+ "Hide the suggestion overlay"
+ (when (lsp-inline-completion--overlay-visible)
+ (delete-overlay lsp-inline-completion--overlay))
+ (setq lsp-inline-completion--overlay nil))
+
+
+(defun lsp-inline-completion--get-overlay (beg end)
+ "Build the suggestions overlay"
+ (when (overlayp lsp-inline-completion--overlay)
+ (lsp-inline-completion--clear-overlay))
+
+ (setq lsp-inline-completion--overlay (make-overlay beg end nil nil t))
+ (overlay-put lsp-inline-completion--overlay 'keymap lsp-inline-completion-active-map)
+ (overlay-put lsp-inline-completion--overlay 'priority lsp-inline-completion-overlay-priority)
+
+ lsp-inline-completion--overlay)
+
+
+(defun lsp-inline-completion--show-keys ()
+ "Shows active keymap hints in the minibuffer"
+
+ (unless (and lsp-inline-completion--items
+ (numberp lsp-inline-completion--current))
+ (error "No completions to show"))
+
+ (let ((message-log-max nil))
+ (message (concat "Completion "
+ (propertize (format "%d" (1+ lsp-inline-completion--current)) 'face 'bold)
+ "/"
+ (propertize (format "%d" (length lsp-inline-completion--items)) 'face 'bold)
+
+ (-when-let (keys (where-is-internal #'lsp-inline-completion-next lsp-inline-completion-active-map))
+ (concat ". "
+ (propertize " Next" 'face 'italic)
+ (format ": [%s]"
+ (string-join (--map (propertize (key-description it) 'face 'help-key-binding)
+ keys)
+ "/"))))
+ (-when-let (keys (where-is-internal #'lsp-inline-completion-accept lsp-inline-completion-active-map))
+ (concat (propertize " Accept" 'face 'italic)
+ (format ": [%s]"
+ (string-join (--map (propertize (key-description it) 'face 'help-key-binding)
+ keys)
+ "/"))))))))
+
+(defun lsp-inline-completion-show-overlay ()
+ "Makes the suggestion overlay visible"
+ (unless (and lsp-inline-completion--items
+ (numberp lsp-inline-completion--current))
+ (error "No completions to show"))
+
+ (lsp-inline-completion--clear-overlay)
+
+ (run-hooks 'lsp-inline-completion-before-show-hook)
+
+ (-let* ((suggestion
+ (elt lsp-inline-completion--items
+ lsp-inline-completion--current))
+ ((&InlineCompletionItem? :insert-text :range?) suggestion)
+ ((&RangeToPoint :start :end) range?)
+ (start-point (or start (point)))
+ (showing-at-eol (save-excursion
+ (goto-char start-point)
+ (eolp)))
+ (beg (if showing-at-eol (1- start-point) start-point))
+ (end-point (or end (1+ beg)))
+ (text (cond
+ ((lsp-markup-content? insert-text) (lsp:markup-content-value insert-text))
+ (t insert-text)))
+ (propertizedText (concat
+ (buffer-substring beg start-point)
+ (propertize text 'face 'lsp-inline-completion-overlay-face)))
+ (ov (lsp-inline-completion--get-overlay beg end-point))
+ (completion-is-substr (string-equal
+ (buffer-substring beg lsp-inline-completion--start-point)
+ (substring propertizedText 0 (- lsp-inline-completion--start-point beg))))
+ display-str after-str target-position)
+
+ (goto-char beg)
+
+ (put-text-property 0 (length propertizedText) 'cursor t propertizedText)
+
+ (if completion-is-substr
+ (progn
+ ;; Show the prefix as `display'
+ (setq display-str (substring propertizedText 0 (- lsp-inline-completion--start-point beg)))
+ (setq after-str (substring propertizedText (- lsp-inline-completion--start-point beg) nil))
+ (setq target-position lsp-inline-completion--start-point))
+
+
+ (setq display-str (substring propertizedText 0 1))
+ (setq after-str (substring propertizedText 1))
+ (setq target-position beg))
+
+ (overlay-put ov 'display display-str)
+ (overlay-put ov 'after-string after-str)
+
+ (goto-char target-position)
+
+ (lsp-inline-completion--show-keys)
+ (run-hooks 'lsp-inline-completion-shown-hook)))
+
+(defun lsp-inline-completion--insert-sugestion (text kind start end command?)
+ (let* ((text-insert-start (or start lsp-inline-completion--start-point))
+ text-insert-end
+ (completion-is-substr (string-equal
+ (buffer-substring text-insert-start lsp-inline-completion--start-point)
+ (substring text 0 (- lsp-inline-completion--start-point text-insert-start)))))
+ (when text-insert-start
+ (goto-char text-insert-start))
+
+ ;; When range is provided, must replace the text of the range by the text
+ ;; to insert
+ (when (and start end (/= start end))
+ (delete-region start end))
+
+ ;; Insert suggestion, keeping the cursor at the start point
+ (insert text)
+
+ (setq text-insert-end (point))
+
+ ;; If a template, format it -- keep track of the end position!
+ (when (eq kind 'snippet)
+ (let ((end-marker (set-marker (make-marker) (point))))
+ (lsp--expand-snippet (buffer-substring text-insert-start text-insert-end)
+ text-insert-start
+ text-insert-end)
+ (setq text-insert-end (marker-position end-marker))
+ (set-marker end-marker nil)))
+
+ ;; Post command
+ (when command?
+ (lsp--execute-command command?))
+
+ (if completion-is-substr
+ (goto-char lsp-inline-completion--start-point)
+ (goto-char text-insert-start))
+
+ ;; hooks
+ (run-hook-with-args-until-failure 'lsp-inline-completion-accepted-hook text text-insert-start text-insert-end)))
+
+(defun lsp-inline-completion-accept ()
+ "Accepts the current suggestion"
+ (interactive)
+ (unless (lsp-inline-completion--overlay-visible)
+ (error "Not showing suggestions"))
+
+ (lsp-inline-completion--clear-overlay)
+ (-let* ((suggestion (elt lsp-inline-completion--items lsp-inline-completion--current))
+ ((&InlineCompletionItem? :insert-text :range? :command?) suggestion)
+ ((kind . text) (cond
+ ((lsp-markup-content? insert-text)
+ (cons 'snippet (lsp:markup-content-value insert-text) ))
+ (t (cons 'text insert-text))))
+ ((start . end) (when range?
+ (-let (((&RangeToPoint :start :end) range?)) (cons start end)))))
+
+ (with-no-warnings
+ ;; Compiler does not believes this macro is defined
+ (lsp-inline-completion--with-undo-amalgamate
+ (lsp-inline-completion--insert-sugestion text kind start end command?)))))
+
+(defun lsp-inline-completion-accept-on-click (event)
+ (interactive "e")
+
+ (lsp-inline-completion-accept)
+ (-let (((col . row) (posn-actual-col-row (event-end event))))
+ (move-to-window-line row)
+ (beginning-of-line)
+ (forward-char (- col
+ (if (bound-and-true-p display-line-numbers-mode)
+ (+ 2 (line-number-display-width))
+ 0)))))
+
+(defun lsp-inline-completion-cancel ()
+ "Close the suggestion overlay"
+ (interactive)
+ (when (lsp-inline-completion--overlay-visible)
+
+ (lsp-inline-completion--clear-overlay)
+
+ (when lsp-inline-completion--start-point
+ (goto-char lsp-inline-completion--start-point))
+
+ (run-hooks 'lsp-inline-completion-cancelled-hook)))
+
+(defun lsp-inline-completion-cancel-with-input (event &optional arg)
+ "Cancel the inline completion and executes whatever event was received"
+ (interactive (list last-input-event current-prefix-arg))
+
+ (lsp-inline-completion-cancel)
+
+ (let ((command (lookup-key (current-active-maps) (vector event)))
+ (current-prefix-arg arg))
+
+ (when (commandp command)
+ (call-interactively command))))
+
+(defun lsp-inline-completion-next ()
+ "Display the next inline completion"
+ (interactive)
+ (unless (lsp-inline-completion--overlay-visible)
+ (error "Not showing suggestions"))
+ (setq lsp-inline-completion--current
+ (mod (1+ lsp-inline-completion--current)
+ (length lsp-inline-completion--items)))
+
+ (lsp-inline-completion-show-overlay))
+
+(defun lsp-inline-completion-prev ()
+ "Display the previous inline completion"
+ (interactive)
+ (unless (lsp-inline-completion--overlay-visible)
+ (error "Not showing suggestions"))
+ (setq lsp-inline-completion--current
+ (mod (1- lsp-inline-completion--current)
+ (length lsp-inline-completion--items)))
+
+ (lsp-inline-completion-show-overlay))
+
+;;;###autoload
+(defun lsp-inline-completion-display (&optional implicit)
+ "Displays the inline completions overlay"
+ (interactive)
+
+ (unless implicit
+ (lsp--spinner-start) )
+
+ (unwind-protect
+ (if-let* ((resp (lsp-request-while-no-input "textDocument/inlineCompletion"
+ (lsp-inline-completion--params implicit)))
+ (items (lsp-inline-completion--parse-items resp)))
+
+ (progn
+ (lsp-inline-completion--clear-overlay)
+ (setq lsp-inline-completion--items items)
+ (setq lsp-inline-completion--current 0)
+ (setq lsp-inline-completion--start-point (point))
+ (lsp-inline-completion-show-overlay))
+ (unless implicit
+ (lsp--info "No Suggestions!")))
+ ;; Clean up
+ (unless implicit
+ (lsp--spinner-stop))))
+
+
+;; Inline Completion Mode
+(defcustom lsp-inline-completion-enable t
+ "If non-nil it will enable inline completions on idle."
+ :type 'boolean
+ :group 'lsp-mode
+ :package-version '(lsp-mode . "9.0.1"))
+
+(defcustom lsp-inline-completion-idle-delay 2
+ "The number of seconds before trying to fetch inline completions, when
+lsp-inline-completion-mode is active"
+ :type 'number
+ :group 'lsp-mode
+ :package-version '(lsp-mode . "9.0.1"))
+
+(defcustom lsp-inline-completion-inhibit-predicates nil
+ "When a function of this list returns non nil, lsp-inline-completion-mode will not show the completion"
+ :type '(repeat function)
+ :group 'lsp-mode)
+
+(defvar-local lsp-inline-completion--idle-timer nil
+ "The idle timer used by lsp-inline-completion-mode")
+
+;;;###autoload
+(define-minor-mode lsp-inline-completion-mode
+ "Mode automatically displaying inline completions."
+ :lighter nil
+ (cond
+ ((and lsp-inline-completion-mode lsp--buffer-workspaces)
+ (add-hook 'lsp-on-change-hook #'lsp-inline-completion--after-change nil t))
+ (t
+ (when lsp-inline-completion--idle-timer
+ (cancel-timer lsp-inline-completion--idle-timer))
+
+ (lsp-inline-completion-cancel)
+
+ (remove-hook 'lsp-on-change-hook #'lsp-inline-completion--after-change t))))
+
+(defun lsp-inline-completion--maybe-display (original-buffer original-point)
+ ;; This is executed on an idle timer -- ensure state did not change before
+ ;; displaying
+ (when (and (buffer-live-p original-buffer)
+ (eq (current-buffer) original-buffer)
+ (eq (point) original-point)
+ (--none? (funcall it) lsp-inline-completion-inhibit-predicates))
+ (setq last-command this-command)
+ (setq this-command 'lsp-inline-completion-display)
+ (lsp-inline-completion-display 'implicit)))
+
+(defun lsp-inline-completion--after-change (&rest _)
+ ;; This function is in lsp-on-change-hooks, which is executed on a timer by
+ ;; lsp-on-change. Do not assume that the buffer/window state has not been
+ ;; modified in the meantime! Use the values in lsp--after-change-vals to
+ ;; ensure this.
+
+ (when lsp-inline-completion--idle-timer
+ (cancel-timer lsp-inline-completion--idle-timer))
+
+ (when (and lsp-inline-completion-mode lsp--buffer-workspaces)
+ (let ((original-buffer (plist-get lsp--after-change-vals :buffer))
+ (original-point (plist-get lsp--after-change-vals :point)))
+ (setq lsp-inline-completion--idle-timer
+ (run-with-idle-timer lsp-inline-completion-idle-delay
+ nil
+ #'lsp-inline-completion--maybe-display
+ original-buffer
+ original-point)))))
+
+;;;###autoload
+(add-hook 'lsp-configure-hook (lambda ()
+ (when (and lsp-inline-completion-enable
+ (lsp-feature? "textDocument/inlineCompletion"))
+ (lsp-inline-completion-mode))))
+
+;; Company default integration
+
+(declare-function company--active-p "ext:company")
+(declare-function company-cancel "ext:company" (&optional result))
+(declare-function company-manual-begin "ext:company")
+(defvar company--begin-inhibit-commands)
+(defcustom lsp-inline-completion-mode-inhibit-when-company-active t
+ "If the inline completion mode should avoid calling completions when company is active"
+ :type 'boolean
+ :group 'lsp-mode)
+
+(defvar-local lsp-inline-completion--showing-company nil "If company was active when the tooltip is shown")
+
+(defun lsp-inline-completion--company-save-state-and-hide ()
+ (setq lsp-inline-completion--showing-company
+ (and (bound-and-true-p company-mode)
+ (company--active-p)))
+
+ (when lsp-inline-completion--showing-company
+ (company-cancel)))
+
+(defun lsp-inline-completion--company-restore-state ()
+ (when lsp-inline-completion--showing-company
+ (company-manual-begin))
+ (setq lsp-inline-completion--showing-company nil))
+
+(defun lsp-inline-completion--company-active-p ()
+ (and (bound-and-true-p company-mode) (company--active-p)))
+
+;;;###autoload
+(define-minor-mode lsp-inline-completion-company-integration-mode
+ "Minor mode to be used when company mode is active with lsp-inline-completion-mode"
+ :lighter nil
+ (cond
+ ((and lsp-inline-completion-company-integration-mode lsp--buffer-workspaces (bound-and-true-p company-mode))
+ (add-hook 'lsp-inline-completion-before-show-hook #'lsp-inline-completion--company-save-state-and-hide nil t)
+ (add-hook 'lsp-inline-completion-cancelled-hook #'lsp-inline-completion--company-restore-state nil t)
+ (unless (memq #'lsp-inline-completion-display company--begin-inhibit-commands)
+ (setq-local company--begin-inhibit-commands
+ (cons #'lsp-inline-completion-display company--begin-inhibit-commands)))
+ (when (and lsp-inline-completion-mode-inhibit-when-company-active
+ (not (memq #'lsp-inline-completion--company-active-p lsp-inline-completion-inhibit-predicates)))
+ (setq-local lsp-inline-completion-inhibit-predicates
+ (cons #'lsp-inline-completion--company-active-p lsp-inline-completion-inhibit-predicates))))
+
+ (t
+ (remove-hook 'lsp-inline-completion-before-show-hook #'lsp-inline-completion--company-save-state-and-hide t)
+ (remove-hook 'lsp-inline-completion-cancelled-hook #'lsp-inline-completion--company-save-state-and-hide t)
+ (when (boundp 'company--begin-inhibit-commands)
+ (setq-local company--begin-inhibit-commands (delq #'lsp-inline-completion-display company--begin-inhibit-commands)))
+ (setq-local lsp-inline-completion-inhibit-predicates
+ (delq #'lsp-inline-completion--company-active-p lsp-inline-completion-inhibit-predicates)))))
+
+(provide 'lsp-inline-completion)
diff --git a/lsp-mode.el b/lsp-mode.el
index 5f81502ec9b..3bb4478a90a 100644
--- a/lsp-mode.el
+++ b/lsp-mode.el
@@ -1010,6 +1010,7 @@ directory")
(with-lsp-workspace wk
(lsp:completion-options-resolve-provider?
(lsp--capability-for-method "textDocument/completion")))))
+ ("textDocument/inlineCompletion" :capability :inlineCompletionProvider)
("textDocument/declaration" :capability :declarationProvider)
("textDocument/definition" :capability :definitionProvider)
("textDocument/documentColor" :capability :colorProvider)
@@ -4949,6 +4950,12 @@ Added to `after-change-functions'."
lsp-managed-mode)
(run-hooks 'lsp-on-change-hook)))
+
+(defvar-local lsp--after-change-vals nil
+ "plist that stores the buffer state when `lsp--after-change' has ben activated. Since the
+functions in `lsp-on-change-hook' are called with a timer, mouse
+movements may have changed the position")
+
(defun lsp--after-change (buffer)
"Called after most textDocument/didChange events."
(setq lsp--signature-last-index nil
@@ -4964,6 +4971,9 @@ Added to `after-change-functions'."
(lsp--semantic-tokens-refresh-if-enabled buffer))
(when lsp--on-change-timer
(cancel-timer lsp--on-change-timer))
+
+ (setq lsp--after-change-vals (list :point (point)
+ :buffer (current-buffer)))
(setq lsp--on-change-timer (run-with-idle-timer
lsp-idle-delay
nil
@@ -5429,9 +5439,9 @@ If EXCLUDE-DECLARATION is non-nil, request the server to include declarations."
(lsp-help-mode)
(with-help-window lsp-help-buf-name
(insert
- (mapconcat 'string-trim-right
- (split-string (lsp--render-on-hover-content contents t) "\n")
- "\n"))))
+ (mapconcat 'string-trim-right
+ (split-string (lsp--render-on-hover-content contents t) "\n")
+ "\n"))))
(run-mode-hooks)))
(lsp--info "No content at point."))))
@@ -6287,7 +6297,10 @@ A reference is highlighted only if it is visible in a window."
(let* ((wins-visible-pos (-map (lambda (win)
(cons (1- (line-number-at-pos (window-start win) t))
- (1+ (line-number-at-pos (window-end win) t))))
+ (1+ (line-number-at-pos (min (window-end win)
+ (with-current-buffer (window-buffer win)
+ (buffer-end +1)))
+ t))))
(get-buffer-window-list nil nil 'visible))))
(setq lsp--have-document-highlights t)
(-map
diff --git a/lsp-protocol.el b/lsp-protocol.el
index f1d8fd90967..3b39db0e210 100644
--- a/lsp-protocol.el
+++ b/lsp-protocol.el
@@ -500,6 +500,8 @@ See `-let' for a description of the destructuring mechanism."
(defconst lsp/completion-trigger-kind-invoked 1)
(defconst lsp/completion-trigger-kind-trigger-character 2)
(defconst lsp/completion-trigger-kind-trigger-for-incomplete-completions 3)
+(defconst lsp/inline-completion-trigger-invoked 1 "Explicit invocation as per https://microsoft.github.io/language-server-protocol/specifications/lsp/3.18/specification/#inlineCompletionTriggerKind")
+(defconst lsp/inline-completion-trigger-automatic 2 "Automatic invocation as per https://microsoft.github.io/language-server-protocol/specifications/lsp/3.18/specification/#inlineCompletionTriggerKind")
(defvar lsp/diagnostic-severity-lookup
[nil Error Warning Information Hint Max])
(defconst lsp/diagnostic-severity-error 1)
@@ -819,7 +821,12 @@ See `-let' for a description of the destructuring mechanism."
;; 3.17
(InlayHint (:label :position) (:kind :paddingLeft :paddingRight))
(InlayHintLabelPart (:value) (:tooltip :location :command))
- (InlayHintsParams (:textDocument) (:range)))
+ (InlayHintsParams (:textDocument) (:range))
+ ;; 3.18
+ (InlineCompletionParams (:textDocument :position :context))
+ (InlineCompletionContext (:triggerKind))
+ (InlineCompletionItem (:insertText) (:filterText :range :command))
+ (InlineCompletionList (:items) nil))
;; 3.17
(defconst lsp/inlay-hint-kind-type-hint 1)