Support unpacking with :let

Author: J-Fields

src/cmd_line/commands/let.ts

@@ -1,5 +1,5 @@
 // eslint-disable-next-line id-denylist
-import { alt, optWhitespace, Parser, seq, string, whitespace } from 'parsimmon';
+import { alt, optWhitespace, Parser, sepBy, seq, string, whitespace } from 'parsimmon';
 import { env } from 'process';
 import { VimState } from '../../state/vimState';
 import { StatusBar } from '../../statusBar';
@@ -20,17 +20,24 @@ import {
   optionParser,
   registerParser,
   variableParser,
+  varNameParser,
 } from '../../vimscript/expression/parser';
 import {
   EnvVariableExpression,
   Expression,
   OptionExpression,
   RegisterExpression,
+  Value,
   VariableExpression,
 } from '../../vimscript/expression/types';
 import { displayValue } from '../../vimscript/expression/displayValue';
 import { ErrorCode, VimError } from '../../error';
 
+type Unpack = {
+  type: 'unpack';
+  names: string[];
+};
+
 export type LetCommandOperation = '=' | '+=' | '-=' | '*=' | '/=' | '%=' | '.=' | '..=';
 export type LetCommandVariable =
   | VariableExpression
@@ -40,7 +47,7 @@ export type LetCommandVariable =
 export type LetCommandArgs =
   | {
       operation: LetCommandOperation;
-      variable: LetCommandVariable;
+      variable: LetCommandVariable | Unpack;
       expression: Expression;
       lock: boolean;
     }
@@ -67,8 +74,14 @@ const letVarParser = alt<LetCommandVariable>(
   registerParser,
 );
 
+const unpackParser: Parser<Unpack> = sepBy(varNameParser, string(',').trim(optWhitespace))
+  .wrap(string('[').then(optWhitespace), optWhitespace.then(string(']')))
+  .map((names) => ({
+    type: 'unpack',
+    names,
+  }));
+
 export class LetCommand extends ExCommand {
-  // TODO: Support unpacking
   // TODO: Support indexing
   // TODO: Support slicing
   public static readonly argParser = (lock: boolean) =>
@@ -78,7 +91,11 @@ export class LetCommand extends ExCommand {
       // `:let {var} -= {expr}`
       // `:let {var} .= {expr}`
       whitespace.then(
-        seq(letVarParser, operationParser.wrap(optWhitespace, optWhitespace), expressionParser).map(
+        seq(
+          alt<LetCommandVariable | Unpack>(letVarParser, unpackParser),
+          operationParser.trim(optWhitespace),
+          expressionParser,
+        ).map(
           ([variable, operation, expression]) =>
             new LetCommand({
               operation,
@@ -107,7 +124,7 @@ export class LetCommand extends ExCommand {
       if (this.args.variables.length === 0) {
         // TODO
       } else {
-        const variable = this.args.variables[this.args.variables.length - 1];
+        const variable = this.args.variables.at(-1)!;
         const value = context.evaluate(variable);
         const prefix = value.type === 'number' ? '#' : value.type === 'funcref' ? '*' : '';
         StatusBar.setText(vimState, `${variable.name}    ${prefix}${displayValue(value)}`);
@@ -118,7 +135,7 @@ export class LetCommand extends ExCommand {
       if (this.args.lock) {
         if (this.args.operation !== '=') {
           throw VimError.fromCode(ErrorCode.CannotModifyExistingVariable);
-        } else if (this.args.variable.type !== 'variable') {
+        } else if (variable.type !== 'variable') {
           // TODO: this error message should vary by type
           throw VimError.fromCode(ErrorCode.CannotLockARegister);
         }
@@ -148,6 +165,25 @@ export class LetCommand extends ExCommand {
         // TODO
       } else if (variable.type === 'env_variable') {
         value = str(env[variable.name] ?? '');
+      } else if (variable.type === 'unpack') {
+        // TODO: Support :let [a, b; rest] = ["aval", "bval", 3, 4]
+        if (value.type !== 'list') {
+          throw VimError.fromCode(ErrorCode.ListRequired);
+        }
+        if (variable.names.length < value.items.length) {
+          throw VimError.fromCode(ErrorCode.LessTargetsThanListItems);
+        }
+        if (variable.names.length > value.items.length) {
+          throw VimError.fromCode(ErrorCode.MoreTargetsThanListItems);
+        }
+        for (let i = 0; i < variable.names.length; i++) {
+          await new LetCommand({
+            operation: this.args.operation,
+            variable: { type: 'variable', namespace: undefined, name: variable.names[i] },
+            expression: value.items[i],
+            lock: this.args.lock,
+          }).execute(vimState);
+        }
       }
     }
   }

src/error.ts

@@ -46,6 +46,8 @@ export enum ErrorCode {
   ChangeListIsEmpty = 664,
   ListIndexOutOfRange = 684,
   ArgumentOfSortMustBeAList = 686,
+  LessTargetsThanListItems = 687,
+  MoreTargetsThanListItems = 688,
   CanOnlyCompareListWithList = 691,
   InvalidOperationForList = 692,
   CannotIndexAFuncref = 695,
@@ -128,6 +130,8 @@ export const ErrorMessage: IErrorMessage = {
   664: 'changelist is empty',
   684: 'list index out of range',
   686: 'Argument of sort() must be a List',
+  687: 'Less targets than List items',
+  688: 'More targets than List items',
   691: 'Can only compare List with List',
   692: 'Invalid operation for List',
   695: 'Cannot index a Funcref',

src/vimscript/expression/parser.ts

@@ -185,6 +185,8 @@ const nestedExpressionParser: Parser<Expression> = lazy(() => expressionParser)
   .wrap(string('('), string(')'))
   .desc('a nested expression');
 
+export const varNameParser = regexp(/[a-zA-Z0-9_]+/);
+
 export const variableParser: Parser<VariableExpression> = seq(
   alt(
     string('b'),
@@ -198,7 +200,7 @@ export const variableParser: Parser<VariableExpression> = seq(
   )
     .skip(string(':'))
     .fallback(undefined),
-  regexp(/[a-zA-Z][a-zA-Z0-9]*/).desc('a variable'),
+  varNameParser.desc('a variable'),
 ).map(([namespace, name]) => {
   return { type: 'variable', namespace, name };
 });

test/vimscript/exCommandParse.test.ts

@@ -369,6 +369,16 @@ suite('Ex command parsing', () => {
       }),
     );
 
+    exParseTest(
+      ':let [a, b, c] = [1, 2, 3]',
+      new LetCommand({
+        operation: '=',
+        variable: { type: 'unpack', names: ['a', 'b', 'c'] },
+        expression: list([int(1), int(2), int(3)]),
+        lock: false,
+      }),
+    );
+
     exParseTest(
       ':const foo = 5',
       new LetCommand({ operation: '=', variable: variable('foo'), expression: int(5), lock: true }),