More testing

Author: AndreasArvidsson

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

@@ -24,11 +24,23 @@ export class FallbackScopeHandler extends BaseScopeHandler {
     );
   }
 
-  constructor(
-    public scopeHandlerFactory: ScopeHandlerFactory,
-    private fallbackScopeType: FallbackScopeType,
-    private languageId: string,
-  ) {
+  static create(
+    scopeHandlerFactory: ScopeHandlerFactory,
+    scopeType: FallbackScopeType,
+    languageId: string,
+  ): ScopeHandler {
+    const scopeHandlers: ScopeHandler[] = scopeType.scopeTypes.map(
+      (scopeType) => scopeHandlerFactory.create(scopeType, languageId),
+    );
+
+    return this.createFromScopeHandlers(scopeHandlers);
+  }
+
+  static createFromScopeHandlers(scopeHandlers: ScopeHandler[]): ScopeHandler {
+    return new FallbackScopeHandler(scopeHandlers);
+  }
+
+  private constructor(private scopeHandlers: ScopeHandler[]) {
     super();
   }
 
@@ -38,12 +50,7 @@ export class FallbackScopeHandler extends BaseScopeHandler {
     direction: Direction,
     hints: ScopeIteratorRequirements,
   ): Iterable<TargetScope> {
-    const scopeHandlers: ScopeHandler[] = this.fallbackScopeType.scopeTypes.map(
-      (scopeType) =>
-        this.scopeHandlerFactory.create(scopeType, this.languageId),
-    );
-
-    for (const scopeHandler of scopeHandlers) {
+    for (const scopeHandler of this.scopeHandlers) {
       yield* scopeHandler.generateScopes(editor, position, direction, hints);
     }
   }

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

@@ -133,7 +133,7 @@ export class ScopeHandlerFactoryImpl implements ScopeHandlerFactory {
       case "oneOf":
         return OneOfScopeHandler.create(this, scopeType, languageId);
       case "fallback":
-        return new FallbackScopeHandler(this, scopeType, languageId);
+        return FallbackScopeHandler.create(this, scopeType, languageId);
       case "conditional":
         return new ConditionalScopeHandler(this, scopeType, languageId);
       case "instance":

packages/cursorless-engine/src/processTargets/modifiers/scopeHandlers/SurroundingPairScopeHandler/InteriorScopeHandler.ts

@@ -1,5 +1,4 @@
 import {
-  NoContainingScopeError,
   type Direction,
   type Position,
   type ScopeType,
@@ -8,6 +7,7 @@ import {
 } from "@cursorless/common";
 import type { LanguageDefinitions } from "../../../../languages/LanguageDefinitions";
 import { BaseScopeHandler } from "../BaseScopeHandler";
+import { FallbackScopeHandler } from "../FallbackScopeHandler";
 import { OneOfScopeHandler } from "../OneOfScopeHandler";
 import type { TargetScope } from "../scope.types";
 import type {
@@ -27,25 +27,14 @@ export class InteriorScopeHandler extends BaseScopeHandler {
   }
 
   constructor(
-    scopeHandlerFactory: ScopeHandlerFactory,
+    private scopeHandlerFactory: ScopeHandlerFactory,
     languageDefinitions: LanguageDefinitions,
     scopeType: SimpleScopeType,
-    languageId: string,
+    private languageId: string,
   ) {
     super();
 
     this.scopeHandler = (() => {
-      const languageScopeHandler = languageDefinitions
-        .get(languageId)
-        ?.getScopeHandler(this.scopeType);
-
-      if (scopeType.type === "interiorTreeOnly") {
-        if (languageScopeHandler == null) {
-          throw new NoContainingScopeError(this.scopeType.type);
-        }
-        return languageScopeHandler;
-      }
-
       const pairInteriorScopeHandler = scopeHandlerFactory.create(
         {
           type: "surroundingPairInterior",
@@ -55,10 +44,21 @@ export class InteriorScopeHandler extends BaseScopeHandler {
         languageId,
       );
 
+      const languageScopeHandler = languageDefinitions
+        .get(languageId)
+        ?.getScopeHandler(this.scopeType);
+
       if (languageScopeHandler == null) {
         return pairInteriorScopeHandler;
       }
 
+      if (scopeType.type === "interiorTreeOnly") {
+        return FallbackScopeHandler.createFromScopeHandlers([
+          languageScopeHandler,
+          pairInteriorScopeHandler,
+        ]);
+      }
+
       return OneOfScopeHandler.createFromScopeHandlers(
         scopeHandlerFactory,
         {

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

@@ -52,14 +52,22 @@ export class TreeSitterScopeHandler extends BaseTreeSitterScopeHandler {
     const domain =
       getRelatedRange(match, scopeTypeType, "domain", true) ?? contentRange;
 
-    const removalRange = getRelatedRange(match, scopeTypeType, "removal", true);
+    if (scopeTypeType === "interior") {
+      return {
+        editor,
+        domain,
+        allowMultiple,
+        getTargets: (isReversed) => [
+          new InteriorTarget({
+            editor,
+            isReversed,
+            fullInteriorRange: contentRange,
+          }),
+        ],
+      };
+    }
 
-    const interiorRange = getRelatedRange(
-      match,
-      scopeTypeType,
-      "interior",
-      true,
-    );
+    const removalRange = getRelatedRange(match, scopeTypeType, "removal", true);
 
     const prefixRange = getRelatedRange(
       match,
@@ -82,21 +90,6 @@ export class TreeSitterScopeHandler extends BaseTreeSitterScopeHandler {
       true,
     )?.with(contentRange.end);
 
-    if (scopeTypeType === "interior") {
-      return {
-        editor,
-        domain,
-        allowMultiple,
-        getTargets: (isReversed) => [
-          new InteriorTarget({
-            editor,
-            isReversed,
-            fullInteriorRange: contentRange,
-          }),
-        ],
-      };
-    }
-
     return {
       editor,
       domain,
@@ -111,7 +104,6 @@ export class TreeSitterScopeHandler extends BaseTreeSitterScopeHandler {
           removalRange,
           leadingDelimiterRange,
           trailingDelimiterRange,
-          interiorRange,
           insertionDelimiter,
         }),
       ],

packages/cursorless-engine/src/processTargets/modifiers/scopeTypeStages/LegacyContainingSyntaxScopeStage.ts

@@ -65,7 +65,6 @@ export class LegacyContainingSyntaxScopeStage implements ModifierStage {
         leadingDelimiterRange,
         trailingDelimiterRange,
         removalRange,
-        interiorRange,
       } = scope.context;
 
       if (
@@ -85,7 +84,6 @@ export class LegacyContainingSyntaxScopeStage implements ModifierStage {
         isReversed: target.isReversed,
         contentRange: contentSelection,
         removalRange: removalRange,
-        interiorRange: interiorRange,
         insertionDelimiter: containingListDelimiter,
         leadingDelimiterRange,
         trailingDelimiterRange,

packages/cursorless-engine/src/processTargets/targets/ScopeTypeTarget.ts

@@ -1,9 +1,8 @@
 import type { Range, SimpleScopeTypeType } from "@cursorless/common";
+import type { Target } from "../../typings/target.types";
 import type { CommonTargetParameters } from "./BaseTarget";
 import { BaseTarget } from "./BaseTarget";
-import { InteriorTarget } from "./InteriorTarget";
 import { PlainTarget } from "./PlainTarget";
-import type { Target } from "../../typings/target.types";
 import {
   createContinuousRange,
   createContinuousRangeFromRanges,
@@ -20,7 +19,6 @@ export interface ScopeTypeTargetParameters extends CommonTargetParameters {
   readonly insertionDelimiter?: string;
   readonly prefixRange?: Range;
   readonly removalRange?: Range;
-  readonly interiorRange?: Range;
   readonly leadingDelimiterRange?: Range;
   readonly trailingDelimiterRange?: Range;
 }
@@ -29,7 +27,6 @@ export class ScopeTypeTarget extends BaseTarget<ScopeTypeTargetParameters> {
   type = "ScopeTypeTarget";
   private scopeTypeType_: SimpleScopeTypeType;
   private removalRange_?: Range;
-  private interiorRange_?: Range;
   private leadingDelimiterRange_?: Range;
   private trailingDelimiterRange_?: Range;
   private hasDelimiterRange_: boolean;
@@ -40,7 +37,6 @@ export class ScopeTypeTarget extends BaseTarget<ScopeTypeTargetParameters> {
     super(parameters);
     this.scopeTypeType_ = parameters.scopeTypeType;
     this.removalRange_ = parameters.removalRange;
-    this.interiorRange_ = parameters.interiorRange;
     this.leadingDelimiterRange_ = parameters.leadingDelimiterRange;
     this.trailingDelimiterRange_ = parameters.trailingDelimiterRange;
     this.prefixRange = parameters.prefixRange;
@@ -79,19 +75,6 @@ export class ScopeTypeTarget extends BaseTarget<ScopeTypeTargetParameters> {
     return undefined;
   }
 
-  getInterior() {
-    if (this.interiorRange_ == null) {
-      return super.getInterior();
-    }
-    return [
-      new InteriorTarget({
-        editor: this.editor,
-        isReversed: this.isReversed,
-        fullInteriorRange: this.interiorRange_,
-      }),
-    ];
-  }
-
   getRemovalRange(): Range {
     return this.removalRange_ != null
       ? this.removalRange_