Add text object and remove concept of inclusive/exclusive motions.

src/actions/actions.ts

@@ -366,9 +366,7 @@ class CommandEsc extends BaseCommand {
   key = "<esc>";
 
   public async exec(position: Position, vimState: VimState): Promise<VimState> {
-    if (vimState.currentMode === ModeName.Visual) {
-      vimState.cursorPosition = position;
-    } else {
+    if (vimState.currentMode !== ModeName.Visual) {
       vimState.cursorPosition = position.getLeft();
     }
 
@@ -484,7 +482,7 @@ class CommandInsertAtLineEnd extends BaseCommand {
 
   public async exec(position: Position, vimState: VimState): Promise<VimState> {
     const pos = new Position(position.line,
-                position.getLineEnd(PositionOptions.CharacterWiseInclusive).character, position.positionOptions);
+                position.getLineEnd().character + 1, position.positionOptions);
 
     vimState.currentMode = ModeName.Insert;
     vimState.cursorPosition = pos;
@@ -803,6 +801,31 @@ class ActionDeleteLineVisualMode extends BaseCommand {
   }
 }
 
+@RegisterAction
+class MovementAWordTextObject extends BaseMovement {
+  modes = [ModeName.Normal, ModeName.Visual];
+  key = "aw";
+
+  public async execAction(position: Position, vimState: VimState): Promise<VimState> {
+    if (vimState.currentMode === ModeName.Visual && !vimState.cursorPosition.isEqual(vimState.cursorStartPosition)) {
+      // TODO: This is kind of a bad way to do this.
+      return new MoveWordBegin().execAction(position, vimState);
+    }
+
+    let currentChar = TextEditor.getLineAt(position).text[position.character];
+
+    if (currentChar === ' ' || currentChar === '\t') {
+      vimState.cursorStartPosition = position.getLastWordEnd();
+      vimState.cursorPosition = position.getCurrentWordEnd();
+    } else {
+      vimState.cursorStartPosition = position.getWordLeft();
+      vimState.cursorPosition = position.getWordRight();
+    }
+
+    return vimState;
+  }
+}
+
 /*
 // Doing this correctly is very difficult.
    https://github.com/Microsoft/vscode/issues/7177
@@ -871,21 +894,6 @@ class ActionChangeCurrentWord {
   }
 }
 
-@RegisterAction
-class ActionChangeCurrentWordToNext {
-  modes = [ModeName.Normal];
-  key = "caw";
-
-  public async execAction(position: Position): Promise<VimState> {
-    motion.changeMode(MotionMode.Cursor);
-    let currentChar = TextEditor.getLineAt(motion.position).text[motion.position.character];
-    if (currentChar === ' ' || currentChar === '\t') {
-      await new ChangeOperator(modeHandler).run(motion.position.getLastWordEnd(), motion.position.getCurrentWordEnd());
-    } else {
-      await new ChangeOperator(modeHandler).run(motion.position.getWordLeft(), motion.position.getWordRight());
-    }
-  }
-}
 
 @RegisterAction
 class ActionPaste {

src/mode/modeHandler.ts

@@ -53,7 +53,14 @@ export class VimState {
     /**
      * The position the cursor will be when this action finishes.
      */
-    public cursorPosition = new Position(0, 0, PositionOptions.CharacterWiseInclusive);
+    public cursorPosition = new Position(0, 0, PositionOptions.CharacterWiseExclusive);
+
+    /**
+     * The effective starting position of the movement, used along with cursorPosition to determine
+     * the range over which to run an Operator. May rarely be different than where the cursor
+     * actually starts e.g. if you use the "aw" text motion in the middle of a word.
+     */
+    public cursorStartPosition = new Position(0, 0, PositionOptions.CharacterWiseExclusive);
 
     /**
      * The mode Vim will be in once this action finishes.
@@ -264,6 +271,8 @@ export class ModeHandler implements vscode.Disposable {
                 await (this.currentMode as any).handleAction(actionState);
                 this._vimState.actionState = new ActionState(this._vimState);
 
+                this._vimState.cursorPosition = this._motion.position.getRight();
+
                 return true;
             } else {
                 // This is the ultimate failure case. Just insert the key into the document. This is
@@ -291,6 +300,11 @@ export class ModeHandler implements vscode.Disposable {
         }
 
         if (actionState.readyToExecute) {
+            if (this.currentMode.name !== ModeName.Visual &&
+                this.currentMode.name !== ModeName.VisualLine) {
+                this._vimState.cursorStartPosition = this._motion.position;
+            }
+
             this._vimState = await this.executeState();
 
             if (this._vimState.commandAction !== VimCommandActions.DoNothing) {
@@ -313,7 +327,7 @@ export class ModeHandler implements vscode.Disposable {
             // Update mode
 
             if (this._vimState.currentMode !== this.currentModeName) {
-                this.setCurrentModeByName(this._vimState.currentMode)
+                this.setCurrentModeByName(this._vimState.currentMode);
             }
 
             // Update cursor position
@@ -327,9 +341,14 @@ export class ModeHandler implements vscode.Disposable {
             }
 
             if (this.currentMode instanceof NormalMode) {
+                if (stop.character >= Position.getLineLength(stop.line)) {
+                    stop = stop.getLeft();
+                    this._vimState.cursorPosition = stop;
+                }
+
                 this._motion.moveTo(stop.line, stop.character);
             } else if (this.currentMode instanceof VisualMode) {
-                await (this.currentMode as VisualMode).handleMotion(stop);
+                await (this.currentMode as VisualMode).handleMotion(this._vimState.cursorStartPosition, stop);
             } else if (this.currentMode instanceof InsertMode) {
                 this._motion.moveTo(stop.line, stop.character);
             } else {
@@ -356,21 +375,22 @@ export class ModeHandler implements vscode.Disposable {
     }
 
     private async executeState(): Promise<VimState> {
-        let start: Position, stop: Position;
+        let start = this._vimState.cursorStartPosition;
+        let stop = this._vimState.cursorPosition;
         let actionState = this._vimState.actionState;
         let newState: VimState;
 
         if (actionState.command) {
-            return await actionState.command.exec(this._motion.position, this._vimState);
+            return await actionState.command.exec(stop, this._vimState);
         }
 
-        start = this._motion.position;
         if (actionState.movement) {
             newState = actionState.operator ?
-                await actionState.movement.execActionForOperator(start, this._vimState) :
-                await actionState.movement.execAction           (start, this._vimState);
+                await actionState.movement.execActionForOperator(stop, this._vimState) :
+                await actionState.movement.execAction           (stop, this._vimState);
 
             actionState = newState.actionState;
+            start       = newState.cursorStartPosition;
             stop        = newState.cursorPosition;
         }
 

src/mode/modeVisual.ts

@@ -45,8 +45,9 @@ export class VisualMode extends Mode {
         this.motion.select(this._selectionStart, this._selectionStop);
     }
 
-    public async handleMotion(position: Position): Promise<boolean> {
+    public async handleMotion(start: Position, position: Position): Promise<boolean> {
         this._selectionStop = position;
+        this._selectionStart = start;
         this.motion.moveTo(this._selectionStart.line, this._selectionStart.character);
 
         /**

src/motion/position.ts

@@ -20,8 +20,7 @@ export class Position extends vscode.Position {
 
     constructor(line: number, character: number, options: PositionOptions) {
         super(line, character);
-
-        this.positionOptions = options;
+        this.positionOptions = PositionOptions.CharacterWiseExclusive;
 
         this._nonWordCharRegex = this.makeWordRegex(Position.NonWordCharacters);
         this._nonBigWordCharRegex = this.makeWordRegex(Position.NonBigWordCharacters);
@@ -79,7 +78,7 @@ export class Position extends vscode.Position {
     public getDown(desiredColumn: number) : Position {
         if (this.getDocumentEnd().line !== this.line) {
             let nextLine = this.line + 1;
-            let nextLineLength = Position.getLineLength(nextLine, this.positionOptions);
+            let nextLineLength = Position.getLineLength(nextLine);
 
             return new Position(nextLine, Math.min(nextLineLength, desiredColumn), this.positionOptions);
         }
@@ -93,7 +92,7 @@ export class Position extends vscode.Position {
     public getUp(desiredColumn: number) : Position {
         if (this.getDocumentBegin().line !== this.line) {
             let prevLine = this.line - 1;
-            let prevLineLength  = Position.getLineLength(prevLine, this.positionOptions);
+            let prevLineLength  = Position.getLineLength(prevLine);
 
             return new Position(prevLine, Math.min(prevLineLength, desiredColumn), this.positionOptions);
         }
@@ -180,7 +179,7 @@ export class Position extends vscode.Position {
      */
     public getLineEnd(opts: PositionOptions = null) : Position {
         if (opts === null) { opts = this.positionOptions; }
-        return new Position(this.line, Position.getLineLength(this.line, opts), opts);
+        return new Position(this.line, Position.getLineLength(this.line), opts);
     }
 
     public getDocumentBegin() : Position {
@@ -190,7 +189,7 @@ export class Position extends vscode.Position {
     public getDocumentEnd() : Position {
         let lineCount = TextEditor.getLineCount();
         let line = lineCount > 0 ? lineCount - 1 : 0;
-        let char = Position.getLineLength(line, this.positionOptions);
+        let char = Position.getLineLength(line);
 
         return new Position(line, char, this.positionOptions);
     }
@@ -203,8 +202,8 @@ export class Position extends vscode.Position {
         }
 
         // char
-        let charCount = Position.getLineLength(this.line, this.positionOptions);
-        if (this.character > charCount) {
+        let charCount = Position.getLineLength(this.line);
+        if (this.character > charCount + 1) {
             return false;
         }
 
@@ -226,8 +225,8 @@ export class Position extends vscode.Position {
     /**
      * Is this position at the end of the line?
      */
-    public isLineEnd() : boolean {
-        return this.character === Position.getLineLength(this.line, this.positionOptions);
+    public isLineEnd(): boolean {
+        return this.character >= Position.getLineLength(this.line);
     }
 
     public isAtDocumentEnd(): boolean {
@@ -246,19 +245,8 @@ export class Position extends vscode.Position {
         return new Position(0, 0, this.positionOptions);
     }
 
-    private static getLineLength(line: number, options: PositionOptions) : number {
-        switch (options) {
-            case PositionOptions.CharacterWiseExclusive:
-                // Valid Positions for Caret: [0, eol)
-                var len = TextEditor.readLineAt(line).length;
-                return len > 0 ? len - 1 : len;
-            case PositionOptions.CharacterWiseInclusive:
-                // Valid Positions for Caret: [0, eol]
-                return TextEditor.readLineAt(line).length;
-
-            default:
-                throw new Error("Unhandled PositionOptions: " + options);
-        }
+    public static getLineLength(line: number) : number {
+        return TextEditor.readLineAt(line).length;
     }
 
     private makeWordRegex(characterSet: string) : RegExp {
@@ -344,9 +332,6 @@ export class Position extends vscode.Position {
             }
 
             if (newCharacter !== undefined) {
-                if (this.positionOptions === PositionOptions.CharacterWiseInclusive) {
-                    newCharacter++;
-                }
                 return new Position(currentLine, newCharacter, this.positionOptions);
             }
         }
@@ -360,9 +345,6 @@ export class Position extends vscode.Position {
             let newCharacter = _.find(positions, index => index > this.character || currentLine !== this.line);
 
             if (newCharacter !== undefined) {
-                if (this.positionOptions === PositionOptions.CharacterWiseInclusive) {
-                    newCharacter++;
-                }
                 return new Position(currentLine, newCharacter, this.positionOptions);
             }
         }

test/motion.test.ts

@@ -38,20 +38,12 @@ suite("motion", () => {
         };
     });
 
-    test("char right: caret", () => {
-        let motion = new Motion(MotionMode.Caret);
-
-        motion = motion.moveTo(0, 7).right();
-        assert.equal(motion.position.line, 0);
-        assert.equal(motion.position.character, 7);
-    });
-
-    test("char right: cursor", () => {
+    test("char right", () => {
         let motion = new Motion(MotionMode.Cursor);
-        motion = motion.moveTo(0, 8).right();
+        motion = motion.moveTo(0, 9).right();
 
         assert.equal(motion.position.line, 0);
-        assert.equal(motion.position.character, 8);
+        assert.equal(motion.position.character, 9);
     });
 
     test("char left: should move cursor one column left", () => {
@@ -242,7 +234,7 @@ suite("word motion", () => {
         test("last word on last line should go to end of document (special case!)", () => {
             let motion = new Motion(MotionMode.Caret).moveTo(6, 6).wordRight();
             assert.equal(motion.position.line, 6);
-            assert.equal(motion.position.character, 9);
+            assert.equal(motion.position.character, 10);
         });
 
     });
@@ -458,7 +450,7 @@ suite("paragraph motion", () => {
         test("paragraph at end of document", () => {
             let motion = new Motion(MotionMode.Caret).moveTo(7, 0).goToEndOfCurrentParagraph();
             assert.equal(motion.position.line, 8);
-            assert.equal(motion.position.character, 2);
+            assert.equal(motion.position.character, 3);
         });
     });