Implement :unl[et]

Author: J-Fields

src/cmd_line/commands/let.ts

@@ -1,5 +1,5 @@
 // eslint-disable-next-line id-denylist
-import { alt, optWhitespace, Parser, sepBy, seq, string, whitespace } from 'parsimmon';
+import { alt, optWhitespace, Parser, sepBy, seq, seqMap, string, whitespace } from 'parsimmon';
 import { VimState } from '../../state/vimState';
 import { StatusBar } from '../../statusBar';
 import { ExCommand } from '../../vimscript/exCommand';
@@ -283,3 +283,35 @@ export class LetCommand extends ExCommand {
     }
   }
 }
+
+export class UnletCommand extends ExCommand {
+  public static readonly argParser = seqMap(
+    string('!').fallback(undefined),
+    whitespace.then(variableParser.sepBy(whitespace)),
+    (bang, variables) => {
+      if (variables.length === 0) {
+        throw VimError.fromCode(ErrorCode.ArgumentRequired);
+      }
+      return new UnletCommand(variables, bang !== undefined);
+    },
+  );
+
+  private variables: VariableExpression[];
+  private bang: boolean;
+  public constructor(variables: VariableExpression[], bang: boolean) {
+    super();
+    this.variables = variables;
+    this.bang = bang;
+  }
+
+  async execute(vimState: VimState): Promise<void> {
+    const ctx = new EvaluationContext();
+    for (const variable of this.variables) {
+      const store = ctx.getVariableStore(variable.namespace);
+      const existed = store?.delete(variable.name);
+      if (!existed && !this.bang) {
+        throw VimError.fromCode(ErrorCode.NoSuchVariable, `"${variable.name}"`);
+      }
+    }
+  }
+}

src/error.ts

@@ -16,6 +16,7 @@ export enum ErrorCode {
   NoWriteSinceLastChange = 37,
   MultipleMatches = 93,
   NoMatchingBuffer = 94,
+  NoSuchVariable = 108,
   MissingQuote = 114,
   UnknownFunction_call = 117,
   TooManyArgs = 118,
@@ -104,6 +105,7 @@ export const ErrorMessage: IErrorMessage = {
   37: 'No write since last change (add ! to override)',
   93: 'More than one match',
   94: 'No matching buffer',
+  108: 'No such variable',
   114: 'Missing quote',
   117: 'Unknown function',
   118: 'Too many arguments for function',

src/vimscript/exCommandParser.ts

@@ -51,7 +51,7 @@ import { StatusBar } from '../statusBar';
 import { ExCommand } from './exCommand';
 import { LineRange } from './lineRange';
 import { nameAbbrevParser } from './parserUtils';
-import { LetCommand } from '../cmd_line/commands/let';
+import { LetCommand, UnletCommand } from '../cmd_line/commands/let';
 import { CallCommand, EvalCommand } from '../cmd_line/commands/eval';
 import { PwdCommand } from '../cmd_line/commands/pwd';
 
@@ -566,7 +566,7 @@ export const builtinExCommands: ReadonlyArray<[[string, string], ArgParser | und
   [['undoj', 'oin'], undefined],
   [['undol', 'ist'], undefined],
   [['unh', 'ide'], undefined],
-  [['unl', 'et'], undefined],
+  [['unl', 'et'], UnletCommand.argParser],
   [['unlo', 'ckvar'], undefined],
   [['unm', 'ap'], undefined],
   [['unme', 'nu'], undefined],

src/vimscript/expression/evaluate.ts

@@ -127,7 +127,7 @@ export class Variable {
   }
 }
 
-type VariableStore = Map<string, Variable>;
+export type VariableStore = Map<string, Variable>;
 
 export class EvaluationContext {
   private static globalVariables: VariableStore = new Map();
@@ -266,14 +266,7 @@ export class EvaluationContext {
       throw VimError.fromCode(ErrorCode.FuncrefVariableNameMustStartWithACapital, varExpr.name);
     }
 
-    let store: VariableStore | undefined;
-    if (this.localScopes.length > 0 && varExpr.namespace === undefined) {
-      store = this.localScopes.at(-1);
-    } else if (varExpr.namespace === 'g' || varExpr.namespace === undefined) {
-      store = EvaluationContext.globalVariables;
-    } else {
-      // TODO
-    }
+    const store = this.getVariableStore(varExpr.namespace);
 
     if (store) {
       const _var = store.get(varExpr.name);
@@ -364,6 +357,16 @@ export class EvaluationContext {
     );
   }
 
+  public getVariableStore(namespace: string | undefined): VariableStore | undefined {
+    if (this.localScopes.length > 0 && namespace === undefined) {
+      return this.localScopes.at(-1);
+    } else if (namespace === 'g' || namespace === undefined) {
+      return EvaluationContext.globalVariables;
+    }
+    // TODO
+    return undefined;
+  }
+
   private evaluateIndex(sequence: Value, index: Value): Value {
     switch (sequence.type) {
       case 'string':