Updates for newer Tree sitter version (#2912)

Should be merged after
cursorless-dev/vscode-parse-tree#104

Author: AndreasArvidsson

packages/common/src/types/TreeSitter.ts

@@ -1,30 +1,31 @@
 import type { Range, TextDocument } from "@cursorless/common";
-import type { Language, SyntaxNode, Tree } from "web-tree-sitter";
+import type { Node, Query, Tree } from "web-tree-sitter";
 
 export interface TreeSitter {
   /**
    * Function to access nodes in the tree sitter.
    */
-  getNodeAtLocation(document: TextDocument, range: Range): SyntaxNode;
+  getNodeAtLocation(document: TextDocument, range: Range): Node;
 
   /**
    * Function to access the tree sitter tree.
    */
   getTree(document: TextDocument): Tree;
 
-  /**
-   * Gets a language if it is loaded
-   *
-   * @param languageId The language id of the language to get
-   * @returns The language if it is already loaded
-   */
-  getLanguage(languageId: string): Language | undefined;
-
   /**
    * Loads a language, returning true if it was successfully loaded
    *
    * @param languageId The language id of the language to load
    * @returns `true` if the language was successfully loaded
    */
   loadLanguage(languageId: string): Promise<boolean>;
+
+  /**
+   * Create a query if the language is loaded.
+   *
+   * @param languageId The language id of the language to get
+   * @param source The query source
+   * @returns The query if that language is already loaded
+   */
+  createQuery(languageId: string, source: string): Query | undefined;
 }

packages/cursorless-engine/src/disabledComponents/DisabledLanguageDefinitions.ts

@@ -1,5 +1,5 @@
 import type { TextDocument, Range, Listener } from "@cursorless/common";
-import type { SyntaxNode } from "web-tree-sitter";
+import type { Node } from "web-tree-sitter";
 import type { LanguageDefinition } from "../languages/LanguageDefinition";
 import type { LanguageDefinitions } from "../languages/LanguageDefinitions";
 
@@ -16,10 +16,7 @@ export class DisabledLanguageDefinitions implements LanguageDefinitions {
     return undefined;
   }
 
-  getNodeAtLocation(
-    _document: TextDocument,
-    _range: Range,
-  ): SyntaxNode | undefined {
+  getNodeAtLocation(_document: TextDocument, _range: Range): Node | undefined {
     return undefined;
   }
 

packages/cursorless-engine/src/disabledComponents/DisabledTreeSitter.ts

@@ -1,5 +1,5 @@
 import type { Range, TextDocument, TreeSitter } from "@cursorless/common";
-import type { Language, SyntaxNode, Tree } from "web-tree-sitter";
+import type { Node, Query, Tree } from "web-tree-sitter";
 
 export class DisabledTreeSitter implements TreeSitter {
   getTree(_document: TextDocument): Tree {
@@ -10,11 +10,11 @@ export class DisabledTreeSitter implements TreeSitter {
     return Promise.resolve(false);
   }
 
-  getLanguage(_languageId: string): Language | undefined {
+  getNodeAtLocation(_document: TextDocument, _range: Range): Node {
     throw new Error("Tree sitter not provided");
   }
 
-  getNodeAtLocation(_document: TextDocument, _range: Range): SyntaxNode {
+  createQuery(_languageId: string, _source: string): Query | undefined {
     throw new Error("Tree sitter not provided");
   }
 }

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

@@ -59,9 +59,14 @@ export class LanguageDefinition {
       return undefined;
     }
 
-    const rawQuery = treeSitter
-      .getLanguage(languageId)!
-      .query(rawLanguageQueryString);
+    const rawQuery = treeSitter.createQuery(languageId, rawLanguageQueryString);
+
+    if (rawQuery == null) {
+      throw Error(
+        `Could not create Tree sitter query for language ${languageId}`,
+      );
+    }
+
     const query = TreeSitterQuery.create(languageId, treeSitter, rawQuery);
 
     return new LanguageDefinition(query);

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

@@ -8,7 +8,7 @@ import {
   type TreeSitter,
 } from "@cursorless/common";
 import { toString } from "lodash-es";
-import type { SyntaxNode } from "web-tree-sitter";
+import type { Node } from "web-tree-sitter";
 import { LanguageDefinition } from "./LanguageDefinition";
 import { treeSitterQueryCache } from "./TreeSitterQuery/treeSitterQueryCache";
 
@@ -36,10 +36,7 @@ export interface LanguageDefinitions {
   /**
    * @deprecated Only for use in legacy containing scope stage
    */
-  getNodeAtLocation(
-    document: TextDocument,
-    range: Range,
-  ): SyntaxNode | undefined;
+  getNodeAtLocation(document: TextDocument, range: Range): Node | undefined;
 }
 
 /**
@@ -163,7 +160,7 @@ export class LanguageDefinitionsImpl
     return definition === LANGUAGE_UNDEFINED ? undefined : definition;
   }
 
-  public getNodeAtLocation(document: TextDocument, range: Range): SyntaxNode {
+  public getNodeAtLocation(document: TextDocument, range: Range): Node {
     return this.treeSitter.getNodeAtLocation(document, range);
   }
 

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

@@ -32,7 +32,7 @@ export type InferSchemaType<T extends HasSchema> = T["schema"];
  * Maps from an operand schema output type to the type of the argument that
  * will be passed to the `accept` function of the predicate operator.  For example:
  *
- * - `{type: "capture", name: string}` -> `SyntaxNode`
+ * - `{type: "capture", name: string}` -> `Node`
  * - `{type: "integer", value: number}` -> `number`
  */
 type PredicateParameterType<T extends SchemaOutputType> = T extends {

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

@@ -1,4 +1,4 @@
-import type { PredicateOperand } from "web-tree-sitter";
+import type { PredicateStep } from "web-tree-sitter";
 import type { z } from "zod";
 import type {
   AcceptFunctionArgs,
@@ -41,7 +41,7 @@ export abstract class QueryPredicateOperator<T extends HasSchema> {
    *
    * @param args The arguments to the operator, converted to the types specified
    * in the schema.  For example, if the schema is `z.tuple([q.node, q.string])`,
-   * then `args` will be `SyntaxNode, string`.
+   * then `args` will be `Node, string`.
    */
   protected abstract run(
     ...args: AcceptFunctionArgs<z.infer<InferSchemaType<T>>>
@@ -71,7 +71,7 @@ export abstract class QueryPredicateOperator<T extends HasSchema> {
    * @returns Either a predicate function, or a list of error messages if the operands
    * were invalid.
    */
-  createPredicate(inputOperands: PredicateOperand[]): PredicateResult {
+  createPredicate(inputOperands: PredicateStep[]): PredicateResult {
     const result = this.schema.safeParse(inputOperands);
 
     return result.success

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

@@ -1,10 +1,10 @@
-import type { PredicateOperand } from "web-tree-sitter";
+import type { PredicateStep } from "web-tree-sitter";
 import type { z } from "zod";
 import { operandToString } from "./predicateToString";
 
 export function constructZodErrorMessages(
-  inputOperands: PredicateOperand[],
-  error: z.ZodError<PredicateOperand[]>,
+  inputOperands: PredicateStep[],
+  error: z.ZodError<PredicateStep[]>,
 ): string[] {
   return error.errors
     .filter(
@@ -21,7 +21,7 @@ export function constructZodErrorMessages(
     .map((error) => getErrorMessage(inputOperands, error));
 }
 
-function getErrorMessage(inputOperands: PredicateOperand[], error: z.ZodIssue) {
+function getErrorMessage(inputOperands: PredicateStep[], error: z.ZodIssue) {
   if (error.path.length === 0) {
     if (error.code === "too_small") {
       return "Too few arguments";

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

@@ -1,17 +1,17 @@
-import type { SyntaxNode } from "web-tree-sitter";
+import type { Node } from "web-tree-sitter";
 
 /**
  * Determines whether the given node or one of its ancestors is an error node
  * @param node The node to check
  * @returns True if the given node is contained in an error node
  */
-export function isContainedInErrorNode(node: SyntaxNode) {
+export function isContainedInErrorNode(node: Node) {
   // This node or one of it descendants is an error node
   if (node.hasError) {
     return true;
   }
 
-  let ancestorNode: SyntaxNode | null = node.parent;
+  let ancestorNode: Node | null = node.parent;
 
   while (ancestorNode != null) {
     // Ancestral node is an error node

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { assertTypesEqual } from "./assertTypesEqual";
-import type { PredicateOperand } from "web-tree-sitter";
+import type { PredicateStep } from "web-tree-sitter";
 
 const string = z.object({ type: z.literal("string"), value: z.string() });
 
@@ -62,9 +62,9 @@ export type SchemaTypes = (typeof q)[keyof typeof q];
 
 /**
  * The type of the input to the schema.  This should always be
- * `PredicateOperand`, as that is what we always get from tree-sitter
+ * `PredicateStep`, as that is what we always get from tree-sitter
  */
-export type SchemaInputType = PredicateOperand;
+export type SchemaInputType = PredicateStep;
 // eslint-disable-next-line @typescript-eslint/no-unused-expressions
 assertTypesEqual<SchemaInputType, z.input<SchemaTypes>, SchemaInputType>;