Reworked weak target (#888)

* Renamed weak target, Renamed is weak, Added explicit range attribute

* Don't remove leading or trailing delimited ranges for empty selection

* Added clone parameters

* Updated comment

* Always create continuous range

* Renamed UnTypedRangeTarget to UnTypedTarget

* Process targets before test recorded command hook

* Added tests

* Renamed to ifUntyped

* Added item tests

* Cleanup

* Update src/typings/targetDescriptor.types.ts

Co-authored-by: Pokey Rule <[email protected]>

* Update src/typings/targetDescriptor.types.ts

Co-authored-by: Pokey Rule <[email protected]>

* Cleanup

* Cleanup

* Added tests

* Cleanup

* Added tests

* added tests

* Use undefined return value in error test cases

* Docstring

* Better error type for no inside / bounds

* Remove code sharing from ThatStage and CursorStage

* Doc strings

* Switch test subset

* Fix docstring link

* Record alternate "leading funk" test

* Record some more tests

* Add a bunch of tests

* Cleaned up from review

* Docstring

* More tests

* One more test

* Another test

* Rollback imports to avoid circular import

* Improve test

* Revert "Rollback imports to avoid circular import"

This reverts commit 9ad7e9f.

* Fix imports

* Add tests; fix bug with `"every block"`

* Minor tweak

* Fix doc

* Docstrings

Co-authored-by: Pokey Rule <[email protected]>

Author: AndreasArvidsson

package.json

@@ -546,6 +546,7 @@
 		"@types/vscode": "~1.61.0",
 		"@typescript-eslint/eslint-plugin": "^5.20.0",
 		"@typescript-eslint/parser": "^5.20.0",
+		"@vscode/test-electron": "^2.1.3",
 		"esbuild": "^0.11.12",
 		"eslint": "^8.13.0",
 		"eslint-config-prettier": "^8.5.0",
@@ -558,8 +559,7 @@
 		"semver": "^7.3.7",
 		"sinon": "^11.1.1",
 		"ts-unused-exports": "8.0.0",
-		"typescript": "^4.5.5",
-		"@vscode/test-electron": "^2.1.3"
+		"typescript": "^4.5.5"
 	},
 	"dependencies": {
 		"@types/lodash": "^4.14.168",

src/actions/EditNew/EditNew.ts

@@ -1,4 +1,4 @@
-import { weakContainingLineStage } from "../../processTargets/modifiers/commonWeakContainingScopeStages";
+import { containingLineIfUntypedStage } from "../../processTargets/modifiers/commonContainingScopeIfUntypedStages";
 import PositionStage from "../../processTargets/modifiers/PositionStage";
 import { ModifierStage } from "../../processTargets/PipelineStages.types";
 import { Target } from "../../typings/target.types";
@@ -14,7 +14,7 @@ import { runEditTargets } from "./runEditTargets";
 
 export class EditNew implements Action {
   getFinalStages(): ModifierStage[] {
-    return [weakContainingLineStage];
+    return [containingLineIfUntypedStage];
   }
 
   constructor(private graph: Graph) {

src/actions/InsertCopy.ts

@@ -1,15 +1,15 @@
 import { flatten, zip } from "lodash";
 import { DecorationRangeBehavior, Selection, TextEditor } from "vscode";
 import { performEditsAndUpdateSelectionsWithBehavior } from "../core/updateSelections/updateSelections";
-import { weakContainingLineStage } from "../processTargets/modifiers/commonWeakContainingScopeStages";
+import { containingLineIfUntypedStage } from "../processTargets/modifiers/commonContainingScopeIfUntypedStages";
 import { Target } from "../typings/target.types";
 import { Graph } from "../typings/Types";
 import { setSelectionsWithoutFocusingEditor } from "../util/setSelectionsAndFocusEditor";
 import { createThatMark, runOnTargetsForEachEditor } from "../util/targetUtils";
 import { Action, ActionReturnValue } from "./actions.types";
 
 class InsertCopy implements Action {
-  getFinalStages = () => [weakContainingLineStage];
+  getFinalStages = () => [containingLineIfUntypedStage];
 
   constructor(private graph: Graph, private isBefore: boolean) {
     this.run = this.run.bind(this);

src/actions/InsertSnippet.ts

@@ -4,7 +4,7 @@ import {
   callFunctionAndUpdateSelectionInfos,
   getSelectionInfo,
 } from "../core/updateSelections/updateSelections";
-import ModifyIfWeakStage from "../processTargets/modifiers/ModifyIfWeakStage";
+import ModifyIfUntypedStage from "../processTargets/modifiers/ModifyIfUntypedStage";
 import { Snippet, SnippetDefinition } from "../typings/snippet";
 import { Target } from "../typings/target.types";
 import { Graph } from "../typings/Types";
@@ -29,8 +29,8 @@ export default class InsertSnippet implements Action {
     }
 
     return [
-      new ModifyIfWeakStage({
-        type: "modifyIfWeak",
+      new ModifyIfUntypedStage({
+        type: "modifyIfUntyped",
         modifier: {
           type: "cascading",
           modifiers: defaultScopeTypes.map((scopeType) => ({

src/actions/Rewrap.ts

@@ -1,12 +1,12 @@
 import { performEditsAndUpdateRanges } from "../core/updateSelections/updateSelections";
-import { weakContainingSurroundingPairStage } from "../processTargets/modifiers/commonWeakContainingScopeStages";
+import { containingSurroundingPairIfUntypedStage } from "../processTargets/modifiers/commonContainingScopeIfUntypedStages";
 import { Target } from "../typings/target.types";
 import { Graph } from "../typings/Types";
 import { createThatMark, runOnTargetsForEachEditor } from "../util/targetUtils";
 import { Action, ActionReturnValue } from "./actions.types";
 
 export default class Rewrap implements Action {
-  getFinalStages = () => [weakContainingSurroundingPairStage];
+  getFinalStages = () => [containingSurroundingPairIfUntypedStage];
 
   constructor(private graph: Graph) {
     this.run = this.run.bind(this);

src/actions/ToggleBreakpoint.ts

@@ -6,7 +6,7 @@ import {
   SourceBreakpoint,
   Uri,
 } from "vscode";
-import { weakContainingLineStage } from "../processTargets/modifiers/commonWeakContainingScopeStages";
+import { containingLineIfUntypedStage } from "../processTargets/modifiers/commonContainingScopeIfUntypedStages";
 import { Target } from "../typings/target.types";
 import { Graph } from "../typings/Types";
 import { createThatMark } from "../util/targetUtils";
@@ -22,7 +22,7 @@ function getBreakpoints(uri: Uri, range: Range) {
 }
 
 export default class ToggleBreakpoint implements Action {
-  getFinalStages = () => [weakContainingLineStage];
+  getFinalStages = () => [containingLineIfUntypedStage];
 
   constructor(private graph: Graph) {
     this.run = this.run.bind(this);

src/actions/WrapWithSnippet.ts

@@ -1,6 +1,6 @@
 import { commands } from "vscode";
 import { callFunctionAndUpdateSelections } from "../core/updateSelections/updateSelections";
-import ModifyIfWeakStage from "../processTargets/modifiers/ModifyIfWeakStage";
+import ModifyIfUntypedStage from "../processTargets/modifiers/ModifyIfUntypedStage";
 import { Target } from "../typings/target.types";
 import { Graph } from "../typings/Types";
 import {
@@ -28,8 +28,8 @@ export default class WrapWithSnippet implements Action {
     }
 
     return [
-      new ModifyIfWeakStage({
-        type: "modifyIfWeak",
+      new ModifyIfUntypedStage({
+        type: "modifyIfUntyped",
         modifier: {
           type: "containingScope",
           scopeType: {

src/processTargets/getMarkStage.ts

@@ -3,8 +3,7 @@ import CursorStage from "./marks/CursorStage";
 import DecoratedSymbolStage from "./marks/DecoratedSymbolStage";
 import LineNumberStage from "./marks/LineNumberStage";
 import NothingStage from "./marks/NothingStage";
-import SourceStage from "./marks/SourceStage";
-import ThatStage from "./marks/ThatStage";
+import { SourceStage, ThatStage } from "./marks/ThatStage";
 import { MarkStage } from "./PipelineStages.types";
 
 export default (mark: Mark): MarkStage => {

src/processTargets/getModifierStage.ts

@@ -12,7 +12,7 @@ import {
 } from "./modifiers/InteriorStage";
 import ItemStage from "./modifiers/ItemStage";
 import { LeadingStage, TrailingStage } from "./modifiers/LeadingTrailingStages";
-import ModifyIfWeakStage from "./modifiers/ModifyIfWeakStage";
+import ModifyIfUntypedStage from "./modifiers/ModifyIfUntypedStage";
 import OrdinalRangeSubTokenStage, {
   OrdinalRangeSubTokenModifier,
 } from "./modifiers/OrdinalRangeSubTokenStage";
@@ -70,8 +70,8 @@ export default (modifier: Modifier): ModifierStage => {
       );
     case "cascading":
       return new CascadingStage(modifier);
-    case "modifyIfWeak":
-      return new ModifyIfWeakStage(modifier);
+    case "modifyIfUntyped":
+      return new ModifyIfUntypedStage(modifier);
   }
 };
 

src/processTargets/marks/CursorStage.ts

@@ -3,24 +3,20 @@ import type { CursorMark } from "../../typings/targetDescriptor.types";
 import { ProcessedTargetsContext } from "../../typings/Types";
 import { isReversed } from "../../util/selectionUtils";
 import { MarkStage } from "../PipelineStages.types";
-import WeakTarget from "../targets/WeakTarget";
-import TokenTarget from "../targets/TokenTarget";
+import UntypedTarget from "../targets/UntypedTarget";
 
 export default class CursorStage implements MarkStage {
-  constructor(_modifier: CursorMark) {
-    // takes mark for consistency and does nothing
-  }
+  constructor(private modifier: CursorMark) {}
 
   run(context: ProcessedTargetsContext): Target[] {
-    return context.currentSelections.map((selection) => {
-      const parameters = {
-        editor: selection.editor,
-        isReversed: isReversed(selection.selection),
-        contentRange: selection.selection,
-      };
-      return selection.selection.isEmpty
-        ? new WeakTarget(parameters)
-        : new TokenTarget(parameters);
-    });
+    return context.currentSelections.map(
+      (selection) =>
+        new UntypedTarget({
+          editor: selection.editor,
+          isReversed: isReversed(selection.selection),
+          contentRange: selection.selection,
+          hasExplicitRange: !selection.selection.isEmpty,
+        })
+    );
   }
 }

src/processTargets/marks/DecoratedSymbolStage.ts

@@ -2,7 +2,7 @@ import { Target } from "../../typings/target.types";
 import { DecoratedSymbolMark } from "../../typings/targetDescriptor.types";
 import { ProcessedTargetsContext } from "../../typings/Types";
 import { MarkStage } from "../PipelineStages.types";
-import { WeakTarget } from "../targets";
+import { UntypedTarget } from "../targets";
 
 export default class implements MarkStage {
   constructor(private modifier: DecoratedSymbolMark) {}
@@ -20,10 +20,11 @@ export default class implements MarkStage {
     }
 
     return [
-      new WeakTarget({
+      new UntypedTarget({
         editor: token.editor,
         contentRange: token.range,
         isReversed: false,
+        hasExplicitRange: false,
       }),
     ];
   }

src/processTargets/marks/SourceStage.ts

@@ -1,23 +1,45 @@
 import { Target } from "../../typings/target.types";
-import { ThatMark } from "../../typings/targetDescriptor.types";
-import { ProcessedTargetsContext } from "../../typings/Types";
+import { SourceMark, ThatMark } from "../../typings/targetDescriptor.types";
+import {
+  ProcessedTargetsContext,
+  SelectionWithEditor,
+} from "../../typings/Types";
 import { isReversed } from "../../util/selectionUtils";
 import { MarkStage } from "../PipelineStages.types";
-import WeakTarget from "../targets/WeakTarget";
+import { UntypedTarget } from "../targets";
 
-export default class implements MarkStage {
+export class ThatStage implements MarkStage {
   constructor(private modifier: ThatMark) {}
 
   run(context: ProcessedTargetsContext): Target[] {
     if (context.thatMark.length === 0) {
       throw Error("No available that marks");
     }
-    return context.thatMark.map((selection) => {
-      return new WeakTarget({
+
+    return selectionsToTarget(context.thatMark);
+  }
+}
+
+export class SourceStage implements MarkStage {
+  constructor(private modifier: SourceMark) {}
+
+  run(context: ProcessedTargetsContext): Target[] {
+    if (context.sourceMark.length === 0) {
+      throw Error("No available source marks");
+    }
+
+    return selectionsToTarget(context.sourceMark);
+  }
+}
+
+function selectionsToTarget(selections: SelectionWithEditor[]) {
+  return selections.map(
+    (selection) =>
+      new UntypedTarget({
         editor: selection.editor,
         isReversed: isReversed(selection.selection),
         contentRange: selection.selection,
-      });
-    });
-  }
+        hasExplicitRange: !selection.selection.isEmpty,
+      })
+  );
 }

src/processTargets/marks/ThatStage.ts

@@ -5,13 +5,13 @@ import {
 } from "../../typings/targetDescriptor.types";
 import { ProcessedTargetsContext } from "../../typings/Types";
 import { ModifierStage } from "../PipelineStages.types";
-import { weakContainingSurroundingPairStage } from "./commonWeakContainingScopeStages";
+import { containingSurroundingPairIfUntypedStage } from "./commonContainingScopeIfUntypedStages";
 
 export class InteriorOnlyStage implements ModifierStage {
   constructor(private modifier: InteriorOnlyModifier) {}
 
   run(context: ProcessedTargetsContext, target: Target): Target[] {
-    return weakContainingSurroundingPairStage
+    return containingSurroundingPairIfUntypedStage
       .run(context, target)
       .flatMap((target) => target.getInteriorStrict());
   }
@@ -21,7 +21,7 @@ export class ExcludeInteriorStage implements ModifierStage {
   constructor(private modifier: ExcludeInteriorModifier) {}
 
   run(context: ProcessedTargetsContext, target: Target): Target[] {
-    return weakContainingSurroundingPairStage
+    return containingSurroundingPairIfUntypedStage
       .run(context, target)
       .flatMap((target) => target.getBoundaryStrict());
   }

src/processTargets/modifiers/InteriorStage.ts

@@ -40,10 +40,10 @@ export default class ItemStage implements ModifierStage {
   private getEveryTarget(context: ProcessedTargetsContext, target: Target) {
     const itemInfos = getItemInfosForIterationScope(context, target);
 
-    // If weak expand to all items in iteration scope
-    const filteredItemInfos = target.isWeak
-      ? itemInfos
-      : filterItemInfos(target, itemInfos);
+    // If target has explicit range filter to items in that range. Otherwise expand to all items in iteration scope.
+    const filteredItemInfos = target.hasExplicitRange
+      ? filterItemInfos(target, itemInfos)
+      : itemInfos;
 
     if (filteredItemInfos.length === 0) {
       throw new NoContainingScopeError(this.modifier.scopeType.type);

src/processTargets/modifiers/ItemStage/ItemStage.ts

@@ -5,16 +5,27 @@ import {
 } from "../../typings/targetDescriptor.types";
 import { ProcessedTargetsContext } from "../../typings/Types";
 import { ModifierStage } from "../PipelineStages.types";
-import { weakContainingTokenStage } from "./commonWeakContainingScopeStages";
+import { containingTokenIfUntypedStage } from "./commonContainingScopeIfUntypedStages";
+
+/**
+ * Throw this error if user has requested leading or trailing delimiter but no
+ * such delimiter exists on the given target.
+ */
+class NoDelimiterError extends Error {
+  constructor(type: "leading" | "trailing") {
+    super(`Target has no ${type} delimiter.`);
+    this.name = "NoDelimiterError";
+  }
+}
 
 export class LeadingStage implements ModifierStage {
   constructor(private modifier: LeadingModifier) {}
 
   run(context: ProcessedTargetsContext, target: Target): Target[] {
-    return weakContainingTokenStage.run(context, target).map((target) => {
+    return containingTokenIfUntypedStage.run(context, target).map((target) => {
       const leading = target.getLeadingDelimiterTarget();
       if (leading == null) {
-        throw Error("No available leading delimiter range");
+        throw new NoDelimiterError("leading");
       }
       return leading;
     });
@@ -25,10 +36,10 @@ export class TrailingStage implements ModifierStage {
   constructor(private modifier: TrailingModifier) {}
 
   run(context: ProcessedTargetsContext, target: Target): Target[] {
-    return weakContainingTokenStage.run(context, target).map((target) => {
+    return containingTokenIfUntypedStage.run(context, target).map((target) => {
       const trailing = target.getTrailingDelimiterTarget();
       if (trailing == null) {
-        throw Error("No available trailing delimiter range");
+        throw new NoDelimiterError("trailing");
       }
       return trailing;
     });