porffor 0.20.6 → 0.20.7

package/compiler/builtins/object.ts

@@ -83,6 +83,17 @@ export const __Object_entries = (obj: any): any[] => {
   return out;
 };
 
+export const __Object_fromEntries = (iterable: any): object => {
+  const out: object = {};
+
+  for (const x of iterable) {
+    if (Porffor.rawType(x) < 0x06) throw new TypeError('Iterator contains non-object');
+    out[ecma262.ToPropertyKey(x[0])] = x[1];
+  }
+
+  return out;
+};
+
 
 export const __Object_prototype_hasOwnProperty = (_this: any, prop: any) => {
   const p: any = ecma262.ToPropertyKey(prop);
@@ -103,6 +114,23 @@ export const __Object_hasOwn = (obj: any, prop: any) => {
 };
 
 
+export const __Object_assign = (target: any, ...sources: any[]) => {
+  if (target == null) throw new TypeError('Argument is nullish, expected object');
+
+  for (const x of sources) {
+    const keys: any[] = __Object_keys(x);
+    const vals: any[] = __Object_values(x);
+
+    const len: i32 = keys.length;
+    for (let i: i32 = 0; i < len; i++) {
+      target[keys[i]] = vals[i];
+    }
+  }
+
+  return target;
+};
+
+
 export const __Object_prototype_toString = (_this: object) => {
   let out: bytestring = '[object Object]';
   return out;

package/compiler/builtins/set.ts

@@ -184,10 +184,7 @@ export const Set = function (iterable: any): Set {
 
   const out: Set = __Porffor_allocate();
 
-  if (Porffor.fastAnd(
-    Porffor.rawType(iterable) != Porffor.TYPES.undefined,
-    iterable !== null
-  )) for (const x of iterable) {
+  if (iterable != null) for (const x of iterable) {
     __Set_prototype_add(out, x);
   }
 

package/compiler/builtins/weakref.ts

@@ -3,7 +3,7 @@ import type {} from './porffor.d.ts';
 export const WeakRef = function (target: any): WeakRef {
   if (!new.target) throw new TypeError("Constructor WeakRef requires 'new'");
 
-  if (Porffor.rawType(target) < 0x04) throw new TypeError('Target for WeakRef needs to be an object or symbol');
+  if (Porffor.rawType(target) < 0x05) throw new TypeError('Target for WeakRef needs to be an object or symbol');
 
   const out: WeakRef = Porffor.allocateBytes(9);
 

package/compiler/builtins/z_map.ts

@@ -97,10 +97,8 @@ export const Map = function (iterable: any): Map {
   const vals: any[] = Porffor.allocate();
   Porffor.wasm.i32.store(out, vals, 0, 4);
 
-  if (Porffor.fastAnd(
-    Porffor.rawType(iterable) != Porffor.TYPES.undefined,
-    iterable !== null
-  )) for (const x of iterable) {
+  if (iterable != null) for (const x of iterable) {
+    if (Porffor.rawType(x) < 0x06) throw new TypeError('Iterator contains non-object');
     __Map_prototype_set(out, x[0], x[1]);
   }
 

package/compiler/builtins/z_weakmap.ts

@@ -3,7 +3,7 @@ import type {} from './porffor.d.ts';
 export const __WeakMap_prototype_has = (_this: WeakMap, key: any) => __Map_prototype_has(_this, key);
 
 export const __WeakMap_prototype_set = (_this: WeakMap, key: any, value: any) => {
-  if (Porffor.rawType(key) < 0x04) throw new TypeError('Value in WeakSet needs to be an object or symbol');
+  if (Porffor.rawType(key) < 0x05) throw new TypeError('Value in WeakSet needs to be an object or symbol');
 
   __Map_prototype_set(_this, key, value);
   return _this;
@@ -22,10 +22,8 @@ export const WeakMap = function (iterable: any): WeakMap {
   const vals: any[] = Porffor.allocate();
   Porffor.wasm.i32.store(out, vals, 0, 4);
 
-  if (Porffor.fastAnd(
-    Porffor.rawType(iterable) != Porffor.TYPES.undefined,
-    iterable !== null
-  )) for (const x of iterable) {
+  if (iterable != null) for (const x of iterable) {
+    if (Porffor.rawType(x) < 0x06) throw new TypeError('Iterator contains non-object');
     __WeakMap_prototype_set(out, x[0], x[1]);
   }
 

package/compiler/builtins/z_weakset.ts

@@ -3,7 +3,7 @@ import type {} from './porffor.d.ts';
 export const __WeakSet_prototype_has = (_this: WeakSet, value: any) => __Set_prototype_has(_this, value);
 
 export const __WeakSet_prototype_add = (_this: WeakSet, value: any) => {
-  if (Porffor.rawType(value) < 0x04) throw new TypeError('Value in WeakSet needs to be an object or symbol');
+  if (Porffor.rawType(value) < 0x05) throw new TypeError('Value in WeakSet needs to be an object or symbol');
 
   __Set_prototype_add(_this, value);
   return _this;
@@ -16,10 +16,7 @@ export const WeakSet = function (iterable: any): WeakSet {
 
   const out: WeakSet = __Porffor_allocate();
 
-  if (Porffor.fastAnd(
-    Porffor.rawType(iterable) != Porffor.TYPES.undefined,
-    iterable !== null
-  )) for (const x of iterable) {
+  if (iterable != null) for (const x of iterable) {
     __WeakSet_prototype_add(out, x);
   }
 

package/compiler/codegen.js

@@ -1332,7 +1332,7 @@ const isExistingProtoFunc = name => {
 const getType = (scope, _name) => {
   const name = mapName(_name);
 
-  // if (scope.locals[name] && !scope.locals[name + '#type']) console.log(name);
+  if (Object.hasOwn(builtinVars, name)) return number(builtinVars[name].type ?? TYPES.number, Valtype.i32);
 
   if (typedInput && scope.locals[name]?.metadata?.type != null) return number(scope.locals[name].metadata.type, Valtype.i32);
   if (Object.hasOwn(scope.locals, name)) return [ [ Opcodes.local_get, scope.locals[name + '#type'].idx ] ];
@@ -1340,13 +1340,13 @@ const getType = (scope, _name) => {
   if (typedInput && globals[name]?.metadata?.type != null) return number(globals[name].metadata.type, Valtype.i32);
   if (Object.hasOwn(globals, name)) return [ [ Opcodes.global_get, globals[name + '#type'].idx ] ];
 
-  let type = TYPES.undefined;
-  if (Object.hasOwn(builtinVars, name)) type = builtinVars[name].type ?? TYPES.number;
-  if (Object.hasOwn(builtinFuncs, name) || Object.hasOwn(importedFuncs, name) || Object.hasOwn(funcIndex, name) || Object.hasOwn(internalConstrs, name)) type = TYPES.function;
+  if (Object.hasOwn(builtinFuncs, name) || Object.hasOwn(importedFuncs, name) ||
+      Object.hasOwn(funcIndex, name) || Object.hasOwn(internalConstrs, name))
+        return number(TYPES.function, Valtype.i32);
 
-  if (isExistingProtoFunc(name)) type = TYPES.function;
+  if (isExistingProtoFunc(name)) return number(TYPES.function, Valtype.i32);
 
-  return number(type, Valtype.i32);
+  return number(TYPES.undefined, Valtype.i32);
 };
 
 const setType = (scope, _name, type) => {
@@ -3430,16 +3430,22 @@ const generateForOf = (scope, decl) => {
     // get length
     [ Opcodes.local_get, pointer ],
     [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
-    [ Opcodes.local_set, length ]
+    [ Opcodes.local_tee, length ],
+
+    [ Opcodes.if, Blocktype.void ]
   );
 
+  depth.push('if');
   depth.push('forof');
+  depth.push('block');
+  depth.push('block');
 
   // setup local for left
   generate(scope, decl.left);
 
   let leftName = decl.left.declarations?.[0]?.id?.name;
   if (!leftName && decl.left.name) {
+    // todo: should be sloppy mode only
     leftName = decl.left.name;
 
     generateVar(scope, { kind: 'var', _bare: true, declarations: [ { id: { name: leftName } } ] })
@@ -3450,9 +3456,6 @@ const generateForOf = (scope, decl) => {
   const [ local, isGlobal ] = lookupName(scope, leftName);
   if (!local) return todo(scope, 'for of failed to get left local (probably destructure)');
 
-  depth.push('block');
-  depth.push('block');
-
   // // todo: we should only do this for strings but we don't know at compile-time :(
   // hack: this is naughty and will break things!
   let newOut = number(0, Valtype.i32), newPointer = number(0, Valtype.i32);
@@ -3595,12 +3598,6 @@ const generateForOf = (scope, decl) => {
       ...generate(scope, decl.body),
       [ Opcodes.end ],
 
-      // increment iter pointer
-      // [ Opcodes.local_get, pointer ],
-      // ...number(1, Valtype.i32),
-      // [ Opcodes.i32_add ],
-      // [ Opcodes.local_set, pointer ],
-
       // increment counter by 1
       [ Opcodes.local_get, counter ],
       ...number(1, Valtype.i32),
@@ -3758,6 +3755,8 @@ const generateForOf = (scope, decl) => {
     default: internalThrow(scope, 'TypeError', `Tried for..of on non-iterable type`)
   }, Blocktype.void));
 
+  out.push([ Opcodes.end ]); // end if
+
   depth.pop();
   depth.pop();
   depth.pop();