r

Author: AndreasArvidsson

data/fixtures/scopes/r/functionCall.chain.scope

@@ -0,0 +1,19 @@
+foo().bar()
+---
+
+[#1 Content] =
+[#1 Removal] =
+[#1 Domain] = 0:0-0:5
+  >-----<
+0| foo().bar()
+
+[#1 Insertion delimiter] = " "
+
+
+[#2 Content] =
+[#2 Removal] =
+[#2 Domain] = 0:0-0:11
+  >-----------<
+0| foo().bar()
+
+[#2 Insertion delimiter] = " "

data/fixtures/scopes/r/functionCallee.chain.scope

@@ -0,0 +1,25 @@
+foo().bar()
+---
+
+[#1 Content] =
+[#1 Removal] = 0:0-0:3
+  >---<
+0| foo().bar()
+
+[#1 Domain] = 0:0-0:5
+  >-----<
+0| foo().bar()
+
+[#1 Insertion delimiter] = " "
+
+
+[#2 Content] =
+[#2 Removal] = 0:0-0:9
+  >---------<
+0| foo().bar()
+
+[#2 Domain] = 0:0-0:11
+  >-----------<
+0| foo().bar()
+
+[#2 Insertion delimiter] = " "

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

@@ -264,6 +264,67 @@ class GrowToNamedSiblings extends QueryPredicateOperator<GrowToNamedSiblings> {
     return true;
   }
 }
+/**
+ * A predicate operator that modifies the range of the match to grow to leading siblings of the same type.
+ *
+ * The `leadingSeparator` argument specificies the separator each node except the first sibling will be separated by.
+ *
+ * ```
+ * (#call-chain! @foo ".")
+ * ```
+ */
+class CallChain extends QueryPredicateOperator<CallChain> {
+  name = "call-chain!" as const;
+  schema = z.union([z.tuple([q.node]), z.tuple([q.node, q.string])]);
+
+  run(nodeInfo: MutableQueryCapture, leadingSeparator: string) {
+    const { node, range, document } = nodeInfo;
+
+    if (node.parent == null) {
+      throw Error("Node has no parent");
+    }
+
+    const { children } = node.parent;
+    const nodeIndex = children.findIndex((n) => n.id === node.id);
+
+    if (nodeIndex === -1) {
+      throw Error("Node not found in parent");
+    }
+
+    let start = children[nodeIndex];
+    let end = start;
+
+    for (let i = nodeIndex; i > -1; --i) {
+      const child = children[i];
+
+      if (child.type !== node.type) {
+        break;
+      }
+
+      start = child;
+
+      const childRange = makeRangeFromPositions(
+        child.startPosition,
+        child.endPosition,
+      );
+
+      const childText = document.getText(childRange);
+
+      if (!childText.startsWith(leadingSeparator)) {
+        break;
+      }
+    }
+
+    if (start.id !== end.id) {
+      nodeInfo.range = makeRangeFromPositions(
+        start.startPosition,
+        end.endPosition,
+      );
+    }
+
+    return true;
+  }
+}
 
 /**
  * A predicate operator that modifies the range of the match by trimming trailing whitespace,
@@ -442,6 +503,7 @@ export const queryPredicateOperators = [
   new CharacterRange(),
   new ShrinkToMatch(),
   new GrowToNamedSiblings(),
+  new CallChain(),
   new AllowMultiple(),
   new InsertionDelimiter(),
   new SingleOrMultilineDelimiter(),

queries/r.scm

@@ -134,15 +134,16 @@
 ;; Function calls
 ;;!! foo()
 ;;!  ^^^^^
-;;!  -----
-(call) @functionCall @argumentOrParameter.iteration.domain
-
-;;!! foo()
 ;;!  ^^^
 ;;!  -----
-(call
-  (identifier) @functionCallee
-) @_.domain
+(
+  (call
+    (identifier) @functionCallee.end
+  ) @functionCall @functionCallee.start.startOf @functionCallee.domain
+  (#call-chain! @functionCall ".")
+  (#call-chain! @functionCallee.start.startOf ".")
+  (#call-chain! @functionCallee.domain ".")
+)
 
 ;; Technically lists and arrays are just calls to the function `list` or `c`
 ;;!! list(1, 2, 3)