Update cache

Author: AndreasArvidsson

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

@@ -16,6 +16,10 @@ export class DisabledLanguageDefinitions implements LanguageDefinitions {
     return undefined;
   }
 
+  clearCache(): void {
+    // Do nothing
+  }
+
   getNodeAtLocation(
     _document: TextDocument,
     _range: Range,

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

@@ -18,21 +18,23 @@ import { TreeSitterQuery } from "./TreeSitterQuery";
 import type { QueryCapture } from "./TreeSitterQuery/QueryCapture";
 import { validateQueryCaptures } from "./TreeSitterQuery/validateQueryCaptures";
 
-const cache = new LanguageDefinitionCache();
-
 /**
  * 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 cache: LanguageDefinitionCache;
+
   private constructor(
     /**
      * The tree-sitter query used to extract scopes for the given language.
      * Note that this query contains patterns for all scope types that the
      * language supports using new-style tree-sitter queries
      */
     private query: TreeSitterQuery,
-  ) {}
+  ) {
+    this.cache = new LanguageDefinitionCache();
+  }
 
   /**
    * Construct a language definition for the given language id, if the language
@@ -97,11 +99,15 @@ export class LanguageDefinition {
     document: TextDocument,
     captureName: SimpleScopeTypeType,
   ): QueryCapture[] {
-    if (!cache.isValid(document)) {
-      cache.update(document, this.getCapturesMap(document));
+    if (!this.cache.isValid(document)) {
+      this.cache.update(document, this.getCapturesMap(document));
     }
 
-    return cache.get(captureName);
+    return this.cache.get(captureName);
+  }
+
+  clearCache(): void {
+    this.cache.clear();
   }
 
   /**

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

@@ -4,27 +4,26 @@ import type {
   TextDocument,
 } from "@cursorless/common";
 import type { QueryCapture } from "./TreeSitterQuery/QueryCapture";
-import { ide } from "..";
 
 export class LanguageDefinitionCache {
-  private languageId: string = "";
   private documentUri: string = "";
   private documentVersion: number = -1;
   private captures: StringRecord<QueryCapture[]> = {};
 
+  clear() {
+    this.documentUri = "";
+    this.documentVersion = -1;
+    this.captures = {};
+  }
+
   isValid(document: TextDocument) {
-    if (ide().runMode === "test") {
-      return false;
-    }
     return (
-      this.languageId === document.languageId &&
       this.documentUri === document.uri.toString() &&
       this.documentVersion === document.version
     );
   }
 
   update(document: TextDocument, captures: StringRecord<QueryCapture[]>) {
-    this.languageId = document.languageId;
     this.documentUri = document.uri.toString();
     this.documentVersion = document.version;
     this.captures = captures;

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

@@ -32,6 +32,11 @@ export interface LanguageDefinitions {
    */
   get(languageId: string): LanguageDefinition | undefined;
 
+  /**
+   * Clear the cache of all language definitions. This is run at the start of a command.
+   */
+  clearCache(): void;
+
   /**
    * @deprecated Only for use in legacy containing scope stage
    */
@@ -155,6 +160,14 @@ export class LanguageDefinitionsImpl
     return definition === LANGUAGE_UNDEFINED ? undefined : definition;
   }
 
+  clearCache(): void {
+    for (const definition of this.languageDefinitions.values()) {
+      if (definition !== LANGUAGE_UNDEFINED) {
+        definition.clearCache();
+      }
+    }
+  }
+
   public getNodeAtLocation(document: TextDocument, range: Range): SyntaxNode {
     return this.treeSitter.getNodeAtLocation(document, range);
   }

packages/cursorless-engine/src/runCommand.ts

@@ -71,6 +71,8 @@ export async function runCommand(
     commandRunner = decorator.wrapCommandRunner(readableHatMap, commandRunner);
   }
 
+  languageDefinitions.clearCache();
+
   const response = await commandRunner.run(commandComplete);
 
   return await unwrapLegacyCommandResponse(command, response);