Make "inside" fall back to pair when the target doesn't have an interior (#2426)

This one bit me a lot. See the test case for what now works. Basically
"inside value" when value is a string is the most common one

## 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/implicitExpansion/clearBoundsToken.yml

@@ -16,4 +16,10 @@ initialState:
     - anchor: {line: 0, character: 1}
       active: {line: 0, character: 1}
   marks: {}
-thrownError: {name: NoContainingScopeError}
+finalState:
+  documentContents: aaa
+  selections:
+    - anchor: {line: 0, character: 0}
+      active: {line: 0, character: 0}
+    - anchor: {line: 0, character: 3}
+      active: {line: 0, character: 3}

data/fixtures/recorded/implicitExpansion/clearCoreToken.yml

@@ -16,4 +16,8 @@ initialState:
     - anchor: {line: 0, character: 1}
       active: {line: 0, character: 1}
   marks: {}
-thrownError: {name: NoContainingScopeError}
+finalState:
+  documentContents: ()
+  selections:
+    - anchor: {line: 0, character: 1}
+      active: {line: 0, character: 1}

data/fixtures/recorded/implicitExpansion/squareSwitchFunk.yml

@@ -22,4 +22,13 @@ initialState:
     - anchor: {line: 2, character: 7}
       active: {line: 2, character: 7}
   marks: {}
-thrownError: {name: NoContainingScopeError}
+finalState:
+  documentContents: |-
+    [
+      function myFunk() {
+        // aaa
+      }
+    ]
+  selections:
+    - anchor: {line: 2, character: 7}
+      active: {line: 2, character: 7}

data/fixtures/recorded/modifiers/changeBoundsValue.yml

@@ -0,0 +1,32 @@
+languageId: typescript
+command:
+  version: 7
+  spokenForm: change bounds value
+  action:
+    name: clearAndSetSelection
+    target:
+      type: primitive
+      modifiers:
+        - {type: excludeInterior}
+        - type: containingScope
+          scopeType: {type: value}
+  usePrePhraseSnapshot: true
+initialState:
+  documentContents: |-
+    const aaa = {
+        bbb: "ccc ddd"
+    }
+  selections:
+    - anchor: {line: 1, character: 4}
+      active: {line: 1, character: 4}
+  marks: {}
+finalState:
+  documentContents: |-
+    const aaa = {
+        bbb: ccc ddd
+    }
+  selections:
+    - anchor: {line: 1, character: 9}
+      active: {line: 1, character: 9}
+    - anchor: {line: 1, character: 16}
+      active: {line: 1, character: 16}

data/fixtures/recorded/modifiers/changeInsideValue.yml

@@ -0,0 +1,30 @@
+languageId: typescript
+command:
+  version: 7
+  spokenForm: change inside value
+  action:
+    name: clearAndSetSelection
+    target:
+      type: primitive
+      modifiers:
+        - {type: interiorOnly}
+        - type: containingScope
+          scopeType: {type: value}
+  usePrePhraseSnapshot: true
+initialState:
+  documentContents: |-
+    const aaa = {
+        bbb: "ccc ddd"
+    }
+  selections:
+    - anchor: {line: 1, character: 4}
+      active: {line: 1, character: 4}
+  marks: {}
+finalState:
+  documentContents: |-
+    const aaa = {
+        bbb: ""
+    }
+  selections:
+    - anchor: {line: 1, character: 10}
+      active: {line: 1, character: 10}

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

@@ -2,7 +2,6 @@ import { FlashStyle } from "@cursorless/common";
 import { RangeUpdater } from "../core/updateSelections/RangeUpdater";
 import { performEditsAndUpdateRanges } from "../core/updateSelections/updateSelections";
 import { ModifierStageFactory } from "../processTargets/ModifierStageFactory";
-import { containingSurroundingPairIfUntypedModifier } from "../processTargets/modifiers/commonContainingScopeIfUntypedModifiers";
 import { ide } from "../singletons/ide.singleton";
 import { Target } from "../typings/target.types";
 import {
@@ -11,12 +10,11 @@ import {
   runOnTargetsForEachEditor,
 } from "../util/targetUtils";
 import { ActionReturnValue } from "./actions.types";
+import { getContainingSurroundingPairIfNoBoundaryStage } from "../processTargets/modifiers/InteriorStage";
 
 export default class Rewrap {
   getFinalStages = () => [
-    this.modifierStageFactory.create(
-      containingSurroundingPairIfUntypedModifier,
-    ),
+    getContainingSurroundingPairIfNoBoundaryStage(this.modifierStageFactory),
   ];
 
   constructor(
@@ -32,7 +30,7 @@ export default class Rewrap {
     right: string,
   ): Promise<ActionReturnValue> {
     const boundaryTargets = targets.flatMap((target) => {
-      const boundary = target.getBoundaryStrict();
+      const boundary = target.getBoundary()!;
 
       if (boundary.length !== 2) {
         throw Error("Target must have an opening and closing delimiter");

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

@@ -59,6 +59,23 @@ export class ModifyIfUntypedStage extends ConditionalModifierBaseStage {
   }
 }
 
+/**
+ * Runs {@link nestedModifier} if {@link modificationCondition} returns `true`.
+ */
+export class ModifyIfConditionStage extends ConditionalModifierBaseStage {
+  constructor(
+    modifierStageFactory: ModifierStageFactory,
+    nestedModifier: Modifier,
+    private modificationCondition: (target: Target) => boolean,
+  ) {
+    super(modifierStageFactory, nestedModifier);
+  }
+
+  protected shouldModify(target: Target): boolean {
+    return this.modificationCondition(target);
+  }
+}
+
 /**
  * Runs {@link nestedModifier} if
  * - the target has no explicit scope type, ie if

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

@@ -5,32 +5,66 @@ import {
 import { Target } from "../../typings/target.types";
 import { ModifierStageFactory } from "../ModifierStageFactory";
 import { ModifierStage } from "../PipelineStages.types";
-import { containingSurroundingPairIfUntypedModifier } from "./commonContainingScopeIfUntypedModifiers";
+import { ModifyIfConditionStage } from "./ConditionalModifierStages";
 
 export class InteriorOnlyStage implements ModifierStage {
+  private containingSurroundingPairIfNoInteriorStage: ModifierStage;
+
   constructor(
     private modifierStageFactory: ModifierStageFactory,
     private modifier: InteriorOnlyModifier,
-  ) {}
+  ) {
+    this.containingSurroundingPairIfNoInteriorStage =
+      getContainingSurroundingPairIfNoInteriorStage(this.modifierStageFactory);
+  }
 
   run(target: Target): Target[] {
-    return this.modifierStageFactory
-      .create(containingSurroundingPairIfUntypedModifier)
+    return this.containingSurroundingPairIfNoInteriorStage
       .run(target)
-      .flatMap((target) => target.getInteriorStrict());
+      .flatMap((target) => target.getInterior()!);
   }
 }
 
 export class ExcludeInteriorStage implements ModifierStage {
+  private containingSurroundingPairIfNoBoundaryStage: ModifierStage;
+
   constructor(
     private modifierStageFactory: ModifierStageFactory,
     private modifier: ExcludeInteriorModifier,
-  ) {}
+  ) {
+    this.containingSurroundingPairIfNoBoundaryStage =
+      getContainingSurroundingPairIfNoBoundaryStage(this.modifierStageFactory);
+  }
 
   run(target: Target): Target[] {
-    return this.modifierStageFactory
-      .create(containingSurroundingPairIfUntypedModifier)
+    return this.containingSurroundingPairIfNoBoundaryStage
       .run(target)
-      .flatMap((target) => target.getBoundaryStrict());
+      .flatMap((target) => target.getBoundary()!);
   }
 }
+
+function getContainingSurroundingPairIfNoInteriorStage(
+  modifierStageFactory: ModifierStageFactory,
+): ModifierStage {
+  return new ModifyIfConditionStage(
+    modifierStageFactory,
+    {
+      type: "containingScope",
+      scopeType: { type: "surroundingPair", delimiter: "any" },
+    },
+    (target) => target.getInterior() == null,
+  );
+}
+
+export function getContainingSurroundingPairIfNoBoundaryStage(
+  modifierStageFactory: ModifierStageFactory,
+): ModifierStage {
+  return new ModifyIfConditionStage(
+    modifierStageFactory,
+    {
+      type: "containingScope",
+      scopeType: { type: "surroundingPair", delimiter: "any" },
+    },
+    (target) => target.getBoundary() == null,
+  );
+}

packages/cursorless-engine/src/processTargets/modifiers/ItemStage/getIterationScope.ts

@@ -28,7 +28,7 @@ export function getIterationScope(
       )
     ) {
       return {
-        range: surroundingTarget.getInteriorStrict()[0].contentRange,
+        range: surroundingTarget.getInterior()[0].contentRange,
         boundary: getBoundary(surroundingTarget),
       };
     }
@@ -107,7 +107,7 @@ function useInteriorOfSurroundingTarget(
 }
 
 function getBoundary(surroundingTarget: SurroundingPairTarget): [Range, Range] {
-  return surroundingTarget.getBoundaryStrict().map((t) => t.contentRange) as [
+  return surroundingTarget.getBoundary().map((t) => t.contentRange) as [
     Range,
     Range,
   ];

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

@@ -7,19 +7,6 @@ import { Modifier } from "@cursorless/common";
 // eslint-disable-next-line @typescript-eslint/no-unused-vars, unused-imports/no-unused-imports
 import type { Target } from "../../typings/target.types";
 
-/**
- * Expands the given target to the nearest containing surrounding pair if the
- * target has no explicit scope type, ie if {@link Target.hasExplicitScopeType}
- * is `false`.
- */
-export const containingSurroundingPairIfUntypedModifier: Modifier = {
-  type: "modifyIfUntyped",
-  modifier: {
-    type: "containingScope",
-    scopeType: { type: "surroundingPair", delimiter: "any" },
-  },
-};
-
 /**
  * Expands the given target to the nearest containing line if the target has no
  * explicit scope type, ie if {@link Target.hasExplicitScopeType} is `false`.