Enable noImplicitOverride

Fixes #6670

src/actions/base.ts

@@ -182,7 +182,7 @@ export abstract class BaseAction {
  * A command is something like <Esc>, :, v, i, etc.
  */
 export abstract class BaseCommand extends BaseAction {
-  isCommand = true;
+  override isCommand = true;
 
   /**
    * If isCompleteAction is true, then triggering this command is a complete action -

src/actions/baseMotion.ts

@@ -50,7 +50,7 @@ export function failedMovement(vimState: VimState): IMovement {
 export abstract class BaseMovement extends BaseAction {
   modes = [Mode.Normal, Mode.Visual, Mode.VisualLine, Mode.VisualBlock];
 
-  isMotion = true;
+  override isMotion = true;
 
   /**
    * If movement can be repeated with semicolon or comma this will be true when

src/actions/commands/commandLine.ts

@@ -32,7 +32,7 @@ import { Position } from 'vscode';
 class CommandTabInCommandline extends BaseCommand {
   modes = [Mode.CommandlineInProgress];
   keys = [['<tab>'], ['<S-tab>']];
-  runsOnceForEveryCursor() {
+  override runsOnceForEveryCursor() {
     return this.keysPressed[0] === '\n';
   }
 
@@ -56,7 +56,7 @@ class CommandTabInCommandline extends BaseCommand {
     vimState.statusBarCursorCharacterPos = vimState.currentCommandlineText.length - restCmd.length;
   }
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     const key = this.keysPressed[0];
     const isTabForward = key === '<tab>';
 
@@ -137,11 +137,11 @@ class CommandTabInCommandline extends BaseCommand {
 class CommandEnterInCommandline extends BaseCommand {
   modes = [Mode.CommandlineInProgress];
   keys = [['\n'], ['<C-m>']];
-  runsOnceForEveryCursor() {
+  override runsOnceForEveryCursor() {
     return this.keysPressed[0] === '\n';
   }
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     await commandLine.Run(vimState.currentCommandlineText, vimState);
     await vimState.setCurrentMode(Mode.Normal);
   }
@@ -151,11 +151,11 @@ class CommandEnterInCommandline extends BaseCommand {
 class CommandRemoveWordCommandline extends BaseCommand {
   modes = [Mode.CommandlineInProgress];
   keys = [['<C-w>'], ['<C-BS>']];
-  runsOnceForEveryCursor() {
+  override runsOnceForEveryCursor() {
     return false;
   }
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     const key = this.keysPressed[0];
     const pos = vimState.statusBarCursorCharacterPos;
     const cmdText = vimState.currentCommandlineText;
@@ -176,11 +176,11 @@ class CommandRemoveWordCommandline extends BaseCommand {
 class CommandRemoveWordInSearchMode extends BaseCommand {
   modes = [Mode.SearchInProgressMode];
   keys = [['<C-w>'], ['<C-BS>']];
-  runsOnceForEveryCursor() {
+  override runsOnceForEveryCursor() {
     return false;
   }
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     const searchState = globalState.searchState;
     if (searchState === undefined) {
       // TODO: log warning, at least
@@ -204,11 +204,11 @@ class CommandRemoveWordInSearchMode extends BaseCommand {
 class WordLeftInCommandline extends BaseCommand {
   modes = [Mode.CommandlineInProgress];
   keys = ['<C-left>'];
-  runsOnceForEveryCursor() {
+  override runsOnceForEveryCursor() {
     return false;
   }
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     const cmdText = vimState.currentCommandlineText;
     vimState.statusBarCursorCharacterPos =
       getWordLeftInText(cmdText, vimState.statusBarCursorCharacterPos, WordType.Big) ?? 0;
@@ -219,11 +219,11 @@ class WordLeftInCommandline extends BaseCommand {
 class WordRightInCommandline extends BaseCommand {
   modes = [Mode.CommandlineInProgress];
   keys = ['<C-right>'];
-  runsOnceForEveryCursor() {
+  override runsOnceForEveryCursor() {
     return false;
   }
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     const cmdText = vimState.currentCommandlineText;
     vimState.statusBarCursorCharacterPos =
       getWordRightInText(cmdText, vimState.statusBarCursorCharacterPos, WordType.Big) ??
@@ -235,11 +235,11 @@ class WordRightInCommandline extends BaseCommand {
 class WordLeftInSearchMode extends BaseCommand {
   modes = [Mode.SearchInProgressMode];
   keys = ['<C-left>'];
-  runsOnceForEveryCursor() {
+  override runsOnceForEveryCursor() {
     return false;
   }
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     const searchState = globalState.searchState;
     if (searchState === undefined) {
       // TODO: log warning, at least
@@ -256,11 +256,11 @@ class WordLeftInSearchMode extends BaseCommand {
 class WordRightInSearchMode extends BaseCommand {
   modes = [Mode.SearchInProgressMode];
   keys = ['<C-right>'];
-  runsOnceForEveryCursor() {
+  override runsOnceForEveryCursor() {
     return false;
   }
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     const searchState = globalState.searchState;
     if (searchState === undefined) {
       // TODO: log warning, at least
@@ -293,11 +293,11 @@ class CommandInsertInCommandline extends BaseCommand {
     ['<End>'],
     ['<Del>'],
   ];
-  runsOnceForEveryCursor() {
+  override runsOnceForEveryCursor() {
     return this.keysPressed[0] === '\n';
   }
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     const key = this.keysPressed[0];
 
     // handle special keys first
@@ -390,13 +390,13 @@ class CommandInsertInSearchMode extends BaseCommand {
     ['<End>'],
     ['<Del>'],
   ];
-  isJump = true;
+  override isJump = true;
 
-  runsOnceForEveryCursor() {
+  override runsOnceForEveryCursor() {
     return this.keysPressed[0] === '\n';
   }
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     if (globalState.searchState === undefined) {
       // TODO: log warning, at least
       return;
@@ -523,11 +523,11 @@ class CommandInsertInSearchMode extends BaseCommand {
 class CommandEscInCommandline extends BaseCommand {
   modes = [Mode.CommandlineInProgress];
   keys = [['<Esc>'], ['<C-c>'], ['<C-[>']];
-  runsOnceForEveryCursor() {
+  override runsOnceForEveryCursor() {
     return this.keysPressed[0] === '\n';
   }
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     const key = this.keysPressed[0];
 
     await vimState.setCurrentMode(Mode.Normal);
@@ -540,11 +540,11 @@ class CommandEscInCommandline extends BaseCommand {
 class CommandEscInSearchMode extends BaseCommand {
   modes = [Mode.SearchInProgressMode];
   keys = [['<Esc>'], ['<C-c>'], ['<C-[>']];
-  runsOnceForEveryCursor() {
+  override runsOnceForEveryCursor() {
     return this.keysPressed[0] === '\n';
   }
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     const searchState = globalState.searchState;
     if (searchState === undefined) {
       // TODO: log warning, at least
@@ -576,9 +576,9 @@ class CommandEscInSearchMode extends BaseCommand {
 class CommandInsertRegisterContentInCommandLine extends BaseCommand {
   modes = [Mode.CommandlineInProgress];
   keys = ['<C-r>', '<character>'];
-  isCompleteAction = false;
+  override isCompleteAction = false;
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     if (!Register.isValidRegister(this.keysPressed[1])) {
       return;
     }
@@ -618,9 +618,9 @@ class CommandInsertRegisterContentInCommandLine extends BaseCommand {
 class CommandInsertRegisterContentInSearchMode extends BaseCommand {
   modes = [Mode.SearchInProgressMode];
   keys = ['<C-r>', '<character>'];
-  isCompleteAction = false;
+  override isCompleteAction = false;
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     if (globalState.searchState === undefined) {
       // TODO: log warning, at least
       return;
@@ -665,7 +665,7 @@ class CommandInsertWord extends BaseCommand {
   modes = [Mode.CommandlineInProgress, Mode.SearchInProgressMode];
   keys = ['<C-r>', '<C-w>'];
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     if (globalState.searchState === undefined) {
       // TODO: log warning, at least
       return;
@@ -689,7 +689,7 @@ class CommandInsertWord extends BaseCommand {
 class CommandNavigateInCommandlineOrSearchMode extends BaseCommand {
   modes = [Mode.CommandlineInProgress, Mode.SearchInProgressMode];
   keys = [['<left>'], ['<right>']];
-  runsOnceForEveryCursor() {
+  override runsOnceForEveryCursor() {
     return this.keysPressed[0] === '\n';
   }
 
@@ -702,7 +702,7 @@ class CommandNavigateInCommandlineOrSearchMode extends BaseCommand {
     return trimmedStatusBarText;
   }
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     const key = this.keysPressed[0];
     const statusBarText = this.getTrimmedStatusBarText();
     if (key === '<right>') {
@@ -722,11 +722,11 @@ class CommandNavigateInCommandlineOrSearchMode extends BaseCommand {
 class CommandPasteInCommandline extends BaseCommand {
   modes = [Mode.CommandlineInProgress];
   keys = [['<C-v>'], ['<D-v>']];
-  runsOnceForEveryCursor() {
+  override runsOnceForEveryCursor() {
     return false;
   }
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     const key = this.keysPressed[0];
     const pos = vimState.statusBarCursorCharacterPos;
     const cmdText = vimState.currentCommandlineText;
@@ -746,11 +746,11 @@ class CommandPasteInCommandline extends BaseCommand {
 class CommandPasteInSearchMode extends BaseCommand {
   modes = [Mode.SearchInProgressMode];
   keys = [['<C-v>'], ['<D-v>']];
-  runsOnceForEveryCursor() {
+  override runsOnceForEveryCursor() {
     return false;
   }
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     if (globalState.searchState === undefined) {
       // TODO: log warning, at least
       return;
@@ -771,11 +771,11 @@ class CommandPasteInSearchMode extends BaseCommand {
 class CommandCtrlLInSearchMode extends BaseCommand {
   modes = [Mode.SearchInProgressMode];
   keys = ['<C-l>'];
-  runsOnceForEveryCursor() {
+  override runsOnceForEveryCursor() {
     return false;
   }
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     if (globalState.searchState === undefined) {
       // TODO: log warning, at least
       return;

src/actions/commands/insert.ts

@@ -30,11 +30,11 @@ export class CommandEscInsertMode extends BaseCommand {
   modes = [Mode.Insert];
   keys = [['<Esc>'], ['<C-c>'], ['<C-[>']];
 
-  runsOnceForEveryCursor() {
+  override runsOnceForEveryCursor() {
     return false;
   }
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     vscode.commands.executeCommand('closeParameterHints');
 
     vimState.cursors = vimState.cursors.map((x) => x.withNewStop(x.stop.getLeft()));
@@ -115,11 +115,11 @@ export class CommandEscInsertMode extends BaseCommand {
 export class CommandInsertPreviousText extends BaseCommand {
   modes = [Mode.Insert];
   keys = ['<C-a>'];
-  runsOnceForEveryCursor() {
+  override runsOnceForEveryCursor() {
     return false;
   }
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     const register = await Register.get('.');
     if (
       register === undefined ||
@@ -154,7 +154,7 @@ class CommandInsertPreviousTextAndQuit extends BaseCommand {
   modes = [Mode.Insert];
   keys = ['<C-shift+2>']; // <C-@>
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     await new CommandInsertPreviousText().exec(position, vimState);
     await vimState.setCurrentMode(Mode.Normal);
   }
@@ -165,7 +165,7 @@ class IncreaseIndent extends BaseCommand {
   modes = [Mode.Insert];
   keys = ['<C-t>'];
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     const originalText = vimState.document.lineAt(position).text;
     const indentationWidth = TextEditor.getIndentationLevel(originalText);
     const tabSize = configuration.tabstop || Number(vimState.editor.options.tabSize);
@@ -187,7 +187,7 @@ class DecreaseIndent extends BaseCommand {
   modes = [Mode.Insert];
   keys = ['<C-d>'];
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     const originalText = vimState.document.lineAt(position).text;
     const indentationWidth = TextEditor.getIndentationLevel(originalText);
     const tabSize = configuration.tabstop || Number(vimState.editor.options.tabSize);
@@ -226,7 +226,7 @@ class CommandBackspaceInInsertMode extends BaseCommand {
   modes = [Mode.Insert];
   keys = [['<BS>'], ['<C-h>']];
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     const line = vimState.document.lineAt(position).text;
     const selection = vimState.editor.selections.find((s) => s.contains(position));
 
@@ -275,7 +275,7 @@ class CommandDeleteInInsertMode extends BaseCommand {
   modes = [Mode.Insert];
   keys = ['<Del>'];
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     const selection = vimState.editor.selection;
 
     if (!selection.isEmpty) {
@@ -299,7 +299,7 @@ export class CommandInsertInInsertMode extends BaseCommand {
   modes = [Mode.Insert];
   keys = ['<character>'];
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     const char = this.keysPressed[this.keysPressed.length - 1];
 
     vimState.recordedState.transformer.addTransformation({
@@ -309,7 +309,7 @@ export class CommandInsertInInsertMode extends BaseCommand {
     });
   }
 
-  public toString(): string {
+  public override toString(): string {
     return this.keysPressed[this.keysPressed.length - 1];
   }
 }
@@ -318,9 +318,9 @@ export class CommandInsertInInsertMode extends BaseCommand {
 class CommandInsertDigraph extends BaseCommand {
   modes = [Mode.Insert];
   keys = ['<C-k>', '<any>', '<any>'];
-  isCompleteAction = false;
+  override isCompleteAction = false;
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     const digraph = this.keysPressed.slice(1, 3).join('');
     const reverseDigraph = digraph.split('').reverse().join('');
     let charCodes = (DefaultDigraphs[digraph] ||
@@ -338,7 +338,7 @@ class CommandInsertDigraph extends BaseCommand {
     });
   }
 
-  public doesActionApply(vimState: VimState, keysPressed: string[]): boolean {
+  public override doesActionApply(vimState: VimState, keysPressed: string[]): boolean {
     if (!super.doesActionApply(vimState, keysPressed)) {
       return false;
     }
@@ -352,7 +352,7 @@ class CommandInsertDigraph extends BaseCommand {
     );
   }
 
-  public couldActionApply(vimState: VimState, keysPressed: string[]): boolean {
+  public override couldActionApply(vimState: VimState, keysPressed: string[]): boolean {
     if (!super.couldActionApply(vimState, keysPressed)) {
       return false;
     }
@@ -376,9 +376,9 @@ class CommandInsertDigraph extends BaseCommand {
 class CommandInsertRegisterContent extends BaseCommand {
   modes = [Mode.Insert];
   keys = ['<C-r>', '<character>'];
-  isCompleteAction = false;
+  override isCompleteAction = false;
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     if (!Register.isValidRegister(this.keysPressed[1])) {
       return;
     }
@@ -417,7 +417,7 @@ class CommandOneNormalCommandInInsertMode extends BaseCommand {
   modes = [Mode.Insert];
   keys = ['<C-o>'];
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     vimState.returnToInsertAfterCommand = true;
     vimState.actionCount = 0;
     await new CommandEscInsertMode().exec(position, vimState);
@@ -429,7 +429,7 @@ class CommandCtrlW extends BaseCommand {
   modes = [Mode.Insert];
   keys = ['<C-w>'];
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     if (position.isAtDocumentBegin()) {
       return;
     }
@@ -457,7 +457,7 @@ export class InsertCharAbove extends BaseCommand {
   modes = [Mode.Insert];
   keys = ['<C-y>'];
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     if (position.line === 0) {
       return;
     }
@@ -482,7 +482,7 @@ export class InsertCharBelow extends BaseCommand {
   modes = [Mode.Insert];
   keys = ['<C-e>'];
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     if (position.line >= vimState.document.lineCount - 1) {
       return;
     }
@@ -507,7 +507,7 @@ class CommandCtrlUInInsertMode extends BaseCommand {
   modes = [Mode.Insert];
   keys = ['<C-u>'];
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     let start: Position;
     if (position.character === 0) {
       start = position.getLeftThroughLineBreaks(true);
@@ -531,11 +531,11 @@ class CommandCtrlUInInsertMode extends BaseCommand {
 class CommandNavigateAutocompleteDown extends BaseCommand {
   modes = [Mode.Insert];
   keys = [['<C-n>'], ['<C-j>']];
-  runsOnceForEveryCursor() {
+  override runsOnceForEveryCursor() {
     return false;
   }
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     await vscode.commands.executeCommand('selectNextSuggestion');
   }
 }
@@ -544,11 +544,11 @@ class CommandNavigateAutocompleteDown extends BaseCommand {
 class CommandNavigateAutocompleteUp extends BaseCommand {
   modes = [Mode.Insert];
   keys = ['<C-p>'];
-  runsOnceForEveryCursor() {
+  override runsOnceForEveryCursor() {
     return false;
   }
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     await vscode.commands.executeCommand('selectPrevSuggestion');
   }
 }
@@ -558,7 +558,7 @@ class CommandCtrlVInInsertMode extends BaseCommand {
   modes = [Mode.Insert];
   keys = ['<C-v>'];
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     const clipboard = await Register.get('*', this.multicursorIndex);
     const text = clipboard?.text instanceof RecordedState ? undefined : clipboard?.text;
 
@@ -576,11 +576,11 @@ class CommandCtrlVInInsertMode extends BaseCommand {
 class CommandShowLineAutocomplete extends BaseCommand {
   modes = [Mode.Insert];
   keys = ['<C-x>', '<C-l>'];
-  runsOnceForEveryCursor() {
+  override runsOnceForEveryCursor() {
     return false;
   }
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     await lineCompletionProvider.showLineCompletionsQuickPick(position, vimState);
   }
 }
@@ -590,7 +590,7 @@ class NewLineInsertMode extends BaseCommand {
   modes = [Mode.Insert];
   keys = [['<C-j>'], ['<C-m>']];
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     vimState.recordedState.transformer.addTransformation({
       type: 'insertText',
       text: '\n',
@@ -605,7 +605,7 @@ class CommandReplaceAtCursorFromInsertMode extends BaseCommand {
   modes = [Mode.Insert];
   keys = ['<Insert>'];
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     await new CommandReplaceAtCursorFromNormalMode().exec(position, vimState);
   }
 }

src/actions/commands/put.ts

@@ -20,9 +20,9 @@ function firstNonBlankChar(text: string): number {
 
 abstract class BasePutCommand extends BaseCommand {
   modes = [Mode.Normal, Mode.Visual, Mode.VisualLine, Mode.VisualBlock];
-  canBeRepeatedWithDot = true;
+  override canBeRepeatedWithDot = true;
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     const register = await Register.get(vimState.recordedState.registerName, this.multicursorIndex);
     if (register === undefined) {
       StatusBar.displayError(vimState, VimError.fromCode(ErrorCode.NothingInRegister));
@@ -380,13 +380,13 @@ class PutCommand extends BasePutCommand {
 
 @RegisterAction
 class PutBeforeCommand extends PutCommand {
-  keys: string[] | string[][] = ['P'];
+  override keys: string[] | string[][] = ['P'];
 
-  protected putBefore(): boolean {
+  protected override putBefore(): boolean {
     return true;
   }
 
-  protected adjustLinewiseRegisterText(mode: Mode, text: string): string {
+  protected override adjustLinewiseRegisterText(mode: Mode, text: string): string {
     if (mode === Mode.Normal || mode === Mode.VisualBlock) {
       return text + '\n';
     }
@@ -394,7 +394,11 @@ class PutBeforeCommand extends PutCommand {
     return super.adjustLinewiseRegisterText(mode, text);
   }
 
-  protected getReplaceRange(mode: Mode, cursor: Cursor, registerMode: RegisterMode): vscode.Range {
+  protected override getReplaceRange(
+    mode: Mode,
+    cursor: Cursor,
+    registerMode: RegisterMode
+  ): vscode.Range {
     if (mode === Mode.Normal) {
       if (registerMode === RegisterMode.CharacterWise || registerMode === RegisterMode.BlockWise) {
         const pos = cursor.stop;
@@ -408,7 +412,7 @@ class PutBeforeCommand extends PutCommand {
     return super.getReplaceRange(mode, cursor, registerMode);
   }
 
-  protected getCursorPosition(
+  protected override getCursorPosition(
     document: TextDocument,
     mode: Mode,
     replaceRange: vscode.Range,
@@ -429,7 +433,7 @@ class PutBeforeCommand extends PutCommand {
 
 function PlaceCursorAfterText<TBase extends new (...args: any[]) => PutCommand>(Base: TBase) {
   return class CursorAfterText extends Base {
-    protected getCursorPosition(
+    protected override getCursorPosition(
       document: TextDocument,
       mode: Mode,
       replaceRange: vscode.Range,
@@ -492,18 +496,18 @@ function PlaceCursorAfterText<TBase extends new (...args: any[]) => PutCommand>(
 @RegisterAction
 @PlaceCursorAfterText
 class GPutCommand extends PutCommand {
-  keys = ['g', 'p'];
+  override keys = ['g', 'p'];
 }
 
 @RegisterAction
 @PlaceCursorAfterText
 class GPutBeforeCommand extends PutBeforeCommand {
-  keys = ['g', 'P'];
+  override keys = ['g', 'P'];
 }
 
 function AdjustIndent<TBase extends new (...args: any[]) => PutCommand>(Base: TBase) {
   return class AdjustedIndent extends Base {
-    protected shouldAdjustIndent(mode: Mode, registerMode: RegisterMode): boolean {
+    protected override shouldAdjustIndent(mode: Mode, registerMode: RegisterMode): boolean {
       return (
         (mode === Mode.Normal || mode === Mode.VisualLine) && registerMode === RegisterMode.LineWise
       );
@@ -514,13 +518,13 @@ function AdjustIndent<TBase extends new (...args: any[]) => PutCommand>(Base: TB
 @RegisterAction
 @AdjustIndent
 class PutWithIndentCommand extends PutCommand {
-  keys = [']', 'p'];
+  override keys = [']', 'p'];
 }
 
 @RegisterAction
 @AdjustIndent
 class PutBeforeWithIndentCommand extends PutBeforeCommand {
-  keys = [
+  override keys = [
     ['[', 'P'],
     [']', 'P'],
     ['[', 'p'],
@@ -535,11 +539,11 @@ function ExCommand<TBase extends new (...args: any[]) => PutCommand>(Base: TBase
       this.insertLine = insertLine;
     }
 
-    protected getRegisterMode(register: IRegisterContent): RegisterMode {
+    protected override getRegisterMode(register: IRegisterContent): RegisterMode {
       return RegisterMode.LineWise;
     }
 
-    protected getReplaceRange(
+    protected override getReplaceRange(
       mode: Mode,
       cursor: Cursor,
       registerMode: RegisterMode
@@ -549,7 +553,7 @@ function ExCommand<TBase extends new (...args: any[]) => PutCommand>(Base: TBase
       return new vscode.Range(pos, pos);
     }
 
-    protected getCursorPosition(
+    protected override getCursorPosition(
       document: TextDocument,
       mode: Mode,
       replaceRange: vscode.Range,

src/actions/commands/replace.ts

@@ -10,7 +10,7 @@ class ExitReplaceMode extends BaseCommand {
   modes = [Mode.Replace];
   keys = [['<Esc>'], ['<C-c>'], ['<C-[>']];
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     const replaceState = vimState.replaceState!;
 
     // `3Rabc` results in 'abc' replacing the next characters 2 more times
@@ -34,7 +34,7 @@ class ReplaceModeToInsertMode extends BaseCommand {
   modes = [Mode.Replace];
   keys = ['<Insert>'];
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     await vimState.setCurrentMode(Mode.Insert);
   }
 }
@@ -44,7 +44,7 @@ class BackspaceInReplaceMode extends BaseCommand {
   modes = [Mode.Replace];
   keys = [['<BS>'], ['<S-BS>'], ['<C-BS>'], ['<C-h>']];
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     const replaceState = vimState.replaceState!;
     if (position.isBeforeOrEqual(replaceState.replaceCursorStartPosition)) {
       // If you backspace before the beginning of where you started to replace, just move the cursor back.
@@ -84,9 +84,9 @@ class BackspaceInReplaceMode extends BaseCommand {
 class ReplaceInReplaceMode extends BaseCommand {
   modes = [Mode.Replace];
   keys = ['<character>'];
-  canBeRepeatedWithDot = true;
+  override canBeRepeatedWithDot = true;
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     const char = this.keysPressed[0];
     const replaceState = vimState.replaceState!;
 

src/actions/commands/search.ts

@@ -139,11 +139,11 @@ async function createSearchStateAndMoveToMatch(args: {
 class CommandSearchCurrentWordExactForward extends BaseCommand {
   modes = [Mode.Normal];
   keys = ['*'];
-  isMotion = true;
-  runsOnceForEachCountPrefix = true;
-  isJump = true;
+  override isMotion = true;
+  override runsOnceForEachCountPrefix = true;
+  override isJump = true;
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     await searchCurrentWord(position, vimState, SearchDirection.Forward, true);
   }
 }
@@ -152,11 +152,11 @@ class CommandSearchCurrentWordExactForward extends BaseCommand {
 class CommandSearchCurrentWordForward extends BaseCommand {
   modes = [Mode.Normal, Mode.Visual, Mode.VisualLine];
   keys = ['g', '*'];
-  isMotion = true;
-  runsOnceForEachCountPrefix = true;
-  isJump = true;
+  override isMotion = true;
+  override runsOnceForEachCountPrefix = true;
+  override isJump = true;
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     await searchCurrentWord(position, vimState, SearchDirection.Forward, false);
   }
 }
@@ -165,11 +165,11 @@ class CommandSearchCurrentWordForward extends BaseCommand {
 class CommandSearchVisualForward extends BaseCommand {
   modes = [Mode.Visual, Mode.VisualLine];
   keys = ['*'];
-  isMotion = true;
-  runsOnceForEachCountPrefix = true;
-  isJump = true;
+  override isMotion = true;
+  override runsOnceForEachCountPrefix = true;
+  override isJump = true;
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     if (configuration.visualstar) {
       await searchCurrentSelection(vimState, SearchDirection.Forward);
     } else {
@@ -182,11 +182,11 @@ class CommandSearchVisualForward extends BaseCommand {
 class CommandSearchCurrentWordExactBackward extends BaseCommand {
   modes = [Mode.Normal];
   keys = ['#'];
-  isMotion = true;
-  runsOnceForEachCountPrefix = true;
-  isJump = true;
+  override isMotion = true;
+  override runsOnceForEachCountPrefix = true;
+  override isJump = true;
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     await searchCurrentWord(position, vimState, SearchDirection.Backward, true);
   }
 }
@@ -195,11 +195,11 @@ class CommandSearchCurrentWordExactBackward extends BaseCommand {
 class CommandSearchCurrentWordBackward extends BaseCommand {
   modes = [Mode.Normal, Mode.Visual, Mode.VisualLine];
   keys = ['g', '#'];
-  isMotion = true;
-  runsOnceForEachCountPrefix = true;
-  isJump = true;
+  override isMotion = true;
+  override runsOnceForEachCountPrefix = true;
+  override isJump = true;
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     await searchCurrentWord(position, vimState, SearchDirection.Backward, false);
   }
 }
@@ -208,11 +208,11 @@ class CommandSearchCurrentWordBackward extends BaseCommand {
 class CommandSearchVisualBackward extends BaseCommand {
   modes = [Mode.Visual, Mode.VisualLine];
   keys = ['#'];
-  isMotion = true;
-  runsOnceForEachCountPrefix = true;
-  isJump = true;
+  override isMotion = true;
+  override runsOnceForEachCountPrefix = true;
+  override isJump = true;
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     if (configuration.visualstar) {
       await searchCurrentSelection(vimState, SearchDirection.Backward);
     } else {
@@ -225,13 +225,13 @@ class CommandSearchVisualBackward extends BaseCommand {
 class CommandSearchForwards extends BaseCommand {
   modes = [Mode.Normal, Mode.Visual, Mode.VisualLine, Mode.VisualBlock];
   keys = ['/'];
-  isMotion = true;
-  isJump = true;
-  runsOnceForEveryCursor() {
+  override isMotion = true;
+  override isJump = true;
+  override runsOnceForEveryCursor() {
     return false;
   }
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     globalState.searchState = new SearchState(
       SearchDirection.Forward,
       vimState.cursorStopPosition,
@@ -250,13 +250,13 @@ class CommandSearchForwards extends BaseCommand {
 class CommandSearchBackwards extends BaseCommand {
   modes = [Mode.Normal, Mode.Visual, Mode.VisualLine, Mode.VisualBlock];
   keys = ['?'];
-  isMotion = true;
-  isJump = true;
-  runsOnceForEveryCursor() {
+  override isMotion = true;
+  override isJump = true;
+  override runsOnceForEveryCursor() {
     return false;
   }
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     globalState.searchState = new SearchState(
       SearchDirection.Backward,
       vimState.cursorStopPosition,
@@ -335,7 +335,7 @@ class CommandSelectNextLastSearchWord extends BaseCommand {
   modes = [Mode.Normal, Mode.Visual, Mode.VisualBlock];
   keys = ['g', 'n'];
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     await selectLastSearchWord(vimState, SearchDirection.Forward);
   }
 }
@@ -345,7 +345,7 @@ class CommandSelectPreviousLastSearchWord extends BaseCommand {
   modes = [Mode.Normal, Mode.Visual, Mode.VisualBlock];
   keys = ['g', 'N'];
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     await selectLastSearchWord(vimState, SearchDirection.Backward);
   }
 }

src/actions/languages/python/motion.ts

@@ -188,13 +188,16 @@ abstract class BasePythonMovement extends BaseMovement {
   abstract direction: Direction;
   abstract edge: Edge;
 
-  public doesActionApply(vimState: VimState, keysPressed: string[]): boolean {
+  public override doesActionApply(vimState: VimState, keysPressed: string[]): boolean {
     return (
       super.doesActionApply(vimState, keysPressed) && vimState.document.languageId === 'python'
     );
   }
 
-  public async execAction(position: Position, vimState: VimState): Promise<Position | IMovement> {
+  public override async execAction(
+    position: Position,
+    vimState: VimState
+  ): Promise<Position | IMovement> {
     const document = vimState.document;
     return (
       new PythonDocument(document).find(this.type, this.direction, this.edge, position) ??

src/actions/operator.ts

@@ -13,15 +13,15 @@ import { commandLine } from './../cmd_line/commandLine';
 import { Position } from 'vscode';
 
 export abstract class BaseOperator extends BaseAction {
-  isOperator = true;
+  override isOperator = true;
 
   constructor(multicursorIndex?: number) {
     super();
     this.multicursorIndex = multicursorIndex;
   }
-  canBeRepeatedWithDot = true;
+  override canBeRepeatedWithDot = true;
 
-  public doesActionApply(vimState: VimState, keysPressed: string[]): boolean {
+  public override doesActionApply(vimState: VimState, keysPressed: string[]): boolean {
     if (this.doesRepeatedOperatorApply(vimState, keysPressed)) {
       return true;
     }
@@ -44,7 +44,7 @@ export abstract class BaseOperator extends BaseAction {
     return true;
   }
 
-  public couldActionApply(vimState: VimState, keysPressed: string[]): boolean {
+  public override couldActionApply(vimState: VimState, keysPressed: string[]): boolean {
     if (!this.modes.includes(vimState.currentMode)) {
       return false;
     }
@@ -243,7 +243,7 @@ class DeleteOperatorVisual extends BaseOperator {
 export class YankOperator extends BaseOperator {
   public keys = ['y'];
   public modes = [Mode.Normal, Mode.Visual, Mode.VisualLine];
-  canBeRepeatedWithDot = false;
+  override canBeRepeatedWithDot = false;
 
   public async run(vimState: VimState, start: Position, end: Position): Promise<void> {
     [start, end] = sorted(start, end);
@@ -343,7 +343,7 @@ class ChangeOperatorSVisual extends BaseOperator {
   public modes = [Mode.Visual, Mode.VisualLine];
 
   // Don't clash with Sneak plugin
-  public doesActionApply(vimState: VimState, keysPressed: string[]): boolean {
+  public override doesActionApply(vimState: VimState, keysPressed: string[]): boolean {
     return super.doesActionApply(vimState, keysPressed) && !configuration.sneak;
   }
 
@@ -429,8 +429,8 @@ class UpperCaseOperator extends ChangeCaseOperator {
 
 @RegisterAction
 class UpperCaseWithMotion extends UpperCaseOperator {
-  public keys = [['g', 'U']];
-  public modes = [Mode.Normal];
+  public override keys = [['g', 'U']];
+  public override modes = [Mode.Normal];
 }
 
 @RegisterAction
@@ -444,8 +444,8 @@ class LowerCaseOperator extends ChangeCaseOperator {
 
 @RegisterAction
 class LowerCaseWithMotion extends LowerCaseOperator {
-  public keys = [['g', 'u']];
-  public modes = [Mode.Normal];
+  public override keys = [['g', 'u']];
+  public override modes = [Mode.Normal];
 }
 
 @RegisterAction
@@ -467,8 +467,8 @@ class ToggleCaseOperator extends ChangeCaseOperator {
 
 @RegisterAction
 class ToggleCaseWithMotion extends ToggleCaseOperator {
-  public keys = [['g', '~']];
-  public modes = [Mode.Normal];
+  public override keys = [['g', '~']];
+  public override modes = [Mode.Normal];
 }
 
 @RegisterAction
@@ -616,7 +616,11 @@ export class ChangeOperator extends BaseOperator {
     }
   }
 
-  public async runRepeat(vimState: VimState, position: Position, count: number): Promise<void> {
+  public override async runRepeat(
+    vimState: VimState,
+    position: Position,
+    count: number
+  ): Promise<void> {
     const thisLineIndent = vimState.document.getText(
       new vscode.Range(
         position.getLineBegin(),
@@ -655,7 +659,7 @@ export class ChangeOperator extends BaseOperator {
 class YankVisualBlockMode extends BaseOperator {
   public keys = ['y'];
   public modes = [Mode.VisualBlock];
-  canBeRepeatedWithDot = false;
+  override canBeRepeatedWithDot = false;
   runsOnceForEveryCursor() {
     return false;
   }

src/actions/plugins/camelCaseMotion.ts

@@ -9,21 +9,21 @@ import { WordType } from '../../textobject/word';
 import { Position } from 'vscode';
 
 abstract class CamelCaseBaseMovement extends BaseMovement {
-  public doesActionApply(vimState: VimState, keysPressed: string[]) {
+  public override doesActionApply(vimState: VimState, keysPressed: string[]) {
     return configuration.camelCaseMotion.enable && super.doesActionApply(vimState, keysPressed);
   }
 
-  public couldActionApply(vimState: VimState, keysPressed: string[]) {
+  public override couldActionApply(vimState: VimState, keysPressed: string[]) {
     return configuration.camelCaseMotion.enable && super.couldActionApply(vimState, keysPressed);
   }
 }
 
 abstract class CamelCaseTextObjectMovement extends TextObjectMovement {
-  public doesActionApply(vimState: VimState, keysPressed: string[]) {
+  public override doesActionApply(vimState: VimState, keysPressed: string[]) {
     return configuration.camelCaseMotion.enable && super.doesActionApply(vimState, keysPressed);
   }
 
-  public couldActionApply(vimState: VimState, keysPressed: string[]) {
+  public override couldActionApply(vimState: VimState, keysPressed: string[]) {
     return configuration.camelCaseMotion.enable && super.couldActionApply(vimState, keysPressed);
   }
 }
@@ -33,7 +33,7 @@ abstract class CamelCaseTextObjectMovement extends TextObjectMovement {
 class MoveCamelCaseWordBegin extends CamelCaseBaseMovement {
   keys = ['<leader>', 'w'];
 
-  public async execAction(position: Position, vimState: VimState): Promise<Position> {
+  public override async execAction(position: Position, vimState: VimState): Promise<Position> {
     if (
       !configuration.changeWordIncludesWhitespace &&
       vimState.recordedState.operator instanceof ChangeOperator
@@ -53,11 +53,14 @@ class MoveCamelCaseWordBegin extends CamelCaseBaseMovement {
 class MoveCamelCaseWordEnd extends CamelCaseBaseMovement {
   keys = ['<leader>', 'e'];
 
-  public async execAction(position: Position, vimState: VimState): Promise<Position> {
+  public override async execAction(position: Position, vimState: VimState): Promise<Position> {
     return position.nextWordEnd(vimState.document, { wordType: WordType.CamelCase });
   }
 
-  public async execActionForOperator(position: Position, vimState: VimState): Promise<Position> {
+  public override async execActionForOperator(
+    position: Position,
+    vimState: VimState
+  ): Promise<Position> {
     const end = position.nextWordEnd(vimState.document, { wordType: WordType.CamelCase });
 
     return new Position(end.line, end.character + 1);
@@ -69,7 +72,7 @@ class MoveCamelCaseWordEnd extends CamelCaseBaseMovement {
 class MoveBeginningCamelCaseWord extends CamelCaseBaseMovement {
   keys = ['<leader>', 'b'];
 
-  public async execAction(position: Position, vimState: VimState): Promise<Position> {
+  public override async execAction(position: Position, vimState: VimState): Promise<Position> {
     return position.prevWordStart(vimState.document, { wordType: WordType.CamelCase });
   }
 }
@@ -77,7 +80,7 @@ class MoveBeginningCamelCaseWord extends CamelCaseBaseMovement {
 // based off of `SelectInnerWord`
 @RegisterAction
 class SelectInnerCamelCaseWord extends CamelCaseTextObjectMovement {
-  modes = [Mode.Normal, Mode.Visual];
+  override modes = [Mode.Normal, Mode.Visual];
   keys = ['i', '<leader>', 'w'];
 
   public async execAction(position: Position, vimState: VimState): Promise<IMovement> {

src/actions/plugins/easymotion/easymotion.cmd.ts

@@ -71,7 +71,7 @@ abstract class BaseEasyMotionCommand extends BaseCommand {
     }
   }
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     // Only execute the action if the configuration is set
     if (configuration.easymotion) {
       // Search all occurences of the character pressed
@@ -232,7 +232,7 @@ export abstract class EasyMotionCharMoveCommandBase extends BaseCommand {
     this._action = action;
   }
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     // Only execute the action if easymotion is enabled
     if (configuration.easymotion) {
       vimState.easyMotion = new EasyMotion();
@@ -322,7 +322,7 @@ class EasyMotionCharInputMode extends BaseCommand {
   modes = [Mode.EasyMotionInputMode];
   keys = ['<character>'];
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     const key = this.keysPressed[0];
     const action = vimState.easyMotion.searchAction;
     action.searchString =
@@ -342,7 +342,7 @@ class CommandEscEasyMotionCharInputMode extends BaseCommand {
   modes = [Mode.EasyMotionInputMode];
   keys = ['<Esc>'];
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     await vimState.setCurrentMode(Mode.Normal);
   }
 }
@@ -351,9 +351,9 @@ class CommandEscEasyMotionCharInputMode extends BaseCommand {
 class MoveEasyMotion extends BaseCommand {
   modes = [Mode.EasyMotionMode];
   keys = ['<character>'];
-  isJump = true;
+  override isJump = true;
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     const key = this.keysPressed[0];
     if (key) {
       // "nail" refers to the accumulated depth keys

src/actions/plugins/replaceWithRegister.ts

@@ -14,11 +14,11 @@ class ReplaceOperator extends BaseOperator {
   public keys = ['g', 'r'];
   public modes = [Mode.Normal, Mode.Visual, Mode.VisualLine];
 
-  public doesActionApply(vimState: VimState, keysPressed: string[]): boolean {
+  public override doesActionApply(vimState: VimState, keysPressed: string[]): boolean {
     return configuration.replaceWithRegister && super.doesActionApply(vimState, keysPressed);
   }
 
-  public couldActionApply(vimState: VimState, keysPressed: string[]): boolean {
+  public override couldActionApply(vimState: VimState, keysPressed: string[]): boolean {
     return configuration.replaceWithRegister && super.doesActionApply(vimState, keysPressed);
   }
 

src/actions/plugins/sneak.ts

@@ -10,9 +10,9 @@ export class SneakForward extends BaseMovement {
     ['s', '<character>', '<character>'],
     ['z', '<character>', '<character>'],
   ];
-  isJump = true;
+  override isJump = true;
 
-  public couldActionApply(vimState: VimState, keysPressed: string[]): boolean {
+  public override couldActionApply(vimState: VimState, keysPressed: string[]): boolean {
     const startingLetter = vimState.recordedState.operator === undefined ? 's' : 'z';
 
     return (
@@ -22,7 +22,10 @@ export class SneakForward extends BaseMovement {
     );
   }
 
-  public async execAction(position: Position, vimState: VimState): Promise<Position | IMovement> {
+  public override async execAction(
+    position: Position,
+    vimState: VimState
+  ): Promise<Position | IMovement> {
     if (!this.isRepeat) {
       vimState.lastSemicolonRepeatableMovement = new SneakForward(this.keysPressed, true);
       vimState.lastCommaRepeatableMovement = new SneakBackward(this.keysPressed, true);
@@ -74,9 +77,9 @@ export class SneakBackward extends BaseMovement {
     ['S', '<character>', '<character>'],
     ['Z', '<character>', '<character>'],
   ];
-  isJump = true;
+  override isJump = true;
 
-  public couldActionApply(vimState: VimState, keysPressed: string[]): boolean {
+  public override couldActionApply(vimState: VimState, keysPressed: string[]): boolean {
     const startingLetter = vimState.recordedState.operator === undefined ? 'S' : 'Z';
 
     return (
@@ -86,7 +89,10 @@ export class SneakBackward extends BaseMovement {
     );
   }
 
-  public async execAction(position: Position, vimState: VimState): Promise<Position | IMovement> {
+  public override async execAction(
+    position: Position,
+    vimState: VimState
+  ): Promise<Position | IMovement> {
     if (!this.isRepeat) {
       vimState.lastSemicolonRepeatableMovement = new SneakBackward(this.keysPressed, true);
       vimState.lastCommaRepeatableMovement = new SneakForward(this.keysPressed, true);

src/actions/plugins/surround.ts

@@ -66,7 +66,7 @@ export interface SurroundState {
 }
 
 abstract class SurroundOperator extends BaseOperator {
-  public doesActionApply(vimState: VimState, keysPressed: string[]): boolean {
+  public override doesActionApply(vimState: VimState, keysPressed: string[]): boolean {
     return configuration.surround && super.doesActionApply(vimState, keysPressed);
   }
 }
@@ -120,7 +120,11 @@ class YankSurroundOperator extends SurroundOperator {
     }
   }
 
-  public async runRepeat(vimState: VimState, position: Position, count: number): Promise<void> {
+  public override async runRepeat(
+    vimState: VimState,
+    position: Position,
+    count: number
+  ): Promise<void> {
     // we want to act on range: first non whitespace to last non whitespace
     await this.run(
       vimState,
@@ -181,11 +185,11 @@ class CommandSurroundModeStartVisualLine extends SurroundOperator {
 
 abstract class CommandSurround extends BaseCommand {
   modes = [Mode.Normal];
-  canBeRepeatedWithDot = true;
-  runsOnceForEveryCursor() {
+  override canBeRepeatedWithDot = true;
+  override runsOnceForEveryCursor() {
     return true;
   }
-  public doesActionApply(vimState: VimState, keysPressed: string[]): boolean {
+  public override doesActionApply(vimState: VimState, keysPressed: string[]): boolean {
     const target = keysPressed[keysPressed.length - 1];
     return (
       configuration.surround &&
@@ -200,7 +204,7 @@ class CommandSurroundDeleteSurround extends CommandSurround {
   keys = ['<plugds>', '<any>'];
   keysHasCnt = false;
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     const target = this.keysPressed[this.keysPressed.length - 1];
     // for derived class, support ds2X
     if (this.keysHasCnt) {
@@ -234,17 +238,17 @@ class CommandSurroundDeleteSurround extends CommandSurround {
 @RegisterAction
 class CommandSurroundDeleteSurroundCnt extends CommandSurroundDeleteSurround {
   // supports cnt up to 9, should be enough
-  keys = ['<plugds>', '<number>', '<any>'];
-  keysHasCnt = true;
+  override keys = ['<plugds>', '<number>', '<any>'];
+  override keysHasCnt = true;
 }
 
 @RegisterAction
 class CommandSurroundChangeSurround extends CommandSurround {
   keys = ['<plugcs>', '<any>'];
-  isCompleteAction = false;
+  override isCompleteAction = false;
   keysHasCnt = false;
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     const target = this.keysPressed[this.keysPressed.length - 1];
     // for derived class, support ds2X
     if (this.keysHasCnt) {
@@ -281,8 +285,8 @@ class CommandSurroundChangeSurround extends CommandSurround {
 @RegisterAction
 class CommandSurroundChangeSurroundCnt extends CommandSurroundChangeSurround {
   // supports cnt up to 9, should be enough
-  keys = ['<plugcs>', '<number>', '<any>'];
-  keysHasCnt = true;
+  override keys = ['<plugcs>', '<number>', '<any>'];
+  override keysHasCnt = true;
 }
 
 @RegisterAction
@@ -290,11 +294,11 @@ class CommandSurroundAddSurrounding extends BaseCommand {
   modes = [Mode.SurroundInputMode];
   // add surrounding / read X when: ys + motion + X. or csYX
   keys = ['<any>'];
-  isCompleteAction = true;
-  runsOnceForEveryCursor() {
+  override isCompleteAction = true;
+  override runsOnceForEveryCursor() {
     return false;
   }
-  public doesActionApply(vimState: VimState, keysPressed: string[]): boolean {
+  public override doesActionApply(vimState: VimState, keysPressed: string[]): boolean {
     const replacement = keysPressed[keysPressed.length - 1];
     return (
       configuration.surround &&
@@ -304,7 +308,7 @@ class CommandSurroundAddSurrounding extends BaseCommand {
     );
   }
 
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     const replacement = this.keysPressed[this.keysPressed.length - 1];
 
     if (!vimState.surround || !SurroundHelper.edgePairings[replacement]) {
@@ -326,12 +330,12 @@ export class CommandSurroundAddSurroundingTag extends BaseCommand {
   modes = [Mode.SurroundInputMode];
   // add surrounding / read X when: ys + motion + X
   keys = [['<'], ['t']];
-  isCompleteAction = true;
+  override isCompleteAction = true;
   recordedTag = ''; // to save for repeat
-  runsOnceForEveryCursor() {
+  override runsOnceForEveryCursor() {
     return false;
   }
-  public async exec(position: Position, vimState: VimState): Promise<void> {
+  public override async exec(position: Position, vimState: VimState): Promise<void> {
     if (!vimState.surround) {
       return;
     }

src/cmd_line/commands/bang.ts

@@ -16,7 +16,7 @@ export class BangCommand extends node.CommandBase {
     this._arguments = args;
   }
 
-  public neovimCapable(): boolean {
+  public override neovimCapable(): boolean {
     return true;
   }
 
@@ -36,7 +36,7 @@ export class BangCommand extends node.CommandBase {
     await externalCommand.run(this._arguments.command);
   }
 
-  async executeWithRange(vimState: VimState, range: node.LineRange): Promise<void> {
+  override async executeWithRange(vimState: VimState, range: node.LineRange): Promise<void> {
     const [startLine, endLine] = range.resolve(vimState);
     const start = new Position(startLine, 0);
     const end = new Position(endLine, 0).getLineEnd();

src/cmd_line/commands/deleteRange.ts

@@ -17,7 +17,7 @@ export class DeleteRangeCommand extends node.CommandBase {
     this.arguments = args;
   }
 
-  public neovimCapable(): boolean {
+  public override neovimCapable(): boolean {
     return true;
   }
 
@@ -61,7 +61,7 @@ export class DeleteRangeCommand extends node.CommandBase {
     this.deleteRange(line, line, vimState);
   }
 
-  async executeWithRange(vimState: VimState, range: node.LineRange): Promise<void> {
+  override async executeWithRange(vimState: VimState, range: node.LineRange): Promise<void> {
     const [start, end] = range.resolve(vimState);
     this.deleteRange(start, end, vimState);
   }

src/cmd_line/commands/goto.ts

@@ -31,7 +31,7 @@ export class GotoCommand extends node.CommandBase {
     this.gotoOffset(vimState, this.offset ?? 0);
   }
 
-  public async executeWithRange(vimState: VimState, range: node.LineRange): Promise<void> {
+  public override async executeWithRange(vimState: VimState, range: node.LineRange): Promise<void> {
     if (this.offset === undefined) {
       // TODO: this isn't perfect (% for instance), but does anyone care?
       this.offset = range.resolve(vimState, false)[1];

src/cmd_line/commands/put.ts

@@ -26,7 +26,7 @@ export class PutExCommand extends node.CommandBase {
     this.arguments = args;
   }
 
-  public neovimCapable(): boolean {
+  public override neovimCapable(): boolean {
     return true;
   }
 
@@ -48,7 +48,7 @@ export class PutExCommand extends node.CommandBase {
     await this.doPut(vimState, vimState.cursorStopPosition);
   }
 
-  async executeWithRange(vimState: VimState, range: node.LineRange): Promise<void> {
+  override async executeWithRange(vimState: VimState, range: node.LineRange): Promise<void> {
     const [_, end] = range.resolve(vimState);
     await this.doPut(vimState, new Position(end, 0).getLineEnd());
   }

src/cmd_line/commands/read.ts

@@ -22,7 +22,7 @@ export class ReadCommand extends node.CommandBase {
     this.arguments = args;
   }
 
-  public neovimCapable(): boolean {
+  public override neovimCapable(): boolean {
     return true;
   }
 

src/cmd_line/commands/sort.ts

@@ -19,7 +19,7 @@ export class SortCommand extends node.CommandBase {
     this.arguments = args;
   }
 
-  public neovimCapable(): boolean {
+  public override neovimCapable(): boolean {
     return true;
   }
 
@@ -78,7 +78,7 @@ export class SortCommand extends node.CommandBase {
     });
   }
 
-  async executeWithRange(vimState: VimState, range: node.LineRange): Promise<void> {
+  override async executeWithRange(vimState: VimState, range: node.LineRange): Promise<void> {
     const [start, end] = range.resolve(vimState);
 
     await this.sortLines(vimState, start, end);

src/cmd_line/commands/substitute.ts

@@ -91,7 +91,7 @@ export class SubstituteCommand extends node.CommandBase {
     this.abort = false;
   }
 
-  public neovimCapable(): boolean {
+  public override neovimCapable(): boolean {
     // We need to use VSCode's quickpick capabilities to do confirmation
     return (this.arguments.flags & SubstituteFlags.ConfirmEach) === 0;
   }
@@ -281,7 +281,7 @@ export class SubstituteCommand extends node.CommandBase {
     }
   }
 
-  async executeWithRange(vimState: VimState, range: node.LineRange): Promise<void> {
+  override async executeWithRange(vimState: VimState, range: node.LineRange): Promise<void> {
     let [startLine, endLine] = range.resolve(vimState);
 
     if (this.arguments.count && this.arguments.count >= 0) {

src/cmd_line/commands/yank.ts

@@ -37,7 +37,7 @@ export class YankCommand extends CommandBase {
     await this.yank(vimState, vimState.cursorStartPosition, vimState.cursorStopPosition);
   }
 
-  async executeWithRange(vimState: VimState, range: LineRange): Promise<void> {
+  override async executeWithRange(vimState: VimState, range: LineRange): Promise<void> {
     const [start, end] = range.resolve(vimState);
     await this.yank(vimState, new Position(start, 0), new Position(end, 0));
   }

src/cmd_line/subparser.ts

@@ -423,7 +423,7 @@ class UnimplementedCommand extends CommandBase {
   fullName: string;
   parserMapping: CommandParserMapping;
 
-  public neovimCapable(): boolean {
+  public override neovimCapable(): boolean {
     // If the user has neovim integration enabled, don't stop them from using these commands
     return true;
   }

src/error.ts

@@ -60,7 +60,7 @@ export const ErrorMessage: IErrorMessage = {
 
 export class VimError extends Error {
   public readonly code: number;
-  public readonly message: string;
+  public override readonly message: string;
 
   private constructor(code: number, message: string) {
     super();
@@ -76,7 +76,7 @@ export class VimError extends Error {
     throw new Error('unknown error code: ' + code);
   }
 
-  toString(): string {
+  override toString(): string {
     return `E${this.code}: ${this.message}`;
   }
 }

src/platform/node/loggerImpl.ts

@@ -24,7 +24,7 @@ class VsCodeMessage extends TransportStream {
     this.prefix = options.prefix;
   }
 
-  public async log(info: { level: string; message: string }, callback: () => void) {
+  public override async log(info: { level: string; message: string }, callback: () => void) {
     if (this.configuration && this.configuration.debug.silent) {
       return;
     }

src/textobject/textobject.ts

@@ -22,9 +22,12 @@ import { Position, TextDocument } from 'vscode';
 import { WordType } from './word';
 
 export abstract class TextObjectMovement extends BaseMovement {
-  modes = [Mode.Normal, Mode.Visual, Mode.VisualBlock];
+  override modes = [Mode.Normal, Mode.Visual, Mode.VisualBlock];
 
-  public async execActionForOperator(position: Position, vimState: VimState): Promise<IMovement> {
+  public override async execActionForOperator(
+    position: Position,
+    vimState: VimState
+  ): Promise<IMovement> {
     const res = await this.execAction(position, vimState);
     // Since we need to handle leading spaces, we cannot use MoveWordBegin.execActionForOperator
     // In normal mode, the character on the stop position will be the first character after the operator executed
@@ -34,7 +37,7 @@ export abstract class TextObjectMovement extends BaseMovement {
     return res;
   }
 
-  public abstract execAction(position: Position, vimState: VimState): Promise<IMovement>;
+  public abstract override execAction(position: Position, vimState: VimState): Promise<IMovement>;
 }
 
 @RegisterAction
@@ -175,9 +178,9 @@ export class SelectABigWord extends TextObjectMovement {
 @RegisterAction
 export class SelectAnExpandingBlock extends ExpandingSelection {
   keys = ['a', 'f'];
-  modes = [Mode.Visual, Mode.VisualLine];
+  override modes = [Mode.Visual, Mode.VisualLine];
 
-  public async execAction(position: Position, vimState: VimState): Promise<IMovement> {
+  public override async execAction(position: Position, vimState: VimState): Promise<IMovement> {
     const blocks = [
       new MoveAroundDoubleQuotes(),
       new MoveAroundSingleQuotes(),
@@ -269,7 +272,7 @@ export class SelectAnExpandingBlock extends ExpandingSelection {
 
 @RegisterAction
 export class SelectInnerWord extends TextObjectMovement {
-  modes = [Mode.Normal, Mode.Visual];
+  override modes = [Mode.Normal, Mode.Visual];
   keys = ['i', 'w'];
 
   public async execAction(position: Position, vimState: VimState): Promise<IMovement> {
@@ -310,7 +313,7 @@ export class SelectInnerWord extends TextObjectMovement {
 
 @RegisterAction
 export class SelectInnerBigWord extends TextObjectMovement {
-  modes = [Mode.Normal, Mode.Visual];
+  override modes = [Mode.Normal, Mode.Visual];
   keys = ['i', 'W'];
 
   public async execAction(position: Position, vimState: VimState): Promise<IMovement> {
@@ -574,7 +577,7 @@ export class SelectEntireIgnoringLeadingTrailing extends TextObjectMovement {
 }
 
 abstract class IndentObjectMatch extends TextObjectMovement {
-  setsDesiredColumnToEOL = true;
+  override setsDesiredColumnToEOL = true;
 
   protected includeLineAbove = false;
   protected includeLineBelow = false;
@@ -638,7 +641,10 @@ abstract class IndentObjectMatch extends TextObjectMovement {
     };
   }
 
-  public async execActionForOperator(position: Position, vimState: VimState): Promise<IMovement> {
+  public override async execActionForOperator(
+    position: Position,
+    vimState: VimState
+  ): Promise<IMovement> {
     return this.execAction(position, vimState);
   }
 
@@ -689,18 +695,18 @@ class InsideIndentObject extends IndentObjectMatch {
 @RegisterAction
 class InsideIndentObjectAbove extends IndentObjectMatch {
   keys = ['a', 'i'];
-  includeLineAbove = true;
+  override includeLineAbove = true;
 }
 
 @RegisterAction
 class InsideIndentObjectBoth extends IndentObjectMatch {
   keys = ['a', 'I'];
-  includeLineAbove = true;
-  includeLineBelow = true;
+  override includeLineAbove = true;
+  override includeLineBelow = true;
 }
 
 abstract class SelectArgument extends TextObjectMovement {
-  modes = [Mode.Normal, Mode.Visual];
+  override modes = [Mode.Normal, Mode.Visual];
 
   private static openingDelimiterCharacters(): string[] {
     return configuration.argumentObjectOpeningDelimiters;
@@ -955,13 +961,13 @@ abstract class SelectArgument extends TextObjectMovement {
 
 @RegisterAction
 export class SelectInnerArgument extends SelectArgument {
-  modes = [Mode.Normal, Mode.Visual];
+  override modes = [Mode.Normal, Mode.Visual];
   keys = ['i', 'a'];
 }
 
 @RegisterAction
 export class SelectAroundArgument extends SelectArgument {
-  modes = [Mode.Normal, Mode.Visual];
+  override modes = [Mode.Normal, Mode.Visual];
   keys = ['a', 'a'];
-  selectAround = true;
+  override selectAround = true;
 }

test/configuration/remapper.test.ts

@@ -77,7 +77,7 @@ suite('Remapper', () => {
       super('configKey', [Mode.Insert]);
     }
 
-    public findMatchingRemap(
+    public override findMatchingRemap(
       userDefinedRemappings: Map<string, IKeyRemapping>,
       inputtedKeys: string[],
       currentMode: Mode

tsconfig.json

@@ -4,6 +4,7 @@
     "module": "commonjs",
     "target": "ES2019",
     "outDir": "out",
+    "noImplicitOverride": true,
     "noImplicitReturns": true,
     "noUnusedLocals": false,
     "noUnusedParameters": false,