Draft PR: Create Scope Visualizer for "that" Mark

cursorless-talon/src/spoken_forms.json

@@ -182,7 +182,8 @@
       "short paint": "boundedNonWhitespaceSequence",
       "short block": "boundedParagraph",
       "link": "url",
-      "cell": "notebookCell"
+      "cell": "notebookCell",
+      "that": "that"
     },
     "surrounding_pair_scope_type": {
       "string": "string"

packages/common/src/types/command/PartialTargetDescriptor.types.ts

@@ -202,6 +202,7 @@ export const simpleScopeTypeTypes = [
   "boundedNonWhitespaceSequence",
   "url",
   "notebookCell",
+  "that",
   // Talon
   "command",
   // Private scope types

packages/cursorless-engine/src/cursorlessEngine.ts

@@ -150,7 +150,10 @@ function createScopeProvider(
   storedTargets: StoredTargetMap,
   customSpokenFormGenerator: CustomSpokenFormGeneratorImpl,
 ): ScopeProvider {
-  const scopeHandlerFactory = new ScopeHandlerFactoryImpl(languageDefinitions);
+  const scopeHandlerFactory = new ScopeHandlerFactoryImpl(
+    languageDefinitions,
+    storedTargets,
+  );
 
   const rangeProvider = new ScopeRangeProvider(
     scopeHandlerFactory,
@@ -164,6 +167,7 @@ function createScopeProvider(
   const rangeWatcher = new ScopeRangeWatcher(
     languageDefinitions,
     rangeProvider,
+    storedTargets,
   );
   const supportChecker = new ScopeSupportChecker(scopeHandlerFactory);
   const infoProvider = new ScopeInfoProvider(customSpokenFormGenerator);

packages/cursorless-engine/src/processTargets/modifiers/scopeHandlers/ScopeHandlerFactoryImpl.ts

@@ -32,8 +32,10 @@ import {
   SurroundingPairScopeHandler,
 } from "./SurroundingPairScopeHandler";
 import { InteriorScopeHandler } from "./SurroundingPairScopeHandler/InteriorScopeHandler";
+import { ThatScopeHandler } from "./ThatScopeHandler";
 import { TokenScopeHandler } from "./TokenScopeHandler";
 import { WordScopeHandler } from "./WordScopeHandler/WordScopeHandler";
+import type { StoredTargetMap } from "../../../core/StoredTargets";
 
 /**
  * Returns a scope handler for the given scope type and language id, or
@@ -46,7 +48,10 @@ import { WordScopeHandler } from "./WordScopeHandler/WordScopeHandler";
  * undefined if the given scope type / language id combination is not supported.
  */
 export class ScopeHandlerFactoryImpl implements ScopeHandlerFactory {
-  constructor(private languageDefinitions: LanguageDefinitions) {
+  constructor(
+    private languageDefinitions: LanguageDefinitions,
+    private storedTargets: StoredTargetMap,
+  ) {
     this.maybeCreate = this.maybeCreate.bind(this);
     this.create = this.create.bind(this);
   }
@@ -118,6 +123,13 @@ export class ScopeHandlerFactoryImpl implements ScopeHandlerFactory {
           scopeType,
           languageId,
         );
+      case "that":
+        return new ThatScopeHandler(
+          this,
+          scopeType,
+          languageId,
+          this.storedTargets,
+        );
       case "interior":
         return InteriorScopeHandler.maybeCreate(
           this.languageDefinitions,

packages/cursorless-engine/src/processTargets/modifiers/scopeHandlers/ThatScopeHandler.ts

@@ -0,0 +1,57 @@
+import type { Direction, ScopeType } from "@cursorless/common";
+import type { StoredTargetMap } from "../../../core/StoredTargets";
+import { TokenTarget } from "../../targets";
+import { NestedScopeHandler } from "./NestedScopeHandler";
+import type { ScopeHandlerFactory } from "./ScopeHandlerFactory";
+import type { TargetScope } from "./scope.types";
+
+/**
+ * Scope handler that returns the range(s) from the "that" mark.
+ * The "that" mark stores the targets from the most recent Cursorless command.
+ */
+export class ThatScopeHandler extends NestedScopeHandler {
+  public readonly scopeType = { type: "that" } as const;
+  public readonly iterationScopeType: ScopeType = { type: "document" };
+
+  constructor(
+    scopeHandlerFactory: ScopeHandlerFactory,
+    scopeType: ScopeType,
+    languageId: string,
+    private storedTargets: StoredTargetMap,
+  ) {
+    super(scopeHandlerFactory, scopeType, languageId);
+  }
+
+  protected *generateScopesInSearchScope(
+    _direction: Direction,
+    { editor }: TargetScope,
+  ): Iterable<TargetScope> {
+    // Get the targets stored in the "that" mark
+    const thatTargets = this.storedTargets.get("that");
+
+    if (thatTargets == null || thatTargets.length === 0) {
+      // No "that" mark available, yield nothing
+      return;
+    }
+
+    // Filter targets to only those in the current editor
+    const editorTargets = thatTargets.filter(
+      (target) => target.editor.id === editor.id,
+    );
+
+    // Yield a TargetScope for each target
+    for (const target of editorTargets) {
+      yield {
+        editor: target.editor,
+        domain: target.contentRange,
+        getTargets: (isReversed) => [
+          new TokenTarget({
+            editor: target.editor,
+            contentRange: target.contentRange,
+            isReversed,
+          }),
+        ],
+      };
+    }
+  }
+}

packages/cursorless-engine/src/runCommand.ts

@@ -103,7 +103,7 @@ function createCommandRunner(
   const modifierStageFactory = new ModifierStageFactoryImpl(
     languageDefinitions,
     storedTargets,
-    new ScopeHandlerFactoryImpl(languageDefinitions),
+    new ScopeHandlerFactoryImpl(languageDefinitions, storedTargets),
   );
 
   const markStageFactory = new MarkStageFactoryImpl(

packages/cursorless-engine/src/scopeProviders/ScopeInfoProvider.ts

@@ -180,6 +180,7 @@ function isLanguageSpecific(scopeType: ScopeType): boolean {
     case "boundedNonWhitespaceSequence":
     case "url":
     case "notebookCell":
+    case "that":
     case "surroundingPair":
     case "surroundingPairInterior":
     case "customRegex":

packages/cursorless-engine/src/scopeProviders/ScopeRangeWatcher.ts

@@ -13,6 +13,7 @@ import type { LanguageDefinitions } from "../languages/LanguageDefinitions";
 import { ide } from "../singletons/ide.singleton";
 import type { ScopeRangeProvider } from "./ScopeRangeProvider";
 import { DecorationDebouncer } from "../util/DecorationDebouncer";
+import type { StoredTargetMap } from "../core/StoredTargets";
 
 /**
  * Watches for changes to the scope ranges of visible editors and notifies
@@ -25,6 +26,7 @@ export class ScopeRangeWatcher {
   constructor(
     languageDefinitions: LanguageDefinitions,
     private scopeRangeProvider: ScopeRangeProvider,
+    storedTargets: StoredTargetMap,
   ) {
     this.onChange = this.onChange.bind(this);
     this.onDidChangeScopeRanges = this.onDidChangeScopeRanges.bind(this);
@@ -48,6 +50,12 @@ export class ScopeRangeWatcher {
       ide().onDidChangeTextDocument(debouncer.run),
       ide().onDidChangeTextEditorVisibleRanges(debouncer.run),
       languageDefinitions.onDidChangeDefinition(this.onChange),
+      // Listen for "that" mark changes to update the "that" scope visualization
+      storedTargets.onStoredTargets((key, _targets) => {
+        if (key === "that") {
+          debouncer.run();
+        }
+      }),
       debouncer,
     );
   }

packages/cursorless-engine/src/spokenForms/defaultSpokenFormMapCore.ts

@@ -102,6 +102,7 @@ export const defaultSpokenFormMapCore: DefaultSpokenFormMapDefinition = {
     boundedNonWhitespaceSequence: "short paint",
     url: "link",
     notebookCell: "cell",
+    that: "that",
 
     string: isPrivate("parse tree string"),
     textFragment: isPrivate("text fragment"),