New interface for performing edits and updating ranges (#2551)

This introduces a new interface to perform updates. The requirements I
had was:
1. Support both selections and ranges
2. Support both edits and callback
3. Support setting range expansion behavior per range/selection
4. Support updating selection internally

What this pr doesn't try to do:
1. Improve the range updater logic

Example
```ts
const {
  selections: [updatedContentSelections],
  ranges: [updatedEditRanges]
} = await new EditsUpdater(rangeUpdater, editableEditor, edits)
  .selections(contentSelections)
  .ranges(editRanges, RangeExpansionBehavior.openOpen)
  .updateEditorSelections()
  .run();
```

## Ponderings
1. Should updating editor selections be opt out instead?
1. Here I'm using two separate classes `EditsUpdater` and
`CallbackUpdater`. I'm a bit tempted to just use a single class and a
polymorphic argument. `editsOrCallback: Edit[] | () => Promise<void>`.
Something like that.
2. Strict necessary we don't actually need the two separate return
lists. Internally the range updater works with selections so we
converting ranges to selections internally. We could just return a
single list of selections and since all selections are also ranges I
don't think any of the actions would actually care?

If we embrace this polymorphic nature it could look something like this:
```ts
const [updatedEditSelections, updatedContentSelections] =
  await new EditsUpdater(rangeUpdater, editableEditor, edits)
    .add(contentSelections)
    .add(editRanges, RangeExpansionBehavior.openOpen)
    .updateEditorSelections()
    .run();
```

Personally I am a fan of the above since it became cleaner and simpler,
but I know that @pokey generally doesn't prefer union arguments if it
can be avoided.

We could of course get rid of `new` if we wanted to make it even
cleaner.

```ts
const [updatedEditSelections, updatedContentSelections] =
  await performUpdates(rangeUpdater, editableEditor, edits)
    .add(contentSelections)
    .add(editRanges, RangeExpansionBehavior.openOpen)
    .updateEditorSelections()
    .run();
```

Related to #729

## Checklist

- [/] I have added
[tests](https://www.cursorless.org/docs/contributing/test-case-recorder/)
- [/] I have updated the
[docs](https://github.com/cursorless-dev/cursorless/tree/main/docs) and
[cheatsheet](https://github.com/cursorless-dev/cursorless/tree/main/cursorless-talon/src/cheatsheet)
- [/] I have not broken the cheatsheet

---------

Co-authored-by: Pokey Rule <755842+pokey@users.noreply.github.com>

Author: AndreasArvidsson

packages/cursorless-engine/src/actions/BreakLine.ts

@@ -7,7 +7,7 @@ import {
 } from "@cursorless/common";
 import { flatten, zip } from "lodash-es";
 import type { RangeUpdater } from "../core/updateSelections/RangeUpdater";
-import { performEditsAndUpdateRanges } from "../core/updateSelections/updateSelections";
+import { performEditsAndUpdateSelections } from "../core/updateSelections/updateSelections";
 import { ide } from "../singletons/ide.singleton";
 import { Target } from "../typings/target.types";
 import { flashTargets, runOnTargetsForEachEditor } from "../util/targetUtils";
@@ -25,13 +25,17 @@ export class BreakLine {
       await runOnTargetsForEachEditor(targets, async (editor, targets) => {
         const contentRanges = targets.map(({ contentRange }) => contentRange);
         const edits = getEdits(editor, contentRanges);
+        const editableEditor = ide().getEditableTextEditor(editor);
 
-        const [updatedRanges] = await performEditsAndUpdateRanges(
-          this.rangeUpdater,
-          ide().getEditableTextEditor(editor),
-          edits,
-          [contentRanges],
-        );
+        const { contentRanges: updatedRanges } =
+          await performEditsAndUpdateSelections({
+            rangeUpdater: this.rangeUpdater,
+            editor: editableEditor,
+            edits,
+            selections: {
+              contentRanges,
+            },
+          });
 
         return zip(targets, updatedRanges).map(([target, range]) => ({
           editor: target!.editor,

packages/cursorless-engine/src/actions/BringMoveSwap.ts

@@ -7,10 +7,7 @@ import {
 } from "@cursorless/common";
 import { flatten } from "lodash-es";
 import { RangeUpdater } from "../core/updateSelections/RangeUpdater";
-import {
-  getSelectionInfo,
-  performEditsAndUpdateFullSelectionInfos,
-} from "../core/updateSelections/updateSelections";
+import { performEditsAndUpdateSelections } from "../core/updateSelections/updateSelections";
 import { ide } from "../singletons/ide.singleton";
 import { EditWithRangeUpdater } from "../typings/Types";
 import { Destination, Target } from "../typings/target.types";
@@ -158,64 +155,35 @@ abstract class BringMoveSwap {
               ? edits
               : edits.filter(({ isSource }) => !isSource);
 
-          // Sources should be closedClosed, because they should be logically
-          // the same as the original source.
-          const sourceEditSelectionInfos = sourceEdits.map(
-            ({ edit: { range }, originalTarget }) =>
-              getSelectionInfo(
-                editor.document,
-                range.toSelection(originalTarget.isReversed),
-                RangeExpansionBehavior.closedClosed,
-              ),
-          );
-
-          // Destinations should be openOpen, because they should grow to contain
-          // the new text.
-          const destinationEditSelectionInfos = destinationEdits.map(
-            ({ edit: { range }, originalTarget }) =>
-              getSelectionInfo(
-                editor.document,
-                range.toSelection(originalTarget.isReversed),
-                RangeExpansionBehavior.openOpen,
-              ),
-          );
-
-          const cursorSelectionInfos = editor.selections.map((selection) =>
-            getSelectionInfo(
-              editor.document,
-              selection,
-              RangeExpansionBehavior.closedClosed,
-            ),
+          const sourceEditRanges = sourceEdits.map(({ edit }) => edit.range);
+          const destinationEditRanges = destinationEdits.map(
+            ({ edit }) => edit.range,
           );
-
           const editableEditor = ide().getEditableTextEditor(editor);
 
-          const [
-            updatedSourceEditSelections,
-            updatedDestinationEditSelections,
-            cursorSelections,
-          ]: Selection[][] = await performEditsAndUpdateFullSelectionInfos(
-            this.rangeUpdater,
-            editableEditor,
-            filteredEdits.map(({ edit }) => edit),
-            [
-              sourceEditSelectionInfos,
-              destinationEditSelectionInfos,
-              cursorSelectionInfos,
-            ],
-          );
-
-          // NB: We set the selections here because we don't trust vscode to
-          // properly move the cursor on a bring. Sometimes it will smear an
-          // empty selection
-          await editableEditor.setSelections(cursorSelections);
+          const {
+            sourceEditRanges: updatedSourceEditRanges,
+            destinationEditRanges: updatedDestinationEditRanges,
+          } = await performEditsAndUpdateSelections({
+            rangeUpdater: this.rangeUpdater,
+            editor: editableEditor,
+            edits: filteredEdits.map(({ edit }) => edit),
+            selections: {
+              // Sources should be closedClosed, because they should be logically
+              // the same as the original source.
+              sourceEditRanges,
+              // Destinations should be openOpen, because they should grow to contain
+              // the new text.
+              destinationEditRanges: {
+                selections: destinationEditRanges,
+                behavior: RangeExpansionBehavior.openOpen,
+              },
+            },
+          });
 
           const marks = [
-            ...this.getMarks(sourceEdits, updatedSourceEditSelections),
-            ...this.getMarks(
-              destinationEdits,
-              updatedDestinationEditSelections,
-            ),
+            ...this.getMarks(sourceEdits, updatedSourceEditRanges),
+            ...this.getMarks(destinationEdits, updatedDestinationEditRanges),
           ];
 
           // Restore original order before split into source and destination
@@ -231,13 +199,10 @@ abstract class BringMoveSwap {
     );
   }
 
-  private getMarks(
-    edits: ExtendedEdit[],
-    selections: Selection[],
-  ): MarkEntry[] {
+  private getMarks(edits: ExtendedEdit[], ranges: Range[]): MarkEntry[] {
     return edits.map((edit, index): MarkEntry => {
-      const selection = selections[index];
-      const range = edit.edit.updateRange(selection);
+      const originalRange = ranges[index];
+      const range = edit.edit.updateRange(originalRange);
       const target = edit.originalTarget;
       return {
         editor: edit.editor,

packages/cursorless-engine/src/actions/CallbackAction.ts

@@ -2,7 +2,7 @@ import { EditableTextEditor, FlashStyle, TextEditor } from "@cursorless/common";
 import { flatten } from "lodash-es";
 import { selectionToStoredTarget } from "../core/commandRunner/selectionToStoredTarget";
 import { RangeUpdater } from "../core/updateSelections/RangeUpdater";
-import { callFunctionAndUpdateSelections } from "../core/updateSelections/updateSelections";
+import { performEditsAndUpdateSelections } from "../core/updateSelections/updateSelections";
 import { ide } from "../singletons/ide.singleton";
 import { Target } from "../typings/target.types";
 import {
@@ -97,13 +97,19 @@ export class CallbackAction {
       });
     }
 
-    const [updatedOriginalSelections, updatedTargetSelections] =
-      await callFunctionAndUpdateSelections(
-        this.rangeUpdater,
-        () => options.callback(editableEditor, targets),
-        editor.document,
-        [originalSelections, targetSelections],
-      );
+    const {
+      originalSelections: updatedOriginalSelections,
+      targetSelections: updatedTargetSelections,
+    } = await performEditsAndUpdateSelections({
+      rangeUpdater: this.rangeUpdater,
+      editor: editableEditor,
+      callback: () => options.callback(editableEditor, targets),
+      preserveCursorSelections: true,
+      selections: {
+        originalSelections,
+        targetSelections,
+      },
+    });
 
     // Reset original selections
     if (options.setSelection && options.restoreSelection) {

packages/cursorless-engine/src/actions/EditNew/runEditTargets.ts

@@ -1,11 +1,7 @@
-import {
-  EditableTextEditor,
-  RangeExpansionBehavior,
-  Selection,
-} from "@cursorless/common";
+import { EditableTextEditor, RangeExpansionBehavior } from "@cursorless/common";
 import { zip } from "lodash-es";
 import { RangeUpdater } from "../../core/updateSelections/RangeUpdater";
-import { performEditsAndUpdateSelectionsWithBehavior } from "../../core/updateSelections/updateSelections";
+import { performEditsAndUpdateSelections } from "../../core/updateSelections/updateSelections";
 import { EditDestination, State } from "./EditNew.types";
 
 /**
@@ -46,10 +42,6 @@ export async function runEditTargets(
     destination.destination.constructChangeEdit(""),
   );
 
-  const thatSelections = {
-    selections: state.thatRanges.map((r) => r.toSelection(false)),
-  };
-
   // We need to remove undefined cursor locations.  Note that these undefined
   // locations will be the locations where our edit targets will go.  The only
   // cursor positions defined at this point will have come from command targets
@@ -59,44 +51,45 @@ export async function runEditTargets(
     .filter(({ range }) => range != null);
 
   const cursorIndices = cursorInfos.map(({ index }) => index);
+  const cursorRanges = cursorInfos.map(({ range }) => range!);
+  const editRanges = edits.map((edit) => edit.range);
 
-  const cursorSelections = {
-    selections: cursorInfos.map(({ range }) => range!.toSelection(false)),
-  };
-
-  const editSelections = {
-    selections: edits.map((edit) => edit.range.toSelection(false)),
-    rangeBehavior: RangeExpansionBehavior.openOpen,
-  };
-
-  const [
-    updatedThatSelections,
-    updatedCursorSelections,
-    updatedEditSelections,
-  ]: Selection[][] = await performEditsAndUpdateSelectionsWithBehavior(
+  const {
+    thatRanges: updatedThatRanges,
+    cursorRanges: updatedCursorRanges,
+    editRanges: updatedEditRanges,
+  } = await performEditsAndUpdateSelections({
     rangeUpdater,
     editor,
     edits,
-    [thatSelections, cursorSelections, editSelections],
-  );
+    preserveCursorSelections: true,
+    selections: {
+      thatRanges: state.thatRanges,
+      cursorRanges,
+      editRanges: {
+        selections: editRanges,
+        behavior: RangeExpansionBehavior.openOpen,
+      },
+    },
+  });
 
-  const updatedCursorRanges = [...state.cursorRanges];
+  const finalCursorRanges = [...state.cursorRanges];
 
   // Update the cursor positions for the command targets
-  zip(cursorIndices, updatedCursorSelections).forEach(([index, selection]) => {
-    updatedCursorRanges[index!] = selection;
+  zip(cursorIndices, updatedCursorRanges).forEach(([index, range]) => {
+    finalCursorRanges[index!] = range;
   });
 
   // Add cursor positions for our edit targets.
   destinations.forEach((delimiterTarget, index) => {
     const edit = edits[index];
-    const range = edit.updateRange(updatedEditSelections[index]);
-    updatedCursorRanges[delimiterTarget.index] = range;
+    const range = edit.updateRange(updatedEditRanges[index]);
+    finalCursorRanges[delimiterTarget.index] = range;
   });
 
   return {
     destinations: state.destinations,
-    thatRanges: updatedThatSelections,
-    cursorRanges: updatedCursorRanges,
+    thatRanges: updatedThatRanges,
+    cursorRanges: finalCursorRanges,
   };
 }

packages/cursorless-engine/src/actions/EditNew/runInsertLineAfterTargets.ts

@@ -1,6 +1,6 @@
 import { CommandCapabilities, EditableTextEditor } from "@cursorless/common";
 import { RangeUpdater } from "../../core/updateSelections/RangeUpdater";
-import { callFunctionAndUpdateRanges } from "../../core/updateSelections/updateSelections";
+import { performEditsAndUpdateSelections } from "../../core/updateSelections/updateSelections";
 import { EditDestination, State } from "./EditNew.types";
 
 /**
@@ -39,27 +39,33 @@ export async function runInsertLineAfterTargets(
   const contentRanges = destinations.map(
     ({ destination }) => destination.contentRange,
   );
+  const targetRanges = state.destinations.map(
+    ({ contentRange }) => contentRange,
+  );
+
+  const callback = async () => {
+    if (acceptsLocation) {
+      await editor.insertLineAfter(contentRanges);
+    } else {
+      await editor.setSelections(
+        contentRanges.map((range) => range.toSelection(false)),
+      );
+      await editor.focus();
+      await editor.insertLineAfter();
+    }
+  };
 
-  const [updatedTargetRanges, updatedThatRanges] =
-    await callFunctionAndUpdateRanges(
+  const { targetRanges: updatedTargetRanges, thatRanges: updatedThatRanges } =
+    await performEditsAndUpdateSelections({
       rangeUpdater,
-      async () => {
-        if (acceptsLocation) {
-          await editor.insertLineAfter(contentRanges);
-        } else {
-          await editor.setSelections(
-            contentRanges.map((range) => range.toSelection(false)),
-          );
-          await editor.focus();
-          await editor.insertLineAfter();
-        }
+      editor,
+      callback,
+      preserveCursorSelections: true,
+      selections: {
+        targetRanges,
+        thatRanges: state.thatRanges,
       },
-      editor.document,
-      [
-        state.destinations.map(({ contentRange }) => contentRange),
-        state.thatRanges,
-      ],
-    );
+    });
 
   // For each of the given command targets, the cursor will go where it ended
   // up after running the command.  We add it to the state so that any