6 files changed, 93 insertions, 88 deletions

diff --git a/editors/code/package.json b/editors/code/package.json
index 808dc5dc1..48ab886bf 100644
--- a/editors/code/package.json
+++ b/editors/code/package.json
@@ -197,6 +197,11 @@
                     ],
                     "description": "Whether to run `cargo watch` on startup"
                 },
+                "rust-analyzer.excludeGlobs": {
+                    "type": "array",
+                    "default": "[]",
+                    "description": "Paths to exclude from analysis"
+                },
                 "rust-analyzer.cargo-watch.arguments": {
                     "type": "string",
                     "description": "`cargo-watch` arguments. (e.g: `--features=\"shumway,pdf\"` will run as `cargo watch -x \"check --features=\"shumway,pdf\"\"` )",
diff --git a/editors/code/src/commands/inlay_hints.ts b/editors/code/src/commands/inlay_hints.ts
index 3ba9da48b..5393a2bc9 100644
--- a/editors/code/src/commands/inlay_hints.ts
+++ b/editors/code/src/commands/inlay_hints.ts
@@ -22,53 +22,56 @@ const typeHintDecorationType = vscode.window.createTextEditorDecorationType({
 export class HintsUpdater {
     private displayHints = true;
 
-    public async loadHints(
-        editor: vscode.TextEditor | undefined
-    ): Promise<void> {
-        if (
-            this.displayHints &&
-            editor !== undefined &&
-            this.isRustDocument(editor.document)
-        ) {
-            await this.updateDecorationsFromServer(
-                editor.document.uri.toString(),
-                editor
-            );
-        }
-    }
-
     public async toggleHintsDisplay(displayHints: boolean): Promise<void> {
         if (this.displayHints !== displayHints) {
             this.displayHints = displayHints;
-
-            if (displayHints) {
-                return this.updateHints();
-            } else {
-                const editor = vscode.window.activeTextEditor;
-                if (editor != null) {
-                    return editor.setDecorations(typeHintDecorationType, []);
-                }
-            }
+            return this.refreshVisibleEditorsHints(
+                displayHints ? undefined : []
+            );
         }
     }
 
-    public async updateHints(cause?: TextDocumentChangeEvent): Promise<void> {
+    public async refreshHintsForVisibleEditors(
+        cause?: TextDocumentChangeEvent
+    ): Promise<void> {
         if (!this.displayHints) {
             return;
         }
-        const editor = vscode.window.activeTextEditor;
-        if (editor == null) {
+        if (
+            cause !== undefined &&
+            (cause.contentChanges.length === 0 ||
+                !this.isRustDocument(cause.document))
+        ) {
             return;
         }
-        const document = cause == null ? editor.document : cause.document;
-        if (!this.isRustDocument(document)) {
-            return;
+        return this.refreshVisibleEditorsHints();
+    }
+
+    private async refreshVisibleEditorsHints(
+        newDecorations?: vscode.DecorationOptions[]
+    ) {
+        const promises: Array<Promise<void>> = [];
+
+        for (const rustEditor of vscode.window.visibleTextEditors.filter(
+            editor => this.isRustDocument(editor.document)
+        )) {
+            if (newDecorations !== undefined) {
+                promises.push(
+                    Promise.resolve(
+                        rustEditor.setDecorations(
+                            typeHintDecorationType,
+                            newDecorations
+                        )
+                    )
+                );
+            } else {
+                promises.push(this.updateDecorationsFromServer(rustEditor));
+            }
         }
 
-        return await this.updateDecorationsFromServer(
-            document.uri.toString(),
-            editor
-        );
+        for (const promise of promises) {
+            await promise;
+        }
     }
 
     private isRustDocument(document: vscode.TextDocument): boolean {
@@ -76,11 +79,10 @@ export class HintsUpdater {
     }
 
     private async updateDecorationsFromServer(
-        documentUri: string,
         editor: TextEditor
     ): Promise<void> {
-        const newHints = await this.queryHints(documentUri);
-        if (newHints != null) {
+        const newHints = await this.queryHints(editor.document.uri.toString());
+        if (newHints !== null) {
             const newDecorations = newHints.map(hint => ({
                 range: hint.range,
                 renderOptions: { after: { contentText: `: ${hint.label}` } }
diff --git a/editors/code/src/config.ts b/editors/code/src/config.ts
index 4d58a1a93..4df6b50ef 100644
--- a/editors/code/src/config.ts
+++ b/editors/code/src/config.ts
@@ -22,6 +22,7 @@ export class Config {
     public showWorkspaceLoadedNotification = true;
     public lruCapacity: null | number = null;
     public displayInlayHints = true;
+    public excludeGlobs = [];
     public cargoWatchOptions: CargoWatchOptions = {
         enableOnStartup: 'ask',
         trace: 'off',
@@ -128,5 +129,8 @@ export class Config {
         if (config.has('displayInlayHints')) {
             this.displayInlayHints = config.get('displayInlayHints') as boolean;
         }
+        if (config.has('excludeGlobs')) {
+            this.excludeGlobs = config.get('excludeGlobs') || [];
+        }
     }
 }
diff --git a/editors/code/src/extension.ts b/editors/code/src/extension.ts
index c6efc2e7e..39fe6efd8 100644
--- a/editors/code/src/extension.ts
+++ b/editors/code/src/extension.ts
@@ -151,15 +151,27 @@ export function activate(context: vscode.ExtensionContext) {
 
     if (Server.config.displayInlayHints) {
         const hintsUpdater = new HintsUpdater();
-        hintsUpdater.loadHints(vscode.window.activeTextEditor).then(() => {
+        hintsUpdater.refreshHintsForVisibleEditors().then(() => {
+            // vscode may ignore top level hintsUpdater.refreshHintsForVisibleEditors()
+            // so update the hints once when the focus changes to guarantee their presence
+            let editorChangeDisposable: vscode.Disposable | null = null;
+            editorChangeDisposable = vscode.window.onDidChangeActiveTextEditor(
+                _ => {
+                    if (editorChangeDisposable !== null) {
+                        editorChangeDisposable.dispose();
+                    }
+                    return hintsUpdater.refreshHintsForVisibleEditors();
+                }
+            );
+
             disposeOnDeactivation(
-                vscode.window.onDidChangeActiveTextEditor(editor =>
-                    hintsUpdater.loadHints(editor)
+                vscode.window.onDidChangeVisibleTextEditors(_ =>
+                    hintsUpdater.refreshHintsForVisibleEditors()
                 )
             );
             disposeOnDeactivation(
                 vscode.workspace.onDidChangeTextDocument(e =>
-                    hintsUpdater.updateHints(e)
+                    hintsUpdater.refreshHintsForVisibleEditors(e)
                 )
             );
             disposeOnDeactivation(
diff --git a/editors/code/src/server.ts b/editors/code/src/server.ts
index 7029142fd..2b4c25c28 100644
--- a/editors/code/src/server.ts
+++ b/editors/code/src/server.ts
@@ -36,7 +36,8 @@ export class Server {
                 publishDecorations: true,
                 showWorkspaceLoaded:
                     Server.config.showWorkspaceLoadedNotification,
-                lruCapacity: Server.config.lruCapacity
+                lruCapacity: Server.config.lruCapacity,
+                excludeGlobs: Server.config.excludeGlobs
             },
             traceOutputChannel
         };
diff --git a/editors/emacs/ra-emacs-lsp.el b/editors/emacs/ra-emacs-lsp.el
index d7656476e..79822c8ce 100644
--- a/editors/emacs/ra-emacs-lsp.el
+++ b/editors/emacs/ra-emacs-lsp.el
@@ -14,7 +14,7 @@
 ;;    - 'hover' type information & documentation (with lsp-ui)
 ;;  - implements source changes (for code actions etc.), except for file system changes
 ;;  - implements joinLines (you need to bind rust-analyzer-join-lines to a key)
-;;  - implements extendSelection (either bind rust-analyzer-extend-selection to a key, or use expand-region)
+;;  - implements selectionRanges (either bind lsp-extend-selection to a key, or use expand-region)
 ;;  - provides rust-analyzer-inlay-hints-mode for inline type hints
 
 ;; What's missing:
@@ -79,6 +79,10 @@
   :ignore-messages nil
   :server-id 'rust-analyzer))
 
+(defun rust-analyzer--initialized? ()
+  (when-let ((workspace (lsp-find-workspace 'rust-analyzer (buffer-file-name))))
+    (eq 'initialized (lsp--workspace-status workspace))))
+
 (with-eval-after-load 'company-lsp
   ;; company-lsp provides a snippet handler for rust by default that adds () after function calls, which RA does better
   (setq company-lsp--snippet-functions (cl-delete "rust" company-lsp--snippet-functions :key #'car :test #'equal)))
@@ -99,39 +103,13 @@
                                        (rust-analyzer--join-lines-params)))
    (rust-analyzer--apply-source-change)))
 
-;; extend selection
-
-(defun rust-analyzer-extend-selection ()
-  (interactive)
-  (-let (((&hash "start" "end") (rust-analyzer--extend-selection)))
-    (rust-analyzer--goto-lsp-loc start)
-    (set-mark (point))
-    (rust-analyzer--goto-lsp-loc end)
-    (exchange-point-and-mark)))
-
-(defun rust-analyzer--extend-selection-params ()
-  "Extend selection params."
-  (list :textDocument (lsp--text-document-identifier)
-        :selections
-        (vector
-         (if (use-region-p)
-             (lsp--region-to-range (region-beginning) (region-end))
-           (lsp--region-to-range (point) (point))))))
-
-(defun rust-analyzer--extend-selection ()
-  (->
-   (lsp-send-request
-    (lsp-make-request
-     "rust-analyzer/extendSelection"
-     (rust-analyzer--extend-selection-params)))
-   (ht-get "selections")
-   (seq-first)))
+;; selection ranges
 
 (defun rust-analyzer--add-er-expansion ()
   (make-variable-buffer-local 'er/try-expand-list)
   (setq er/try-expand-list (append
                             er/try-expand-list
-                            '(rust-analyzer-extend-selection))))
+                            '(lsp-extend-selection))))
 
 (with-eval-after-load 'expand-region
   ;; add the expansion for all existing rust-mode buffers. If expand-region is
@@ -229,21 +207,22 @@
           (pop-to-buffer buf))))))
 
 ;; inlay hints
-(defun rust-analyzer--update-inlay-hints ()
-  (lsp-send-request-async
-   (lsp-make-request "rust-analyzer/inlayHints"
-                     (list :textDocument (lsp--text-document-identifier)))
-   (lambda (res)
-     (remove-overlays (point-min) (point-max) 'rust-analyzer--inlay-hint t)
-     (dolist (hint res)
-       (-let* (((&hash "range" "label" "kind") hint)
-               ((beg . end) (lsp--range-to-region range))
-               (overlay (make-overlay beg end)))
-         (overlay-put overlay 'rust-analyzer--inlay-hint t)
-         (overlay-put overlay 'evaporate t)
-         (overlay-put overlay 'after-string (propertize (concat ": " label)
-                                                        'font-lock-face 'font-lock-comment-face)))))
-   'tick)
+(defun rust-analyzer--update-inlay-hints (buffer)
+  (if (and (rust-analyzer--initialized?) (eq buffer (current-buffer)))
+    (lsp-send-request-async
+     (lsp-make-request "rust-analyzer/inlayHints"
+                       (list :textDocument (lsp--text-document-identifier)))
+     (lambda (res)
+       (remove-overlays (point-min) (point-max) 'rust-analyzer--inlay-hint t)
+       (dolist (hint res)
+         (-let* (((&hash "range" "label" "kind") hint)
+                 ((beg . end) (lsp--range-to-region range))
+                 (overlay (make-overlay beg end)))
+           (overlay-put overlay 'rust-analyzer--inlay-hint t)
+           (overlay-put overlay 'evaporate t)
+           (overlay-put overlay 'after-string (propertize (concat ": " label)
+                                                          'font-lock-face 'font-lock-comment-face)))))
+     'tick))
   nil)
 
 (defvar-local rust-analyzer--inlay-hints-timer nil)
@@ -252,17 +231,19 @@
   (when rust-analyzer--inlay-hints-timer
     (cancel-timer rust-analyzer--inlay-hints-timer))
   (setq rust-analyzer--inlay-hints-timer
-        (run-with-idle-timer 0.1 nil #'rust-analyzer--update-inlay-hints)))
+        (run-with-idle-timer 0.1 nil #'rust-analyzer--update-inlay-hints (current-buffer))))
 
 (define-minor-mode rust-analyzer-inlay-hints-mode
   "Mode for showing inlay hints."
   nil nil nil
   (cond
    (rust-analyzer-inlay-hints-mode
-    (rust-analyzer--update-inlay-hints)
+    (rust-analyzer--update-inlay-hints (current-buffer))
+    (add-hook 'lsp-after-initialize-hook #'rust-analyzer--inlay-hints-change-handler nil t)
     (add-hook 'after-change-functions #'rust-analyzer--inlay-hints-change-handler nil t))
    (t
     (remove-overlays (point-min) (point-max) 'rust-analyzer--inlay-hint t)
+    (remove-hook 'lsp-after-initialize-hook #'rust-analyzer--inlay-hints-change-handler t)
     (remove-hook 'after-change-functions #'rust-analyzer--inlay-hints-change-handler t))))