Separate values from expressions

Author: J-Fields

.eslintrc.js

@@ -165,7 +165,6 @@ module.exports = {
     'no-invalid-this': 'off',
     'no-loss-of-precision': 'off',
     'no-new-wrappers': 'error',
-    'no-redeclare': 'error',
     'no-return-await': 'error',
     'no-shadow': 'off',
     'no-throw-literal': 'error',

src/cmd_line/commands/let.ts

@@ -11,6 +11,7 @@ import {
   modulo,
   multiply,
   subtract,
+  toExpr,
 } from '../../vimscript/expression/build';
 import { EvaluationContext, toInt, toString } from '../../vimscript/expression/evaluate';
 import {
@@ -179,19 +180,19 @@ export class LetCommand extends ExCommand {
       const value = context.evaluate(this.args.expression);
       const newValue = (_var: Expression, _value: Value) => {
         if (this.args.operation === '+=') {
-          return context.evaluate(add(_var, _value));
+          return context.evaluate(add(_var, toExpr(_value)));
         } else if (this.args.operation === '-=') {
-          return context.evaluate(subtract(_var, _value));
+          return context.evaluate(subtract(_var, toExpr(_value)));
         } else if (this.args.operation === '*=') {
-          return context.evaluate(multiply(_var, _value));
+          return context.evaluate(multiply(_var, toExpr(_value)));
         } else if (this.args.operation === '/=') {
-          return context.evaluate(divide(_var, _value));
+          return context.evaluate(divide(_var, toExpr(_value)));
         } else if (this.args.operation === '%=') {
-          return context.evaluate(modulo(_var, _value));
+          return context.evaluate(modulo(_var, toExpr(_value)));
         } else if (this.args.operation === '.=') {
-          return context.evaluate(concat(_var, _value));
+          return context.evaluate(concat(_var, toExpr(_value)));
         } else if (this.args.operation === '..=') {
-          return context.evaluate(concat(_var, _value));
+          return context.evaluate(concat(_var, toExpr(_value)));
         }
         return _value;
       };
@@ -233,7 +234,7 @@ export class LetCommand extends ExCommand {
           );
           varValue.items[idx] = newItem;
           context.setVariable(variable.variable, varValue, this.args.lock);
-        } else if (varValue.type === 'dict_val') {
+        } else if (varValue.type === 'dictionary') {
           const key = toString(context.evaluate(variable.index));
           const newItem = newValue(
             {

src/vimscript/expression/build.ts

@@ -17,6 +17,12 @@ import {
   Value,
   BlobValue,
   FuncrefCallExpression,
+  NumberExpression,
+  BlobExpression,
+  DictionaryExpression,
+  FloatExpression,
+  FuncRefExpression,
+  StringExpression,
 } from './types';
 
 export function int(value: number): NumberValue {
@@ -53,17 +59,20 @@ export function list(items: Value[]): ListValue {
 
 export function dictionary(items: Map<string, Value>): DictionaryValue {
   return {
-    type: 'dict_val',
+    type: 'dictionary',
     items,
   };
 }
 
-export function funcref(name: string, arglist?: ListValue, dict?: DictionaryValue): FuncRefValue {
+export function funcref(args: {
+  name: string;
+  body?: (args: Value[]) => Value;
+  arglist?: ListValue;
+  dict?: DictionaryValue;
+}): FuncRefValue {
   return {
     type: 'funcref',
-    name,
-    arglist,
-    dict,
+    ...args,
   };
 }
 
@@ -74,6 +83,42 @@ export function blob(data: Uint8Array<ArrayBuffer>): BlobValue {
   };
 }
 
+export function toExpr(value: NumberValue): NumberExpression;
+export function toExpr(value: FloatValue): FloatExpression;
+export function toExpr(value: StringValue): StringExpression;
+export function toExpr(value: ListValue): ListExpression;
+export function toExpr(value: DictionaryValue): DictionaryExpression;
+export function toExpr(value: FuncRefValue): FuncRefExpression;
+export function toExpr(value: BlobValue): BlobExpression;
+export function toExpr(value: Value): Expression;
+export function toExpr(value: Value): Expression {
+  if (value.type === 'number' || value.type === 'float' || value.type === 'string') {
+    return value;
+  } else if (value.type === 'list') {
+    return listExpr(value.items.map(toExpr));
+  } else if (value.type === 'dictionary') {
+    return {
+      type: 'dictionary',
+      items: [...value.items.entries()].map(([key, val]) => [str(key), toExpr(val)]),
+    };
+  } else if (value.type === 'funcref') {
+    return {
+      type: 'funcref',
+      name: value.name,
+      body: value.body,
+      arglist: value.arglist ? toExpr(value.arglist) : undefined,
+      dict: value.dict ? toExpr(value.dict) : undefined,
+    };
+  } else if (value.type === 'blob') {
+    return {
+      type: 'blob',
+      data: value.data,
+    };
+  }
+  const guard: never = value;
+  throw new Error(`Unknown value type in toExpr()`);
+}
+
 export function listExpr(items: Expression[]): ListExpression {
   return {
     type: 'list',

src/vimscript/expression/displayValue.ts

@@ -16,7 +16,7 @@ export function displayValue(value: Value, topLevel = true): string {
       return topLevel ? value.value : `'${value.value.replace("'", "''")}'`;
     case 'list':
       return `[${value.items.map((v) => displayValue(v, false)).join(', ')}]`;
-    case 'dict_val':
+    case 'dictionary':
       return `{${[...value.items]
         .map(([k, v]) => `'${k}': ${displayValue(v, false)}`)
         .join(', ')}}`;