Migrate key and value

Author: AndreasArvidsson

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

@@ -1,17 +1,18 @@
 import type { Range, TextDocument } from "@cursorless/common";
-import type { Point } from "web-tree-sitter";
+import type { Point, TreeCursor } from "web-tree-sitter";
 
 /**
  * Simple representation of the tree sitter syntax node. Used by
  * {@link MutableQueryCapture} to avoid using range/text and other mutable
  * parameters directly from the node.
  */
-interface SimpleSyntaxNode {
+export interface SimpleSyntaxNode {
   readonly id: number;
   readonly type: string;
   readonly isNamed: boolean;
   readonly parent: SimpleSyntaxNode | null;
   readonly children: Array<SimpleChildSyntaxNode>;
+  walk(): TreeCursor;
 }
 
 /**

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

@@ -0,0 +1,19 @@
+import type { SimpleSyntaxNode } from "./QueryCapture";
+
+export function getChildNodesForFieldName(
+  node: SimpleSyntaxNode,
+  fieldName: string,
+): SimpleSyntaxNode[] {
+  const nodes = [];
+  const treeCursor = node.walk();
+  let hasNext = treeCursor.gotoFirstChild();
+
+  while (hasNext) {
+    if (treeCursor.currentFieldName === fieldName) {
+      nodes.push(treeCursor.currentNode);
+    }
+    hasNext = treeCursor.gotoNextSibling();
+  }
+
+  return nodes;
+}

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

@@ -4,8 +4,39 @@ import { z } from "zod";
 import { makeRangeFromPositions } from "../../util/nodeSelectors";
 import type { MutableQueryCapture } from "./QueryCapture";
 import { QueryPredicateOperator } from "./QueryPredicateOperator";
+import { getChildNodesForFieldName } from "./getChildNodesForFieldName";
 import { q } from "./operatorArgumentSchemaTypes";
 
+/**
+ * A predicate operator that returns true if the node matches the desired index parity.
+ * For example, `(#parity? @foo value 0)` will accept the match if the `@foo`
+ * capture is at index parity 0 (even) among its parents value children.
+ */
+class Parity extends QueryPredicateOperator<Parity> {
+  name = "parity?" as const;
+  schema = z.tuple([q.node, q.string, q.integer]);
+  run(
+    { document, range, node }: MutableQueryCapture,
+    fieldName: string,
+    parity: 0 | 1,
+  ) {
+    if (node.parent == null) {
+      return false;
+    }
+
+    const children = getChildNodesForFieldName(node.parent, fieldName);
+    const nodeIndex = children.findIndex(({ id }) => id === node.id);
+
+    if (nodeIndex === -1) {
+      return false;
+    }
+
+    const desiredIndex = Math.floor(nodeIndex / 2) * 2 + parity;
+
+    return nodeIndex === desiredIndex;
+  }
+}
+
 /**
  * A predicate operator that returns true if the node matches the given text.
  * For example, `(#text? @foo bar)` will accept the match if the `@foo`
@@ -402,6 +433,7 @@ class EmptySingleMultiDelimiter extends QueryPredicateOperator<EmptySingleMultiD
 
 export const queryPredicateOperators = [
   new Log(),
+  new Parity(),
   new Text(),
   new Type(),
   new NotType(),

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

@@ -5,25 +5,6 @@ import { patternFinder } from "../util/nodeFinders";
 import { createPatternMatchers, matcher } from "../util/nodeMatchers";
 import { getChildNodesForFieldName } from "../util/treeSitterUtils";
 
-/**
- * Picks a node by rounding down and using the given parity. This function is
- * useful for picking the picking eg the key in a sequence of key-value pairs
- * @param parentFinder The finder to use to determine whether the parent is a
- * match
- * @param parity The parity that we're looking for
- * @returns A node finder
- */
-function parityNodeFinder(parentFinder: NodeFinder, parity: 0 | 1) {
-  return indexNodeFinder(
-    parentFinder,
-    (nodeIndex: number) => Math.floor(nodeIndex / 2) * 2 + parity,
-  );
-}
-
-function mapParityNodeFinder(parity: 0 | 1) {
-  return parityNodeFinder(patternFinder("map_lit"), parity);
-}
-
 /**
  * Creates a node finder which will apply a transformation to the index of a
  * value node and return the node at the given index of the nodes parent
@@ -57,6 +38,8 @@ function indexNodeFinder(
 
     const desiredIndex = indexTransform(nodeIndex);
 
+    console.log(node.text, nodeIndex, desiredIndex);
+
     if (desiredIndex === -1) {
       return null;
     }
@@ -78,10 +61,6 @@ const functionCallPattern = "~quoting_lit.list_lit!";
 const nodeMatchers: Partial<
   Record<SimpleScopeTypeType, NodeMatcherAlternative>
 > = {
-  collectionKey: matcher(mapParityNodeFinder(0)),
-  value: matcher(mapParityNodeFinder(1)),
-
-  // FIXME: Handle formal parameters
   argumentOrParameter: matcher(
     indexNodeFinder(patternFinder(functionCallPattern), (nodeIndex: number) =>
       nodeIndex !== 0 ? nodeIndex : -1,

queries/clojure.scm

@@ -133,3 +133,20 @@
   (#text? @_dummy "if" "if-let" "when" "when-let")
   (#not-parent-type? @ifStatement quoting_lit)
 )
+
+;;!! {:foo 1, :bar 2}
+;;!   ^^^^    ^^^^
+;;!        ^       ^
+(map_lit
+  value: (_) @collectionKey @collectionKey.domain.start @value.domain.start
+  value: (_) @value @collectionKey.domain.end @value.domain.end
+  (#parity? @collectionKey value 0)
+  (#parity? @value value 1)
+)
+
+;;!! {:foo 1, :bar 2}
+;;!   ^^^^^^^^^^^^^^
+(map_lit
+  "{" @collectionKey.iteration.start.endOf @value.iteration.start.endOf
+  "}" @collectionKey.iteration.end.startOf @value.iteration.end.startOf
+)