Added Tree sitter provider

packages/common/src/ide/types/RawTreeSitterQueryProvider.ts

@@ -0,0 +1,13 @@
+import { Disposable } from "@cursorless/common";
+
+export interface RawTreeSitterQueryProvider {
+  /**
+   * Listen for changes to language definitions
+   */
+  onChanges(listener: () => void): Disposable;
+
+  /**
+   * Read a query definition. The query name is the name of one of our `.scm` files.
+   */
+  readQuery(name: string): Promise<string | undefined>;
+}

packages/common/src/index.ts

@@ -31,6 +31,7 @@ export * from "./ide/types/QuickPickOptions";
 export * from "./ide/types/events.types";
 export * from "./ide/types/Paths";
 export * from "./ide/types/CommandHistoryStorage";
+export * from "./ide/types/RawTreeSitterQueryProvider";
 export * from "./ide/types/FileSystem.types";
 export * from "./types/RangeExpansionBehavior";
 export * from "./types/InputBoxOptions";

packages/cursorless-engine/src/cursorlessEngine.ts

@@ -6,6 +6,7 @@ import {
   IDE,
   ScopeProvider,
   ensureCommandShape,
+  type RawTreeSitterQueryProvider,
 } from "@cursorless/common";
 import { KeyboardTargetUpdater } from "./KeyboardTargetUpdater";
 import {
@@ -17,10 +18,15 @@ import { HatTokenMapImpl } from "./core/HatTokenMapImpl";
 import type { Snippets } from "./core/Snippets";
 import { StoredTargetMap } from "./core/StoredTargets";
 import { RangeUpdater } from "./core/updateSelections/RangeUpdater";
+import { DisabledLanguageDefinitions } from "./disabledComponents/DisabledLanguageDefinitions";
 import { DisabledSnippets } from "./disabledComponents/DisabledSnippets";
 import { DisabledTalonSpokenForms } from "./disabledComponents/DisabledTalonSpokenForms";
+import { DisabledTreeSitter } from "./disabledComponents/DisabledTreeSitter";
 import { CustomSpokenFormGeneratorImpl } from "./generateSpokenForm/CustomSpokenFormGeneratorImpl";
-import { LanguageDefinitions } from "./languages/LanguageDefinitions";
+import {
+  LanguageDefinitionsImpl,
+  type LanguageDefinitions,
+} from "./languages/LanguageDefinitions";
 import { ModifierStageFactoryImpl } from "./processTargets/ModifierStageFactoryImpl";
 import { ScopeHandlerFactoryImpl } from "./processTargets/modifiers/scopeHandlers";
 import { runCommand } from "./runCommand";
@@ -35,12 +41,13 @@ import { injectIde } from "./singletons/ide.singleton";
 import { TreeSitter } from "./typings/TreeSitter";
 
 export async function createCursorlessEngine(
-  treeSitter: TreeSitter,
+  treeSitter: TreeSitter = new DisabledTreeSitter(),
   ide: IDE,
   hats: Hats,
   commandServerApi: CommandServerApi | null,
   fileSystem: FileSystem,
   talonSpokenForms: TalonSpokenForms | undefined,
+  treeSitterQueryProvider: RawTreeSitterQueryProvider | undefined,
   snippets: Snippets = new DisabledSnippets(),
 ): Promise<CursorlessEngine> {
   injectIde(ide);
@@ -61,7 +68,9 @@ export async function createCursorlessEngine(
 
   const keyboardTargetUpdater = new KeyboardTargetUpdater(storedTargets);
 
-  const languageDefinitions = new LanguageDefinitions(fileSystem, treeSitter);
+  const languageDefinitions = treeSitterQueryProvider
+    ? new LanguageDefinitionsImpl(ide, treeSitter, treeSitterQueryProvider)
+    : new DisabledLanguageDefinitions();
   await languageDefinitions.init();
 
   const customSpokenFormGenerator = new CustomSpokenFormGeneratorImpl(

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

@@ -0,0 +1,33 @@
+import type { TextDocument, Range, Listener } from "@cursorless/common";
+import type { SyntaxNode } from "web-tree-sitter";
+import type { LanguageDefinition } from "../languages/LanguageDefinition";
+import type { LanguageDefinitions } from "../languages/LanguageDefinitions";
+
+export class DisabledLanguageDefinitions implements LanguageDefinitions {
+  init(): Promise<void> {
+    return Promise.resolve();
+  }
+
+  onDidChangeDefinition(_listener: Listener) {
+    return { dispose: () => {} };
+  }
+
+  loadLanguage(_languageId: string): Promise<void> {
+    return Promise.resolve();
+  }
+
+  get(_languageId: string): LanguageDefinition | undefined {
+    return undefined;
+  }
+
+  getNodeAtLocation(
+    _document: TextDocument,
+    _range: Range,
+  ): SyntaxNode | undefined {
+    return undefined;
+  }
+
+  dispose(): void {
+    // Do nothing
+  }
+}

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

@@ -0,0 +1,21 @@
+import type { TextDocument, Range } from "@cursorless/common";
+import type { SyntaxNode, Tree, Language } from "web-tree-sitter";
+import type { TreeSitter } from "../typings/TreeSitter";
+
+export class DisabledTreeSitter implements TreeSitter {
+  getTree(_document: TextDocument): Tree {
+    throw new Error("Tree sitter not provided");
+  }
+
+  loadLanguage(_languageId: string): Promise<boolean> {
+    return Promise.resolve(false);
+  }
+
+  getLanguage(_languageId: string): Language | undefined {
+    throw new Error("Tree sitter not provided");
+  }
+
+  getNodeAtLocation(_document: TextDocument, _range: Range): SyntaxNode {
+    throw new Error("Tree sitter not provided");
+  }
+}

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

@@ -1,12 +1,12 @@
 import {
-  FileSystem,
   ScopeType,
   SimpleScopeType,
   showError,
+  type IDE,
+  type RawTreeSitterQueryProvider,
 } from "@cursorless/common";
-import { basename, dirname, join } from "pathe";
+import { dirname, join } from "pathe";
 import { TreeSitterScopeHandler } from "../processTargets/modifiers/scopeHandlers";
-import { ide } from "../singletons/ide.singleton";
 import { TreeSitter } from "../typings/TreeSitter";
 import { matchAll } from "../util/regex";
 import { TreeSitterQuery } from "./TreeSitterQuery";
@@ -36,16 +36,15 @@ export class LanguageDefinition {
    * id doesn't have a new-style query definition
    */
   static async create(
+    ide: IDE,
+    treeSitterQueryProvider: RawTreeSitterQueryProvider,
     treeSitter: TreeSitter,
-    fileSystem: FileSystem,
-    queryDir: string,
     languageId: string,
   ): Promise<LanguageDefinition | undefined> {
-    const languageQueryPath = join(queryDir, `${languageId}.scm`);
-
     const rawLanguageQueryString = await readQueryFileAndImports(
-      fileSystem,
-      languageQueryPath,
+      ide,
+      treeSitterQueryProvider,
+      `${languageId}.scm`,
     );
 
     if (rawLanguageQueryString == null) {
@@ -91,43 +90,42 @@ export class LanguageDefinition {
  * @returns The text of the query file, with all imports inlined
  */
 async function readQueryFileAndImports(
-  fileSystem: FileSystem,
-  languageQueryPath: string,
+  ide: IDE,
+  provider: RawTreeSitterQueryProvider,
+  languageQueryName: string,
 ) {
   // Seed the map with the query file itself
   const rawQueryStrings: Record<string, string | null> = {
-    [languageQueryPath]: null,
+    [languageQueryName]: null,
   };
 
-  const doValidation = ide().runMode !== "production";
+  const doValidation = ide.runMode !== "production";
 
   // Keep reading imports until we've read all the imports. Every time we
   // encounter an import in a query file, we add it to the map with a value
   // of null, so that it will be read on the next iteration
   while (Object.values(rawQueryStrings).some((v) => v == null)) {
-    for (const [queryPath, rawQueryString] of Object.entries(rawQueryStrings)) {
+    for (const [queryName, rawQueryString] of Object.entries(rawQueryStrings)) {
       if (rawQueryString != null) {
         continue;
       }
 
-      const fileName = basename(queryPath);
-
-      let rawQuery = await fileSystem.readBundledFile(queryPath);
+      let rawQuery = await provider.readQuery(queryName);
 
       if (rawQuery == null) {
-        if (queryPath === languageQueryPath) {
+        if (queryName === languageQueryName) {
           // If this is the main query file, then we know that this language
           // just isn't defined using new-style queries
           return undefined;
         }
 
         showError(
-          ide().messages,
+          ide.messages,
           "LanguageDefinition.readQueryFileAndImports.queryNotFound",
-          `Could not find imported query file ${queryPath}`,
+          `Could not find imported query file ${queryName}`,
         );
 
-        if (ide().runMode === "test") {
+        if (ide.runMode === "test") {
           throw new Error("Invalid import statement");
         }
 
@@ -136,10 +134,10 @@ async function readQueryFileAndImports(
       }
 
       if (doValidation) {
-        validateQueryCaptures(fileName, rawQuery);
+        validateQueryCaptures(queryName, rawQuery);
       }
 
-      rawQueryStrings[queryPath] = rawQuery;
+      rawQueryStrings[queryName] = rawQuery;
       matchAll(
         rawQuery,
         // Matches lines like:
@@ -154,10 +152,10 @@ async function readQueryFileAndImports(
           const relativeImportPath = match[1];
 
           if (doValidation) {
-            validateImportSyntax(fileName, relativeImportPath, match[0]);
+            validateImportSyntax(ide, queryName, relativeImportPath, match[0]);
           }
 
-          const importQueryPath = join(dirname(queryPath), relativeImportPath);
+          const importQueryPath = join(dirname(queryName), relativeImportPath);
           rawQueryStrings[importQueryPath] =
             rawQueryStrings[importQueryPath] ?? null;
         },
@@ -169,6 +167,7 @@ async function readQueryFileAndImports(
 }
 
 function validateImportSyntax(
+  ide: IDE,
   file: string,
   relativeImportPath: string,
   actual: string,
@@ -177,12 +176,12 @@ function validateImportSyntax(
 
   if (actual !== canonicalSyntax) {
     showError(
-      ide().messages,
+      ide.messages,
       "LanguageDefinition.readQueryFileAndImports.malformedImport",
       `Malformed import statement in ${file}: "${actual}". Import statements must be of the form "${canonicalSyntax}"`,
     );
 
-    if (ide().runMode === "test") {
+    if (ide.runMode === "test") {
       throw new Error("Invalid import statement");
     }
   }