Rework breakpoint implementation

Author: pokey

src/actions/ToggleBreakpoint.ts

@@ -1,4 +1,4 @@
-import { Range } from "@cursorless/common";
+import { BreakpointDescriptor } from "../libs/common/types/TextEditor";
 import ide from "../libs/cursorless-engine/singletons/ide.singleton";
 import { containingLineIfUntypedStage } from "../processTargets/modifiers/commonContainingScopeIfUntypedStages";
 import { Target } from "../typings/target.types";
@@ -22,16 +22,25 @@ export default class ToggleBreakpoint implements Action {
     );
 
     await runOnTargetsForEachEditor(targets, async (editor, targets) => {
-      const ranges = targets.map((target) => {
-        const range = target.contentRange;
-        // The action preference give us line content but line breakpoints are registered on character 0
-        if (target.isLine) {
-          return new Range(range.start.line, 0, range.end.line, 0);
-        }
-        return range;
-      });
+      const breakpointDescriptors: BreakpointDescriptor[] = targets.map(
+        (target) => {
+          const range = target.contentRange;
+          return target.isLine
+            ? {
+                type: "line",
+                startLine: range.start.line,
+                endLine: range.end.line,
+              }
+            : {
+                type: "inline",
+                range,
+              };
+        },
+      );
 
-      await ide().getEditableTextEditor(editor).toggleBreakpoint(ranges);
+      await ide()
+        .getEditableTextEditor(editor)
+        .toggleBreakpoint(breakpointDescriptors);
     });
 
     return {

src/ide/vscode/VscodeTextEditorImpl.ts

@@ -1,4 +1,5 @@
 import {
+  BreakpointDescriptor,
   EditableTextEditor,
   Position,
   Range,
@@ -127,8 +128,8 @@ export class VscodeTextEditorImpl implements EditableTextEditor {
     return vscodeUnfold(this.ide, this, ranges);
   }
 
-  public toggleBreakpoint(ranges?: Range[]): Promise<void> {
-    return vscodeToggleBreakpoint(this, ranges);
+  public toggleBreakpoint(descriptors?: BreakpointDescriptor[]): Promise<void> {
+    return vscodeToggleBreakpoint(this, descriptors);
   }
 
   public async toggleLineComment(_ranges?: Range[]): Promise<void> {

src/ide/vscode/VscodeToggleBreakpoint.ts

@@ -1,25 +1,36 @@
-import { Range } from "@cursorless/common";
+import { BreakpointDescriptor } from "@cursorless/common";
 import { toVscodeRange } from "@cursorless/vscode-common";
 import * as vscode from "vscode";
 import { VscodeTextEditorImpl } from "./VscodeTextEditorImpl";
 
 export async function vscodeToggleBreakpoint(
   editor: VscodeTextEditorImpl,
-  ranges: Range[] | undefined,
+  descriptors: BreakpointDescriptor[] | undefined,
 ): Promise<void> {
+  if (descriptors == null) {
+    return await vscode.commands.executeCommand(
+      "editor.debug.action.toggleBreakpoint",
+    );
+  }
+
   const uri = editor.document.uri;
   const toAdd: vscode.Breakpoint[] = [];
   const toRemove: vscode.Breakpoint[] = [];
-  const actualRanges = ranges ?? editor.selections;
 
-  actualRanges.forEach((range) => {
-    const vscodeRange = toVscodeRange(range);
-    const existing = getBreakpoints(uri, vscodeRange);
+  descriptors.forEach((descriptor) => {
+    const existing = getBreakpoints(uri, descriptor);
     if (existing.length > 0) {
       toRemove.push(...existing);
     } else {
       toAdd.push(
-        new vscode.SourceBreakpoint(new vscode.Location(uri, vscodeRange)),
+        new vscode.SourceBreakpoint(
+          new vscode.Location(
+            uri,
+            descriptor.type === "line"
+              ? new vscode.Range(descriptor.startLine, 0, descriptor.endLine, 0)
+              : toVscodeRange(descriptor.range),
+          ),
+        ),
       );
     }
   });
@@ -28,11 +39,22 @@ export async function vscodeToggleBreakpoint(
   vscode.debug.removeBreakpoints(toRemove);
 }
 
-function getBreakpoints(uri: vscode.Uri, range: vscode.Range) {
+function getBreakpoints(uri: vscode.Uri, descriptor: BreakpointDescriptor) {
+  let descriptorIntersectsRange: (range: vscode.Range) => boolean;
+
+  if (descriptor.type === "line") {
+    descriptorIntersectsRange = ({ start, end }) =>
+      descriptor.startLine <= start.line && descriptor.endLine >= end.line;
+  } else {
+    const descriptorRange = toVscodeRange(descriptor.range);
+    descriptorIntersectsRange = (range) =>
+      range.intersection(descriptorRange) != null;
+  }
+
   return vscode.debug.breakpoints.filter(
     (breakpoint) =>
       breakpoint instanceof vscode.SourceBreakpoint &&
       breakpoint.location.uri.toString() === uri.toString() &&
-      breakpoint.location.range.intersection(range) != null,
+      descriptorIntersectsRange(breakpoint.location.range),
   );
 }

src/libs/common/types/TextEditor.ts

@@ -155,10 +155,13 @@ export interface EditableTextEditor extends TextEditor {
   clipboardPaste(ranges?: Range[]): Promise<void>;
 
   /**
-   * Toggle breakpoints
-   * @param ranges A list of {@link Range ranges}
+   * Toggle breakpoints. For each of the descriptors in {@link descriptors},
+   * remove all breakpoints overlapping with the given descriptor if it overlaps
+   * with any existing breakpoint, otherwise add a new breakpoint at the given
+   * location.
+   * @param descriptors A list of breakpoint descriptors
    */
-  toggleBreakpoint(ranges?: Range[]): Promise<void>;
+  toggleBreakpoint(descriptors?: BreakpointDescriptor[]): Promise<void>;
 
   /**
    * Toggle line comments
@@ -239,3 +242,21 @@ export interface EditableTextEditor extends TextEditor {
    */
   extractVariable(range?: Range): Promise<void>;
 }
+
+interface LineBreakpointDescriptor {
+  type: "line";
+  startLine: number;
+  /**
+   * Last line, inclusive
+   */
+  endLine: number;
+}
+
+interface InlineBreakpointDescriptor {
+  type: "inline";
+  range: Range;
+}
+
+export type BreakpointDescriptor =
+  | LineBreakpointDescriptor
+  | InlineBreakpointDescriptor;