Change complex cope handlers to return undefined if the internal scopes cannot be created

Author: AndreasArvidsson

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

@@ -46,7 +46,7 @@ export class CollectionItemScopeHandler extends BaseScopeHandler {
         return textualScopeHandler;
       }
 
-      return SortedScopeHandler.createFromScopeHandlers([
+      return new SortedScopeHandler(scopeHandlerFactory, languageId, [
         languageScopeHandler,
         textualScopeHandler,
       ]);

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

@@ -10,6 +10,7 @@ import { BaseScopeHandler } from "./BaseScopeHandler";
 import type { TargetScope } from "./scope.types";
 import type {
   ConditionalScopeType,
+  ScopeHandler,
   ScopeIteratorRequirements,
 } from "./scopeHandler.types";
 import type { ScopeHandlerFactory } from "./ScopeHandlerFactory";
@@ -18,10 +19,26 @@ export class ConditionalScopeHandler extends BaseScopeHandler {
   public scopeType = undefined;
   protected isHierarchical = true;
 
-  constructor(
-    public scopeHandlerFactory: ScopeHandlerFactory,
+  static maybeCreate(
+    scopeHandlerFactory: ScopeHandlerFactory,
+    conditionalScopeType: ConditionalScopeType,
+    languageId: string,
+  ): ConditionalScopeHandler | undefined {
+    const scopeHandler = scopeHandlerFactory.maybeCreate(
+      conditionalScopeType.scopeType,
+      languageId,
+    );
+
+    if (scopeHandler == null) {
+      return undefined;
+    }
+
+    return new ConditionalScopeHandler(scopeHandler, conditionalScopeType);
+  }
+
+  private constructor(
+    private scopeHandler: ScopeHandler,
     private conditionalScopeType: ConditionalScopeType,
-    private languageId: string,
   ) {
     super();
   }
@@ -38,13 +55,8 @@ export class ConditionalScopeHandler extends BaseScopeHandler {
     direction: Direction,
     hints: ScopeIteratorRequirements,
   ): Iterable<TargetScope> {
-    const scopeHandler = this.scopeHandlerFactory.create(
-      this.conditionalScopeType.scopeType,
-      this.languageId,
-    );
-
     return ifilter(
-      scopeHandler.generateScopes(editor, position, direction, hints),
+      this.scopeHandler.generateScopes(editor, position, direction, hints),
       this.conditionalScopeType.predicate,
     );
   }

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

@@ -16,11 +16,11 @@ export class FallbackScopeHandler extends BaseScopeHandler {
   public scopeType = undefined;
   protected isHierarchical = true;
 
-  static create(
+  static maybeCreate(
     scopeHandlerFactory: ScopeHandlerFactory,
     scopeType: FallbackScopeType,
     languageId: string,
-  ): ScopeHandler {
+  ): ScopeHandler | undefined {
     const scopeHandlers = scopeType.scopeTypes
       .map((scopeType) =>
         scopeHandlerFactory.maybeCreate(scopeType, languageId),
@@ -29,18 +29,18 @@ export class FallbackScopeHandler extends BaseScopeHandler {
         (scopeHandler): scopeHandler is ScopeHandler => scopeHandler != null,
       );
 
+    if (scopeHandlers.length === 0) {
+      return undefined;
+    }
+
     if (scopeHandlers.length === 1) {
       return scopeHandlers[0];
     }
 
-    return this.createFromScopeHandlers(scopeHandlers);
-  }
-
-  static createFromScopeHandlers(scopeHandlers: ScopeHandler[]): ScopeHandler {
     return new FallbackScopeHandler(scopeHandlers);
   }
 
-  private constructor(private scopeHandlers: ScopeHandler[]) {
+  constructor(private scopeHandlers: ScopeHandler[]) {
     super();
   }
 

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

@@ -46,7 +46,7 @@ export class NotebookCellScopeHandler extends BaseScopeHandler {
         return apiScopeHandler;
       }
 
-      return SortedScopeHandler.createFromScopeHandlers([
+      return new SortedScopeHandler(scopeHandlerFactory, languageId, [
         languageScopeHandler,
         apiScopeHandler,
       ]);

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

@@ -136,11 +136,11 @@ export class ScopeHandlerFactoryImpl implements ScopeHandlerFactory {
       case "custom":
         return scopeType.scopeHandler;
       case "sorted":
-        return SortedScopeHandler.create(this, scopeType, languageId);
+        return SortedScopeHandler.maybeCreate(this, scopeType, languageId);
       case "fallback":
-        return FallbackScopeHandler.create(this, scopeType, languageId);
+        return FallbackScopeHandler.maybeCreate(this, scopeType, languageId);
       case "conditional":
-        return new ConditionalScopeHandler(this, scopeType, languageId);
+        return ConditionalScopeHandler.maybeCreate(this, scopeType, languageId);
       default:
         // Pseudoscopes are handled separately in their own modifiers.
         if (pseudoScopes.has(scopeType.type)) {

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

@@ -1,15 +1,11 @@
-import type {
-  Direction,
-  Position,
-  ScopeType,
-  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,
@@ -21,11 +17,11 @@ export class SortedScopeHandler extends BaseScopeHandler {
   private iterationScopeHandler: SortedScopeHandler | undefined;
   private lastYieldedIndex: number | undefined;
 
-  static create(
+  static maybeCreate(
     scopeHandlerFactory: ScopeHandlerFactory,
     scopeType: SortedScopeType,
     languageId: string,
-  ): ScopeHandler {
+  ): ScopeHandler | undefined {
     const scopeHandlers = scopeType.scopeTypes
       .map((scopeType) =>
         scopeHandlerFactory.maybeCreate(scopeType, languageId),
@@ -34,25 +30,43 @@ export class SortedScopeHandler extends BaseScopeHandler {
         (scopeHandler): scopeHandler is ScopeHandler => scopeHandler != null,
       );
 
+    if (scopeHandlers.length === 0) {
+      return undefined;
+    }
+
     if (scopeHandlers.length === 1) {
       return scopeHandlers[0];
     }
 
-    return this.createFromScopeHandlers(scopeHandlers);
-  }
-
-  static createFromScopeHandlers(scopeHandlers: ScopeHandler[]): ScopeHandler {
-    return new SortedScopeHandler(scopeHandlers);
+    return new SortedScopeHandler(
+      scopeHandlerFactory,
+      languageId,
+      scopeHandlers,
+    );
   }
 
-  private constructor(private scopeHandlers: ScopeHandler[]) {
+  constructor(
+    private scopeHandlerFactory: ScopeHandlerFactory,
+    private languageId: string,
+    private scopeHandlers: ScopeHandler[],
+  ) {
     super();
   }
 
-  get iterationScopeType(): SortedScopeType {
+  get iterationScopeType(): CustomScopeType {
+    if (this.iterationScopeHandler == null) {
+      const iterationScopeHandlers = this.scopeHandlers.map((s) =>
+        this.scopeHandlerFactory.create(s.iterationScopeType, this.languageId),
+      );
+      this.iterationScopeHandler = new SortedScopeHandler(
+        this.scopeHandlerFactory,
+        this.languageId,
+        iterationScopeHandlers,
+      );
+    }
     return {
-      type: "sorted",
-      scopeTypes: this.scopeHandlers.map((s) => s.iterationScopeType),
+      type: "custom",
+      scopeHandler: this.iterationScopeHandler,
     };
   }