Contiguous scope

packages/common/src/util/itertools.ts

@@ -65,3 +65,17 @@ export function isEmptyIterable(iterable: Iterable<unknown>): boolean {
 
   return true;
 }
+
+/**
+ * Returns the first element of the given iterable, or `undefined` if the
+ * iterable is empty
+ * @param iterable The iterable to get the first element of
+ * @returns The first element of the iterable, or `undefined` if the iterable
+ * is empty
+ */
+export function next<T>(generator: Iterable<T>): T | undefined {
+  for (const value of generator) {
+    return value;
+  }
+  return undefined;
+}

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

@@ -2,10 +2,11 @@ import { ScopeType, SimpleScopeType, showError } from "@cursorless/common";
 import { existsSync, readFileSync } from "fs";
 import { dirname, join } from "path";
 import { TreeSitterScopeHandler } from "../processTargets/modifiers/scopeHandlers";
+import { ContiguousScopeHandler } from "../processTargets/modifiers/scopeHandlers/ContiguousScopeHandler";
 import { TreeSitterTextFragmentScopeHandler } from "../processTargets/modifiers/scopeHandlers/TreeSitterScopeHandler/TreeSitterTextFragmentScopeHandler";
-import { ScopeHandler } from "../processTargets/modifiers/scopeHandlers/scopeHandler.types";
+import type { ScopeHandler } from "../processTargets/modifiers/scopeHandlers/scopeHandler.types";
 import { ide } from "../singletons/ide.singleton";
-import { TreeSitter } from "../typings/TreeSitter";
+import type { TreeSitter } from "../typings/TreeSitter";
 import { matchAll } from "../util/regex";
 import { TreeSitterQuery } from "./TreeSitterQuery";
 import { TEXT_FRAGMENT_CAPTURE_NAME } from "./captureNames";
@@ -60,12 +61,21 @@ export class LanguageDefinition {
    * undefined if the given scope type / language id combination is still using
    * legacy pathways
    */
-  getScopeHandler(scopeType: ScopeType) {
+  getScopeHandler(scopeType: ScopeType): ScopeHandler | undefined {
     if (!this.query.captureNames.includes(scopeType.type)) {
       return undefined;
     }
 
-    return new TreeSitterScopeHandler(this.query, scopeType as SimpleScopeType);
+    const scopeHandler = new TreeSitterScopeHandler(
+      this.query,
+      scopeType as SimpleScopeType,
+    );
+
+    if (useContiguousScopeHandler(scopeType)) {
+      return new ContiguousScopeHandler(scopeHandler);
+    }
+
+    return scopeHandler;
   }
 
   getTextFragmentScopeHandler(): ScopeHandler | undefined {
@@ -141,3 +151,15 @@ function readQueryFileAndImports(languageQueryPath: string) {
 
   return Object.values(rawQueryStrings).join("\n");
 }
+
+/**
+ * Returns true if the given scope type should use a contiguous scope handler.
+ */
+function useContiguousScopeHandler(scopeType: ScopeType): boolean {
+  switch (scopeType.type) {
+    case "comment":
+      return true;
+    default:
+      return false;
+  }
+}

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

@@ -0,0 +1,160 @@
+import {
+  Direction,
+  Position,
+  Range,
+  ScopeType,
+  TextEditor,
+  next,
+} from "@cursorless/common";
+import { Target } from "../../../typings/target.types";
+import { ensureSingleTarget } from "../../../util/targetUtils";
+import { constructScopeRangeTarget } from "../constructScopeRangeTarget";
+import { BaseScopeHandler } from "./BaseScopeHandler";
+import type { TargetScope } from "./scope.types";
+import type {
+  CustomScopeType,
+  ScopeHandler,
+  ScopeIteratorRequirements,
+} from "./scopeHandler.types";
+
+export class ContiguousScopeHandler extends BaseScopeHandler {
+  protected readonly isHierarchical = false;
+
+  constructor(private scopeHandler: ScopeHandler) {
+    super();
+  }
+
+  get scopeType(): ScopeType | undefined {
+    return this.scopeHandler.scopeType;
+  }
+
+  get iterationScopeType(): ScopeType | CustomScopeType {
+    return this.scopeHandler.iterationScopeType;
+  }
+
+  *generateScopeCandidates(
+    editor: TextEditor,
+    position: Position,
+    direction: Direction,
+    _hints: ScopeIteratorRequirements,
+  ): Iterable<TargetScope> {
+    let targetRangeOpposite = next(
+      generateTargetRangesInDirection(
+        this.scopeHandler,
+        editor,
+        position,
+        direction === "forward" ? "backward" : "forward",
+      ),
+    );
+
+    const targetRangesIter = generateTargetRangesInDirection(
+      this.scopeHandler,
+      editor,
+      position,
+      direction,
+    );
+
+    for (const targetRange of targetRangesIter) {
+      if (
+        targetRangeOpposite != null &&
+        isAdjacent(targetRangeOpposite.proximal, targetRange.proximal)
+      ) {
+        yield combineScopes(targetRangeOpposite.distal, targetRange.distal);
+        targetRangeOpposite = undefined;
+      } else {
+        yield combineScopes(targetRange.proximal, targetRange.distal);
+      }
+    }
+  }
+}
+
+function combineScopes(scope1: TargetScope, scope2: TargetScope): TargetScope {
+  if (scope1.domain.isRangeEqual(scope2.domain)) {
+    return scope1;
+  }
+
+  return {
+    editor: scope1.editor,
+    domain: scope1.domain.union(scope2.domain),
+    getTargets: (isReversed) => {
+      return constructScopeRangeTarget(isReversed, scope1, scope2);
+    },
+  };
+}
+
+function* generateTargetRangesInDirection(
+  scopeHandler: ScopeHandler,
+  editor: TextEditor,
+  position: Position,
+  direction: Direction,
+): Iterable<{ proximal: TargetScope; distal: TargetScope }> {
+  let proximal, distal: TargetScope | undefined;
+
+  const generator = scopeHandler.generateScopes(editor, position, direction, {
+    allowAdjacentScopes: true,
+    skipAncestorScopes: true,
+  });
+
+  for (const scope of generator) {
+    if (proximal == null) {
+      proximal = scope;
+    }
+
+    if (distal != null) {
+      if (!isAdjacent(distal, scope)) {
+        yield { proximal, distal };
+        proximal = scope;
+      }
+    }
+
+    distal = scope;
+  }
+
+  if (proximal != null && distal != null) {
+    yield { proximal, distal };
+  }
+}
+
+function isAdjacent(scope1: TargetScope, scope2: TargetScope): boolean {
+  if (scope1.domain.isRangeEqual(scope2.domain)) {
+    return true;
+  }
+
+  const [startTarget, endTarget] = getTargetsInDocumentOrder(
+    ensureSingleTarget(scope1.getTargets(false)),
+    ensureSingleTarget(scope2.getTargets(false)),
+  );
+
+  const leadingRange =
+    startTarget.getTrailingDelimiterTarget()?.contentRange ??
+    startTarget.contentRange;
+  const trailingRange =
+    endTarget.getLeadingDelimiterTarget()?.contentRange ??
+    endTarget.contentRange;
+
+  if (leadingRange.intersection(trailingRange) != null) {
+    return true;
+  }
+
+  // Non line targets are excluded if they are separated by more than one line
+  if (
+    !startTarget.isLine &&
+    trailingRange.start.line - leadingRange.end.line > 1
+  ) {
+    return false;
+  }
+
+  // Finally targets are excluded if there is non whitespace text between them
+  const rangeBetween = new Range(leadingRange.end, trailingRange.start);
+  const text = startTarget.editor.document.getText(rangeBetween);
+  return /^\s*$/.test(text);
+}
+
+function getTargetsInDocumentOrder(
+  target1: Target,
+  target2: Target,
+): [Target, Target] {
+  return target1.contentRange.start.isBefore(target2.contentRange.start)
+    ? [target1, target2]
+    : [target2, target1];
+}

packages/cursorless-vscode-e2e/src/suite/fixtures/recorded/contiguousScope/changeComment.yml

@@ -0,0 +1,25 @@
+languageId: javascript
+command:
+  version: 6
+  spokenForm: change comment
+  action:
+    name: clearAndSetSelection
+    target:
+      type: primitive
+      modifiers:
+        - type: containingScope
+          scopeType: {type: comment}
+  usePrePhraseSnapshot: true
+initialState:
+  documentContents: |-
+    // hello
+    // world
+  selections:
+    - anchor: {line: 0, character: 0}
+      active: {line: 0, character: 0}
+  marks: {}
+finalState:
+  documentContents: ""
+  selections:
+    - anchor: {line: 0, character: 0}
+      active: {line: 0, character: 0}

packages/cursorless-vscode-e2e/src/suite/fixtures/recorded/contiguousScope/changeComment2.yml

@@ -0,0 +1,25 @@
+languageId: javascript
+command:
+  version: 6
+  spokenForm: change comment
+  action:
+    name: clearAndSetSelection
+    target:
+      type: primitive
+      modifiers:
+        - type: containingScope
+          scopeType: {type: comment}
+  usePrePhraseSnapshot: true
+initialState:
+  documentContents: |-
+    // hello
+    // world
+  selections:
+    - anchor: {line: 1, character: 8}
+      active: {line: 1, character: 8}
+  marks: {}
+finalState:
+  documentContents: ""
+  selections:
+    - anchor: {line: 0, character: 0}
+      active: {line: 0, character: 0}

packages/cursorless-vscode-e2e/src/suite/fixtures/recorded/contiguousScope/changeComment3.yml

@@ -0,0 +1,25 @@
+languageId: javascript
+command:
+  version: 6
+  spokenForm: change comment
+  action:
+    name: clearAndSetSelection
+    target:
+      type: primitive
+      modifiers:
+        - type: containingScope
+          scopeType: {type: comment}
+  usePrePhraseSnapshot: true
+initialState:
+  documentContents: |-
+    // hello
+      // world
+  selections:
+    - anchor: {line: 1, character: 0}
+      active: {line: 1, character: 0}
+  marks: {}
+finalState:
+  documentContents: ""
+  selections:
+    - anchor: {line: 0, character: 0}
+      active: {line: 0, character: 0}

packages/cursorless-vscode-e2e/src/suite/fixtures/recorded/contiguousScope/changeComment4.yml

@@ -0,0 +1,29 @@
+languageId: javascript
+command:
+  version: 6
+  spokenForm: change comment
+  action:
+    name: clearAndSetSelection
+    target:
+      type: primitive
+      modifiers:
+        - type: containingScope
+          scopeType: {type: comment}
+  usePrePhraseSnapshot: true
+initialState:
+  documentContents: |-
+    // hello
+
+    // world
+  selections:
+    - anchor: {line: 0, character: 0}
+      active: {line: 0, character: 0}
+  marks: {}
+finalState:
+  documentContents: |-
+
+
+    // world
+  selections:
+    - anchor: {line: 0, character: 0}
+      active: {line: 0, character: 0}