Contiguous scope

packages/common/src/scopeSupportFacets/java.ts

@@ -12,6 +12,9 @@ export const javaScopeSupport: LanguageScopeSupportFacetMap = {
   "value.foreach": supported,
   "type.foreach": supported,
 
+  "comment.line": supported,
+  "comment.block": supported,
+
   element: notApplicable,
   tags: notApplicable,
   attribute: notApplicable,

packages/common/src/scopeSupportFacets/python.ts

@@ -16,6 +16,9 @@ export const pythonScopeSupport: LanguageScopeSupportFacetMap = {
   "argument.formal": supportedLegacy,
   "argument.formal.iteration": supportedLegacy,
 
+  "comment.line": supported,
+  "comment.block": supported,
+
   element: notApplicable,
   tags: notApplicable,
   attribute: notApplicable,

packages/common/src/scopeSupportFacets/talon.ts

@@ -9,4 +9,7 @@ const { supported } = ScopeSupportFacetLevel;
 
 export const talonScopeSupport: LanguageScopeSupportFacetMap = {
   command: supported,
+
+  "comment.line": supported,
+  "comment.block": supported,
 };

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/languages/TreeSitterQuery/QueryCapture.ts

@@ -36,6 +36,9 @@ export interface QueryCapture {
    * content ranges. */
   readonly allowMultiple: boolean;
 
+  /** Whether this scope should expand contiguously to its siblings. */
+  readonly contiguous: boolean;
+
   /** The insertion delimiter to use if any */
   readonly insertionDelimiter: string | undefined;
 }
@@ -63,6 +66,7 @@ export interface MutableQueryCapture extends QueryCapture {
   readonly document: TextDocument;
   range: Range;
   allowMultiple: boolean;
+  contiguous: boolean;
   insertionDelimiter: string | undefined;
 }
 

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

@@ -82,6 +82,7 @@ export class TreeSitterQuery {
             range: getNodeRange(node),
             insertionDelimiter: undefined,
             allowMultiple: false,
+            contiguous: false,
           })),
         }),
       )
@@ -114,6 +115,7 @@ export class TreeSitterQuery {
               .map(({ range }) => range)
               .reduce((accumulator, range) => range.union(accumulator)),
             allowMultiple: captures.some((capture) => capture.allowMultiple),
+            contiguous: captures.some((capture) => capture.contiguous),
             insertionDelimiter: captures.find(
               (capture) => capture.insertionDelimiter != null,
             )?.insertionDelimiter,

packages/cursorless-engine/src/languages/TreeSitterQuery/checkCaptureStartEnd.test.ts

@@ -5,7 +5,10 @@ import assert from "assert";
 
 interface TestCase {
   name: string;
-  captures: Omit<QueryCapture, "allowMultiple" | "insertionDelimiter">[];
+  captures: Omit<
+    QueryCapture,
+    "allowMultiple" | "contiguous" | "insertionDelimiter"
+  >[];
   isValid: boolean;
   expectedErrorMessageIds: string[];
 }
@@ -192,6 +195,7 @@ suite("checkCaptureStartEnd", () => {
         testCase.captures.map((capture) => ({
           ...capture,
           allowMultiple: false,
+          contiguous: false,
           insertionDelimiter: undefined,
         })),
         messages,

packages/cursorless-engine/src/languages/TreeSitterQuery/queryPredicateOperators.ts

@@ -185,6 +185,23 @@ class AllowMultiple extends QueryPredicateOperator<AllowMultiple> {
   }
 }
 
+/** Indicates that it's okay for this scope to extend contiguously it through its siblings. */
+class Contiguous extends QueryPredicateOperator<Contiguous> {
+  name = "contiguous!" as const;
+  schema = z.union([z.tuple([q.node]), z.tuple([q.node, q.string])]);
+
+  run(nodeInfo: MutableQueryCapture, pattern?: string) {
+    if (pattern != null) {
+      const text = nodeInfo.document.getText(nodeInfo.range);
+      nodeInfo.contiguous = new RegExp(pattern, "s").test(text);
+    } else {
+      nodeInfo.contiguous = true;
+    }
+
+    return true;
+  }
+}
+
 /**
  * A predicate operator that logs a node, for debugging.
  */
@@ -254,6 +271,7 @@ export const queryPredicateOperators = [
   new ChildRange(),
   new ShrinkToMatch(),
   new AllowMultiple(),
+  new Contiguous(),
   new InsertionDelimiter(),
   new SingleOrMultilineDelimiter(),
   new HasMultipleChildrenOfType(),

packages/cursorless-engine/src/languages/TreeSitterQuery/rewriteStartOfEndOf.test.ts

@@ -54,6 +54,7 @@ function fillOutCapture(capture: NameRange): MutableQueryCapture {
   return {
     ...capture,
     allowMultiple: false,
+    contiguous: false,
     insertionDelimiter: undefined,
     document: null as unknown as TextDocument,
     node: null as unknown as SyntaxNode,

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

@@ -0,0 +1,164 @@
+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.contiguous || !scope2.contiguous) {
+    return false;
+  }
+
+  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-engine/src/processTargets/modifiers/scopeHandlers/TreeSitterScopeHandler/BaseTreeSitterScopeHandler.ts

@@ -95,4 +95,5 @@ export abstract class BaseTreeSitterScopeHandler extends BaseScopeHandler {
 
 export interface ExtendedTargetScope extends TargetScope {
   allowMultiple: boolean;
+  contiguous: boolean;
 }

packages/cursorless-engine/src/processTargets/modifiers/scopeHandlers/TreeSitterScopeHandler/TreeSitterIterationScopeHandler.ts

@@ -42,7 +42,7 @@ export class TreeSitterIterationScopeHandler extends BaseTreeSitterScopeHandler
       return undefined;
     }
 
-    const { range: contentRange, allowMultiple } = capture;
+    const { range: contentRange, allowMultiple, contiguous } = capture;
 
     const domain =
       getRelatedRange(match, scopeTypeType, "iteration.domain", false) ??
@@ -52,6 +52,7 @@ export class TreeSitterIterationScopeHandler extends BaseTreeSitterScopeHandler
       editor,
       domain,
       allowMultiple,
+      contiguous,
       getTargets: (isReversed) => [
         new PlainTarget({
           editor,