porffor 0.55.22 → 0.55.23

package/compiler/codegen.js

@@ -1539,7 +1539,7 @@ const getNodeType = (scope, node) => {
       return getType(scope, node.name);
     }
 
-    if (node.type === 'ObjectExpression') {
+    if (node.type === 'ObjectExpression' || node.type === 'Super') {
       return TYPES.object;
     }
 
@@ -1571,24 +1571,6 @@ const getNodeType = (scope, node) => {
       if (Object.hasOwn(builtinFuncs, name) && builtinFuncs[name].returnType != null) return builtinFuncs[name].returnType;
       if (Object.hasOwn(internalConstrs, name) && internalConstrs[name].type != null) return internalConstrs[name].type;
 
-      // check if this is a prototype function
-      // if so and there is only one impl (eg charCodeAt)
-      // or all impls have the same return type
-      // use that return type as that is the only possibility
-      // (if non-matching type it would error out)
-      if (name.startsWith('__')) {
-        const spl = name.slice(2).split('_');
-
-        const func = spl[spl.length - 1];
-        const protoFuncs = Object.keys(prototypeFuncs).filter(x => x != TYPES.bytestring && prototypeFuncs[x][func] != null);
-        if (
-          protoFuncs.length === 1 ||
-          (protoFuncs.length > 1 && protoFuncs.every(x => x.returnType === protoFuncs[0].returnType))
-        ) {
-          if (protoFuncs[0].returnType != null) return protoFuncs[0].returnType;
-        }
-      }
-
       if (name.startsWith('__Porffor_wasm_')) {
         // todo: return undefined for non-returning ops
         return TYPES.number;
@@ -1860,29 +1842,6 @@ const createNewTarget = (scope, decl, idx = 0, force = false) => {
   ];
 };
 
-const makeObject = (scope, obj) => {
-  const properties = [];
-  for (const x in obj) {
-    properties.push({
-      type: 'Property',
-      method: false,
-      shorthand: false,
-      computed: false,
-      key: {
-        type: 'Identifier',
-        name: x
-      },
-      value: obj[x],
-      kind: 'init'
-    });
-  }
-
-  return generate(scope, {
-    type: 'ObjectExpression',
-    properties
-  });
-};
-
 const getObjProp = (obj, prop) => {
   if (typeof obj === 'string') obj = {
     type: 'Identifier',
@@ -1967,32 +1926,22 @@ const createThisArg = (scope, decl) => {
       number(TYPES.object, Valtype.i32)
     ];
 
-    // create new object with __proto__ set to callee prototype
+    // create new object with prototype set to callee prototype
     const tmp = localTmp(scope, '#this_create_tmp');
     const proto = getObjProp(decl.callee, 'prototype');
 
     return [
-      ...makeObject(scope, {}),
+      [ Opcodes.call, includeBuiltin(scope, '__Porffor_allocate').index ],
+      Opcodes.i32_from_u,
       [ Opcodes.local_tee, tmp ],
       Opcodes.i32_to_u,
-
       number(TYPES.object, Valtype.i32),
 
-      ...generate(scope, {
-        type: 'Literal',
-        value: '__proto__'
-      }),
-      Opcodes.i32_to_u,
-      number(TYPES.bytestring, Valtype.i32),
-
       ...generate(scope, proto),
+      Opcodes.i32_to_u,
       ...getNodeType(scope, proto),
 
-      // flags: writable
-      number(0b1000, Valtype.i32),
-      number(TYPES.number, Valtype.i32),
-
-      [ Opcodes.call, includeBuiltin(scope, '__Porffor_object_expr_initWithFlags').index ],
+      [ Opcodes.call, includeBuiltin(scope, '__Porffor_object_setPrototype').index ],
 
       [ Opcodes.local_get, tmp ],
       number(TYPES.object, Valtype.i32)
@@ -2353,30 +2302,34 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
           const protoLocal2 = protoFunc.local2 ? localTmp(scope, `__${protoName}_tmp2`, protoFunc.local2) : -1;
 
           let optUnused = false;
-          const protoOut = protoFunc(getPointer, {
-            getCachedI32: () => [ [ Opcodes.local_get, lengthLocal ] ],
-            setCachedI32: () => [ [ Opcodes.local_set, lengthLocal ] ],
-            get: () => ArrayUtil.getLength(getPointer),
-            getI32: () => ArrayUtil.getLengthI32(getPointer),
-            set: value => ArrayUtil.setLength(getPointer, value),
-            setI32: value => ArrayUtil.setLengthI32(getPointer, value)
-          },
-          generate(scope, decl.arguments[0] ?? DEFAULT_VALUE()),
-          getNodeType(scope, decl.arguments[0] ?? DEFAULT_VALUE()),
-          protoLocal, protoLocal2,
-          bytes => [
-            number(bytes, Valtype.i32),
-            [ Opcodes.call, includeBuiltin(scope, '__Porffor_allocateBytes').index ]
-          ],
-          () => {
-            optUnused = true;
-            return unusedValue;
+          const protoOut = protoFunc({
+            pointer: getPointer,
+            length: {
+              getCachedI32: () => [ [ Opcodes.local_get, lengthLocal ] ],
+              setCachedI32: () => [ [ Opcodes.local_set, lengthLocal ] ],
+              get: () => ArrayUtil.getLength(getPointer),
+              getI32: () => ArrayUtil.getLengthI32(getPointer),
+              set: value => ArrayUtil.setLength(getPointer, value),
+              setI32: value => ArrayUtil.setLengthI32(getPointer, value)
+            },
+            arg: generate(scope, decl.arguments[0] ?? DEFAULT_VALUE()),
+            argType: getNodeType(scope, decl.arguments[0] ?? DEFAULT_VALUE()),
+            iTmp: protoLocal,
+            iTmp2: protoLocal2,
+            alloc: bytes => [
+              number(bytes, Valtype.i32),
+              [ Opcodes.call, includeBuiltin(scope, '__Porffor_allocateBytes').index ]
+            ],
+            unusedValue: () => {
+              optUnused = true;
+              return unusedValue;
+            },
+            setType: type => setLastType(scope, type)
           });
 
           return [
             [ Opcodes.block, unusedValue ? Blocktype.void : valtypeBinary ],
               ...protoOut,
-              ...(unusedValue && optUnused ? [] : (protoFunc.returnType != null ? setLastType(scope, protoFunc.returnType) : setLastType(scope))),
               ...(unusedValue && !optUnused ? [ [ Opcodes.drop ] ] : []),
             [ Opcodes.end ]
           ];
@@ -2774,8 +2727,19 @@ const generateThis = (scope, decl) => {
   ];
 };
 
-const generateSuper = (scope, decl) => generate(scope,
-  getObjProp(getObjProp({ type: 'ThisExpression', _noGlobalThis: true }, '__proto__'), '__proto__'));
+const generateSuper = (scope, decl) => generate(scope, {
+  type: 'CallExpression',
+  callee: { type: 'Identifier', name: '__Porffor_object_getPrototype' },
+  arguments: [
+    {
+      type: 'CallExpression',
+      callee: { type: 'Identifier', name: '__Porffor_object_getPrototype' },
+      arguments: [
+        { type: 'ThisExpression', _noGlobalThis: true }
+      ]
+    }
+  ]
+});
 
 // bad hack for undefined and null working without additional logic
 const DEFAULT_VALUE = () => ({
@@ -4887,7 +4851,7 @@ const generateForIn = (scope, decl) => {
 
     // get length
     [ Opcodes.local_get, pointer ],
-    [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
+    [ Opcodes.i32_load16_u, 0, 0 ],
     [ Opcodes.local_tee, length ],
 
     [ Opcodes.if, Blocktype.void ]
@@ -4920,7 +4884,7 @@ const generateForIn = (scope, decl) => {
 
     // read key
     [ Opcodes.local_get, pointer ],
-    [ Opcodes.i32_load, 0, 5 ],
+    [ Opcodes.i32_load, 0, 12 ],
     [ Opcodes.local_tee, tmp ],
 
     ...setType(scope, tmpName, [
@@ -4952,7 +4916,7 @@ const generateForIn = (scope, decl) => {
     // todo/perf: do not read key for non-enumerables
     // only run body if entry is enumerable
     [ Opcodes.local_get, pointer ],
-    [ Opcodes.i32_load8_u, 0, 17 ],
+    [ Opcodes.i32_load8_u, 0, 24 ],
     [ Opcodes.i32_const, 0b0100 ],
     [ Opcodes.i32_and ],
     [ Opcodes.if, Blocktype.void ],
@@ -4960,9 +4924,9 @@ const generateForIn = (scope, decl) => {
     [ Opcodes.drop ],
     [ Opcodes.end ],
 
-    // increment pointer by 14
+    // increment pointer by 18
     [ Opcodes.local_get, pointer ],
-    number(14, Valtype.i32),
+    number(18, Valtype.i32),
     [ Opcodes.i32_add ],
     [ Opcodes.local_set, pointer ],
 
@@ -5786,60 +5750,6 @@ const generateMember = (scope, decl, _global, _name) => {
     if (known == null) extraBC = bc;
   }
 
-  if (decl.property.name === '__proto__') {
-    // todo: support optional
-    const bc = {};
-    const prototypes = Object.keys(builtinVars).filter(x => x.endsWith('_prototype'));
-
-    const known = knownType(scope, getNodeType(scope, decl.object));
-    for (const x of prototypes) {
-      let type = TYPES[x.split('_prototype')[0].slice(2).toLowerCase()];
-      if (type == null) continue;
-
-      // do not __proto__ primitive hack for objects or functions
-      if (type === TYPES.object || type === TYPES.function) continue;
-
-      // hack: do not support primitives for Object.prototype.isPrototypeOf
-      if (scope.name === '__Object_prototype_isPrototypeOf') {
-        switch (type) {
-          case TYPES.boolean:
-            type = TYPES.booleanobject;
-            break;
-
-          case TYPES.number:
-            type = TYPES.numberobject;
-            break;
-
-          case TYPES.string:
-            type = TYPES.stringobject;
-            break;
-
-          case TYPES.bytestring:
-            continue;
-        }
-      }
-
-      const ident = {
-        type: 'Identifier',
-        name: x
-      };
-
-      // hack: bytestrings should return string prototype
-      if (type === TYPES.bytestring) ident.name = '__String_prototype';
-
-      bc[type] = () => [
-        ...generate(scope, ident),
-        ...setLastType(scope, getNodeType(scope, ident))
-      ];
-      if (type === known) return bc[type]();
-    }
-
-    if (known == null) {
-      aliasPrimObjsBC(bc);
-      extraBC = bc;
-    }
-  }
-
   const useCoctc = Prefs.coctc && coctcOffset(decl) > 0;
   const coctcObjTmp = useCoctc && localTmp(scope, '#coctc_obj' + uniqId(), Valtype.i32);
 
@@ -6009,7 +5919,7 @@ const generateMember = (scope, decl, _global, _name) => {
       }),
     } : {}),
 
-    [TYPES.undefined]: internalThrow(scope, 'TypeError', 'Cannot read property of undefined', true),
+    [TYPES.undefined]: internalThrow(scope, 'TypeError', `Cannot read property of undefined`, true),
 
     // default: internalThrow(scope, 'TypeError', 'Unsupported member expression object', true)
     default: () => [
@@ -6164,10 +6074,25 @@ const generateClass = (scope, decl) => {
       // class Foo {}
       // class Bar extends Foo {}
       // Bar.__proto__ = Foo
-      // Bar.prototype.__proto__ = Foo.prototype
-      ...generate(scope, setObjProp(root, '__proto__', decl.superClass)),
+      ...generate(scope, {
+        type: 'CallExpression',
+        callee: { type: 'Identifier', name: '__Porffor_object_setPrototype' },
+        arguments: [
+          root,
+          decl.superClass
+        ]
+      }),
       [ Opcodes.drop ],
-      ...generate(scope, setObjProp(proto, '__proto__', getObjProp(decl.superClass, 'prototype'))),
+
+      // Bar.prototype.__proto__ = Foo.prototype
+      ...generate(scope, {
+        type: 'CallExpression',
+        callee: { type: 'Identifier', name: '__Porffor_object_setPrototype' },
+        arguments: [
+          proto,
+          getObjProp(decl.superClass, 'prototype')
+        ]
+      }),
       [ Opcodes.drop ]
     );
   }
@@ -6354,7 +6279,7 @@ const generateTaggedTemplate = (scope, decl, global = false, name = undefined, v
               return funcIndex[x];
             }
 
-            return scope.locals[x]?.idx ?? globals[x].idx;
+            return scope.locals[x]?.idx ?? globals[x]?.idx ?? (log.warning('codegen', `unknown immediate in Porffor.wasm: ${x}`) || 0);
           }
 
           return n;
@@ -6428,7 +6353,6 @@ const objectHack = node => {
 
       // hack: block these properties as they can be accessed on functions
       if (node.object.name !== 'Porffor' && (node.property.name === 'length' || node.property.name === 'name' || node.property.name === 'call')) return abortOut;
-
       if (node.property.name === '__proto__') return abortOut;
 
       let objectName = node.object.name;

package/compiler/precompile.js

@@ -1,6 +1,6 @@
 import { Opcodes, Valtype } from './wasmSpec.js';
 import { read_signedLEB128, read_unsignedLEB128 } from './encoding.js';
-import { TYPES } from './types.js';
+import { TYPES, TYPE_NAMES } from './types.js';
 import { log } from './log.js';
 
 import process from 'node:process';
@@ -41,7 +41,7 @@ const compile = async (file, _funcs) => {
   let first = source.slice(0, source.indexOf('\n'));
 
   if (first.startsWith('export default')) {
-    source = await (await import('file://' + file)).default();
+    source = await (await import('file://' + file)).default({ TYPES, TYPE_NAMES });
     first = source.slice(0, source.indexOf('\n'));
   }
 
@@ -155,11 +155,10 @@ const compile = async (file, _funcs) => {
         }
 
         if (n[0] === Opcodes.throw) {
-          if (!bodyHasTopLevelThrow && depth === 0) log.warning('codegen', `top-level throw in ${x.name}`);
-
           x.usesTag = true;
+          let id;
           if (y[0] === Opcodes.i32_const && n[1] === 0) {
-            const id = read_signedLEB128(y.slice(1));
+            id = read_signedLEB128(y.slice(1));
             y.splice(0, 10, 'throw', exceptions[id].constructor, exceptions[id].message);
 
             // remove throw inst
@@ -167,6 +166,8 @@ const compile = async (file, _funcs) => {
           } else {
             n[1]--;
           }
+
+          if (!bodyHasTopLevelThrow && depth === 0) log.warning('codegen', `top-level throw in ${x.name} (${exceptions[id].constructor}: ${exceptions[id].message})`);
         }
 
         if (n[0] === Opcodes.catch) {