Clean up

Author: AndreasArvidsson

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

@@ -0,0 +1,30 @@
+import type { SimpleSyntaxNode } from "./QueryCapture";
+
+/**
+ * Checks if a node is at an even index within its parent's field.
+ *
+ * @param node - The node to check.
+ * @param fieldName - The name of the field in the parent node.
+ * @returns True if the node is at an even index, false otherwise.
+ */
+export function isEven(node: SimpleSyntaxNode, fieldName: string): boolean {
+  if (node.parent == null) {
+    throw Error("Node has no parent");
+  }
+
+  const treeCursor = node.parent.walk();
+  let hasNext = treeCursor.gotoFirstChild();
+  let even = true;
+
+  while (hasNext) {
+    if (treeCursor.currentFieldName === fieldName) {
+      if (treeCursor.currentNode.id === node.id) {
+        return even;
+      }
+      even = !even;
+    }
+    hasNext = treeCursor.gotoNextSibling();
+  }
+
+  throw Error(`Node not found in parent for field: ${fieldName}`);
+}

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

@@ -4,32 +4,32 @@ import { z } from "zod";
 import { makeRangeFromPositions } from "../../util/nodeSelectors";
 import type { MutableQueryCapture } from "./QueryCapture";
 import { QueryPredicateOperator } from "./QueryPredicateOperator";
-import { getChildNodesForFieldName } from "./getChildNodesForFieldName";
+import { isEven } from "./isEven";
 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.
+ * A predicate operator that returns true if the node is at an even index within
+ * its parents field. For example, `(#even? @foo value)` will accept the match
+ * if the `@foo` capture is at an even index among its parents value children.
  */
-class Parity extends QueryPredicateOperator<Parity> {
-  name = "parity?" as const;
-  schema = z.tuple([q.node, q.string, q.integer]);
-  run({ 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;
+class Even extends QueryPredicateOperator<Even> {
+  name = "even?" as const;
+  schema = z.tuple([q.node, q.string]);
+  run({ node }: MutableQueryCapture, fieldName: string) {
+    return isEven(node, fieldName);
+  }
+}
 
-    return nodeIndex === desiredIndex;
+/**
+ * A predicate operator that returns true if the node is at an odd index within
+ * its parents field. For example, `(#odd? @foo value)` will accept the match
+ * if the `@foo` capture is at an odd index among its parents value children.
+ */
+class Odd extends QueryPredicateOperator<Odd> {
+  name = "odd?" as const;
+  schema = z.tuple([q.node, q.string]);
+  run({ node }: MutableQueryCapture, fieldName: string) {
+    return !isEven(node, fieldName);
   }
 }
 
@@ -429,7 +429,8 @@ class EmptySingleMultiDelimiter extends QueryPredicateOperator<EmptySingleMultiD
 
 export const queryPredicateOperators = [
   new Log(),
-  new Parity(),
+  new Even(),
+  new Odd(),
   new Text(),
   new Type(),
   new NotType(),

queries/clojure.scm

@@ -151,8 +151,8 @@
 (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)
+  (#even? @collectionKey value)
+  (#odd? @value value)
 )
 
 ;;!! {:foo 1, :bar 2}