Started working on selected scope visualizer

Author: AndreasArvidsson

packages/common/src/types/ScopeProvider.ts

@@ -19,6 +19,12 @@ export interface ScopeProvider {
     config: ScopeRangeConfig,
   ) => ScopeRanges[];
 
+  provideScopeRangesForRange(
+    editor: TextEditor,
+    scopeType: ScopeType,
+    range: Range,
+  ): ScopeRanges[];
+
   /**
    * Get the iteration scope ranges for the given editor.
    * @param editor The editor

packages/cursorless-engine/src/cursorlessEngine.ts

@@ -175,6 +175,7 @@ function createScopeProvider(
 
   return {
     provideScopeRanges: rangeProvider.provideScopeRanges,
+    provideScopeRangesForRange: rangeProvider.provideScopeRangesForRange,
     provideIterationScopeRanges: rangeProvider.provideIterationScopeRanges,
     onDidChangeScopeRanges: rangeWatcher.onDidChangeScopeRanges,
     onDidChangeIterationScopeRanges:

packages/cursorless-engine/src/scopeProviders/ScopeRangeProvider.ts

@@ -1,8 +1,10 @@
-import type {
+import {
   IterationScopeRangeConfig,
   IterationScopeRanges,
+  Range,
   ScopeRangeConfig,
   ScopeRanges,
+  ScopeType,
   TextEditor,
 } from "@cursorless/common";
 
@@ -21,6 +23,8 @@ export class ScopeRangeProvider {
     private modifierStageFactory: ModifierStageFactory,
   ) {
     this.provideScopeRanges = this.provideScopeRanges.bind(this);
+    this.provideScopeRangesForRange =
+      this.provideScopeRangesForRange.bind(this);
     this.provideIterationScopeRanges =
       this.provideIterationScopeRanges.bind(this);
   }
@@ -45,6 +49,32 @@ export class ScopeRangeProvider {
     );
   }
 
+  provideScopeRangesForRange(
+    editor: TextEditor,
+    scopeType: ScopeType,
+    range: Range,
+  ): ScopeRanges[] {
+    const scopeHandler = this.scopeHandlerFactory.maybeCreate(
+      scopeType,
+      editor.document.languageId,
+    );
+
+    if (scopeHandler == null) {
+      return [];
+    }
+
+    // Need to have a non empty intersection with the scopes
+    if (range.isEmpty) {
+      const offset = editor.document.offsetAt(range.start);
+      range = new Range(
+        editor.document.positionAt(offset - 1),
+        editor.document.positionAt(offset + 1),
+      );
+    }
+
+    return getScopeRanges(editor, scopeHandler, range);
+  }
+
   provideIterationScopeRanges(
     editor: TextEditor,
     { scopeType, visibleOnly, includeNestedTargets }: IterationScopeRangeConfig,

packages/cursorless-vscode/src/ScopeTreeProvider.ts

@@ -2,6 +2,7 @@ import type {
   CursorlessCommandId,
   ScopeProvider,
   ScopeSupportInfo,
+  ScopeType,
   ScopeTypeInfo,
 } from "@cursorless/common";
 import {
@@ -12,13 +13,17 @@ import {
   serializeScopeType,
   uriEncodeHashId,
 } from "@cursorless/common";
-import type { CustomSpokenFormGenerator } from "@cursorless/cursorless-engine";
-import type { VscodeApi } from "@cursorless/vscode-common";
+import {
+  ide,
+  type CustomSpokenFormGenerator,
+} from "@cursorless/cursorless-engine";
+import { fromVscodeSelection, type VscodeApi } from "@cursorless/vscode-common";
 import { isEqual } from "lodash-es";
 import type {
   Disposable,
   Event,
   ExtensionContext,
+  TextEditorSelectionChangeEvent,
   TreeDataProvider,
   TreeItemLabel,
   TreeView,
@@ -61,6 +66,8 @@ export class ScopeTreeProvider implements TreeDataProvider<MyTreeItem> {
     private customSpokenFormGenerator: CustomSpokenFormGenerator,
     private hasCommandServer: boolean,
   ) {
+    this.onChangeTextSelection = this.onChangeTextSelection.bind(this);
+
     this.treeView = vscodeApi.window.createTreeView(
       CURSORLESS_SCOPE_TREE_VIEW_ID,
       {
@@ -79,7 +86,7 @@ export class ScopeTreeProvider implements TreeDataProvider<MyTreeItem> {
     }
   }
 
-  onDidChangeVisible(e: TreeViewVisibilityChangeEvent) {
+  private onDidChangeVisible(e: TreeViewVisibilityChangeEvent) {
     if (e.visible) {
       if (this.visibleDisposable != null) {
         return;
@@ -96,6 +103,46 @@ export class ScopeTreeProvider implements TreeDataProvider<MyTreeItem> {
     }
   }
 
+  private onChangeTextSelection(e: TextEditorSelectionChangeEvent) {
+    if (e.selections.length !== 1) {
+      return;
+    }
+
+    const editor = ide().activeTextEditor;
+
+    if (editor == null) {
+      return;
+    }
+
+    const selection = fromVscodeSelection(e.selections[0]);
+
+    console.log("selection", selection.concise());
+
+    for (const supportLevel of this.supportLevels) {
+      if (supportLevel.support !== ScopeSupport.supportedAndPresentInEditor) {
+        continue;
+      }
+
+      const scopes = this.scopeProvider.provideScopeRangesForRange(
+        editor,
+        supportLevel.scopeType,
+        selection,
+      );
+
+      if (scopes.length === 0) {
+        continue;
+      }
+
+      console.log(supportLevel.scopeType.type);
+
+      for (const scope of scopes) {
+        for (const target of scope.targets) {
+          console.log(target.contentRange.concise());
+        }
+      }
+    }
+  }
+
   private registerScopeSupportListener() {
     this.visibleDisposable = disposableFrom(
       this.scopeProvider.onDidChangeScopeSupport((supportLevels) => {
@@ -105,6 +152,9 @@ export class ScopeTreeProvider implements TreeDataProvider<MyTreeItem> {
       this.scopeVisualizer.onDidChangeScopeType(() => {
         this._onDidChangeTreeData.fire();
       }),
+      this.vscodeApi.window.onDidChangeTextEditorSelection(
+        this.onChangeTextSelection,
+      ),
     );
   }