goscript 0.2.2 → 0.2.4

package/dist/gs/reflect/type.js

@@ -397,6 +397,25 @@ export class Value {
         const cloned = new Value(this._value, this._type, this._parentVarRef, this._parentStruct, this._fieldName);
         return cloned;
     }
+    currentValue() {
+        if (this._parentVarRef) {
+            return this._parentVarRef.value;
+        }
+        if (this._parentStruct && this._fieldName !== undefined) {
+            const value = this._parentStruct[this._fieldName];
+            return value === undefined ? null : value;
+        }
+        return this._value;
+    }
+    storeValue(value) {
+        this._value = value;
+        if (this._parentVarRef) {
+            this._parentVarRef.value = value;
+        }
+        if (this._parentStruct && this._fieldName !== undefined) {
+            this._parentStruct[this._fieldName] = value;
+        }
+    }
     // Methods required by godoc.txt and used throughout the codebase
     Int() {
         const value = this.numericValue();
@@ -461,6 +480,16 @@ export class Value {
         if (this.Kind() === Slice || this.Kind() === Array) {
             return $.len(this._value);
         }
+        if (this.Kind() === Map) {
+            const value = this.currentValue();
+            if (value instanceof globalThis.Map) {
+                return value.size;
+            }
+            if (value !== null && value !== undefined) {
+                throw new ValueError({ Kind: this.Kind(), Method: 'Len' });
+            }
+            return 0;
+        }
         // Check for slice objects created by $.arrayToSlice
         if (this._value &&
             typeof this._value === 'object' &&
@@ -506,7 +535,8 @@ export class Value {
         return this._type !== invalidTypeInstance;
     }
     IsNil() {
-        return this._value === null || this._value === undefined;
+        const value = this.currentValue();
+        return value === null || value === undefined;
     }
     Index(i) {
         if (this.Kind() === Slice || this.Kind() === Array) {
@@ -708,15 +738,7 @@ export class Value {
         if (!xType.AssignableTo(thisType)) {
             throw new Error('reflect: assign to wrong type');
         }
-        this._value = x.value;
-        // Also update the parent VarRef if we were dereferenced from one
-        if (this._parentVarRef) {
-            this._parentVarRef.value = x.value;
-        }
-        // Also update the parent struct field if this is a struct field
-        if (this._parentStruct && this._fieldName) {
-            this._parentStruct[this._fieldName] = x.value;
-        }
+        this.storeValue(x.value);
     }
     // Additional methods from deleted reflect.gs.ts
     Interface() {
@@ -768,40 +790,43 @@ export class Value {
         if (this.Kind() !== Map) {
             throw new ValueError({ Kind: this.Kind(), Method: 'MapRange' });
         }
-        if (this._value === null || this._value === undefined) {
+        const value = this.currentValue();
+        if (value === null || value === undefined) {
             return new MapIter(new globalThis.Map());
         }
-        if (!(this._value instanceof globalThis.Map)) {
+        if (!(value instanceof globalThis.Map)) {
             throw new ValueError({ Kind: this.Kind(), Method: 'MapRange' });
         }
-        return new MapIter(this._value);
+        return new MapIter(value);
     }
     MapIndex(key) {
         if (this.Kind() !== Map) {
             throw new ValueError({ Kind: this.Kind(), Method: 'MapIndex' });
         }
-        if (!(this._value instanceof globalThis.Map)) {
+        const value = this.currentValue();
+        if (!(value instanceof globalThis.Map)) {
             return new Value(null, new BasicType(Invalid, 'invalid'));
         }
         const rawKey = key.Interface();
-        if (!this._value.has(rawKey)) {
+        if (!value.has(rawKey)) {
             return new Value(null, new BasicType(Invalid, 'invalid'));
         }
-        return new Value(this._value.get(rawKey), this.Type().Elem());
+        return new Value(value.get(rawKey), this.Type().Elem());
     }
     MapKeys() {
         if (this.Kind() !== Map) {
             throw new ValueError({ Kind: this.Kind(), Method: 'MapKeys' });
         }
-        if (this._value === null || this._value === undefined) {
+        const value = this.currentValue();
+        if (value === null || value === undefined) {
             return $.makeSlice(0);
         }
-        if (!(this._value instanceof globalThis.Map)) {
+        if (!(value instanceof globalThis.Map)) {
             throw new ValueError({ Kind: this.Kind(), Method: 'MapKeys' });
         }
         const keyType = this.Type().Key();
         const keys = [];
-        for (const key of this._value.keys()) {
+        for (const key of value.keys()) {
             keys.push(new Value(key, keyType));
         }
         return $.arrayToSlice(keys);
@@ -970,7 +995,7 @@ export class Value {
             throw new Error('reflect: call of reflect.Value.SetZero on unaddressable value');
         }
         const zeroVal = Zero(this.Type());
-        this._value = zeroVal.value;
+        this.storeValue(zeroVal.value);
     }
     // SetLen sets v's length to n
     SetLen(n) {
@@ -994,9 +1019,16 @@ export class Value {
                 this.Kind() +
                 ' Value');
         }
-        const mapObj = this._value;
+        const mapObj = this.currentValue();
+        if (!(mapObj instanceof globalThis.Map)) {
+            throw new Error('reflect: assignment to entry in nil map');
+        }
         const keyVal = key.value;
         const elemVal = elem.value;
+        if (!elem.IsValid()) {
+            mapObj.delete(keyVal);
+            return;
+        }
         mapObj.set(keyVal, elemVal);
     }
     // Grow increases the slice's capacity, if necessary