PR feedback

Author: pokey

packages/cursorless-engine/src/cursorlessEngine.ts

@@ -9,7 +9,7 @@ import { MarkStageFactoryImpl } from "./processTargets/MarkStageFactoryImpl";
 import { ModifierStageFactoryImpl } from "./processTargets/ModifierStageFactoryImpl";
 import { ScopeHandlerFactoryImpl } from "./processTargets/modifiers/scopeHandlers";
 import { injectIde } from "./singletons/ide.singleton";
-import { LanguageDefinitionsImpl } from "./languages/LanguageDefinitionsImpl";
+import { LanguageDefinitions } from "./languages/LanguageDefinitions";
 
 export function createCursorlessEngine(
   treeSitter: TreeSitter,
@@ -37,7 +37,7 @@ export function createCursorlessEngine(
 
   const testCaseRecorder = new TestCaseRecorder(hatTokenMap);
 
-  const languageDefinitions = new LanguageDefinitionsImpl(treeSitter);
+  const languageDefinitions = new LanguageDefinitions(treeSitter);
   const scopeHandlerFactory = new ScopeHandlerFactoryImpl(languageDefinitions);
   const markStageFactory = new MarkStageFactoryImpl();
   const modifierStageFactory = new ModifierStageFactoryImpl(

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

@@ -0,0 +1,61 @@
+import { ScopeType, SimpleScopeType } from "@cursorless/common";
+import { Query } from "web-tree-sitter";
+import { ide } from "../singletons/ide.singleton";
+import { join } from "path";
+import { TreeSitterScopeHandler } from "../processTargets/modifiers/scopeHandlers";
+import { TreeSitter } from "../typings/TreeSitter";
+import { existsSync, readFileSync } from "fs";
+import { LanguageId } from "./constants";
+
+/**
+ * Represents a language definition for a single language, including the
+ * tree-sitter query used to extract scopes for the given language
+ */
+export class LanguageDefinition {
+  private constructor(private treeSitter: TreeSitter, private query: Query) {}
+
+  /**
+   * Construct a language definition for the given language id, if the language
+   * has a new-style query definition, or return null if the language doesn't
+   *
+   * @param treeSitter The tree-sitter instance to use for parsing
+   * @param languageId The language id for which to create a language definition
+   * @returns A language definition for the given language id, or null if the given language
+   * id doesn't have a new-style query definition
+   */
+  static create(
+    treeSitter: TreeSitter,
+    languageId: LanguageId,
+  ): LanguageDefinition | null {
+    const queryPath = join(ide().assetsRoot, "queries", `${languageId}.scm`);
+
+    if (!existsSync(queryPath)) {
+      return null;
+    }
+
+    const rawLanguageQueryString = readFileSync(queryPath, "utf8");
+
+    return new LanguageDefinition(
+      treeSitter,
+      treeSitter.getLanguage(languageId)!.query(rawLanguageQueryString),
+    );
+  }
+
+  /**
+   * @param scopeType The scope type for which to get a scope handler
+   * @returns A scope handler for the given scope type and language id, or
+   * undefined if the given scope type / language id combination is still using
+   * legacy pathways
+   */
+  getScopeHandler(scopeType: ScopeType) {
+    if (!this.query.captureNames.includes(scopeType.type)) {
+      return undefined;
+    }
+
+    return new TreeSitterScopeHandler(
+      this.treeSitter,
+      this.query,
+      scopeType as SimpleScopeType,
+    );
+  }
+}

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

@@ -1,12 +1,32 @@
-import { ScopeType } from "@cursorless/common";
-import { ScopeHandler } from "../processTargets/modifiers/scopeHandlers/scopeHandler.types";
+import { isLanguageSupported } from ".";
+import { TreeSitter } from "..";
+import { LanguageDefinition } from "./LanguageDefinition";
 
-export interface LanguageDefinitions {
-  get(languageId: string): LanguageDefinition | undefined;
-}
+/**
+ * Keeps a map from language ids to  {@link LanguageDefinition} instances,
+ * constructing them as necessary
+ */
+export class LanguageDefinitions {
+  /**
+   * Maps from language id to {@link LanguageDefinition} or `null` if language
+   * doesn't have new-style definitions
+   */
+  private languageDefinitions: Map<string, LanguageDefinition | null> =
+    new Map();
+
+  constructor(private treeSitter: TreeSitter) {}
+
+  get(languageId: string): LanguageDefinition | undefined {
+    let definition = this.languageDefinitions.get(languageId);
+
+    if (definition === undefined) {
+      definition = isLanguageSupported(languageId)
+        ? LanguageDefinition.create(this.treeSitter, languageId)
+        : null;
+
+      this.languageDefinitions.set(languageId, definition);
+    }
 
-export interface LanguageDefinition {
-  maybeGetLanguageScopeHandler: (
-    scopeType: ScopeType,
-  ) => ScopeHandler | undefined;
+    return definition ?? undefined;
+  }
 }

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

@@ -56,7 +56,7 @@ export class ScopeHandlerFactoryImpl implements ScopeHandlerFactory {
       default:
         return this.languageDefinitions
           .get(languageId)
-          ?.maybeGetLanguageScopeHandler(scopeType);
+          ?.getScopeHandler(scopeType);
     }
   }
 }