Format on Document Range (#1275)

Enables the feature to format highlighted Q# code, rather than
formatting the whole file.

Author: ScottCarda-MS

vscode/src/extension.ts

@@ -39,7 +39,7 @@ import { initCodegen } from "./qirGeneration.js";
 import { createReferenceProvider } from "./references.js";
 import { createRenameProvider } from "./rename.js";
 import { createSignatureHelpProvider } from "./signature.js";
-import { createFormatProvider } from "./format.js";
+import { createFormattingProvider } from "./format.js";
 import { activateTargetProfileStatusBarItem } from "./statusbar.js";
 import {
   EventType,
@@ -185,14 +185,20 @@ async function activateLanguageService(extensionUri: vscode.Uri) {
   // format document
   const isFormattingEnabled = getEnableFormating();
   const formatterHandle = {
-    handle: undefined as vscode.Disposable | undefined,
+    DocumentFormattingHandle: undefined as vscode.Disposable | undefined,
+    DocumentRangeFormattingHandle: undefined as vscode.Disposable | undefined,
   };
   log.debug("Enable formatting set to: " + isFormattingEnabled);
   if (isFormattingEnabled) {
-    formatterHandle.handle =
+    formatterHandle.DocumentFormattingHandle =
       vscode.languages.registerDocumentFormattingEditProvider(
         qsharpLanguageId,
-        createFormatProvider(languageService),
+        createFormattingProvider(languageService),
+      );
+    formatterHandle.DocumentRangeFormattingHandle =
+      vscode.languages.registerDocumentRangeFormattingEditProvider(
+        qsharpLanguageId,
+        createFormattingProvider(languageService),
       );
   }
 
@@ -290,13 +296,21 @@ async function updateLanguageServiceEnableFormatting(
   const isFormattingEnabled = getEnableFormating();
   log.debug("Enable formatting set to: " + isFormattingEnabled);
   if (isFormattingEnabled) {
-    formatterHandle.handle =
+    formatterHandle.DocumentFormattingHandle =
       vscode.languages.registerDocumentFormattingEditProvider(
         qsharpLanguageId,
-        createFormatProvider(languageService),
+        createFormattingProvider(languageService),
+      );
+    formatterHandle.DocumentRangeFormattingHandle =
+      vscode.languages.registerDocumentRangeFormattingEditProvider(
+        qsharpLanguageId,
+        createFormattingProvider(languageService),
       );
   } else {
-    formatterHandle.handle?.dispose();
+    formatterHandle.DocumentFormattingHandle?.dispose();
+    formatterHandle.DocumentFormattingHandle = undefined;
+    formatterHandle.DocumentRangeFormattingHandle?.dispose();
+    formatterHandle.DocumentRangeFormattingHandle = undefined;
   }
 }
 

vscode/src/format.ts

@@ -4,20 +4,32 @@
 import { ILanguageService } from "qsharp-lang";
 import * as vscode from "vscode";
 import { toVscodeRange } from "./common";
-import { EventType, sendTelemetryEvent } from "./telemetry";
+import { EventType, FormatEvent, sendTelemetryEvent } from "./telemetry";
 import { getRandomGuid } from "./utils";
 
-export function createFormatProvider(languageService: ILanguageService) {
-  return new QSharpFormatProvider(languageService);
+export function createFormattingProvider(languageService: ILanguageService) {
+  return new QSharpFormattingProvider(languageService);
 }
 
-class QSharpFormatProvider implements vscode.DocumentFormattingEditProvider {
+class QSharpFormattingProvider
+  implements
+    vscode.DocumentFormattingEditProvider,
+    vscode.DocumentRangeFormattingEditProvider
+{
   constructor(public languageService: ILanguageService) {}
 
-  async provideDocumentFormattingEdits(document: vscode.TextDocument) {
+  private async getFormatChanges(
+    document: vscode.TextDocument,
+    eventKind: FormatEvent,
+    range?: vscode.Range,
+  ) {
     // telemetry start format
     const associationId = getRandomGuid();
-    sendTelemetryEvent(EventType.FormatStart, { associationId }, {});
+    sendTelemetryEvent(
+      EventType.FormatStart,
+      { associationId, event: eventKind },
+      {},
+    );
     const start = performance.now();
 
     const lsEdits = await this.languageService.getFormatChanges(
@@ -37,10 +49,17 @@ class QSharpFormatProvider implements vscode.DocumentFormattingEditProvider {
       return [];
     }
 
-    const edits = lsEdits.map(
+    let edits = lsEdits.map(
       (edit) => new vscode.TextEdit(toVscodeRange(edit.range), edit.newText),
     );
 
+    if (range) {
+      edits = edits.filter(
+        (e) =>
+          range.start.isBefore(e.range.end) && range.end.isAfter(e.range.start),
+      );
+    }
+
     // telemetry end format
     sendTelemetryEvent(
       EventType.FormatEnd,
@@ -53,4 +72,15 @@ class QSharpFormatProvider implements vscode.DocumentFormattingEditProvider {
 
     return edits;
   }
+
+  async provideDocumentFormattingEdits(document: vscode.TextDocument) {
+    return await this.getFormatChanges(document, FormatEvent.OnDocument);
+  }
+
+  async provideDocumentRangeFormattingEdits(
+    document: vscode.TextDocument,
+    range: vscode.Range,
+  ) {
+    return await this.getFormatChanges(document, FormatEvent.OnRange, range);
+  }
 }

vscode/src/telemetry.ts

@@ -209,7 +209,7 @@ type EventTypes = {
     measurements: { timeToCompleteMs: number };
   };
   [EventType.FormatStart]: {
-    properties: { associationId: string };
+    properties: { associationId: string; event: FormatEvent };
     measurements: Empty;
   };
   [EventType.FormatEnd]: {
@@ -237,6 +237,12 @@ export enum DebugEvent {
   Continue = "Continue",
 }
 
+export enum FormatEvent {
+  OnDocument = "OnDocument",
+  OnRange = "OnRange",
+  OnType = "OnType",
+}
+
 let reporter: TelemetryReporter | undefined;
 let userAgentString: string | undefined;
 

vscode/test/suites/language-service/language-service.test.ts

@@ -108,6 +108,57 @@ suite("Q# Language Service Tests", function suite() {
     );
   });
 
+  test("Format Document", async () => {
+    await vscode.workspace.openTextDocument(docUri);
+
+    const actualFormatEdits = (await vscode.commands.executeCommand(
+      "vscode.executeFormatDocumentProvider",
+      docUri,
+    )) as vscode.TextEdit[];
+
+    assert.lengthOf(actualFormatEdits, 1);
+    assert.equal(actualFormatEdits[0].range.start.line, 7);
+    assert.equal(actualFormatEdits[0].range.start.character, 27);
+    assert.equal(actualFormatEdits[0].range.end.line, 8);
+    assert.equal(actualFormatEdits[0].range.end.character, 4);
+    assert.equal(actualFormatEdits[0].newText, "");
+  });
+
+  test("Format Document Range", async () => {
+    await vscode.workspace.openTextDocument(docUri);
+
+    const noEditRange = new vscode.Range(
+      new vscode.Position(7, 24),
+      new vscode.Position(7, 27),
+    );
+    const editRange = new vscode.Range(
+      new vscode.Position(7, 27),
+      new vscode.Position(8, 4),
+    );
+
+    let actualFormatEdits = (await vscode.commands.executeCommand(
+      "vscode.executeFormatRangeProvider",
+      docUri,
+      noEditRange,
+    )) as vscode.TextEdit[];
+
+    // assert that edits outside the range aren't returned
+    assert.isUndefined(actualFormatEdits);
+
+    actualFormatEdits = (await vscode.commands.executeCommand(
+      "vscode.executeFormatRangeProvider",
+      docUri,
+      editRange,
+    )) as vscode.TextEdit[];
+
+    assert.lengthOf(actualFormatEdits, 1);
+    assert.equal(actualFormatEdits[0].range.start.line, 7);
+    assert.equal(actualFormatEdits[0].range.start.character, 27);
+    assert.equal(actualFormatEdits[0].range.end.line, 8);
+    assert.equal(actualFormatEdits[0].range.end.character, 4);
+    assert.equal(actualFormatEdits[0].newText, "");
+  });
+
   test("Code Lens", async () => {
     const doc = await vscode.workspace.openTextDocument(docUri);