replace treesitter #start-position with .startof

This particular query pattern is going to be very common. 
It's worth having syntactic sugar for. 
In particular, this reduces the level of indentation 
required to express that a node's associated scope
(iteration, trailing, leading, etc.)
should start or end at the start or end of a different node.

While we're here, make a related error message more helpful.

Author: josharian

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

@@ -8,6 +8,7 @@ import { parsePredicates } from "./parsePredicates";
 import { predicateToString } from "./predicateToString";
 import { groupBy, uniq } from "lodash";
 import { checkCaptureStartEnd } from "./checkCaptureStartEnd";
+import { rewriteStartOfEndOf } from "./rewriteStartOfEndOf";
 
 /**
  * Wrapper around a tree-sitter query that provides a more convenient API, and
@@ -95,6 +96,7 @@ export class TreeSitterQuery {
         const captures: QueryCapture[] = Object.entries(
           groupBy(match.captures, ({ name }) => normalizeCaptureName(name)),
         ).map(([name, captures]) => {
+          captures = rewriteStartOfEndOf(captures);
           const capturesAreValid = checkCaptureStartEnd(
             captures,
             ide().messages,
@@ -123,7 +125,7 @@ export class TreeSitterQuery {
 }
 
 function normalizeCaptureName(name: string): string {
-  return name.replace(/\.(start|end)$/, "");
+  return name.replace(/\.(start|end)(\.(startof|endof))?$/, "");
 }
 
 function positionToPoint(start: Position): Point {

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

@@ -69,7 +69,9 @@ export function checkCaptureStartEnd(
     showError(
       messages,
       "TreeSitterQuery.checkCaptures.duplicate",
-      `A capture with the same name may only appear once in a single pattern: ${captures}`,
+      `A capture with the same name may only appear once in a single pattern: ${captures.map(
+        ({ name }) => name,
+      )}`,
     );
     shownError = true;
   }

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

@@ -1,4 +1,3 @@
-import { Range } from "@cursorless/common";
 import z from "zod";
 import { makeRangeFromPositions } from "../../util/nodeSelectors";
 import { MutableQueryCapture } from "./QueryCapture";
@@ -46,40 +45,6 @@ class IsNthChild extends QueryPredicateOperator<IsNthChild> {
   }
 }
 
-/**
- * A predicate operator that modifies the range of the match to be a zero-width
- * range at the start of the node.  For example, `(#start-position! @foo)` will
- * modify the range of the `@foo` capture to be a zero-width range at the start
- * of the `@foo` node.
- */
-class StartPosition extends QueryPredicateOperator<StartPosition> {
-  name = "start-position!" as const;
-  schema = z.tuple([q.node]);
-
-  run(nodeInfo: MutableQueryCapture) {
-    nodeInfo.range = new Range(nodeInfo.range.start, nodeInfo.range.start);
-
-    return true;
-  }
-}
-
-/**
- * A predicate operator that modifies the range of the match to be a zero-width
- * range at the end of the node.  For example, `(#end-position! @foo)` will
- * modify the range of the `@foo` capture to be a zero-width range at the end of
- * the `@foo` node.
- */
-class EndPosition extends QueryPredicateOperator<EndPosition> {
-  name = "end-position!" as const;
-  schema = z.tuple([q.node]);
-
-  run(nodeInfo: MutableQueryCapture) {
-    nodeInfo.range = new Range(nodeInfo.range.end, nodeInfo.range.end);
-
-    return true;
-  }
-}
-
 class ChildRange extends QueryPredicateOperator<ChildRange> {
   name = "child-range!" as const;
   schema = z.union([
@@ -131,8 +96,6 @@ export const queryPredicateOperators = [
   new NotType(),
   new NotParentType(),
   new IsNthChild(),
-  new StartPosition(),
-  new EndPosition(),
   new ChildRange(),
   new AllowMultiple(),
 ];

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

@@ -0,0 +1,61 @@
+import { Range } from "@cursorless/common";
+import { MutableQueryCapture } from "./QueryCapture";
+import { SyntaxNode } from "web-tree-sitter";
+import { rewriteStartOfEndOf } from "./rewriteStartOfEndOf";
+import assert = require("assert");
+
+type NameRange = Omit<MutableQueryCapture, "allowMultiple" | "node">;
+
+interface TestCase {
+  name: string;
+  captures: NameRange[];
+  want: NameRange[];
+}
+
+const testCases: TestCase[] = [
+  {
+    name: "should rewrite startof to start of range",
+    captures: [
+      { name: "@value.iteration.start.startof", range: new Range(1, 2, 1, 3) },
+    ],
+    want: [{ name: "@value.iteration.start", range: new Range(1, 2, 1, 2) }],
+  },
+
+  {
+    name: "should rewrite endof to start of range",
+    captures: [
+      { name: "@value.iteration.start.endof", range: new Range(1, 2, 1, 3) },
+    ],
+    want: [{ name: "@value.iteration.start", range: new Range(1, 3, 1, 3) }],
+  },
+
+  {
+    name: "should leave other captures alone",
+    captures: [
+      { name: "@value.iteration.start", range: new Range(1, 2, 1, 3) },
+    ],
+    want: [{ name: "@value.iteration.start", range: new Range(1, 2, 1, 3) }],
+  },
+];
+
+suite("rewriteStartOfEndOf", () => {
+  for (const testCase of testCases) {
+    test(testCase.name, () => {
+      const got = rewriteStartOfEndOf(
+        testCase.captures.map((capture) => ({
+          ...capture,
+          allowMultiple: false,
+          node: null as unknown as SyntaxNode,
+        })),
+      );
+      assert.deepStrictEqual(
+        got,
+        testCase.want.map((capture) => ({
+          ...capture,
+          allowMultiple: false,
+          node: null as unknown as SyntaxNode,
+        })),
+      );
+    });
+  }
+});

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

@@ -0,0 +1,31 @@
+import { MutableQueryCapture } from "./QueryCapture";
+
+/**
+ * Rewrite captures, absorbing .startof and .endof into ranges.
+ *
+ * @param captures A list of captures
+ * @returns rewritten captures, with .startof and .endof removed
+ */
+export function rewriteStartOfEndOf(
+  captures: MutableQueryCapture[],
+): MutableQueryCapture[] {
+  // TODO: mutate instead of copy/create/return?
+  return captures.map((capture) => {
+    // Remove trailing .startof and .endof, adjusting ranges.
+    if (capture.name.endsWith(".startof")) {
+      return {
+        ...capture,
+        name: capture.name.replace(/\.startof$/, ""),
+        range: capture.range.start.toEmptyRange(),
+      };
+    }
+    if (capture.name.endsWith(".endof")) {
+      return {
+        ...capture,
+        name: capture.name.replace(/\.endof$/, ""),
+        range: capture.range.end.toEmptyRange(),
+      };
+    }
+    return capture;
+  });
+}

queries/javascript.core.scm

@@ -97,15 +97,11 @@
 ;; Treat interior of all bodies as iteration scopes for `name`, eg
 ;;!! function foo() {   }
 ;;!                  ***
-(
-  (_
-    body: (_
-        .
-        "{" @name.iteration.start
-        "}" @name.iteration.end
-        .
-    )
+(_
+  body: (_
+      .
+      "{" @name.iteration.start.endof
+      "}" @name.iteration.end.startof
+      .
   )
-  (#end-position! @name.iteration.start)
-  (#start-position! @name.iteration.end)
 )

queries/javascript.jsx.scm

@@ -77,10 +77,7 @@
 ;;!! <>foo</>
 ;;!  {}    {}
 ;;!  --   ---
-(
-  (jsx_fragment
-    "<" @_.domain.start
-    ">" @name @_.domain.end
-  )
-  (#start-position! @name)
+(jsx_fragment
+  "<" @_.domain.start
+  ">" @name.start.startof @_.domain.end
 )