Add VimState.cursor, equivalent to VimState.cursors[0]

Author: J-Fields

src/actions/commands/actions.ts

@@ -159,7 +159,7 @@ class CommandEsc extends BaseCommand {
       vimState.surround = undefined;
 
       if (vimState.isMultiCursor) {
-        vimState.cursors = [vimState.cursors[0]];
+        vimState.cursors = [vimState.cursor];
       } else {
         // If there's nothing to do on the vim side, we might as well call some
         // of vscode's default "close notification" actions. I think we should

src/actions/commands/insert.ts

@@ -134,13 +134,13 @@ class InsertAbove extends BaseCommand {
     }
 
     vimState.cursors = getCursorsAfterSync(vimState.editor);
-    const endPos = vimState.cursors[0].start.character;
+    const endPos = vimState.cursor.start.character;
     const indentAmt = charPos - endPos;
 
     for (let i = 0; i < count; i++) {
-      const newPos = new Position(vimState.cursors[0].start.line + i, charPos);
+      const newPos = new Position(vimState.cursor.start.line + i, charPos);
       if (i === 0) {
-        vimState.cursors[0] = Cursor.atPosition(newPos);
+        vimState.cursor = Cursor.atPosition(newPos);
       } else {
         vimState.cursors.push(Cursor.atPosition(newPos));
       }
@@ -286,7 +286,7 @@ export class ExitInsertMode extends BaseCommand {
     vimState.historyTracker.currentContentChanges = [];
 
     if (vimState.isFakeMultiCursor) {
-      vimState.cursors = [vimState.cursors[0]];
+      vimState.cursors = [vimState.cursor];
       vimState.isFakeMultiCursor = false;
     }
   }

src/actions/commands/put.ts

@@ -50,7 +50,7 @@ abstract class BasePutCommand extends BaseCommand {
       vimState.currentMode === Mode.CommandlineInProgress ? Mode.Normal : vimState.currentMode;
     const registerMode = this.getRegisterMode(register);
 
-    const replaceRange = this.getReplaceRange(mode, vimState.cursors[0], registerMode);
+    const replaceRange = this.getReplaceRange(mode, vimState.cursor, registerMode);
 
     let text = this.getRegisterText(mode, register, count);
     if (this.shouldAdjustIndent(mode, registerMode)) {

src/cmd_line/commands/copy.ts

@@ -61,7 +61,7 @@ export class CopyCommand extends ExCommand {
   }
 
   public async execute(vimState: VimState): Promise<void> {
-    const line = vimState.cursors[0].stop.line;
+    const line = vimState.cursor.stop.line;
     this.copyLines(vimState, line, line);
   }
 

src/cmd_line/commands/fileInfo.ts

@@ -21,6 +21,6 @@ export class FileInfoCommand extends ExCommand {
 
   async execute(vimState: VimState): Promise<void> {
     // TODO: Use `this.args`
-    reportFileInfo(vimState.cursors[0].start, vimState);
+    reportFileInfo(vimState.cursor.start, vimState);
   }
 }

src/cmd_line/commands/move.ts

@@ -91,7 +91,7 @@ export class MoveCommand extends ExCommand {
   }
 
   public async execute(vimState: VimState): Promise<void> {
-    const line = vimState.cursors[0].stop.line;
+    const line = vimState.cursor.stop.line;
     this.moveLines(vimState, line, line);
   }
 

src/mode/modeHandler.ts

@@ -247,7 +247,7 @@ export class ModeHandler implements vscode.Disposable, IModeHandler {
             // like 'editor.action.smartSelect.grow' are handled.
             if (this.vimState.currentMode === Mode.Visual) {
               Logger.trace('Updating Visual Selection!');
-              this.vimState.cursors[0] = Cursor.fromSelection(selection);
+              this.vimState.cursor = Cursor.fromSelection(selection);
               this.updateView({ drawSelection: false, revealRange: false });
 
               // Store selection for commands like gv
@@ -259,7 +259,7 @@ export class ModeHandler implements vscode.Disposable, IModeHandler {
               return;
             } else if (!selection.active.isEqual(selection.anchor)) {
               Logger.trace('Creating Visual Selection from command!');
-              this.vimState.cursors[0] = Cursor.fromSelection(selection);
+              this.vimState.cursor = Cursor.fromSelection(selection);
               await this.setCurrentMode(Mode.Visual);
               this.updateView({ drawSelection: false, revealRange: false });
 
@@ -322,7 +322,7 @@ export class ModeHandler implements vscode.Disposable, IModeHandler {
             selection.active
           }`,
         );
-        this.vimState.cursors[0] = Cursor.fromSelection(selection);
+        this.vimState.cursor = Cursor.fromSelection(selection);
         this.vimState.desiredColumn = selection.active.character;
         this.updateView({ drawSelection: false, revealRange: false });
       }
@@ -1434,7 +1434,7 @@ export class ModeHandler implements vscode.Disposable, IModeHandler {
       if (isLastCursorTracked) {
         cursorToTrack = this.vimState.cursors.at(-1)!;
       } else {
-        cursorToTrack = this.vimState.cursors[0];
+        cursorToTrack = this.vimState.cursor;
       }
 
       const isCursorAboveRange = (visibleRange: vscode.Range): boolean =>

src/state/vimState.ts

@@ -125,33 +125,48 @@ export class VimState implements vscode.Disposable {
   public postponedCodeViewChanges: ViewChange[] = [];
 
   /**
-   * The cursor position (start, stop) when this action finishes.
+   * @deprecated Use cursor.start instead
    */
   public get cursorStartPosition(): Position {
-    return this.cursors[0].start;
+    return this.cursor.start;
   }
   public set cursorStartPosition(value: Position) {
     if (!value.isValid(this.editor)) {
       Logger.warn(`invalid cursor start position. ${value.toString()}.`);
     }
-    this.cursors[0] = this.cursors[0].withNewStart(value);
+    this.cursor = this.cursor.withNewStart(value);
   }
 
+  /**
+   * @deprecated Use cursor.stop instead
+   */
   public get cursorStopPosition(): Position {
-    return this.cursors[0].stop;
+    return this.cursor.stop;
   }
   public set cursorStopPosition(value: Position) {
     if (!value.isValid(this.editor)) {
       Logger.warn(`invalid cursor stop position. ${value.toString()}.`);
     }
-    this.cursors[0] = this.cursors[0].withNewStop(value);
+    this.cursor = this.cursor.withNewStop(value);
   }
 
   /**
    * The position of every cursor. Will never be empty.
    */
   private _cursors: Cursor[] = [Cursor.atPosition(new Position(0, 0))];
 
+  /**
+   * The 'primary' or 'active' cursor.
+   * What this means is somewhat context dependent, but generally it's safe to
+   * use this when you only care about a single cursor.
+   */
+  public get cursor(): Cursor {
+    return this._cursors[0];
+  }
+  public set cursor(value: Cursor) {
+    this._cursors[0] = value;
+  }
+
   public get cursors(): Cursor[] {
     return this._cursors;
   }

src/textEditor.ts

@@ -213,7 +213,7 @@ export class TextEditor {
   ): Iterable<{ line: string; start: Position; end: Position }> {
     const { reverse } = options;
 
-    cursor ??= vimState.cursors[0];
+    cursor ??= vimState.cursor;
 
     const topLeft = visualBlockGetTopLeftPosition(cursor.start, cursor.stop);
     const bottomRight = visualBlockGetBottomRightPosition(cursor.start, cursor.stop);

src/transformations/execute.ts

@@ -153,7 +153,7 @@ export async function executeTransformations(
     switch (transformation.type) {
       case 'insertTextVSCode':
         await TextEditor.insert(vimState.editor, transformation.text);
-        vimState.cursors[0] = Cursor.fromSelection(vimState.editor.selection);
+        vimState.cursor = Cursor.fromSelection(vimState.editor.selection);
         break;
 
       case 'replayRecordedState':