Rename cascadingModifier to fallbackModifier (#3042)

Author: AndreasArvidsson

packages/common/src/types/SpokenFormType.ts

@@ -65,7 +65,7 @@ type SimpleModifierType = Exclude<
   | "ordinalScope"
   | "relativeScope"
   | "modifyIfUntyped"
-  | "cascading"
+  | "fallback"
   | "range"
 >;
 

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

@@ -442,8 +442,8 @@ export interface ModifyIfUntypedModifier {
  * doesn't throw an error, returning the output from the first modifier not
  * throwing an error.
  */
-export interface CascadingModifier {
-  type: "cascading";
+export interface FallbackModifier {
+  type: "fallback";
 
   /**
    * The modifiers to try in turn
@@ -480,7 +480,7 @@ export type Modifier =
   | TrailingModifier
   | RawSelectionModifier
   | ModifyIfUntypedModifier
-  | CascadingModifier
+  | FallbackModifier
   | RangeModifier
   | KeepContentFilterModifier
   | KeepEmptyFilterModifier

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

@@ -30,15 +30,21 @@ export type Command =
 
 export type CommandResponse = { returnValue: unknown } | { fallback: Fallback };
 
-export type FallbackModifier = Modifier | { type: "containingTokenIfEmpty" };
+export type FallbackCommandModifier =
+  | Modifier
+  | { type: "containingTokenIfEmpty" };
 
 export type Fallback =
-  | { action: ActionDescriptor["name"]; modifiers: FallbackModifier[] }
-  | { action: "insert"; modifiers: FallbackModifier[]; text: string }
-  | { action: "callAsFunction"; modifiers: FallbackModifier[]; callee: string }
+  | { action: ActionDescriptor["name"]; modifiers: FallbackCommandModifier[] }
+  | { action: "insert"; modifiers: FallbackCommandModifier[]; text: string }
+  | {
+      action: "callAsFunction";
+      modifiers: FallbackCommandModifier[];
+      callee: string;
+    }
   | {
       action: "wrapWithPairedDelimiter" | "rewrapWithPairedDelimiter";
-      modifiers: FallbackModifier[];
+      modifiers: FallbackCommandModifier[];
       left: string;
       right: string;
     };

packages/cursorless-engine/src/actions/InsertSnippet.ts

@@ -46,7 +46,7 @@ export default class InsertSnippet {
       ? []
       : [
           new ModifyIfUntypedExplicitStage(this.modifierStageFactory, {
-            type: "cascading",
+            type: "fallback",
             modifiers: defaultScopeTypes.map((scopeType) => ({
               type: "containingScope",
               scopeType,

packages/cursorless-engine/src/actions/snippetsLegacy/InsertSnippetLegacy.ts

@@ -43,7 +43,7 @@ export default class InsertSnippetLegacy {
       ? []
       : [
           new ModifyIfUntypedExplicitStage(this.modifierStageFactory, {
-            type: "cascading",
+            type: "fallback",
             modifiers: defaultScopeTypes.map((scopeType) => ({
               type: "containingScope",
               scopeType,

packages/cursorless-engine/src/core/getCommandFallback.ts

@@ -4,7 +4,7 @@ import type {
   CommandServerApi,
   DestinationDescriptor,
   Fallback,
-  FallbackModifier,
+  FallbackCommandModifier,
   PartialTargetDescriptor,
 } from "@cursorless/common";
 import type { ActionReturnValue } from "../actions/actions.types";
@@ -127,7 +127,7 @@ function targetIsSelection(target: PartialTargetDescriptor): boolean {
 
 function getModifiersFromDestination(
   destination: DestinationDescriptor,
-): FallbackModifier[] {
+): FallbackCommandModifier[] {
   if (destination.type === "primitive") {
     return getModifiersFromTarget(destination.target);
   }
@@ -136,7 +136,7 @@ function getModifiersFromDestination(
 
 function getModifiersFromTarget(
   target: PartialTargetDescriptor,
-): FallbackModifier[] {
+): FallbackCommandModifier[] {
   if (target.type === "primitive") {
     if (target.modifiers != null && target.modifiers.length > 0) {
       return target.modifiers;

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

@@ -43,7 +43,7 @@ export class PrimitiveTargetSpokenFormGenerator {
 
   private handleModifier(modifier: Modifier): SpokenFormComponent {
     switch (modifier.type) {
-      case "cascading":
+      case "fallback":
       case "modifyIfUntyped":
       case "preferredScope":
         throw new NoSpokenFormError(`Modifier '${modifier.type}'`);

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

@@ -3,11 +3,11 @@ import type { StoredTargetMap } from "../core/StoredTargets";
 import type { LanguageDefinitions } from "../languages/LanguageDefinitions";
 import type { ModifierStageFactory } from "./ModifierStageFactory";
 import type { ModifierStage } from "./PipelineStages.types";
-import { CascadingStage } from "./modifiers/CascadingStage";
 import { ClassFunctionNameStage } from "./modifiers/ClassFunctionNameStage";
 import { ModifyIfUntypedStage } from "./modifiers/ConditionalModifierStages";
 import { ContainingScopeStage } from "./modifiers/ContainingScopeStage";
 import { EveryScopeStage } from "./modifiers/EveryScopeStage";
+import { FallbackStage } from "./modifiers/FallbackStage";
 import {
   KeepContentFilterStage,
   KeepEmptyFilterStage,
@@ -111,8 +111,8 @@ export class ModifierStageFactoryImpl implements ModifierStageFactory {
         return new KeepContentFilterStage(modifier);
       case "keepEmptyFilter":
         return new KeepEmptyFilterStage(modifier);
-      case "cascading":
-        return new CascadingStage(this, modifier);
+      case "fallback":
+        return new FallbackStage(this, modifier);
       case "modifyIfUntyped":
         return new ModifyIfUntypedStage(this, modifier);
       case "range":

packages/cursorless-engine/src/processTargets/modifiers/CascadingStage.ts renamed to packages/cursorless-engine/src/processTargets/modifiers/FallbackStage.ts

@@ -1,4 +1,4 @@
-import type { CascadingModifier } from "@cursorless/common";
+import type { FallbackModifier } from "@cursorless/common";
 import type { Target } from "../../typings/target.types";
 import type { ModifierStageFactory } from "../ModifierStageFactory";
 import type {
@@ -10,28 +10,20 @@ import type {
  * Tries each of the given modifiers in turn until one of them doesn't throw an
  * error, returning the output from the first modifier not throwing an error.
  */
-export class CascadingStage implements ModifierStage {
-  private nestedStages_?: ModifierStage[];
-
+export class FallbackStage implements ModifierStage {
   constructor(
     private modifierStageFactory: ModifierStageFactory,
-    private modifier: CascadingModifier,
+    private modifier: FallbackModifier,
   ) {}
 
-  private get nestedStages() {
-    if (this.nestedStages_ == null) {
-      this.nestedStages_ = this.modifier.modifiers.map(
-        this.modifierStageFactory.create,
-      );
-    }
-
-    return this.nestedStages_;
-  }
-
   run(target: Target, options: ModifierStateOptions): Target[] {
-    for (const nestedStage of this.nestedStages) {
+    const stages = this.modifier.modifiers.map(
+      this.modifierStageFactory.create,
+    );
+
+    for (const stage of stages) {
       try {
-        return nestedStage.run(target, options);
+        return stage.run(target, options);
       } catch (_error) {
         continue;
       }

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

@@ -23,8 +23,8 @@ export class FallbackScopeHandler extends BaseScopeHandler {
     scopeType: FallbackScopeType,
     languageId: string,
   ): ScopeHandler {
-    const scopeHandlers: ScopeHandler[] = scopeType.scopeTypes.map(
-      (scopeType) => scopeHandlerFactory.create(scopeType, languageId),
+    const scopeHandlers = scopeType.scopeTypes.map((scopeType) =>
+      scopeHandlerFactory.create(scopeType, languageId),
     );
 
     return this.createFromScopeHandlers(scopeHandlers);