Add integration test setup; check for legacy/new scope duplicates (#1428)

This PR adds a test to ensure that we don't try to define the same scope
type both using our legacy node matchers and the new query scope
handlers

I have mixed feelings about the way I made this work, but I wasn't sure
how else to do it. The test needs to be defined in the engine, because
otherwise we'd need to expose lots of stuff to cursorless-vscode-e2e,
but it needs a full tree-sitter instance, so can't be run as a unit
test. This file is the compromise I came up with 🤷‍♂️. We should maybe
revise once we have tree-sitter integrated with this repo

I don't like that this code gets rolled up into our production bundle,
but probably ok for this one-off. If we find this file growing, we
should revisit

It's also possible that once we get rid of our `ide` singleton, we can
relax the restriction that our test harness doesn't import from
`cursorless-engine`. That would enable us to just import what we need
from the engine directly in the test harness to run this test 🤔

- Depends on #629

## Checklist

- [ ] I have added
[tests](https://www.cursorless.org/docs/contributing/test-case-recorder/)
- [ ] I have updated the
[docs](https://github.com/cursorless-dev/cursorless/tree/main/docs) and
[cheatsheet](https://github.com/cursorless-dev/cursorless/tree/main/cursorless-talon/src/cheatsheet)
- [ ] I have not broken the cheatsheet

Author: pokey

packages/cursorless-engine/src/cursorlessEngine.ts

@@ -5,6 +5,7 @@ import { HatTokenMapImpl } from "./core/HatTokenMapImpl";
 import { Snippets } from "./core/Snippets";
 import { RangeUpdater } from "./core/updateSelections/RangeUpdater";
 import { LanguageDefinitions } from "./languages/LanguageDefinitions";
+import { runIntegrationTests } from "./runIntegrationTests";
 import { injectIde } from "./singletons/ide.singleton";
 import { ensureCommandShape } from "./core/commandVersionUpgrades/ensureCommandShape";
 import { runCommand } from "./runCommand";
@@ -72,6 +73,8 @@ export function createCursorlessEngine(
     hatTokenMap,
     snippets,
     injectIde,
+    runIntegrationTests: () =>
+      runIntegrationTests(treeSitter, languageDefinitions),
   };
 }
 
@@ -96,4 +99,5 @@ export interface CursorlessEngine {
   hatTokenMap: HatTokenMapImpl;
   snippets: Snippets;
   injectIde: (ide: IDE | undefined) => void;
+  runIntegrationTests: () => Promise<void>;
 }

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

@@ -2,27 +2,30 @@
  * The language IDs that we have full tree-sitter support for using our legacy
  * modifiers.
  */
-export type LegacyLanguageId =
-  | "c"
-  | "clojure"
-  | "cpp"
-  | "css"
-  | "csharp"
-  | "go"
-  | "html"
-  | "java"
-  | "javascript"
-  | "javascriptreact"
-  | "json"
-  | "jsonc"
-  | "latex"
-  | "markdown"
-  | "php"
-  | "python"
-  | "ruby"
-  | "scala"
-  | "scss"
-  | "rust"
-  | "typescript"
-  | "typescriptreact"
-  | "xml";
+export const legacyLanguageIds = [
+  "c",
+  "clojure",
+  "cpp",
+  "css",
+  "csharp",
+  "go",
+  "html",
+  "java",
+  "javascript",
+  "javascriptreact",
+  "json",
+  "jsonc",
+  "latex",
+  "markdown",
+  "php",
+  "python",
+  "ruby",
+  "scala",
+  "scss",
+  "rust",
+  "typescript",
+  "typescriptreact",
+  "xml",
+];
+
+export type LegacyLanguageId = (typeof legacyLanguageIds)[number];

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

@@ -50,7 +50,7 @@ export function getNodeMatcher(
   return matcher;
 }
 
-const languageMatchers: Record<
+export const languageMatchers: Record<
   LegacyLanguageId,
   Record<SimpleScopeTypeType, NodeMatcher>
 > = {

packages/cursorless-engine/src/runIntegrationTests.ts

@@ -0,0 +1,44 @@
+import assert = require("assert");
+import { languageMatchers } from "./languages/getNodeMatcher";
+import { TreeSitter } from "./typings/TreeSitter";
+import { legacyLanguageIds } from "./languages/LegacyLanguageId";
+import { LanguageDefinitions } from "./languages/LanguageDefinitions";
+
+/**
+ * Run tests that require multiple components to be instantiated, as well as a
+ * full context, eg including tree sitter, but that are too closely tied to the
+ * engine to be defined in cursorless-vscode-e2e
+ *
+ * @param treeSitter The tree sitter instance
+ * @param languageDefinitions The language definitions instance
+ */
+export async function runIntegrationTests(
+  treeSitter: TreeSitter,
+  languageDefinitions: LanguageDefinitions,
+) {
+  await assertNoScopesBothLegacyAndNew(treeSitter, languageDefinitions);
+}
+
+async function assertNoScopesBothLegacyAndNew(
+  treeSitter: TreeSitter,
+  languageDefinitions: LanguageDefinitions,
+) {
+  const errors: string[] = [];
+  for (const languageId of legacyLanguageIds) {
+    await treeSitter.loadLanguage(languageId);
+
+    Object.keys(languageMatchers[languageId]).map((scopeTypeType) => {
+      if (
+        languageDefinitions.get(languageId)?.getScopeHandler({
+          type: scopeTypeType,
+        }) != null
+      ) {
+        errors.push(
+          `Scope '${scopeTypeType}' defined as both legacy and new for language ${languageId}`,
+        );
+      }
+    });
+  }
+
+  assert.deepStrictEqual(errors, []);
+}

packages/cursorless-engine/src/typings/TreeSitter.ts

@@ -15,8 +15,16 @@ export interface TreeSitter {
   /**
    * Gets a language if it is loaded
    *
-   * @param languageId The language id of the language to load
+   * @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>;
 }

packages/cursorless-vscode-e2e/src/suite/cursorlessEngineIntegration.test.ts

@@ -0,0 +1,12 @@
+import { getCursorlessApi } from "@cursorless/vscode-common";
+import { endToEndTestSetup } from "../endToEndTestSetup";
+
+suite("Cursorless engine integration", async function () {
+  endToEndTestSetup(this);
+
+  test("integration", async () => {
+    const cursorlessApi = await getCursorlessApi();
+    const { runIntegrationTests } = cursorlessApi.testHelpers!;
+    await runIntegrationTests();
+  });
+});

packages/cursorless-vscode/src/constructTestHelpers.ts

@@ -28,6 +28,7 @@ export function constructTestHelpers(
   vscodeIDE: VscodeIDE,
   normalizedIde: NormalizedIDE,
   injectIde: (ide: IDE) => void,
+  runIntegrationTests: () => Promise<void>,
 ): TestHelpers | undefined {
   return {
     commandServerApi: commandServerApi!,
@@ -72,5 +73,6 @@ export function constructTestHelpers(
       );
     },
     hatTokenMap,
+    runIntegrationTests,
   };
 }

packages/cursorless-vscode/src/extension.ts

@@ -65,6 +65,7 @@ export async function activate(
     hatTokenMap,
     snippets,
     injectIde,
+    runIntegrationTests,
   } = createCursorlessEngine(
     treeSitter,
     normalizedIde ?? vscodeIDE,
@@ -93,6 +94,7 @@ export async function activate(
           vscodeIDE,
           normalizedIde!,
           injectIde,
+          runIntegrationTests,
         )
       : undefined,
 
@@ -129,6 +131,7 @@ function createTreeSitter(parseTreeApi: ParseTreeApi): TreeSitter {
       return parseTreeApi.getTreeForUri(document.uri);
     },
 
+    loadLanguage: parseTreeApi.loadLanguage,
     getLanguage: parseTreeApi.getLanguage,
   };
 }

packages/vscode-common/src/getExtensionApi.ts

@@ -40,6 +40,8 @@ export interface TestHelpers {
     marks: SerializedMarks | undefined,
     forceRealClipboard: boolean,
   ): Promise<TestCaseSnapshot>;
+
+  runIntegrationTests(): Promise<void>;
 }
 
 export interface CursorlessApi {