Fixes #2217. Support langmap (#8541)

Author: Opisek

package.json

@@ -1149,6 +1149,10 @@
           "type": "string",
           "description": "Path to the shell to use for `!` and `:!` commands.",
           "default": ""
+        },
+        "vim.langmap": {
+          "type": "string",
+          "description": "Language map for alternate keyboard layouts. When you are typing text in Insert (or Replace, etc.) mode, the characters are inserted derectly. Otherwise, they are translated based on the provided map."
         }
       }
     },

src/actions/base.ts

@@ -6,6 +6,7 @@ import { isTextTransformation } from '../transformations/transformations';
 import { configuration } from './../configuration/configuration';
 import { Mode } from './../mode/mode';
 import { VimState } from './../state/vimState';
+import { isLiteralMode, unmapLiteral } from '../configuration/langmap';
 
 export abstract class BaseAction implements IBaseAction {
   abstract readonly actionType: ActionType;
@@ -41,7 +42,7 @@ export abstract class BaseAction implements IBaseAction {
   /**
    * The sequence of keys you use to trigger the action, or a list of such sequences.
    */
-  public abstract readonly keys: readonly string[] | readonly string[][];
+  public abstract keys: readonly string[] | readonly string[][];
 
   /**
    * The keys pressed at the time that this action was triggered.
@@ -51,6 +52,7 @@ export abstract class BaseAction implements IBaseAction {
 
   private static readonly isSingleNumber: RegExp = /^[0-9]$/;
   private static readonly isSingleAlpha: RegExp = /^[a-zA-Z]$/;
+  private static readonly isMacroRegister: RegExp = /^[0-9a-zA-Z]$/;
 
   /**
    * Is this action valid in the current Vim state?
@@ -125,7 +127,9 @@ export abstract class BaseAction implements IBaseAction {
         continue;
       } else if (left === '<alpha>' && this.isSingleAlpha.test(right)) {
         continue;
-      } else if (left === '<character>' && !Notation.IsControlKey(right)) {
+      } else if (left === '<macro>' && this.isMacroRegister.test(right)) {
+        continue;
+      } else if (['<character>', '<register>'].includes(left) && !Notation.IsControlKey(right)) {
         continue;
       } else {
         return false;
@@ -265,7 +269,9 @@ export function getRelevantAction(
     //       I think we can make `doesActionApply` and `couldActionApply` static...
     const action = new actionType();
     if (action.doesActionApply(vimState, keysPressed)) {
-      action.keysPressed = vimState.recordedState.actionKeys.slice(0);
+      action.keysPressed = isLiteralMode(vimState.currentMode)
+        ? [...vimState.recordedState.actionKeys]
+        : unmapLiteral(action.keys, vimState.recordedState.actionKeys);
       return action;
     }
 

src/actions/commands/actions.ts

@@ -290,7 +290,7 @@ export class CommandNumber extends BaseCommand {
 @RegisterAction
 export class CommandRegister extends BaseCommand {
   modes = [Mode.Normal, Mode.Visual, Mode.VisualLine, Mode.VisualBlock];
-  keys = ['"', '<character>'];
+  keys = ['"', '<register>'];
   override name = 'cmd_register';
   override isCompleteAction = false;
 
@@ -310,8 +310,7 @@ export class CommandRegister extends BaseCommand {
 class CommandRecordMacro extends BaseCommand {
   modes = [Mode.Normal, Mode.Visual, Mode.VisualLine];
   keys = [
-    ['q', '<alpha>'],
-    ['q', '<number>'],
+    ['q', '<macro>'],
     ['q', '"'],
   ];
 
@@ -391,7 +390,7 @@ class CommandExecuteLastMacro extends BaseCommand {
 @RegisterAction
 class CommandExecuteMacro extends BaseCommand {
   modes = [Mode.Normal, Mode.Visual, Mode.VisualLine];
-  keys = ['@', '<character>'];
+  keys = ['@', '<register>'];
   override runsOnceForEachCountPrefix = true;
   override createsUndoPoint = true;
 
@@ -582,7 +581,7 @@ class CommandCmdA extends BaseCommand {
 
 @RegisterAction
 class MarkCommand extends BaseCommand {
-  keys = ['m', '<character>'];
+  keys = ['m', '<register>'];
   modes = [Mode.Normal];
 
   public override async exec(position: Position, vimState: VimState): Promise<void> {

src/actions/commands/commandLine.ts

@@ -289,11 +289,12 @@ class CommandInsertRegisterContentInCommandLine extends CommandLineAction {
   override isCompleteAction = false;
 
   protected async run(vimState: VimState, commandLine: CommandLine): Promise<void> {
-    if (!Register.isValidRegister(this.keysPressed[1])) {
+    const registerKey = this.keysPressed[1];
+    if (!Register.isValidRegister(registerKey)) {
       return;
     }
 
-    vimState.recordedState.registerName = this.keysPressed[1];
+    vimState.recordedState.registerName = registerKey;
     const register = await Register.get(vimState.recordedState.registerName, this.multicursorIndex);
     if (register === undefined) {
       StatusBar.displayError(

src/actions/commands/insert.ts

@@ -335,16 +335,14 @@ class CommandInsertRegisterContent extends BaseCommand {
   override isCompleteAction = false;
 
   public override async exec(position: Position, vimState: VimState): Promise<void> {
-    if (!Register.isValidRegister(this.keysPressed[1])) {
+    const registerKey = this.keysPressed[1];
+    if (!Register.isValidRegister(registerKey)) {
       return;
     }
 
-    const register = await Register.get(this.keysPressed[1], this.multicursorIndex);
+    const register = await Register.get(registerKey, this.multicursorIndex);
     if (register === undefined) {
-      StatusBar.displayError(
-        vimState,
-        VimError.fromCode(ErrorCode.NothingInRegister, this.keysPressed[1]),
-      );
+      StatusBar.displayError(vimState, VimError.fromCode(ErrorCode.NothingInRegister, registerKey));
       return;
     }
 

src/actions/motion.ts

@@ -564,7 +564,7 @@ class CommandPreviousSearchMatch extends BaseMovement {
 
 @RegisterAction
 class MarkMovementBOL extends BaseMovement {
-  keys = ["'", '<character>'];
+  keys = ["'", '<register>'];
   override isJump = true;
 
   public override async execAction(position: Position, vimState: VimState): Promise<Position> {
@@ -591,7 +591,7 @@ class MarkMovementBOL extends BaseMovement {
 
 @RegisterAction
 class MarkMovement extends BaseMovement {
-  keys = ['`', '<character>'];
+  keys = ['`', '<register>'];
   override isJump = true;
 
   public override async execAction(position: Position, vimState: VimState): Promise<Position> {

src/cmd_line/commands/set.ts

@@ -154,6 +154,13 @@ export class SetCommand extends ExCommand {
     this.operation = operation;
   }
 
+  // Listeners for options that need to be updated when they change
+  private static listeners: { [key: string]: Array<() => void> } = {};
+  static addListener(option: string, listener: () => void) {
+    if (!(option in SetCommand.listeners)) SetCommand.listeners[option] = [];
+    SetCommand.listeners[option].push(listener);
+  }
+
   async execute(vimState: VimState): Promise<void> {
     if (this.operation.option === undefined) {
       // TODO: Show all options that differ from their default value
@@ -288,6 +295,12 @@ export class SetCommand extends ExCommand {
         const guard: never = this.operation;
         throw new Error('Got unexpected SetOperation.type');
     }
+
+    if (option in SetCommand.listeners) {
+      for (const listener of SetCommand.listeners[option]) {
+        listener();
+      }
+    }
   }
 
   private showOption(vimState: VimState, option: string, value: boolean | string | number) {

src/configuration/configuration.ts

@@ -110,6 +110,11 @@ class Configuration implements IConfiguration {
     'underline-thin': vscode.TextEditorCursorStyle.UnderlineThin,
   };
 
+  private loadListeners: Array<() => void> = [];
+  public addLoadListener(listener: () => void): void {
+    this.loadListeners.push(listener);
+  }
+
   public async load(): Promise<ValidatorResults> {
     const vimConfigs: { [key: string]: any } = Globals.isTesting
       ? Globals.mockConfiguration
@@ -194,6 +199,10 @@ class Configuration implements IConfiguration {
     void VSCodeContext.set('vim.overrideCopy', this.overrideCopy);
     void VSCodeContext.set('vim.overrideCtrlC', this.overrideCopy || this.useCtrlKeys);
 
+    // workaround for circular dependency that would
+    // prevent packaging if we simply called `updateLangmap(configuration.langmap);`
+    this.loadListeners.forEach((listener) => listener());
+
     return validatorResults;
   }
 
@@ -481,6 +490,11 @@ class Configuration implements IConfiguration {
   visualModeKeyBindingsMap: Map<string, IKeyRemapping> = new Map();
   commandLineModeKeyBindingsMap: Map<string, IKeyRemapping> = new Map();
 
+  // langmap
+  langmapBindingsMap: Map<string, string> = new Map();
+  langmapReverseBindingsMap: Map<string, string> = new Map();
+  langmap = '';
+
   get textwidth(): number {
     const textwidth = this.getConfiguration('vim').get('textwidth', 80);
 

src/configuration/iconfiguration.ts

@@ -445,4 +445,6 @@ export interface IConfiguration {
    * Path to the shell to use for `!` and `:!` commands.
    */
   shell: string;
+
+  langmap: string;
 }

src/configuration/langmap.ts

@@ -0,0 +1,132 @@
+import { SetCommand } from '../cmd_line/commands/set';
+import { Mode } from '../mode/mode';
+import { configuration } from './configuration';
+
+const nonMatchable = /<(any|leader|number|alpha|character|register|macro)>/;
+const literalKeys = /<(any|number|alpha|character)>/; // do not treat <register> or <macro> as literal!
+const literalModes = [
+  Mode.Insert,
+  Mode.Replace,
+  Mode.CommandlineInProgress,
+  Mode.SearchInProgressMode,
+];
+
+let lastLangmapString = '';
+
+SetCommand.addListener('langmap', () => {
+  updateLangmap(configuration.langmap);
+});
+configuration.addLoadListener(() => {
+  updateLangmap(configuration.langmap);
+});
+updateLangmap(configuration.langmap);
+
+export function updateLangmap(langmapString: string) {
+  if (lastLangmapString === langmapString) return;
+  const { bindings, reverseBindings } = parseLangmap(langmapString);
+
+  lastLangmapString = langmapString;
+  configuration.langmap = langmapString;
+  configuration.langmapBindingsMap = bindings;
+  configuration.langmapReverseBindingsMap = reverseBindings;
+}
+
+/**
+ *  From :help langmap
+ *  The 'langmap' option is a list of parts, separated with commas.  Each
+ *      part can be in one of two forms:
+ *      1.  A list of pairs.  Each pair is a "from" character immediately
+ *          followed by the "to" character.  Examples: "aA", "aAbBcC".
+ *      2.  A list of "from" characters, a semi-colon and a list of "to"
+ *          characters.  Example: "abc;ABC"
+ */
+function parseLangmap(langmapString: string): {
+  bindings: Map<string, string>;
+  reverseBindings: Map<string, string>;
+} {
+  if (!langmapString) return { bindings: new Map(), reverseBindings: new Map() };
+
+  const bindings: Map<string, string> = new Map();
+  const reverseBindings: Map<string, string> = new Map();
+
+  const getEscaped = (list: string) => {
+    return list.split(/\\?(.)/).filter(Boolean);
+  };
+  langmapString.split(/((?:[^\\,]|\\.)+),/).map((part) => {
+    if (!part) return;
+    const semicolon = part.split(/((?:[^\\;]|\\.)+);/);
+    if (semicolon.length === 3) {
+      const from = getEscaped(semicolon[1]);
+      const to = getEscaped(semicolon[2]);
+      if (from.length !== to.length) return; // skip over malformed part
+      for (let i = 0; i < from.length; ++i) {
+        bindings.set(from[i], to[i]);
+        reverseBindings.set(to[i], from[i]);
+      }
+    } else if (semicolon.length === 1) {
+      const pairs = getEscaped(part);
+      if (pairs.length % 2 !== 0) return; // skip over malformed part
+      for (let i = 0; i < pairs.length; i += 2) {
+        bindings.set(pairs[i], pairs[i + 1]);
+        reverseBindings.set(pairs[i + 1], pairs[i]);
+      }
+    }
+  });
+
+  return { bindings, reverseBindings };
+}
+
+export function isLiteralMode(mode: Mode): boolean {
+  return literalModes.includes(mode);
+}
+
+function map(langmap: Map<string, string>, key: string): string {
+  // Notice that we're not currently remapping <C-> combinations.
+  // From my experience, Vim doesn't handle ctrl remapping either.
+  // It's possible that it's caused by my exact keyboard setup.
+  // We might need to revisit this in the future, in case some user needs it.
+  if (key.length !== 1) return key;
+  return langmap.get(key) || key;
+}
+
+export function remapKey(key: string): string {
+  return map(configuration.langmapBindingsMap, key);
+}
+
+function unmapKey(key: string): string {
+  return map(configuration.langmapReverseBindingsMap, key);
+}
+
+// This is needed for bindings like "fa".
+// We expect this to jump to the next occurence of "a".
+// Thus, we need to revert "a" to its unmapped state.
+export function unmapLiteral(
+  reference: readonly string[] | readonly string[][],
+  keys: readonly string[],
+): string[] {
+  if (reference.length === 0 || keys.length === 0) return [];
+
+  // find best matching if there are multiple
+  if (Array.isArray(reference[0])) {
+    for (const possibility of reference as string[][]) {
+      if (possibility.length !== keys.length) continue;
+      let allMatch = true;
+      for (let i = 0; i < possibility.length; ++i) {
+        if (nonMatchable.test(possibility[i])) continue;
+        if (possibility[i] !== keys[i]) {
+          allMatch = false;
+          break;
+        }
+      }
+      if (allMatch) return unmapLiteral(possibility, keys);
+    }
+  }
+
+  const unmapped = [...keys];
+  for (let i = 0; i < keys.length; ++i) {
+    if (literalKeys.test((reference as string[])[i])) {
+      unmapped[i] = unmapKey(keys[i]);
+    }
+  }
+  return unmapped;
+}