Fix u canceling multi-cursor. Fixes #9835.

Author: J-Fields

src/actions/commands/actions.ts

@@ -641,12 +641,12 @@ export class CommandUndo extends BaseCommand {
   }
 
   public override async exec(position: Position, vimState: VimState): Promise<void> {
-    const newPosition = await vimState.historyTracker.goBackHistoryStep();
+    const cursors = await vimState.historyTracker.goBackHistoryStep();
 
-    if (newPosition === undefined) {
+    if (cursors === undefined) {
       StatusBar.setText(vimState, 'Already at oldest change');
     } else {
-      vimState.cursors = [new Cursor(newPosition, newPosition)];
+      vimState.cursors = cursors;
     }
   }
 }
@@ -677,12 +677,12 @@ export class CommandRedo extends BaseCommand {
   }
 
   public override async exec(position: Position, vimState: VimState): Promise<void> {
-    const newPosition = await vimState.historyTracker.goForwardHistoryStep();
+    const cursors = await vimState.historyTracker.goForwardHistoryStep();
 
-    if (newPosition === undefined) {
+    if (cursors === undefined) {
       StatusBar.setText(vimState, 'Already at newest change');
     } else {
-      vimState.cursors = [new Cursor(newPosition, newPosition)];
+      vimState.cursors = cursors;
     }
   }
 }

src/history/historyTracker.ts

@@ -21,6 +21,7 @@ import { globalState } from '../state/globalState';
 import { Mode } from '../mode/mode';
 import { VimError } from '../error';
 import { Logger } from '../util/logger';
+import { Cursor } from '../common/motion/cursor';
 import { earlierOf } from '../common/motion/position';
 
 const diffEngine = new DiffMatchPatch.diff_match_patch();
@@ -134,9 +135,9 @@ class HistoryStep {
 
   /**
    * The cursor position at the start of this history step.
-   * Restored by `u`. Currently, only one cursor is remembered.
+   * Restored by `u`.
    */
-  public cursorStart: Position | undefined;
+  public cursorsAtStart: readonly Cursor[] | undefined;
 
   /**
    * The position of every mark at the start of this history step.
@@ -390,7 +391,7 @@ class ChangeList {
 export class HistoryTracker {
   public currentContentChanges: vscode.TextDocumentContentChangeEvent[];
 
-  private nextStepStartPosition: Position | undefined;
+  private nextStepCursorsAtStart: readonly Cursor[] | undefined;
 
   private readonly undoStack: UndoStack;
 
@@ -691,10 +692,9 @@ export class HistoryTracker {
       return;
     }
 
-    if (this.nextStepStartPosition === undefined) {
-      const cursor = this.vimState.cursorsInitialState[0];
-      this.nextStepStartPosition = earlierOf(cursor.start, cursor.stop);
-      Logger.debug(`Set nextStepStartPosition to ${this.nextStepStartPosition}`);
+    if (this.nextStepCursorsAtStart === undefined) {
+      this.nextStepCursorsAtStart = this.vimState.cursorsInitialState;
+      Logger.debug(`Set nextStepCursorsAtStart to ${this.nextStepCursorsAtStart}`);
     }
 
     if (
@@ -772,8 +772,10 @@ export class HistoryTracker {
       currentHistoryStep.isFinished = true;
       currentHistoryStep.timestamp = new Date();
 
-      currentHistoryStep.cursorStart ??= this.nextStepStartPosition;
-      this.nextStepStartPosition = undefined;
+      if (this.nextStepCursorsAtStart !== undefined) {
+        currentHistoryStep.cursorsAtStart ??= this.nextStepCursorsAtStart;
+        this.nextStepCursorsAtStart = undefined;
+      }
 
       currentHistoryStep.merge(this.vimState.document);
 
@@ -794,7 +796,7 @@ export class HistoryTracker {
    *
    * @returns the new cursor positions, or undefined if there are no steps to undo
    */
-  public async goBackHistoryStep(): Promise<Position | undefined> {
+  public async goBackHistoryStep(): Promise<Cursor[] | undefined> {
     const step = this.undoStack.stepBackward();
     if (step === undefined) {
       return undefined;
@@ -815,15 +817,18 @@ export class HistoryTracker {
       }  ${step.howLongAgo()}`,
     );
 
-    return step.cursorStart;
+    return step.cursorsAtStart?.map((c) => {
+      const start = earlierOf(c.start, c.stop);
+      return new Cursor(start, start);
+    });
   }
 
   /**
    * Redo the next HistoryStep, if there is one
    *
    * @returns the new cursor positions, or undefined if there are no steps to redo
    */
-  public async goForwardHistoryStep(): Promise<Position | undefined> {
+  public async goForwardHistoryStep(): Promise<Cursor[] | undefined> {
     const step = this.undoStack.stepForward();
     if (step === undefined) {
       return undefined;
@@ -842,7 +847,10 @@ export class HistoryTracker {
       `${changes}; after #${this.undoStack.getCurrentHistoryStepIndex()}  ${step.howLongAgo()}`,
     );
 
-    return step.cursorStart;
+    return step.cursorsAtStart?.map((c) => {
+      const start = earlierOf(c.start, c.stop);
+      return new Cursor(start, start);
+    });
   }
 
   /**
@@ -918,7 +926,7 @@ export class HistoryTracker {
         changes: changesToUndo.map((change) => change.reversed()).reverse(),
         cameFromU: true,
       });
-      this.nextStepStartPosition = lastChange.start;
+      this.nextStepCursorsAtStart = [new Cursor(lastChange.start, lastChange.start)];
       this.undoStack.pushHistoryStep(newStep);
 
       this.finishCurrentStep();
@@ -957,7 +965,7 @@ export class HistoryTracker {
   }
 
   public getLastHistoryStartPosition(): Position | undefined {
-    return this.undoStack.getCurrentHistoryStep()?.cursorStart;
+    return this.undoStack.getCurrentHistoryStep()?.cursorsAtStart?.[0]?.start;
   }
 
   private getLastChangeStartPosition(): Position | undefined {

test/multicursor.test.ts

@@ -60,6 +60,15 @@ suite('Multicursor', () => {
     });
   });
 
+  suite('Undo/redo', () => {
+    newTest({
+      title: 'Can undo with multiple cursors',
+      start: ['|one', '|two', '|three'],
+      keysPressed: 'l' + 'iXXX<Esc>' + '$' + 'u',
+      end: ['o|ne', 't|wo', 't|hree'],
+    });
+  });
+
   test('can add multiple cursors below', async () => {
     await modeHandler.handleMultipleKeyEvents('i11\n22'.split(''));
     await modeHandler.handleMultipleKeyEvents(['<Esc>', 'g', 'g']);