Added complex modifier type

Author: AndreasArvidsson

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

@@ -226,7 +226,6 @@ export class PrimitiveTargetSpokenFormGenerator {
 
   handleScopeType(scopeType: ScopeType): SpokenFormComponent {
     switch (scopeType.type) {
-      case "oneOf":
       case "surroundingPairInterior":
         throw new NoSpokenFormError(`Scope type '${scopeType.type}'`);
       case "glyph":

packages/lib-engine/src/processTargets/ModifierStageFactory.ts

@@ -1,6 +1,7 @@
 import type { Modifier } from "@cursorless/lib-common";
 import type { ModifierStage } from "./PipelineStages.types";
+import type { ComplexModifier } from "./modifiers/modifier.types";
 
 export interface ModifierStageFactory {
-  create(modifier: Modifier): ModifierStage;
+  create(modifier: Modifier | ComplexModifier): ModifierStage;
 }

packages/lib-engine/src/processTargets/ModifierStageFactoryImpl.ts

@@ -24,6 +24,7 @@ import { RangeModifierStage } from "./modifiers/RangeModifierStage";
 import { RawSelectionStage } from "./modifiers/RawSelectionStage";
 import { RelativeScopeStage } from "./modifiers/RelativeScopeStage";
 import { VisibleStage } from "./modifiers/VisibleStage";
+import type { ComplexModifier } from "./modifiers/modifier.types";
 import type { ScopeHandlerFactory } from "./modifiers/scopeHandlers/ScopeHandlerFactory";
 
 export class ModifierStageFactoryImpl implements ModifierStageFactory {
@@ -35,7 +36,7 @@ export class ModifierStageFactoryImpl implements ModifierStageFactory {
     this.create = this.create.bind(this);
   }
 
-  create(modifier: Modifier): ModifierStage {
+  create(modifier: Modifier | ComplexModifier): ModifierStage {
     switch (modifier.type) {
       case "startOf":
         return new StartOfStage();
@@ -62,11 +63,10 @@ export class ModifierStageFactoryImpl implements ModifierStageFactory {
         if (ClassFunctionNameStage.use(modifier.scopeType)) {
           return new ClassFunctionNameStage(this, modifier);
         }
-        return new ContainingScopeStage(
-          this,
-          this.scopeHandlerFactory,
-          modifier,
-        );
+        return new ContainingScopeStage(this.scopeHandlerFactory, modifier);
+
+      case "complexContainingScope":
+        return new ContainingScopeStage(this.scopeHandlerFactory, modifier);
 
       case "preferredScope":
         if (ClassFunctionNameStage.use(modifier.scopeType)) {

packages/lib-engine/src/processTargets/modifiers/ContainingScopeStage.ts

@@ -1,9 +1,9 @@
 import type { ContainingScopeModifier } from "@cursorless/lib-common";
 import { NoContainingScopeError } from "@cursorless/lib-common";
 import type { Target } from "../../typings/target.types";
-import type { ModifierStageFactory } from "../ModifierStageFactory";
 import type { ModifierStage } from "../PipelineStages.types";
 import { getContainingScopeTarget } from "./getContainingScopeTarget";
+import type { ComplexContainingScopeModifier } from "./modifier.types";
 import type { ScopeHandlerFactory } from "./scopeHandlers/ScopeHandlerFactory";
 
 /**
@@ -26,9 +26,8 @@ import type { ScopeHandlerFactory } from "./scopeHandlers/ScopeHandlerFactory";
  */
 export class ContainingScopeStage implements ModifierStage {
   constructor(
-    private modifierStageFactory: ModifierStageFactory,
     private scopeHandlerFactory: ScopeHandlerFactory,
-    private modifier: ContainingScopeModifier,
+    private modifier: ContainingScopeModifier | ComplexContainingScopeModifier,
   ) {}
 
   run(target: Target): Target[] {

packages/lib-engine/src/processTargets/modifiers/HeadTailStage.ts

@@ -101,7 +101,7 @@ class BoundedLineStage implements ModifierStage {
     try {
       return this.modifierStageFactory
         .create({
-          type: "containingScope",
+          type: "complexContainingScope",
           scopeType: compoundInteriorScopeType,
         })
         .run(target, options)[0];

packages/lib-engine/src/processTargets/modifiers/InteriorStage.ts

@@ -1,4 +1,4 @@
-import type { InteriorOnlyModifier, ScopeType } from "@cursorless/lib-common";
+import type { InteriorOnlyModifier } from "@cursorless/lib-common";
 import {
   NoContainingScopeError,
   UnsupportedScopeError,
@@ -9,6 +9,7 @@ import type {
   ModifierStage,
   ModifierStateOptions,
 } from "../PipelineStages.types";
+import type { SortedScopeType } from "./scopeHandlers/scopeHandler.types";
 
 export class InteriorOnlyStage implements ModifierStage {
   constructor(
@@ -56,7 +57,7 @@ export class InteriorOnlyStage implements ModifierStage {
     try {
       return this.modifierStageFactory
         .create({
-          type: "containingScope",
+          type: "complexContainingScope",
           scopeType: compoundInteriorScopeType,
         })
         .run(target, options);
@@ -69,8 +70,8 @@ export class InteriorOnlyStage implements ModifierStage {
   }
 }
 
-export const compoundInteriorScopeType: ScopeType = {
-  type: "oneOf",
+export const compoundInteriorScopeType: SortedScopeType = {
+  type: "sorted",
   scopeTypes: [
     {
       type: "interior",

packages/lib-engine/src/processTargets/modifiers/PreferredScopeStage.ts

@@ -24,7 +24,6 @@ export class PreferredScopeStage implements ModifierStage {
     const { scopeType } = this.modifier;
 
     const containingScopeStage = new ContainingScopeStage(
-      this.modifierStageFactory,
       this.scopeHandlerFactory,
       { type: "containingScope", scopeType },
     );

packages/lib-engine/src/processTargets/modifiers/modifier.types.ts

@@ -0,0 +1,10 @@
+import type { ScopeType } from "packages/lib-common/src";
+import type { ComplexScopeType } from "./scopeHandlers/scopeHandler.types";
+
+export interface ComplexContainingScopeModifier {
+  type: "complexContainingScope";
+  scopeType: ScopeType | ComplexScopeType;
+  ancestorIndex?: number;
+}
+
+export type ComplexModifier = ComplexContainingScopeModifier;

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

@@ -15,6 +15,7 @@ import { BaseScopeHandler } from "./BaseScopeHandler";
 import { compareTargetScopes } from "./compareTargetScopes";
 import type { TargetScope } from "./scope.types";
 import type {
+  ComplexScopeType,
   ScopeHandler,
   ScopeIteratorRequirements,
 } from "./scopeHandler.types";
@@ -46,17 +47,9 @@ abstract class BoundedBaseScopeHandler extends BaseScopeHandler {
     );
   }
 
-  get iterationScopeType(): ScopeType {
-    switch (this.targetScopeHandler.iterationScopeType.type) {
-      case "custom":
-      case "fallback":
-      case "conditional":
-        throw Error(
-          `Iteration scope type can't be '${this.targetScopeHandler.iterationScopeType.type}' for BoundedBaseScopeHandler`,
-        );
-    }
+  get iterationScopeType(): ComplexScopeType {
     return {
-      type: "oneOf",
+      type: "sorted",
       scopeTypes: [
         this.targetScopeHandler.iterationScopeType,
         {

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

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