Fix multiple issues with expand selection commands and pair/block movement

src/actions/commands/actions.ts

@@ -3817,7 +3817,7 @@ class ActionChangeChar extends BaseCommand {
 
   public couldActionApply(vimState: VimState, keysPressed: string[]): boolean {
     return (
-      super.doesActionApply(vimState, keysPressed) &&
+      super.couldActionApply(vimState, keysPressed) &&
       !configuration.sneak &&
       !vimState.recordedState.operator
     );

src/actions/motion.ts

@@ -1338,14 +1338,14 @@ class MoveToMatchingBracket extends BaseMovement {
         if (PairMatcher.pairings[text[i]]) {
           // We found an opening char, now move to the matching closing char
           const openPosition = new Position(position.line, i);
-          return PairMatcher.nextPairedChar(openPosition, text[i], true) || failure;
+          return PairMatcher.nextPairedChar(openPosition, text[i]) || failure;
         }
       }
 
       return failure;
     }
 
-    return PairMatcher.nextPairedChar(position, charToMatch, true) || failure;
+    return PairMatcher.nextPairedChar(position, charToMatch) || failure;
   }
 
   public async execActionForOperator(
@@ -1407,13 +1407,27 @@ export abstract class MoveInsideCharacter extends BaseMovement {
   protected includeSurrounding = false;
 
   public async execAction(position: Position, vimState: VimState): Promise<IMovement> {
-    const failure = { start: position, stop: position, failed: true };
-    const text = TextEditor.getLineAt(position).text;
     const closingChar = PairMatcher.pairings[this.charToMatch].match;
-    const closedMatch = text[position.character] === closingChar;
-
+    let cursorStartPos = new Position(
+      vimState.cursorStartPosition.line,
+      vimState.cursorStartPosition.character
+    );
+    // maintain current selection on failure
+    const failure = { start: cursorStartPos, stop: position, failed: true };
+    if (!this.includeSurrounding) {
+      const adjacentPosLeft = cursorStartPos.getLeftThroughLineBreaks();
+      const adjacentPosRight = position.getRightThroughLineBreaks();
+      const adjacentCharLeft = TextEditor.getCharAt(adjacentPosLeft);
+      const adjacentCharRight = TextEditor.getCharAt(adjacentPosRight);
+      if (adjacentCharLeft === this.charToMatch && adjacentCharRight === closingChar) {
+        cursorStartPos = adjacentPosLeft;
+        vimState.cursorStartPosition = adjacentPosLeft;
+        position = adjacentPosRight;
+        vimState.cursorPosition = adjacentPosRight;
+      }
+    }
     // First, search backwards for the opening character of the sequence
-    let startPos = PairMatcher.nextPairedChar(position, closingChar, closedMatch);
+    let startPos = PairMatcher.nextPairedChar(cursorStartPos, closingChar, vimState);
     if (startPos === undefined) {
       return failure;
     }
@@ -1426,7 +1440,8 @@ export abstract class MoveInsideCharacter extends BaseMovement {
       startPlusOne = new Position(startPos.line, startPos.character + 1);
     }
 
-    let endPos = PairMatcher.nextPairedChar(startPlusOne, this.charToMatch, false);
+    let endPos = PairMatcher.nextPairedChar(position, this.charToMatch, vimState);
+
     if (endPos === undefined) {
       return failure;
     }
@@ -1452,13 +1467,72 @@ export abstract class MoveInsideCharacter extends BaseMovement {
       vimState.recordedState.operatorPositionDiff = startPos.subtract(position);
     }
 
+    vimState.cursorStartPosition = startPos;
     return {
       start: startPos,
       stop: endPos,
       diff: new PositionDiff(0, startPos === position ? 1 : 0),
     };
   }
 
+  public async execActionWithCount(
+    position: Position,
+    vimState: VimState,
+    count: number
+  ): Promise<Position | IMovement> {
+    let recordedState = vimState.recordedState;
+    let result: Position | IMovement = new Position(0, 0); // bogus init to satisfy typechecker
+
+    if (count < 1) {
+      count = 1;
+    } else if (count > 99999) {
+      count = 99999;
+    }
+
+    for (let i = 0; i < count; i++) {
+      const lastIteration = i === count - 1;
+      const temporaryResult =
+        recordedState.operator && lastIteration
+          ? await this.execActionForOperator(position, vimState)
+          : await this.execAction(position, vimState);
+
+      // return failure result when repeat prefixing
+      if (isIMovement(temporaryResult)) {
+        if ((<IMovement>temporaryResult).failed) {
+          return temporaryResult;
+        }
+      }
+
+      if (temporaryResult instanceof Position) {
+        result = temporaryResult;
+        position = temporaryResult;
+      } else if (isIMovement(temporaryResult)) {
+        if (result instanceof Position) {
+          result = {
+            start: new Position(0, 0),
+            stop: new Position(0, 0),
+            failed: false,
+          };
+        }
+
+        result.failed = result.failed || temporaryResult.failed;
+
+        // update start every iteration as selection expands
+        (result as IMovement).start = temporaryResult.start;
+
+        if (lastIteration) {
+          (result as IMovement).stop = temporaryResult.stop;
+        } else {
+          position = temporaryResult.stop;
+        }
+
+        result.registerMode = temporaryResult.registerMode;
+      }
+    }
+
+    return result;
+  }
+
   public async execActionForOperator(
     position: Position,
     vimState: VimState
@@ -1707,11 +1781,7 @@ class MoveToUnclosedRoundBracketBackward extends MoveToMatchingBracket {
   public async execAction(position: Position, vimState: VimState): Promise<Position | IMovement> {
     const failure = { start: position, stop: position, failed: true };
     const charToMatch = ')';
-    const result = PairMatcher.nextPairedChar(
-      position.getLeftThroughLineBreaks(),
-      charToMatch,
-      false
-    );
+    const result = PairMatcher.nextPairedChar(position, charToMatch);
 
     if (!result) {
       return failure;
@@ -1727,11 +1797,7 @@ class MoveToUnclosedRoundBracketForward extends MoveToMatchingBracket {
   public async execAction(position: Position, vimState: VimState): Promise<Position | IMovement> {
     const failure = { start: position, stop: position, failed: true };
     const charToMatch = '(';
-    const result = PairMatcher.nextPairedChar(
-      position.getRightThroughLineBreaks(),
-      charToMatch,
-      false
-    );
+    const result = PairMatcher.nextPairedChar(position, charToMatch);
 
     if (!result) {
       return failure;
@@ -1756,11 +1822,7 @@ class MoveToUnclosedCurlyBracketBackward extends MoveToMatchingBracket {
   public async execAction(position: Position, vimState: VimState): Promise<Position | IMovement> {
     const failure = { start: position, stop: position, failed: true };
     const charToMatch = '}';
-    const result = PairMatcher.nextPairedChar(
-      position.getLeftThroughLineBreaks(),
-      charToMatch,
-      false
-    );
+    const result = PairMatcher.nextPairedChar(position, charToMatch);
 
     if (!result) {
       return failure;
@@ -1776,11 +1838,7 @@ class MoveToUnclosedCurlyBracketForward extends MoveToMatchingBracket {
   public async execAction(position: Position, vimState: VimState): Promise<Position | IMovement> {
     const failure = { start: position, stop: position, failed: true };
     const charToMatch = '{';
-    const result = PairMatcher.nextPairedChar(
-      position.getRightThroughLineBreaks(),
-      charToMatch,
-      false
-    );
+    const result = PairMatcher.nextPairedChar(position, charToMatch);
 
     if (!result) {
       return failure;
@@ -1805,20 +1863,24 @@ abstract class MoveTagMatch extends BaseMovement {
   public async execAction(position: Position, vimState: VimState): Promise<IMovement> {
     const editorText = TextEditor.getText();
     const offset = TextEditor.getOffsetAt(position);
-    const tagMatcher = new TagMatcher(editorText, offset);
+    const tagMatcher = new TagMatcher(editorText, offset, vimState);
+    const cursorStartPos = new Position(
+      vimState.cursorStartPosition.line,
+      vimState.cursorStartPosition.character
+    );
     const start = tagMatcher.findOpening(this.includeTag);
     const end = tagMatcher.findClosing(this.includeTag);
 
     if (start === undefined || end === undefined) {
       return {
-        start: position,
+        start: cursorStartPos,
         stop: position,
         failed: true,
       };
     }
 
-    let startPosition = start ? TextEditor.getPositionAt(start) : position;
-    let endPosition = end ? TextEditor.getPositionAt(end) : position;
+    let startPosition = start >= 0 ? TextEditor.getPositionAt(start) : cursorStartPos;
+    let endPosition = end >= 0 ? TextEditor.getPositionAt(end) : position;
 
     if (position.isAfter(endPosition)) {
       vimState.recordedState.transformations.push({
@@ -1841,12 +1903,71 @@ abstract class MoveTagMatch extends BaseMovement {
         failed: true,
       };
     }
+    vimState.cursorStartPosition = startPosition;
     return {
       start: startPosition,
       stop: endPosition.getLeftThroughLineBreaks(true),
     };
   }
 
+  public async execActionWithCount(
+    position: Position,
+    vimState: VimState,
+    count: number
+  ): Promise<Position | IMovement> {
+    let recordedState = vimState.recordedState;
+    let result: Position | IMovement = new Position(0, 0); // bogus init to satisfy typechecker
+
+    if (count < 1) {
+      count = 1;
+    } else if (count > 99999) {
+      count = 99999;
+    }
+
+    for (let i = 0; i < count; i++) {
+      const lastIteration = i === count - 1;
+      const temporaryResult =
+        recordedState.operator && lastIteration
+          ? await this.execActionForOperator(position, vimState)
+          : await this.execAction(position, vimState);
+
+      // return failure result when repeat prefixing
+      if (isIMovement(temporaryResult)) {
+        if ((<IMovement>temporaryResult).failed) {
+          return temporaryResult;
+        }
+      }
+
+      if (temporaryResult instanceof Position) {
+        result = temporaryResult;
+        position = temporaryResult;
+      } else if (isIMovement(temporaryResult)) {
+        if (result instanceof Position) {
+          result = {
+            start: new Position(0, 0),
+            stop: new Position(0, 0),
+            failed: false,
+          };
+        }
+
+        result.failed = result.failed || temporaryResult.failed;
+
+        // update start every iteration as selection expands
+        (result as IMovement).start = temporaryResult.start;
+
+        if (lastIteration) {
+          (result as IMovement).stop = temporaryResult.stop;
+        } else {
+          position = temporaryResult.stop;
+        }
+
+        result.registerMode = temporaryResult.registerMode;
+      }
+    }
+
+    return result;
+  }
+
   public async execActionForOperator(
     position: Position,
     vimState: VimState

src/actions/plugins/surround.ts

@@ -420,7 +420,7 @@ export class CommandSurroundAddToReplacement extends BaseCommand {
     if (startReplace.length === 1 && startReplace in PairMatcher.pairings) {
       endReplace = PairMatcher.pairings[startReplace].match;
 
-      if (!PairMatcher.pairings[startReplace].nextMatchIsForward) {
+      if (!PairMatcher.pairings[startReplace].isNextMatchForward) {
         [startReplace, endReplace] = [endReplace, startReplace];
       } else {
         startReplace = startReplace + ' ';
@@ -544,25 +544,27 @@ export class CommandSurroundAddToReplacement extends BaseCommand {
     }
 
     if (target === 't') {
+      // `MoveInsideTag` must be run first as otherwise the search will
+      // look for the next enclosing tag after having selected the first
+      let innerTagContent = await new MoveInsideTag().execAction(position, vimState);
       let { start, stop, failed } = await new MoveAroundTag().execAction(position, vimState);
-      let tagEnd = await new MoveInsideTag().execAction(position, vimState);
 
-      if (failed || tagEnd.failed) {
+      if (failed || innerTagContent.failed) {
         return CommandSurroundAddToReplacement.Finish(vimState);
       }
 
       stop = stop.getRight();
-      tagEnd.stop = tagEnd.stop.getRight();
+      innerTagContent.stop = innerTagContent.stop.getRight();
 
       if (failed) {
         return CommandSurroundAddToReplacement.Finish(vimState);
       }
 
       startReplaceRange = new Range(start, start.getRight());
-      endReplaceRange = new Range(tagEnd.stop, tagEnd.stop.getRight());
+      endReplaceRange = new Range(innerTagContent.stop, innerTagContent.stop.getRight());
 
-      startDeleteRange = new Range(start.getRight(), tagEnd.start);
-      endDeleteRange = new Range(tagEnd.stop.getRight(), stop);
+      startDeleteRange = new Range(start.getRight(), innerTagContent.start);
+      endDeleteRange = new Range(innerTagContent.stop.getRight(), stop);
     }
 
     if (operator === 'change') {