Made sorted scope handler a custom scope handler

Author: AndreasArvidsson

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

@@ -260,11 +260,6 @@ export interface SurroundingPairInteriorScopeType {
   delimiter: SurroundingPairName;
 }
 
-export interface OneOfScopeType {
-  type: "oneOf";
-  scopeTypes: ScopeType[];
-}
-
 export interface GlyphScopeType {
   type: "glyph";
   character: string;
@@ -275,7 +270,6 @@ export type ScopeType =
   | SurroundingPairScopeType
   | SurroundingPairInteriorScopeType
   | CustomRegexScopeType
-  | OneOfScopeType
   | GlyphScopeType;
 
 export interface ContainingSurroundingPairModifier extends ContainingScopeModifier {

packages/lib-engine/src/processTargets/modifiers/scopeHandlers/FallbackScopeHandler.ts

@@ -1,8 +1,6 @@
 import {
-  NoContainingScopeError,
   type Direction,
   type Position,
-  type ScopeType,
   type TextEditor,
 } from "@cursorless/lib-common";
 import { BaseScopeHandler } from "./BaseScopeHandler";
@@ -23,9 +21,17 @@ export class FallbackScopeHandler extends BaseScopeHandler {
     scopeType: FallbackScopeType,
     languageId: string,
   ): ScopeHandler {
-    const scopeHandlers = scopeType.scopeTypes.map((scopeType) =>
-      scopeHandlerFactory.create(scopeType, languageId),
-    );
+    const scopeHandlers = scopeType.scopeTypes
+      .map((scopeType) =>
+        scopeHandlerFactory.maybeCreate(scopeType, languageId),
+      )
+      .filter(
+        (scopeHandler): scopeHandler is ScopeHandler => scopeHandler != null,
+      );
+
+    if (scopeHandlers.length === 1) {
+      return scopeHandlers[0];
+    }
 
     return this.createFromScopeHandlers(scopeHandlers);
   }
@@ -38,10 +44,11 @@ export class FallbackScopeHandler extends BaseScopeHandler {
     super();
   }
 
-  get iterationScopeType(): ScopeType {
-    throw new NoContainingScopeError(
-      "Iteration scope for FallbackScopeHandler",
-    );
+  get iterationScopeType(): FallbackScopeType {
+    return {
+      type: "fallback",
+      scopeTypes: this.scopeHandlers.map((s) => s.iterationScopeType),
+    };
   }
 
   *generateScopeCandidates(

packages/lib-engine/src/processTargets/modifiers/scopeHandlers/SortedScopeHandler.ts

@@ -1,18 +1,13 @@
-import type {
-  Direction,
-  OneOfScopeType,
-  Position,
-  TextEditor,
-} from "@cursorless/lib-common";
+import type { Direction, Position, TextEditor } from "@cursorless/lib-common";
 import { BaseScopeHandler } from "./BaseScopeHandler";
 import { advanceIteratorsUntil, getInitialIteratorInfos } from "./IteratorInfo";
 import type { ScopeHandlerFactory } from "./ScopeHandlerFactory";
 import { compareTargetScopes } from "./compareTargetScopes";
 import type { TargetScope } from "./scope.types";
 import type {
-  CustomScopeType,
   ScopeHandler,
   ScopeIteratorRequirements,
+  SortedScopeType,
 } from "./scopeHandler.types";
 
 export class SortedScopeHandler extends BaseScopeHandler {
@@ -23,7 +18,7 @@ export class SortedScopeHandler extends BaseScopeHandler {
 
   static create(
     scopeHandlerFactory: ScopeHandlerFactory,
-    scopeType: OneOfScopeType,
+    scopeType: SortedScopeType,
     languageId: string,
   ): ScopeHandler {
     const scopeHandlers = scopeType.scopeTypes
@@ -38,50 +33,21 @@ export class SortedScopeHandler extends BaseScopeHandler {
       return scopeHandlers[0];
     }
 
-    return this.createFromScopeHandlers(
-      scopeHandlerFactory,
-      languageId,
-      scopeHandlers,
-    );
+    return this.createFromScopeHandlers(scopeHandlers);
   }
 
-  static createFromScopeHandlers(
-    scopeHandlerFactory: ScopeHandlerFactory,
-    languageId: string,
-    scopeHandlers: ScopeHandler[],
-  ): ScopeHandler {
-    const getIterationScopeHandler = () =>
-      new SortedScopeHandler(
-        scopeHandlers.map((scopeHandler) =>
-          scopeHandlerFactory.create(
-            scopeHandler.iterationScopeType,
-            languageId,
-          ),
-        ),
-        () => {
-          throw new Error(
-            "SortedScopeHandler: Iteration scope is not implemented",
-          );
-        },
-      );
-
-    return new SortedScopeHandler(scopeHandlers, getIterationScopeHandler);
+  static createFromScopeHandlers(scopeHandlers: ScopeHandler[]): ScopeHandler {
+    return new SortedScopeHandler(scopeHandlers);
   }
 
-  private constructor(
-    private scopeHandlers: ScopeHandler[],
-    private getIterationScopeHandler: () => SortedScopeHandler,
-  ) {
+  private constructor(private scopeHandlers: ScopeHandler[]) {
     super();
   }
 
-  get iterationScopeType(): CustomScopeType {
-    if (this.iterationScopeHandler == null) {
-      this.iterationScopeHandler = this.getIterationScopeHandler();
-    }
+  get iterationScopeType(): SortedScopeType {
     return {
-      type: "custom",
-      scopeHandler: this.iterationScopeHandler,
+      type: "sorted",
+      scopeTypes: this.scopeHandlers.map((s) => s.iterationScopeType),
     };
   }
 

packages/lib-engine/src/processTargets/modifiers/scopeHandlers/scopeHandler.types.ts

@@ -25,6 +25,14 @@ export interface FallbackScopeType {
   scopeTypes: (ScopeType | ComplexScopeType)[];
 }
 
+/**
+ * Used to handle sorted scope types. The scope types are yielded in sorted order.
+ */
+export interface SortedScopeType {
+  type: "sorted";
+  scopeTypes: (ScopeType | ComplexScopeType)[];
+}
+
 /**
  * Used to handle conditional scope types. The predicate determines if the
  * scope should be yielded or not.
@@ -38,6 +46,7 @@ export interface ConditionalScopeType {
 export type ComplexScopeType =
   | CustomScopeType
   | FallbackScopeType
+  | SortedScopeType
   | ConditionalScopeType;
 
 /**