porffor 0.22.5 → 0.22.7

package/compiler/assemble.js

@@ -230,7 +230,7 @@ export default (funcs, globals, tags, pages, data, flags, noTreeshake = false) =
   //   };
   // }
 
-  const exports = funcs.filter(x => x.export).map((x, i) => [ ...encodeString(x.name === 'main' ? 'm' : x.name), ExportDesc.func, x.index ]);
+  const exports = funcs.filter(x => x.export).map((x, i) => [ ...encodeString(x.name === 'main' ? 'm' : x.name), ExportDesc.func, ...unsignedLEB128(x.index) ]);
 
   if (Prefs.alwaysMemory && pages.size === 0) pages.set('--always-memory', 0);
   if (optLevel === 0) pages.set('O0 precaution', 0);
@@ -276,7 +276,26 @@ export default (funcs, globals, tags, pages, data, flags, noTreeshake = false) =
 
       if (typeCount !== 0) localDecl.push(encodeLocal(typeCount, lastType));
 
-      return encodeVector([ ...encodeVector(localDecl), ...x.wasm.flat().filter(x => x != null && x <= 0xff), Opcodes.end ]);
+      // todo: move const, call transforms here too?
+
+      const wasm = [];
+      for (let i = 0; i < x.wasm.length; i++) {
+        let o = x.wasm[i];
+
+        if (
+          (o[0] === Opcodes.local_get || o[0] === Opcodes.local_set || o[0] === Opcodes.local_tee || o[0] === Opcodes.global_get || o[0] === Opcodes.global_set) &&
+          o[1] > 127
+        ) {
+          const n = o[1];
+          o = [...o];
+          o.pop();
+          unsignedLEB128_into(n, o);
+        }
+
+        wasm.push(...o);
+      }
+
+      return encodeVector([ ...encodeVector(localDecl), ...wasm.flat().filter(x => x != null && x <= 0xff), Opcodes.end ]);
     }))
   );
 

package/compiler/builtins/_internal_object.ts

@@ -269,6 +269,51 @@ local.set ${err}`;
     0, 12);
 };
 
+export const __Porffor_object_delete = (_this: object, key: any): boolean => {
+  const entryPtr: i32 = __Porffor_object_lookup(_this, key);
+  if (entryPtr == -1) {
+    // not found, stop
+    return true;
+  }
+
+  const tail: i32 = Porffor.wasm.i32.load16_u(entryPtr, 0, 12);
+  if (!(tail & 0b0010)) {
+    // not configurable
+    // todo: throw in strict mode
+    return false;
+  }
+
+  const ind: i32 = (entryPtr - Porffor.wasm`local.get ${_this}`) / 14;
+
+  // decrement size
+  let size: i32 = Porffor.wasm.i32.load(_this, 0, 0);
+  Porffor.wasm.i32.store(_this, --size, 0, 0);
+
+  if (size > ind) {
+    // offset all elements after by -1 ind
+    Porffor.wasm`
+;; dst = entryPtr
+local.get ${entryPtr}
+
+;; src = entryPtr + 14 (+ 1 entry)
+local.get ${entryPtr}
+i32.const 14
+i32.add
+
+;; size = (size - ind) * 14
+local.get ${size}
+local.get ${ind}
+i32.sub
+i32.const 14
+i32.mul
+
+memory.copy 0 0`;
+  }
+
+  return true;
+};
+
+
 export const __Porffor_object_isEnumerable = (entryPtr: i32): boolean => {
   const out: boolean = Porffor.wasm.i32.load8_u(entryPtr, 0, 12) & 0b0100;
   return out;
@@ -280,7 +325,6 @@ export const __Porffor_object_isObject = (arg: any): boolean => {
   return Porffor.fastAnd(
     arg != 0, // null
     t > 0x05,
-    t != Porffor.TYPES.undefined,
     t != Porffor.TYPES.string,
     t != Porffor.TYPES.bytestring,
   );
@@ -291,7 +335,6 @@ export const __Porffor_object_isObjectOrSymbol = (arg: any): boolean => {
   return Porffor.fastAnd(
     arg != 0, // null
     t > 0x04,
-    t != Porffor.TYPES.undefined,
     t != Porffor.TYPES.string,
     t != Porffor.TYPES.bytestring,
   );

package/compiler/builtins/reflect.ts

@@ -0,0 +1,132 @@
+import type {} from './porffor.d.ts';
+
+// todo: support receiver
+export const __Reflect_get = (target: any, prop: any) => {
+  if (!Porffor.object.isObject(target)) throw new TypeError('Target is a non-object');
+
+  return target[prop];
+};
+
+// todo: support receiver
+export const __Reflect_set = (target: any, prop: any, value: any) => {
+  if (!Porffor.object.isObject(target)) throw new TypeError('Target is a non-object');
+
+  try {
+    target[prop] = value;
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+export const __Reflect_has = (target: any, prop: any) => {
+  if (!Porffor.object.isObject(target)) throw new TypeError('Target is a non-object');
+
+  return prop in target;
+};
+
+export const __Reflect_defineProperty = (target: any, prop: any, descriptor: any) => {
+  if (!Porffor.object.isObject(target)) throw new TypeError('Target is a non-object');
+  if (!Porffor.object.isObject(descriptor)) throw new TypeError('Descriptor is a non-object');
+
+  try {
+    Object.defineProperty(target, prop, descriptor);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+export const __Reflect_deleteProperty = (target: any, prop: any) => {
+  if (!Porffor.object.isObject(target)) throw new TypeError('Target is a non-object');
+
+  return delete target[prop];
+};
+
+export const __Reflect_getOwnPropertyDescriptor = (target: any, prop: any) => {
+  if (!Porffor.object.isObject(target)) throw new TypeError('Target is a non-object');
+
+  return Object.getOwnPropertyDescriptor(target, prop);
+};
+
+export const __Reflect_isExtensible = (target: any) => {
+  if (!Porffor.object.isObject(target)) throw new TypeError('Target is a non-object');
+
+  return Object.isExtensible(target);
+};
+
+export const __Reflect_preventExtensions = (target: any) => {
+  if (!Porffor.object.isObject(target)) throw new TypeError('Target is a non-object');
+
+  try {
+    Object.preventExtensions(target);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+export const __Reflect_ownKeys = (target: any) => {
+  if (!Porffor.object.isObject(target)) throw new TypeError('Target is a non-object');
+
+  const out: any[] = Porffor.allocate();
+
+  const t: i32 = Porffor.rawType(target);
+  if (t == Porffor.TYPES.object) {
+    let ptr: i32 = Porffor.wasm`local.get ${target}` + 5;
+    const endPtr: i32 = ptr + Porffor.wasm.i32.load(target, 0, 0) * 14;
+
+    let i: i32 = 0;
+    for (; ptr < endPtr; ptr += 14) {
+      let key: any;
+      Porffor.wasm`local raw i32
+local msb i32
+local.get ${ptr}
+i32.to_u
+i32.load 0 0
+local.set raw
+
+local.get raw
+i32.const 30
+i32.shr_u
+local.tee msb
+if 127
+  i32.const 5 ;; symbol
+  i32.const 67 ;; string
+  local.get msb
+  i32.const 3
+  i32.eq
+  select
+  local.set ${key+1}
+
+  local.get raw
+  i32.const 1073741823
+  i32.and ;; unset 2 MSBs
+else
+  i32.const 195
+  local.set ${key+1}
+
+  local.get raw
+end
+i32.from_u
+local.set ${key}`;
+
+      out[i++] = key;
+    }
+
+    out.length = i;
+  } else if (Porffor.fastOr(
+    t == Porffor.TYPES.array,
+    t == Porffor.TYPES.bytestring,
+    t == Porffor.TYPES.string
+  )) {
+    const len: i32 = target.length;
+    out.length = len;
+
+    for (let i: i32 = 0; i < len; i++) {
+      out[i] = __Number_prototype_toString(i);
+    }
+  }
+
+  return out;
+};

package/compiler/codegen.js

@@ -39,7 +39,7 @@ const todo = (scope, msg, expectsValue = undefined) => {
 const isFuncType = type =>
   type === 'FunctionDeclaration' || type === 'FunctionExpression' || type === 'ArrowFunctionExpression';
 const hasFuncWithName = name =>
-  Object.hasOwn(funcIndex, name) != null || Object.hasOwn(builtinFuncs, name) != null || Object.hasOwn(importedFuncs, name) != null || Object.hasOwn(internalConstrs, name) != null;
+  Object.hasOwn(funcIndex, name) || Object.hasOwn(builtinFuncs, name) || Object.hasOwn(importedFuncs, name) || Object.hasOwn(internalConstrs, name);
 
 const astCache = new WeakMap();
 const cacheAst = (decl, wasm) => {
@@ -164,6 +164,8 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
       return cacheAst(decl, generateMember(scope, decl, global, name));
 
     case 'ExportNamedDeclaration':
+      if (!decl.declaration) return todo(scope, 'unsupported export declaration');
+
       const funcsBefore = funcs.map(x => x.name);
       generate(scope, decl.declaration);
 
@@ -2835,14 +2837,20 @@ const generateVar = (scope, decl) => {
         scope.globalInits[name] = newOut;
       }
     }
-
-    // hack: this follows spec properly but is mostly unneeded 😅
-    // out.push(...setType(scope, name, x.init ? getNodeType(scope, x.init) : TYPES.undefined));
   }
 
   return out;
 };
 
+const getMemberProperty = decl => {
+  if (decl.computed) return decl.property;
+
+  return {
+    type: 'Literal',
+    value: decl.property.name
+  };
+};
+
 // todo: optimize this func for valueUnused
 const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
   const { type, name } = decl.left;
@@ -2897,10 +2905,7 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
     const pointerTmp = localTmp(scope, '#member_setter_ptr_tmp', Valtype.i32);
 
     const object = decl.left.object;
-    const property = decl.left.computed ? decl.left.property : {
-      type: 'Literal',
-      value: decl.left.property.name
-    };
+    const property = getMemberProperty(decl.left);
 
     // todo/perf: use i32 object (and prop?) locals
     const objectWasm = [ [ Opcodes.local_get, localTmp(scope, '#member_obj') ] ];
@@ -3249,6 +3254,25 @@ const generateUnary = (scope, decl) => {
     }
 
     case 'delete': {
+      if (decl.argument.type === 'MemberExpression') {
+        const object = decl.argument.object;
+        const property = getMemberProperty(decl.argument);
+
+        return [
+          ...generate(scope, object),
+          Opcodes.i32_to_u,
+          ...getNodeType(scope, object),
+
+          ...generate(scope, property),
+          ...getNodeType(scope, property),
+          ...toPropertyKey(scope, true),
+
+          [ Opcodes.call, ...unsignedLEB128(includeBuiltin(scope, '__Porffor_object_delete').index) ],
+          [ Opcodes.drop ],
+          Opcodes.i32_from_u
+        ];
+      }
+
       let toReturn = true, toGenerate = true;
 
       if (decl.argument.type === 'Identifier') {
@@ -3256,6 +3280,7 @@ const generateUnary = (scope, decl) => {
 
         // if ReferenceError (undeclared var), ignore and return true. otherwise false
         if (!out[1]) {
+          // todo: throw in strict mode
           // exists
           toReturn = false;
         } else {
@@ -4654,20 +4679,29 @@ const generateMember = (scope, decl, _global, _name) => {
       return number(0);
     }
 
+    const useTmp = !Prefs.lengthNoTmp;
+    const tmp = useTmp && localTmp(scope, '#length_tmp', Valtype.i32);
     return [
-      ...out,
-      [ Opcodes.local_set, localTmp(scope, '#length_tmp', Valtype.i32) ],
+      ...(useTmp ? [
+        ...out,
+        [ Opcodes.local_set, tmp ],
+      ] : []),
 
       ...getNodeType(scope, decl.object),
       ...number(TYPE_FLAGS.length, Valtype.i32),
       [ Opcodes.i32_and ],
       [ Opcodes.if, valtypeBinary ],
-        [ Opcodes.local_get, localTmp(scope, '#length_tmp', Valtype.i32) ],
+        ...(useTmp ? [ [ Opcodes.local_get, tmp ] ] : out),
         [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
         Opcodes.i32_from_u,
 
         ...setLastType(scope, TYPES.number),
       [ Opcodes.else ],
+        ...(useTmp ? [] : [
+          ...out,
+          [ Opcodes.drop ]
+        ]),
+
         ...number(0),
         ...setLastType(scope, TYPES.undefined),
       [ Opcodes.end ]
@@ -4703,10 +4737,7 @@ const generateMember = (scope, decl, _global, _name) => {
   }
 
   const object = decl.object;
-  const property = decl.computed ? decl.property : {
-    type: 'Literal',
-    value: decl.property.name
-  };
+  const property = getMemberProperty(decl);
 
   // todo/perf: use i32 object (and prop?) locals
   const objectWasm = [ [ Opcodes.local_get, localTmp(scope, '#member_obj') ] ];