id() and deepcopy()

Author: J-Fields

src/vimscript/expression/build.ts

@@ -25,6 +25,24 @@ import {
   StringExpression,
 } from './types';
 
+class UniqueIdGenerator {
+  private prefix: string;
+  private nextId: number = 1;
+
+  constructor(prefix: string) {
+    this.prefix = prefix;
+  }
+
+  public next(): string {
+    return `${this.prefix}${this.nextId++}`;
+  }
+}
+
+const listIdGen = new UniqueIdGenerator('list');
+const dictIdGen = new UniqueIdGenerator('dict');
+const funcIdGen = new UniqueIdGenerator('func');
+const blobIdGen = new UniqueIdGenerator('blob');
+
 export function int(value: number): NumberValue {
   return {
     type: 'number',
@@ -54,13 +72,15 @@ export function list(items: Value[]): ListValue {
   return {
     type: 'list',
     items,
+    id: listIdGen.next(),
   };
 }
 
 export function dictionary(items: Map<string, Value>): DictionaryValue {
   return {
     type: 'dictionary',
     items,
+    id: dictIdGen.next(),
   };
 }
 
@@ -73,13 +93,15 @@ export function funcref(args: {
   return {
     type: 'funcref',
     ...args,
+    id: funcIdGen.next(),
   };
 }
 
 export function blob(data: Uint8Array<ArrayBuffer>): BlobValue {
   return {
     type: 'blob',
     data,
+    id: blobIdGen.next(),
   };
 }
 

src/vimscript/expression/evaluate.ts

@@ -167,8 +167,9 @@ export class EvaluationContext {
       case 'number':
       case 'float':
       case 'string':
-      case 'blob':
         return expression;
+      case 'blob':
+        return blob(expression.data);
       case 'list':
         return list(expression.items.map((x) => this.evaluate(x)));
       case 'dictionary': {
@@ -590,6 +591,7 @@ export class EvaluationContext {
               )
             );
           case 'is':
+            // NOTE: `id` field should match if and only if they are the same list
             return lhs.items === rhs.items;
           default:
             throw VimError.fromCode(ErrorCode.InvalidOperationForList);
@@ -613,6 +615,7 @@ export class EvaluationContext {
               )
             );
           case 'is':
+            // NOTE: `id` field should match if and only if they are the same dictionary
             return lhs.items === rhs.items;
           default:
             throw VimError.fromCode(ErrorCode.InvalidOperationForDictionary);
@@ -628,6 +631,7 @@ export class EvaluationContext {
           case '==':
             return lhs.name === rhs.name && lhs.dict === rhs.dict;
           case 'is':
+            // NOTE: `id` field should match if and only if they are the same funcref
             return lhs === rhs;
           default:
             throw VimError.fromCode(ErrorCode.InvalidOperationForFuncrefs);
@@ -644,6 +648,7 @@ export class EvaluationContext {
             const [_lhs, _rhs] = [new Uint8Array(lhs.data), new Uint8Array(rhs.data)];
             return _lhs.length === _rhs.length && _lhs.every((byte, idx) => byte === _rhs[idx]);
           case 'is':
+            // NOTE: `id` field should match if and only if they are the same blob
             return lhs.data === rhs.data;
           default:
             throw VimError.fromCode(ErrorCode.InvalidOperationForBlob);
@@ -729,6 +734,18 @@ export class EvaluationContext {
       return false;
     };
 
+    const copy = (arg: Value, deep: boolean): Value => {
+      switch (arg.type) {
+        case 'list':
+          return list(deep ? arg.items.map((item) => copy(item, true)) : arg.items);
+        case 'dictionary':
+          return dictionary(
+            new Map(deep ? [...arg.items].map(([k, v]) => [k, copy(v, true)]) : arg.items),
+          );
+      }
+      return arg;
+    };
+
     const getArgs = (min: number, max?: number) => {
       if (max === undefined) {
         max = min;
@@ -892,13 +909,7 @@ export class EvaluationContext {
       }
       case 'copy': {
         const [x] = getArgs(1);
-        switch (x?.type) {
-          case 'list':
-            return list([...x.items]);
-          case 'dictionary':
-            return dictionary(new Map(x.items));
-        }
-        return x!;
+        return copy(x!, false);
       }
       case 'cos': {
         const [x] = getArgs(1);
@@ -953,9 +964,8 @@ export class EvaluationContext {
       }
       // TODO: cursor()
       case 'deepcopy': {
-        // TODO: real deep copy once references are implemented
         const [x] = getArgs(1);
-        return x!;
+        return copy(x!, true);
       }
       case 'empty': {
         let [x] = getArgs(1);
@@ -1122,7 +1132,14 @@ export class EvaluationContext {
       }
       // TODO: hasmapto()
       // TODO: histadd()/histdel()/histget()/histnr()
-      // TODO: id()
+      case 'id': {
+        // NOTE: Vim behaves differently (generally returning pointer addresses), but this serves the purpose
+        const [x] = getArgs(1);
+        if (x!.type === 'number' || x!.type === 'float' || x!.type === 'string') {
+          return str(x!.value.toString());
+        }
+        return str(x!.id);
+      }
       case 'index': {
         const [_haystack, _needle, _start, ic] = getArgs(2, 4);
         const haystack: Value = _haystack!;

src/vimscript/expression/types.ts

@@ -18,11 +18,13 @@ export type StringValue = {
 export type ListValue = {
   type: 'list';
   items: Value[];
+  id: string;
 };
 
 export type DictionaryValue = {
   type: 'dictionary';
   items: Map<string, Value>;
+  id: string;
 };
 
 export type FuncRefValue = {
@@ -31,11 +33,13 @@ export type FuncRefValue = {
   body?: (args: Value[]) => Value;
   arglist?: ListValue;
   dict?: DictionaryValue;
+  id: string;
 };
 
 export type BlobValue = {
   type: 'blob';
   data: Uint8Array<ArrayBuffer>;
+  id: string;
 };
 
 export type Value =

test/vimscript/expression.test.ts

@@ -14,13 +14,35 @@ import {
   bool,
   list,
   dictionary,
+  blob,
 } from '../../src/vimscript/expression/build';
 import { EvaluationContext } from '../../src/vimscript/expression/evaluate';
 import { expressionParser } from '../../src/vimscript/expression/parser';
 import { Expression, Value } from '../../src/vimscript/expression/types';
 import { displayValue } from '../../src/vimscript/expression/displayValue';
 import { ErrorCode, VimError } from '../../src/error';
 
+function removeIds(value: Value): unknown {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+  const { id, ...rest } = value as any;
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+  const _value: any = { ...rest };
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  if (value.type === 'list') {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    _value.items = value.items.map(removeIds);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  } else if (value.type === 'dictionary') {
+    const items = new Map<string, unknown>();
+    for (const [key, val] of value.items) {
+      items.set(key, removeIds(val));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    _value.items = items;
+  }
+  return _value;
+}
+
 function exprTest(
   input: string,
   asserts: { expr?: Expression } & ({ value?: Value; display?: string } | { error: ErrorCode }),
@@ -37,7 +59,7 @@ function exprTest(
       } else {
         if (asserts.value !== undefined) {
           const ctx = new EvaluationContext(undefined);
-          assert.deepStrictEqual(ctx.evaluate(expression), asserts.value);
+          assert.deepStrictEqual(removeIds(ctx.evaluate(expression)), removeIds(asserts.value));
         }
         if (asserts.display !== undefined) {
           const ctx = new EvaluationContext(undefined);
@@ -113,28 +135,16 @@ suite('Vimscript expressions', () => {
 
     suite('Blobs', () => {
       exprTest('0z', {
-        expr: {
-          type: 'blob',
-          data: new Uint8Array([]),
-        },
+        value: blob(new Uint8Array([])),
       });
       exprTest('0zabcd', {
-        expr: {
-          type: 'blob',
-          data: new Uint8Array([171, 205]),
-        },
+        value: blob(new Uint8Array([171, 205])),
       });
       exprTest('0ZABCD', {
-        expr: {
-          type: 'blob',
-          data: new Uint8Array([171, 205]),
-        },
+        value: blob(new Uint8Array([171, 205])),
       });
       exprTest('0zAB.CD', {
-        expr: {
-          type: 'blob',
-          data: new Uint8Array([171, 205]),
-        },
+        value: blob(new Uint8Array([171, 205])),
       });
       exprTest('0zabc', {
         error: ErrorCode.BlobLiteralShouldHaveAnEvenNumberOfHexCharacters,
@@ -392,6 +402,7 @@ suite('Vimscript expressions', () => {
 
       exprTest('5/0', { value: int(Infinity) }); // TODO: Neovim returns `v:numbermax`
       exprTest('-5/0', { value: int(-Infinity) }); // TODO: Neovim returns `v:numbermin`
+      exprTest('0/0', { value: int(NaN) }); // TODO: Neovim returns `v:numbermax`
 
       // TODO: Grok what Neovim does with 5/0.0
 
@@ -660,6 +671,8 @@ suite('Vimscript expressions', () => {
       exprTest('float2nr(40.0)', { value: int(40) });
       exprTest('float2nr(65.7)', { value: int(65) });
       exprTest('float2nr(-20.7)', { value: int(-20) });
+
+      // TODO: Infinity, -Infinity, NaN
     });
 
     suite('fmod', () => {
@@ -691,6 +704,12 @@ suite('Vimscript expressions', () => {
       exprTest('has_key(#{a:1, b:2, c:3}, "d")', { value: bool(false) });
     });
 
+    suite('id', () => {
+      exprTest('id(2+2) == id(4)', { value: bool(true) });
+      exprTest('id(2+2) == id(5)', { value: bool(false) });
+      // TODO: Everything else
+    });
+
     suite('index', () => {
       exprTest('index(["a","b","c"], "c")', { value: int(2) });
       exprTest('index(["a","b","c"], "k")', { value: int(-1) });