Only do contiguous for comments

Author: AndreasArvidsson

cursorless-talon/src/modifiers/scopes.py

@@ -1,5 +1,3 @@
-from typing import Any
-
 from talon import Module
 
 mod = Module()
@@ -14,45 +12,42 @@
     "cursorless_custom_regex_scope_type_plural",
     desc="Supported plural custom regular expression scope types",
 )
-mod.list(
-    "cursorless_contiguous_scope_type",
-    desc="Cursorless contiguous scope type",
-)
 
 
 @mod.capture(
-    rule="[{user.cursorless_contiguous_scope_type}] ({user.cursorless_scope_type} | {user.cursorless_custom_regex_scope_type})"
+    rule="{user.cursorless_scope_type} | <user.cursorless_glyph_scope_type> | {user.cursorless_custom_regex_scope_type}"
 )
-def cursorless_scope_type(m) -> dict[str, Any]:
+def cursorless_scope_type(m) -> dict[str, str]:
     """Cursorless scope type singular"""
     try:
-        scope_type = {"type": m.cursorless_scope_type}
+        return {"type": m.cursorless_scope_type}
     except AttributeError:
-        scope_type = {
-            "type": "customRegex",
-            "regex": m.cursorless_custom_regex_scope_type,
-        }
+        pass
 
     try:
-        return {"type": m.cursorless_contiguous_scope_type, "scopeType": scope_type}
+        return m.cursorless_glyph_scope_type
     except AttributeError:
-        return scope_type
+        pass
+
+    return {"type": "customRegex", "regex": m.cursorless_custom_regex_scope_type}
 
 
 @mod.capture(
-    rule="[{user.cursorless_contiguous_scope_type}] ({user.cursorless_scope_type_plural} | {user.cursorless_custom_regex_scope_type_plural})"
+    rule="{user.cursorless_scope_type_plural} | <user.cursorless_glyph_scope_type_plural> | {user.cursorless_custom_regex_scope_type_plural}"
 )
-def cursorless_scope_type_plural(m) -> dict[str, Any]:
+def cursorless_scope_type_plural(m) -> dict[str, str]:
     """Cursorless scope type plural"""
     try:
-        scope_type = {"type": m.cursorless_scope_type_plural}
+        return {"type": m.cursorless_scope_type_plural}
     except AttributeError:
-        scope_type = {
-            "type": "customRegex",
-            "regex": m.cursorless_custom_regex_scope_type_plural,
-        }
+        pass
 
     try:
-        return {"type": m.cursorless_contiguous_scope_type, "scopeType": scope_type}
+        return m.cursorless_glyph_scope_type_plural
     except AttributeError:
-        return scope_type
+        pass
+
+    return {
+        "type": "customRegex",
+        "regex": m.cursorless_custom_regex_scope_type_plural,
+    }

cursorless-talon/src/spoken_forms.json

@@ -81,7 +81,6 @@
       "visible": "visible"
     },
     "simple_scope_modifier": { "every": "every" },
-    "contiguous_scope_type": { "fat": "contiguous" },
     "interior_modifier": {
       "inside": "interiorOnly"
     },

packages/common/src/types/command/PartialTargetDescriptor.types.ts

@@ -205,17 +205,11 @@ export interface OneOfScopeType {
   scopeTypes: ScopeType[];
 }
 
-export interface ContiguousScopeType {
-  type: "contiguous";
-  scopeType: ScopeType;
-}
-
 export type ScopeType =
   | SimpleScopeType
   | SurroundingPairScopeType
   | CustomRegexScopeType
-  | OneOfScopeType
-  | ContiguousScopeType;
+  | OneOfScopeType;
 
 export interface ContainingSurroundingPairModifier
   extends ContainingScopeModifier {

packages/cursorless-engine/src/generateSpokenForm/primitiveTargetToSpokenForm.ts

@@ -209,11 +209,6 @@ export class PrimitiveTargetSpokenFormGenerator {
       case "oneOf":
         throw new NoSpokenFormError(`Scope type '${scopeType.type}'`);
 
-      case "contiguous": {
-        const scope = this.handleScopeType(scopeType.scopeType);
-        return [this.spokenFormMap.modifierExtra.contiguousScope, scope];
-      }
-
       case "surroundingPair": {
         const pair = this.spokenFormMap.pairedDelimiter[scopeType.delimiter];
         if (scopeType.forceDirection != null) {

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

@@ -2,10 +2,11 @@ import { ScopeType, SimpleScopeType, showError } from "@cursorless/common";
 import { existsSync, readFileSync } from "fs";
 import { dirname, join } from "path";
 import { TreeSitterScopeHandler } from "../processTargets/modifiers/scopeHandlers";
+import { ContiguousScopeHandler } from "../processTargets/modifiers/scopeHandlers/ContiguousScopeHandler";
 import { TreeSitterTextFragmentScopeHandler } from "../processTargets/modifiers/scopeHandlers/TreeSitterScopeHandler/TreeSitterTextFragmentScopeHandler";
-import { ScopeHandler } from "../processTargets/modifiers/scopeHandlers/scopeHandler.types";
+import type { ScopeHandler } from "../processTargets/modifiers/scopeHandlers/scopeHandler.types";
 import { ide } from "../singletons/ide.singleton";
-import { TreeSitter } from "../typings/TreeSitter";
+import type { TreeSitter } from "../typings/TreeSitter";
 import { matchAll } from "../util/regex";
 import { TreeSitterQuery } from "./TreeSitterQuery";
 import { TEXT_FRAGMENT_CAPTURE_NAME } from "./captureNames";
@@ -60,12 +61,21 @@ export class LanguageDefinition {
    * undefined if the given scope type / language id combination is still using
    * legacy pathways
    */
-  getScopeHandler(scopeType: ScopeType) {
+  getScopeHandler(scopeType: ScopeType): ScopeHandler | undefined {
     if (!this.query.captureNames.includes(scopeType.type)) {
       return undefined;
     }
 
-    return new TreeSitterScopeHandler(this.query, scopeType as SimpleScopeType);
+    const scopeHandler = new TreeSitterScopeHandler(
+      this.query,
+      scopeType as SimpleScopeType,
+    );
+
+    if (scopeType.type === "comment") {
+      return new ContiguousScopeHandler(scopeHandler);
+    }
+
+    return scopeHandler;
   }
 
   getTextFragmentScopeHandler(): ScopeHandler | undefined {

packages/cursorless-engine/src/processTargets/modifiers/scopeHandlers/ContiguousScopeHandler.ts

@@ -1,13 +1,11 @@
 import {
-  ContiguousScopeType,
   Direction,
   Position,
   Range,
   ScopeType,
   TextEditor,
   next,
 } from "@cursorless/common";
-import { ScopeHandlerFactory } from ".";
 import { Target } from "../../../typings/target.types";
 import { constructScopeRangeTarget } from "../constructScopeRangeTarget";
 import { BaseScopeHandler } from "./BaseScopeHandler";
@@ -20,21 +18,13 @@ import type {
 
 export class ContiguousScopeHandler extends BaseScopeHandler {
   protected readonly isHierarchical = false;
-  private readonly scopeHandler: ScopeHandler;
 
-  constructor(
-    private scopeHandlerFactory: ScopeHandlerFactory,
-    public scopeType: ContiguousScopeType,
-    languageId: string,
-  ) {
+  constructor(private scopeHandler: ScopeHandler) {
     super();
-    const handler = scopeHandlerFactory.create(scopeType.scopeType, languageId);
-    if (handler == null) {
-      throw new Error(
-        `No available scope handler for '${scopeType.scopeType.type}'`,
-      );
-    }
-    this.scopeHandler = handler;
+  }
+
+  get scopeType(): ScopeType | undefined {
+    return this.scopeHandler.scopeType;
   }
 
   get iterationScopeType(): ScopeType | CustomScopeType {

packages/cursorless-engine/src/processTargets/modifiers/scopeHandlers/ScopeHandlerFactoryImpl.ts

@@ -75,8 +75,6 @@ export class ScopeHandlerFactoryImpl implements ScopeHandlerFactory {
         return new CustomRegexScopeHandler(this, scopeType, languageId);
       case "custom":
         return scopeType.scopeHandler;
-      case "contiguous":
-        return new ContiguousScopeHandler(this, scopeType, languageId);
       case "instance":
         // Handle instance pseudoscope with its own special modifier
         throw Error("Unexpected scope type 'instance'");

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

@@ -175,9 +175,6 @@ function isLanguageSpecific(scopeType: ScopeType): boolean {
     case "customRegex":
       return false;
 
-    case "contiguous":
-      return isLanguageSpecific(scopeType.scopeType);
-
     case "oneOf":
       throw Error(
         `Can't decide whether scope type ${JSON.stringify(

packages/cursorless-engine/src/spokenForms/SpokenFormType.ts

@@ -59,7 +59,6 @@ type ModifierExtra =
   | "previous"
   | "next"
   | "forward"
-  | "backward"
-  | "contiguousScope";
+  | "backward";
 
 export type SpokenFormType = keyof SpokenFormMapKeyTypes;

packages/cursorless-engine/src/spokenForms/defaultSpokenFormMapCore.ts

@@ -130,7 +130,6 @@ export const defaultSpokenFormMapCore: DefaultSpokenFormMapDefinition = {
     next: "next",
     forward: "forward",
     backward: "backward",
-    contiguousScope: "fat",
   },
 
   customRegex: {},