Add ScopeSupportChecker

packages/common/src/util/itertools.ts

@@ -50,3 +50,18 @@ export function partition<T, U>(
   }
   return [first, second];
 }
+
+/**
+ * Returns `true` if the given iterable is empty, `false` otherwise
+ *
+ * From https://github.com/sindresorhus/is-empty-iterable/blob/12d3b4f966170d9d85a2067f5326668d5bb910a0/index.js
+ * @param iterable The iterable to check
+ * @returns `true` if the iterable is empty, `false` otherwise
+ */
+export function isEmptyIterable(iterable: Iterable<unknown>): boolean {
+  for (const _ of iterable) {
+    return false;
+  }
+
+  return true;
+}

packages/cursorless-engine/src/ScopeVisualizer/ScopeSupportChecker.ts

@@ -0,0 +1,110 @@
+import {
+  Position,
+  ScopeType,
+  SimpleScopeTypeType,
+  TextEditor,
+  isEmptyIterable,
+} from "@cursorless/common";
+import { LegacyLanguageId } from "../languages/LegacyLanguageId";
+import { languageMatchers } from "../languages/getNodeMatcher";
+import { ScopeHandlerFactory } from "../processTargets/modifiers/scopeHandlers/ScopeHandlerFactory";
+import { ScopeHandler } from "../processTargets/modifiers/scopeHandlers/scopeHandler.types";
+import { ScopeSupport } from "../api/ScopeProvider";
+
+/**
+ * Determines the level of support for a given scope type in a given editor.
+ * This is primarily determined by the language id of the editor, though some
+ * scopes are supported in all languages.
+ */
+export class ScopeSupportChecker {
+  constructor(private scopeHandlerFactory: ScopeHandlerFactory) {
+    this.getScopeSupport = this.getScopeSupport.bind(this);
+    this.getIterationScopeSupport = this.getIterationScopeSupport.bind(this);
+  }
+
+  /**
+   * Determine the level of support for {@link scopeType} in {@link editor}, as
+   * determined by its language id.
+   * @param editor The editor to check
+   * @param scopeType The scope type to check
+   * @returns The level of support for {@link scopeType} in {@link editor}
+   */
+  getScopeSupport(editor: TextEditor, scopeType: ScopeType): ScopeSupport {
+    const { languageId } = editor.document;
+    const scopeHandler = this.scopeHandlerFactory.create(scopeType, languageId);
+
+    if (scopeHandler == null) {
+      return getLegacyScopeSupport(languageId, scopeType);
+    }
+
+    return editorContainsScope(editor, scopeHandler)
+      ? ScopeSupport.supportedAndPresentInEditor
+      : ScopeSupport.supportedButNotPresentInEditor;
+  }
+
+  /**
+   * Determine the level of support for the iteration scope of {@link scopeType}
+   * in {@link editor}, as determined by its language id.
+   * @param editor The editor to check
+   * @param scopeType The scope type to check
+   * @returns The level of support for the iteration scope of {@link scopeType}
+   * in {@link editor}
+   */
+  getIterationScopeSupport(
+    editor: TextEditor,
+    scopeType: ScopeType,
+  ): ScopeSupport {
+    const { languageId } = editor.document;
+    const scopeHandler = this.scopeHandlerFactory.create(scopeType, languageId);
+
+    if (scopeHandler == null) {
+      return getLegacyScopeSupport(languageId, scopeType);
+    }
+
+    const iterationScopeHandler = this.scopeHandlerFactory.create(
+      scopeHandler.iterationScopeType,
+      languageId,
+    );
+
+    if (iterationScopeHandler == null) {
+      return ScopeSupport.unsupported;
+    }
+
+    return editorContainsScope(editor, iterationScopeHandler)
+      ? ScopeSupport.supportedAndPresentInEditor
+      : ScopeSupport.supportedButNotPresentInEditor;
+  }
+}
+
+function editorContainsScope(
+  editor: TextEditor,
+  scopeHandler: ScopeHandler,
+): boolean {
+  return !isEmptyIterable(
+    scopeHandler.generateScopes(editor, new Position(0, 0), "forward"),
+  );
+}
+
+function getLegacyScopeSupport(
+  languageId: string,
+  scopeType: ScopeType,
+): ScopeSupport {
+  switch (scopeType.type) {
+    case "boundedNonWhitespaceSequence":
+    case "surroundingPair":
+      return ScopeSupport.supportedLegacy;
+    case "notebookCell":
+      // FIXME: What to do here
+      return ScopeSupport.unsupported;
+    default:
+      if (
+        languageMatchers[languageId as LegacyLanguageId]?.[
+          scopeType.type as SimpleScopeTypeType
+        ] != null
+      ) {
+        return ScopeSupport.supportedLegacy;
+      }
+
+      return ScopeSupport.unsupported;
+  }
+}

packages/cursorless-engine/src/api/ScopeProvider.ts

@@ -53,6 +53,28 @@ export interface ScopeProvider {
     callback: IterationScopeChangeEventCallback,
     config: IterationScopeRangeConfig,
   ) => Disposable;
+
+  /**
+   * Determine the level of support for {@link scopeType} in {@link editor}, as
+   * determined by its language id.
+   * @param editor The editor to check
+   * @param scopeType The scope type to check
+   * @returns The level of support for {@link scopeType} in {@link editor}
+   */
+  getScopeSupport: (editor: TextEditor, scopeType: ScopeType) => ScopeSupport;
+
+  /**
+   * Determine the level of support for the iteration scope of {@link scopeType}
+   * in {@link editor}, as determined by its language id.
+   * @param editor The editor to check
+   * @param scopeType The scope type to check
+   * @returns The level of support for the iteration scope of {@link scopeType}
+   * in {@link editor}
+   */
+  getIterationScopeSupport: (
+    editor: TextEditor,
+    scopeType: ScopeType,
+  ) => ScopeSupport;
 }
 
 interface ScopeRangeConfigBase {
@@ -131,3 +153,10 @@ export interface IterationScopeRanges {
     targets?: TargetRanges[];
   }[];
 }
+
+export enum ScopeSupport {
+  supportedAndPresentInEditor,
+  supportedButNotPresentInEditor,
+  supportedLegacy,
+  unsupported,
+}

packages/cursorless-engine/src/cursorlessEngine.ts

@@ -3,6 +3,7 @@ import { StoredTargetMap, TestCaseRecorder, TreeSitter } from ".";
 import { CursorlessEngine } from "./api/CursorlessEngineApi";
 import { ScopeProvider } from "./api/ScopeProvider";
 import { ScopeRangeProvider } from "./ScopeVisualizer/ScopeRangeProvider";
+import { ScopeSupportChecker } from "./ScopeVisualizer/ScopeSupportChecker";
 import { Debug } from "./core/Debug";
 import { HatTokenMapImpl } from "./core/HatTokenMapImpl";
 import { Snippets } from "./core/Snippets";
@@ -101,12 +102,15 @@ function createScopeProvider(
   );
 
   const rangeWatcher = new ScopeRangeWatcher(rangeProvider);
+  const supportChecker = new ScopeSupportChecker(scopeHandlerFactory);
 
   return {
     provideScopeRanges: rangeProvider.provideScopeRanges,
     provideIterationScopeRanges: rangeProvider.provideIterationScopeRanges,
     onDidChangeScopeRanges: rangeWatcher.onDidChangeScopeRanges,
     onDidChangeIterationScopeRanges:
       rangeWatcher.onDidChangeIterationScopeRanges,
+    getScopeSupport: supportChecker.getScopeSupport,
+    getIterationScopeSupport: supportChecker.getIterationScopeSupport,
   };
 }