Support specifying text fragments via queries

Author: pokey

packages/cursorless-engine/src/cursorlessEngine.ts

@@ -41,6 +41,7 @@ export function createCursorlessEngine(
   const scopeHandlerFactory = new ScopeHandlerFactoryImpl(languageDefinitions);
   const markStageFactory = new MarkStageFactoryImpl();
   const modifierStageFactory = new ModifierStageFactoryImpl(
+    languageDefinitions,
     scopeHandlerFactory,
   );
   const actions = new Actions(snippets, rangeUpdater, modifierStageFactory);

packages/cursorless-engine/src/languages/LanguageDefinition.ts

@@ -2,10 +2,13 @@ import { ScopeType, SimpleScopeType } from "@cursorless/common";
 import { existsSync, readFileSync } from "fs";
 import { join } from "path";
 import { TreeSitterScopeHandler } from "../processTargets/modifiers/scopeHandlers";
+import { TreeSitterTextFragmentScopeHandler } from "../processTargets/modifiers/scopeHandlers/TreeSitterScopeHandler/TreeSitterTextFragmentScopeHandler";
+import { ScopeHandler } from "../processTargets/modifiers/scopeHandlers/scopeHandler.types";
 import { ide } from "../singletons/ide.singleton";
 import { TreeSitter } from "../typings/TreeSitter";
-import { LanguageId } from "./constants";
 import { TreeSitterQuery } from "./TreeSitterQuery";
+import { TEXT_FRAGMENT_CAPTURE_NAME } from "./captureNames";
+import { LanguageId } from "./constants";
 
 /**
  * Represents a language definition for a single language, including the
@@ -63,4 +66,12 @@ export class LanguageDefinition {
 
     return new TreeSitterScopeHandler(this.query, scopeType as SimpleScopeType);
   }
+
+  getTextFragmentScopeHandler(): ScopeHandler | undefined {
+    if (!this.query.captureNames.includes(TEXT_FRAGMENT_CAPTURE_NAME)) {
+      return undefined;
+    }
+
+    return new TreeSitterTextFragmentScopeHandler(this.query);
+  }
 }

packages/cursorless-engine/src/languages/captureNames.ts

@@ -0,0 +1,5 @@
+/**
+ * The name of the capture group that captures text fragments, for use with
+ * surrounding pairs.
+ */
+export const TEXT_FRAGMENT_CAPTURE_NAME = "textFragment";

packages/cursorless-engine/src/languages/getTextFragmentExtractor.ts

@@ -122,7 +122,7 @@ const fullDocumentTextFragmentExtractor = null;
 
 const textFragmentExtractors: Record<
   SupportedLanguageId,
-  TextFragmentExtractor | FullDocumentTextFragmentExtractor
+  TextFragmentExtractor | FullDocumentTextFragmentExtractor | null
 > = {
   c: constructDefaultTextFragmentExtractor("c"),
   clojure: constructDefaultTextFragmentExtractor(

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

@@ -4,6 +4,7 @@ import {
   Modifier,
   SurroundingPairModifier,
 } from "@cursorless/common";
+import { LanguageDefinitions } from "../languages/LanguageDefinitions";
 import { ModifierStageFactory } from "./ModifierStageFactory";
 import { ModifierStage } from "./PipelineStages.types";
 import CascadingStage from "./modifiers/CascadingStage";
@@ -42,7 +43,10 @@ import {
 } from "./modifiers/scopeTypeStages/RegexStage";
 
 export class ModifierStageFactoryImpl implements ModifierStageFactory {
-  constructor(private scopeHandlerFactory: ScopeHandlerFactory) {
+  constructor(
+    private languageDefinitions: LanguageDefinitions,
+    private scopeHandlerFactory: ScopeHandlerFactory,
+  ) {
     this.create = this.create.bind(this);
   }
 
@@ -115,15 +119,22 @@ export class ModifierStageFactoryImpl implements ModifierStageFactory {
       case "nonWhitespaceSequence":
         return new NonWhitespaceSequenceStage(modifier);
       case "boundedNonWhitespaceSequence":
-        return new BoundedNonWhitespaceSequenceStage(this, modifier);
+        return new BoundedNonWhitespaceSequenceStage(
+          this.languageDefinitions,
+          this,
+          modifier,
+        );
       case "url":
         return new UrlStage(modifier);
       case "collectionItem":
-        return new ItemStage(modifier);
+        return new ItemStage(this.languageDefinitions, modifier);
       case "customRegex":
         return new CustomRegexStage(modifier as CustomRegexModifier);
       case "surroundingPair":
-        return new SurroundingPairStage(modifier as SurroundingPairModifier);
+        return new SurroundingPairStage(
+          this.languageDefinitions,
+          modifier as SurroundingPairModifier,
+        );
       default:
         // Default to containing syntax scope using tree sitter
         return new ContainingSyntaxScopeStage(

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

@@ -1,11 +1,15 @@
-import { NoContainingScopeError, Range, TextEditor } from "@cursorless/common";
 import {
   ContainingScopeModifier,
   EveryScopeModifier,
+  NoContainingScopeError,
+  Range,
   SimpleScopeTypeType,
+  TextEditor,
 } from "@cursorless/common";
-import { Target } from "../../../typings/target.types";
+import { LanguageDefinition } from "../../../languages/LanguageDefinition";
+import { LanguageDefinitions } from "../../../languages/LanguageDefinitions";
 import { ProcessedTargetsContext } from "../../../typings/Types";
+import { Target } from "../../../typings/target.types";
 import { getInsertionDelimiter } from "../../../util/nodeSelectors";
 import { getRangeLength } from "../../../util/rangeUtils";
 import { ModifierStage } from "../../PipelineStages.types";
@@ -17,7 +21,10 @@ import { getIterationScope } from "./getIterationScope";
 import { tokenizeRange } from "./tokenizeRange";
 
 export default class ItemStage implements ModifierStage {
-  constructor(private modifier: ContainingScopeModifier | EveryScopeModifier) {}
+  constructor(
+    private languageDefinitions: LanguageDefinitions,
+    private modifier: ContainingScopeModifier | EveryScopeModifier,
+  ) {}
 
   run(context: ProcessedTargetsContext, target: Target): Target[] {
     // First try the language specific implementation of item
@@ -29,15 +36,27 @@ export default class ItemStage implements ModifierStage {
       // do nothing
     }
 
+    const languageDefinition = this.languageDefinitions.get(
+      target.editor.document.languageId,
+    );
+
     // Then try the textual implementation
     if (this.modifier.type === "everyScope") {
-      return this.getEveryTarget(context, target);
+      return this.getEveryTarget(languageDefinition, context, target);
     }
-    return [this.getSingleTarget(context, target)];
+    return [this.getSingleTarget(languageDefinition, context, target)];
   }
 
-  private getEveryTarget(context: ProcessedTargetsContext, target: Target) {
-    const itemInfos = getItemInfosForIterationScope(context, target);
+  private getEveryTarget(
+    languageDefinition: LanguageDefinition | undefined,
+    context: ProcessedTargetsContext,
+    target: Target,
+  ) {
+    const itemInfos = getItemInfosForIterationScope(
+      languageDefinition,
+      context,
+      target,
+    );
 
     // If target has explicit range filter to items in that range. Otherwise expand to all items in iteration scope.
     const filteredItemInfos = target.hasExplicitRange
@@ -53,8 +72,16 @@ export default class ItemStage implements ModifierStage {
     );
   }
 
-  private getSingleTarget(context: ProcessedTargetsContext, target: Target) {
-    const itemInfos = getItemInfosForIterationScope(context, target);
+  private getSingleTarget(
+    languageDefinition: LanguageDefinition | undefined,
+    context: ProcessedTargetsContext,
+    target: Target,
+  ) {
+    const itemInfos = getItemInfosForIterationScope(
+      languageDefinition,
+      context,
+      target,
+    );
 
     const filteredItemInfos = filterItemInfos(target, itemInfos);
 
@@ -117,10 +144,15 @@ function filterItemInfos(target: Target, itemInfos: ItemInfo[]): ItemInfo[] {
 }
 
 function getItemInfosForIterationScope(
+  languageDefinition: LanguageDefinition | undefined,
   context: ProcessedTargetsContext,
   target: Target,
 ) {
-  const { range, boundary } = getIterationScope(context, target);
+  const { range, boundary } = getIterationScope(
+    languageDefinition,
+    context,
+    target,
+  );
   return getItemsInRange(target.editor, range, boundary);
 }
 

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

@@ -1,9 +1,10 @@
 import { Range, TextEditor } from "@cursorless/common";
-import { Target } from "../../../typings/target.types";
+import { LanguageDefinition } from "../../../languages/LanguageDefinition";
 import { ProcessedTargetsContext } from "../../../typings/Types";
+import { Target } from "../../../typings/target.types";
+import { PlainTarget, SurroundingPairTarget } from "../../targets";
 import { fitRangeToLineContent } from "../scopeHandlers";
 import { processSurroundingPair } from "../surroundingPair";
-import { SurroundingPairInfo } from "../surroundingPair/extractSelectionFromSurroundingPairOffsets";
 
 /**
  * Get the iteration scope range for item scope.
@@ -13,21 +14,18 @@ import { SurroundingPairInfo } from "../surroundingPair/extractSelectionFromSurr
  * @returns The stage iteration scope and optional surrounding pair boundaries
  */
 export function getIterationScope(
+  languageDefinition: LanguageDefinition | undefined,
   context: ProcessedTargetsContext,
   target: Target,
 ): { range: Range; boundary?: [Range, Range] } {
-  let pairInfo = getSurroundingPair(
-    context,
-    target.editor,
-    target.contentRange,
-  );
+  let pairInfo = getSurroundingPair(languageDefinition, context, target);
 
   // Iteration is necessary in case of nested strings
   while (pairInfo != null) {
     const stringPairInfo = getStringSurroundingPair(
+      languageDefinition,
       context,
-      target.editor,
-      pairInfo.contentRange,
+      pairInfo,
     );
 
     // We don't look for items inside strings.
@@ -38,12 +36,20 @@ export function getIterationScope(
       stringPairInfo.contentRange.start.isBefore(pairInfo.contentRange.start)
     ) {
       return {
-        range: pairInfo.interiorRange,
-        boundary: pairInfo.boundary,
+        range: pairInfo.getInteriorStrict()[0].contentRange,
+        boundary: pairInfo.getBoundaryStrict().map((t) => t.contentRange) as [
+          Range,
+          Range,
+        ],
       };
     }
 
-    pairInfo = getParentSurroundingPair(context, target.editor, pairInfo);
+    pairInfo = getParentSurroundingPair(
+      languageDefinition,
+      context,
+      target.editor,
+      pairInfo,
+    );
   }
 
   // We have not found a surrounding pair. Use the line.
@@ -53,38 +59,47 @@ export function getIterationScope(
 }
 
 function getParentSurroundingPair(
+  languageDefinition: LanguageDefinition | undefined,
   context: ProcessedTargetsContext,
   editor: TextEditor,
-  pairInfo: SurroundingPairInfo,
+  target: SurroundingPairTarget,
 ) {
-  const startOffset = editor.document.offsetAt(pairInfo.contentRange.start);
+  const startOffset = editor.document.offsetAt(target.contentRange.start);
   // Can't have a parent; already at start of document
   if (startOffset === 0) {
     return null;
   }
   // Step out of this pair and see if we have a parent
   const position = editor.document.positionAt(startOffset - 1);
-  return getSurroundingPair(context, editor, new Range(position, position));
+  return getSurroundingPair(
+    languageDefinition,
+    context,
+    new PlainTarget({
+      editor,
+      contentRange: new Range(position, position),
+      isReversed: false,
+    }),
+  );
 }
 
 function getSurroundingPair(
+  languageDefinition: LanguageDefinition | undefined,
   context: ProcessedTargetsContext,
-  editor: TextEditor,
-  contentRange: Range,
+  target: Target,
 ) {
-  return processSurroundingPair(context, editor, contentRange, {
+  return processSurroundingPair(languageDefinition, context, target, {
     type: "surroundingPair",
     delimiter: "collectionBoundary",
     requireStrongContainment: true,
   });
 }
 
 function getStringSurroundingPair(
+  languageDefinition: LanguageDefinition | undefined,
   context: ProcessedTargetsContext,
-  editor: TextEditor,
-  contentRange: Range,
+  target: Target,
 ) {
-  return processSurroundingPair(context, editor, contentRange, {
+  return processSurroundingPair(languageDefinition, context, target, {
     type: "surroundingPair",
     delimiter: "string",
     requireStrongContainment: true,

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

@@ -1,9 +1,11 @@
-import type { Target } from "../../typings/target.types";
 import type {
   ContainingSurroundingPairModifier,
   SurroundingPairModifier,
 } from "@cursorless/common";
+import { LanguageDefinition } from "../../languages/LanguageDefinition";
+import { LanguageDefinitions } from "../../languages/LanguageDefinitions";
 import type { ProcessedTargetsContext } from "../../typings/Types";
+import type { Target } from "../../typings/target.types";
 import type { ModifierStage } from "../PipelineStages.types";
 import { SurroundingPairTarget } from "../targets";
 import { processSurroundingPair } from "./surroundingPair";
@@ -22,7 +24,10 @@ import { processSurroundingPair } from "./surroundingPair";
  * `null` if none was found
  */
 export default class SurroundingPairStage implements ModifierStage {
-  constructor(private modifier: SurroundingPairModifier) {}
+  constructor(
+    private languageDefinitions: LanguageDefinitions,
+    private modifier: SurroundingPairModifier,
+  ) {}
 
   run(
     context: ProcessedTargetsContext,
@@ -32,31 +37,31 @@ export default class SurroundingPairStage implements ModifierStage {
       throw Error(`Unsupported every scope ${this.modifier.scopeType.type}`);
     }
 
-    return processedSurroundingPairTarget(this.modifier, context, target);
+    return processedSurroundingPairTarget(
+      this.languageDefinitions.get(target.editor.document.languageId),
+      this.modifier,
+      context,
+      target,
+    );
   }
 }
 
 function processedSurroundingPairTarget(
+  languageDefinition: LanguageDefinition | undefined,
   modifier: ContainingSurroundingPairModifier,
   context: ProcessedTargetsContext,
   target: Target,
 ): SurroundingPairTarget[] {
-  const pairInfo = processSurroundingPair(
+  const outputTarget = processSurroundingPair(
+    languageDefinition,
     context,
-    target.editor,
-    target.contentRange,
+    target,
     modifier.scopeType,
   );
 
-  if (pairInfo == null) {
+  if (outputTarget == null) {
     throw new Error("Couldn't find containing pair");
   }
 
-  return [
-    new SurroundingPairTarget({
-      ...pairInfo,
-      editor: target.editor,
-      isReversed: target.isReversed,
-    }),
-  ];
+  return [outputTarget];
 }