Fix peeked editor closing without reopening when triggered again at the same position in the same file

Author: lokesh-tr

src/sourcekit-lsp/peekDocuments.ts

@@ -16,27 +16,82 @@ import * as vscode from "vscode";
 import * as langclient from "vscode-languageclient/node";
 import { PeekDocumentsParams, PeekDocumentsRequest } from "./lspExtensions";
 
+/**
+ * Opens a peeked editor in `uri` at `position` having contents from `locations`.
+ *
+ * **NOTE**:
+ * - If the `uri` is not open in the editor, this opens the `uri` in the editor and then opens a peeked editor.
+ * - This reopens a peeked editor in `uri` **if and only if** the previous peeked editor is being displayed at a
+ *   different position in `uri`.
+ * - This always closes any previously displayed peeked editor in `uri`.
+ *
+ * @param uri The uri of the file in which a peeked editor is to be opened
+ * @param position The position in the file in which a peeked editor is to be opened
+ * @param locations The locations of the contents which has to be displayed by the peeked editor
+ */
+async function openPeekedEditorIn(
+    uri: vscode.Uri,
+    position: vscode.Position,
+    locations: vscode.Location[]
+) {
+    await vscode.commands.executeCommand(
+        "editor.action.peekLocations",
+        uri,
+        position,
+        locations,
+        "peek"
+    );
+}
+
+/**
+ * This function opens at dummy peeked editor in `uri` so that the previously displayed peeked editor gets closed.
+ *
+ * This function exists as a **workaround** for not having any API available to close the previously displayed peeked
+ * editor at `uri`
+ *
+ * **NOTE**: This function call must be immediately followed up by a call to `openPeekedEditorIn` at the same `uri`
+ * inorder to ensure that the dummy peeked editor isn't displayed to the user.
+ *
+ * @param uri The file in which the actual peeked editor is meant to be shown
+ */
+async function openDummyPeekedEditorIn(uri: vscode.Uri) {
+    // Since there isn't any API available to close the previous peeked editor, as a workaround, we open a dummy
+    // peeked editor, causing the previous one to close.
+    await openPeekedEditorIn(uri, new vscode.Position(0, 0), [
+        new vscode.Location(vscode.Uri.parse(""), new vscode.Position(0, 0)),
+    ]);
+}
+
 export function activatePeekDocuments(client: langclient.LanguageClient): vscode.Disposable {
     const peekDocuments = client.onRequest(
         PeekDocumentsRequest.method,
         async (params: PeekDocumentsParams) => {
-            const locations = params.locations.map(uri => {
-                const location = new vscode.Location(
-                    client.protocol2CodeConverter.asUri(uri),
-                    new vscode.Position(0, 0)
-                );
-
-                return location;
-            });
-
-            await vscode.commands.executeCommand(
-                "editor.action.peekLocations",
-                client.protocol2CodeConverter.asUri(params.uri),
-                new vscode.Position(params.position.line, params.position.character),
-                locations,
-                "peek"
+            const peekURI = client.protocol2CodeConverter.asUri(params.uri);
+
+            const peekPosition = new vscode.Position(
+                params.position.line,
+                params.position.character
+            );
+
+            const peekLocations = params.locations.map(
+                location =>
+                    new vscode.Location(
+                        client.protocol2CodeConverter.asUri(location),
+                        new vscode.Position(0, 0)
+                    )
             );
 
+            // If there already exists a peeked editor in `peekURI` at `peekPosition`, then the
+            // `openPeekedEditorIn` call will just close the peeked editor without reopening the peeked
+            // editor with the new `peekLocations`.
+            //
+            // As a workaround, we close the previous peeked editor by opening a dummy peeked editor so that the
+            // `openPeekedEditorIn` call below can just open the peeked editor with the new `peekLocations` in
+            // `peekURI` at `peekPosition`.
+            openDummyPeekedEditorIn(peekURI);
+
+            openPeekedEditorIn(peekURI, peekPosition, peekLocations);
+
             return { success: true };
         }
     );