Added performance tests (#2697)

The tests should pass once
#2700 is merged

This is the result from running it locally on my desktop.
```
  Performance: 10202 lines JSON
    Remove token
      24 ms
    √ Remove token (108ms)
    Select character
      14 ms
    √ Select character (122ms)
    Select word
      10 ms
    √ Select word (113ms)
    Select token
      8 ms
    √ Select token (110ms)
    Select identifier
      7 ms
    √ Select identifier (115ms)
    Select line
      40 ms
    √ Select line (141ms)
    Select sentence
      25 ms
    √ Select sentence (126ms)
    Select paragraph
      5 ms
    √ Select paragraph (104ms)
    Select document
      8 ms
    √ Select document (115ms)
    Select nonWhitespaceSequence
      8 ms
    √ Select nonWhitespaceSequence (96ms)
    Select string
      247 ms
    √ Select string (353ms)
    Select map
      167 ms
    √ Select map (248ms)
    Select collectionKey
      135 ms
    √ Select collectionKey (223ms)
    Select value
      142 ms
    √ Select value (222ms)
    Select boundedParagraph
      11822 ms
    √ Select boundedParagraph (11906ms)
    Select boundedNonWhitespaceSequence
      13749 ms
    √ Select boundedNonWhitespaceSequence (13837ms)
    Select surroundingPair.any
      20893 ms
    √ Select surroundingPair.any (21039ms)
    Select surroundingPair.curlyBrackets
      365 ms
    √ Select surroundingPair.curlyBrackets (483ms)
  18 passing (50s)
```

## Checklist

- [x] 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: AndreasArvidsson

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

@@ -0,0 +1,150 @@
+import {
+  asyncSafety,
+  type ActionDescriptor,
+  type ScopeType,
+  type SimpleScopeTypeType,
+} from "@cursorless/common";
+import { openNewEditor, runCursorlessCommand } from "@cursorless/vscode-common";
+import assert from "assert";
+import * as vscode from "vscode";
+import { endToEndTestSetup } from "../endToEndTestSetup";
+
+const testData = generateTestData(100);
+
+const textBasedThresholdMs = 100;
+const parseTreeThresholdMs = 500;
+const surroundingPairThresholdMs = 500;
+
+suite("Performance", async function () {
+  endToEndTestSetup(this);
+
+  let previousTitle = "";
+
+  // Before each test, print the test title. This is done we have the test
+  // title before the test run time / duration.
+  this.beforeEach(function () {
+    const title = this.currentTest!.title;
+    if (title !== previousTitle) {
+      console.log(`    ${title}`);
+      previousTitle = title;
+    }
+  });
+
+  test(
+    "Remove token",
+    asyncSafety(() => removeToken(textBasedThresholdMs)),
+  );
+
+  const fixtures: [SimpleScopeTypeType | ScopeType, number][] = [
+    // Text based
+    ["character", textBasedThresholdMs],
+    ["word", textBasedThresholdMs],
+    ["token", textBasedThresholdMs],
+    ["identifier", textBasedThresholdMs],
+    ["line", textBasedThresholdMs],
+    ["sentence", textBasedThresholdMs],
+    ["paragraph", textBasedThresholdMs],
+    ["document", textBasedThresholdMs],
+    ["nonWhitespaceSequence", textBasedThresholdMs],
+    // Parse tree based
+    ["string", parseTreeThresholdMs],
+    ["map", parseTreeThresholdMs],
+    ["collectionKey", parseTreeThresholdMs],
+    ["value", parseTreeThresholdMs],
+    // Text based, but utilizes surrounding pair
+    ["boundedParagraph", surroundingPairThresholdMs],
+    ["boundedNonWhitespaceSequence", surroundingPairThresholdMs],
+    ["collectionItem", surroundingPairThresholdMs],
+    // Surrounding pair
+    [{ type: "surroundingPair", delimiter: "any" }, surroundingPairThresholdMs],
+    [
+      { type: "surroundingPair", delimiter: "curlyBrackets" },
+      surroundingPairThresholdMs,
+    ],
+  ];
+
+  for (const [scope, threshold] of fixtures) {
+    const [scopeType, title] = getScopeTypeAndTitle(scope);
+    test(
+      `Select ${title}`,
+      asyncSafety(() => selectScopeType(scopeType, threshold)),
+    );
+  }
+});
+
+async function removeToken(thresholdMs: number) {
+  await testPerformance(thresholdMs, {
+    name: "remove",
+    target: {
+      type: "primitive",
+      modifiers: [{ type: "containingScope", scopeType: { type: "token" } }],
+    },
+  });
+}
+
+async function selectScopeType(scopeType: ScopeType, thresholdMs: number) {
+  await testPerformance(thresholdMs, {
+    name: "setSelection",
+    target: {
+      type: "primitive",
+      modifiers: [{ type: "containingScope", scopeType }],
+    },
+  });
+}
+
+async function testPerformance(thresholdMs: number, action: ActionDescriptor) {
+  const editor = await openNewEditor(testData, { languageId: "json" });
+  // This is the position of the last json key in the document
+  const position = new vscode.Position(editor.document.lineCount - 3, 5);
+  const selection = new vscode.Selection(position, position);
+  editor.selections = [selection];
+  editor.revealRange(selection);
+
+  const start = performance.now();
+
+  await runCursorlessCommand({
+    version: 7,
+    usePrePhraseSnapshot: false,
+    action,
+  });
+
+  const duration = Math.round(performance.now() - start);
+
+  console.log(`      ${duration} ms`);
+
+  assert.ok(
+    duration < thresholdMs,
+    `Duration ${duration}ms exceeds threshold ${thresholdMs}ms`,
+  );
+}
+
+function getScopeTypeAndTitle(
+  scope: SimpleScopeTypeType | ScopeType,
+): [ScopeType, string] {
+  if (typeof scope === "string") {
+    return [{ type: scope }, scope];
+  }
+  switch (scope.type) {
+    case "surroundingPair":
+      return [scope, `${scope.type}.${scope.delimiter}`];
+  }
+  throw Error(`Unexpected scope type: ${scope.type}`);
+}
+
+/**
+ * Generate a large JSON object with n-keys, each with n-values.
+ * {
+ *   "0": { "0": "value", ..., "n-1": "value" },
+ *   ...
+ *   "n-1": { "0": "value", ..., "n-1": "value" }
+ * }
+ */
+function generateTestData(n: number): string {
+  const value = Object.fromEntries(
+    new Array(n).fill("").map((_, i) => [i.toString(), "value"]),
+  );
+  const obj = Object.fromEntries(
+    new Array(n).fill("").map((_, i) => [i.toString(), value]),
+  );
+  return JSON.stringify(obj, null, 2);
+}