Support "inside head" (#2442)

## Checklist

- [x] 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

Author: pokey

data/fixtures/recorded/headTail/changeInsideTailCurly.yml

@@ -0,0 +1,26 @@
+languageId: plaintext
+command:
+  version: 7
+  spokenForm: change inside tail curly
+  action:
+    name: clearAndSetSelection
+    target:
+      type: primitive
+      modifiers:
+        - {type: interiorOnly}
+        - type: extendThroughEndOf
+          modifiers:
+            - type: containingScope
+              scopeType: {type: surroundingPair, delimiter: curlyBrackets}
+  usePrePhraseSnapshot: true
+initialState:
+  documentContents: "{(\"hello\")}"
+  selections:
+    - anchor: {line: 0, character: 5}
+      active: {line: 0, character: 5}
+  marks: {}
+finalState:
+  documentContents: "{(\"he}"
+  selections:
+    - anchor: {line: 0, character: 5}
+      active: {line: 0, character: 5}

packages/cursorless-engine/src/processTargets/ModifierStageFactoryImpl.ts

@@ -16,7 +16,7 @@ import {
   KeepContentFilterStage,
   KeepEmptyFilterStage,
 } from "./modifiers/FilterStages";
-import { HeadStage, TailStage } from "./modifiers/HeadTailStage";
+import { HeadTailStage } from "./modifiers/HeadTailStage";
 import { InstanceStage } from "./modifiers/InstanceStage";
 import {
   ExcludeInteriorStage,
@@ -56,9 +56,8 @@ export class ModifierStageFactoryImpl implements ModifierStageFactory {
       case "endOf":
         return new EndOfStage();
       case "extendThroughStartOf":
-        return new HeadStage(this, modifier);
       case "extendThroughEndOf":
-        return new TailStage(this, modifier);
+        return new HeadTailStage(this, modifier);
       case "toRawSelection":
         return new RawSelectionStage(modifier);
       case "interiorOnly":

packages/cursorless-engine/src/processTargets/modifiers/HeadTailStage.ts

@@ -1,27 +1,21 @@
-import {
-  HeadModifier,
-  Modifier,
-  Range,
-  TailModifier,
-} from "@cursorless/common";
+import { HeadModifier, TailModifier } from "@cursorless/common";
 import { Target } from "../../typings/target.types";
 import { ModifierStageFactory } from "../ModifierStageFactory";
 import { ModifierStage } from "../PipelineStages.types";
 import {
   getModifierStagesFromTargetModifiers,
   processModifierStages,
 } from "../TargetPipelineRunner";
-import { TokenTarget } from "../targets";
+import { HeadTailTarget } from "../targets";
 
-abstract class HeadTailStage implements ModifierStage {
+export class HeadTailStage implements ModifierStage {
   constructor(
     private modifierStageFactory: ModifierStageFactory,
-    private isReversed: boolean,
-    private modifiers?: Modifier[],
+    private modifier: HeadModifier | TailModifier,
   ) {}
 
   run(target: Target): Target[] {
-    const modifiers = this.modifiers ?? [
+    const modifiers = this.modifier.modifiers ?? [
       {
         type: "containingScope",
         scopeType: { type: "line" },
@@ -35,47 +29,15 @@ abstract class HeadTailStage implements ModifierStage {
     const modifiedTargets = processModifierStages(modifierStages, [target]);
 
     return modifiedTargets.map((modifiedTarget) => {
-      const contentRange = this.constructContentRange(
-        target.contentRange,
-        modifiedTarget.contentRange,
-      );
+      const isHead = this.modifier.type === "extendThroughStartOf";
 
-      return new TokenTarget({
+      return new HeadTailTarget({
         editor: target.editor,
-        isReversed: this.isReversed,
-        contentRange,
+        isReversed: isHead,
+        inputTarget: target,
+        modifiedTarget,
+        isHead,
       });
     });
   }
-
-  protected abstract constructContentRange(
-    originalRange: Range,
-    modifiedRange: Range,
-  ): Range;
-}
-
-export class HeadStage extends HeadTailStage {
-  constructor(
-    modifierStageFactory: ModifierStageFactory,
-    modifier: HeadModifier,
-  ) {
-    super(modifierStageFactory, true, modifier.modifiers);
-  }
-
-  protected constructContentRange(originalRange: Range, modifiedRange: Range) {
-    return new Range(modifiedRange.start, originalRange.end);
-  }
-}
-
-export class TailStage extends HeadTailStage {
-  constructor(
-    modifierStageFactory: ModifierStageFactory,
-    modifier: TailModifier,
-  ) {
-    super(modifierStageFactory, false, modifier.modifiers);
-  }
-
-  protected constructContentRange(originalRange: Range, modifiedRange: Range) {
-    return new Range(originalRange.start, modifiedRange.end);
-  }
 }

packages/cursorless-engine/src/processTargets/targets/HeadTailTarget.ts

@@ -0,0 +1,83 @@
+import { Range } from "@cursorless/common";
+import { BaseTarget, MinimumTargetParameters } from "./BaseTarget";
+import { Target } from "../../typings/target.types";
+import {
+  getTokenLeadingDelimiterTarget,
+  getTokenRemovalRange,
+  getTokenTrailingDelimiterTarget,
+} from "./util/insertionRemovalBehaviors/TokenInsertionRemovalBehavior";
+import { PlainTarget } from "./PlainTarget";
+
+export interface HeadTailTargetParameters extends MinimumTargetParameters {
+  inputTarget: Target;
+  modifiedTarget: Target;
+  isHead: boolean;
+}
+
+export class HeadTailTarget extends BaseTarget<HeadTailTargetParameters> {
+  type = "HeadTailTarget";
+  insertionDelimiter = " ";
+  private readonly inputTarget: Target;
+  private readonly modifiedTarget: Target;
+  private readonly isHead: boolean;
+
+  constructor(parameters: HeadTailTargetParameters) {
+    const { inputTarget, modifiedTarget, isHead } = parameters;
+    super({
+      ...parameters,
+      contentRange: constructRange(
+        inputTarget.contentRange,
+        modifiedTarget.contentRange,
+        isHead,
+      ),
+    });
+    this.inputTarget = inputTarget;
+    this.modifiedTarget = modifiedTarget;
+    this.isHead = isHead;
+  }
+  getLeadingDelimiterTarget(): Target | undefined {
+    return getTokenLeadingDelimiterTarget(this);
+  }
+  getTrailingDelimiterTarget(): Target | undefined {
+    return getTokenTrailingDelimiterTarget(this);
+  }
+  getRemovalRange(): Range {
+    return getTokenRemovalRange(this);
+  }
+  getInterior(): Target[] | undefined {
+    const modifiedInterior = this.modifiedTarget.getInterior();
+    if (modifiedInterior == null) {
+      return undefined;
+    }
+    return modifiedInterior.map((target) => {
+      return new PlainTarget({
+        editor: this.editor,
+        contentRange: constructRange(
+          this.inputTarget.contentRange,
+          target.contentRange,
+          this.isHead,
+        ),
+        isReversed: this.isReversed,
+      });
+    });
+  }
+
+  protected getCloneParameters() {
+    return {
+      ...this.state,
+      inputTarget: this.inputTarget,
+      modifiedTarget: this.modifiedTarget,
+      isHead: this.isHead,
+    };
+  }
+}
+
+function constructRange(
+  originalRange: Range,
+  modifiedRange: Range,
+  isHead: boolean,
+): Range {
+  return isHead
+    ? new Range(modifiedRange.start, originalRange.end)
+    : new Range(originalRange.start, modifiedRange.end);
+}

packages/cursorless-engine/src/processTargets/targets/index.ts

@@ -14,3 +14,4 @@ export * from "./TokenTarget";
 export * from "./UntypedTarget";
 export * from "./ImplicitTarget";
 export * from "./InteriorTarget";
+export * from "./HeadTailTarget";

packages/cursorless-vscode-e2e/src/suite/keyboard/basic.vscode.test.ts

@@ -69,6 +69,12 @@ const testCases: TestCase[] = [
     keySequence: ["da", "mi", "c"],
     finalContent: "()",
   },
+  {
+    name: "inside tail curly bat",
+    initialContent: "{(aaa bbb ccc)}",
+    keySequence: ["db", "mt", "wb", "mi", "c"],
+    finalContent: "{(aaa }",
+  },
   {
     name: "wrap",
     initialContent: "a",