porffor 0.55.22 → 0.55.24

package/compiler/codegen.js

@@ -848,13 +848,6 @@ const truthy = (scope, wasm, type, intIn = false, intOut = false, forceTruthyMod
       ] ] ] : []),
 
       [ 'default', def ]
-
-      // [ [ TYPES.boolean, TYPES.number, TYPES.object, TYPES.undefined, TYPES.empty ], def ],
-      // [ 'default', [
-      //   // other types are always truthy
-      //   ...(!useTmp ? [ [ Opcodes.drop ] ] : []),
-      //   number(1, intOut ? Valtype.i32 : valtypeBinary)
-      // ] ]
     ], intOut ? Valtype.i32 : valtypeBinary)
   ];
 };
@@ -921,13 +914,6 @@ const falsy = (scope, wasm, type, intIn = false, intOut = false, forceTruthyMode
       ] ] ] : []),
 
       [ 'default', def ]
-
-      // [ [ TYPES.boolean, TYPES.number, TYPES.object, TYPES.undefined, TYPES.empty ], def ],
-      // [ 'default', [
-      //   // other types are always truthy
-      //   ...(!useTmp ? [ [ Opcodes.drop ] ] : []),
-      //   number(0, intOut ? Valtype.i32 : valtypeBinary)
-      // ] ]
     ], intOut ? Valtype.i32 : valtypeBinary)
   ];
 };
@@ -1539,7 +1525,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 +1557,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;
@@ -1741,7 +1709,6 @@ const getNodeType = (scope, node) => {
   if (guess != null) out.guess = typeof guess === 'number' ? [ number(guess, Valtype.i32) ] : guess;
 
   typeUsed(scope, knownType(scope, out));
-
   return out;
 };
 
@@ -1860,29 +1827,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',
@@ -1932,8 +1876,6 @@ const aliasPrimObjsBC = bc => {
   const add = (x, y) => {
     if (bc[x] == null) return;
 
-    // bc[`${x},${y}`] = original;
-
     // intentionally duplicate to avoid extra bc for prim objs as rarely used
     bc[y] = bc[x];
   };
@@ -1967,32 +1909,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 +2285,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 +2710,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 = () => ({
@@ -3160,8 +3107,6 @@ const extractTypeAnnotation = decl => {
   const typeName = type;
   type = typeAnnoToPorfType(type);
 
-  // if (decl.name) console.log(decl.name, { type, elementType });
-
   return { type, typeName, elementType };
 };
 
@@ -3587,6 +3532,8 @@ const memberTmpNames = scope => {
 
 // COCTC: cross-object compile-time cache
 const coctcOffset = prop => {
+  if (!Prefs.coctc) return 0;
+
   if (typeof prop === 'object') {
     if (
       prop.computed || prop.optional ||
@@ -3727,7 +3674,7 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
     // todo/perf: use i32 object (and prop?) locals
     const { objectTmp, propertyTmp, objectGet, propertyGet } = memberTmpNames(scope);
 
-    const useCoctc = Prefs.coctc && coctcOffset(decl.left) > 0;
+    const useCoctc = coctcOffset(decl.left) > 0;
     if (useCoctc) valueUnused = false;
 
     // opt: do not mark prototype funcs as referenced to optimize this in them
@@ -4173,7 +4120,7 @@ const generateUnary = (scope, decl) => {
         const property = getProperty(decl.argument);
         if (property.value === 'length' || property.value === 'name') scope.noFastFuncMembers = true;
 
-        const useCoctc = Prefs.coctc && coctcOffset(decl.argument) > 0;
+        const useCoctc = coctcOffset(decl.argument) > 0;
         const objectTmp = useCoctc && localTmp(scope, '#coctc_object', Valtype.i32);
 
         const out = [
@@ -4887,7 +4834,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 +4867,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 +4899,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 +4907,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 ],
 
@@ -5694,7 +5641,7 @@ const generateMember = (scope, decl, _global, _name) => {
 
     const out = [
       ...generate(scope, object),
-      Opcodes.i32_to_u,
+      Opcodes.i32_to_u
     ];
 
     if (Prefs.fastLength) {
@@ -5721,7 +5668,7 @@ const generateMember = (scope, decl, _global, _name) => {
       ...out,
       [ Opcodes.local_set, tmp ],
 
-      ...getNodeType(scope, object),
+      ...type,
       number(TYPE_FLAGS.length, Valtype.i32),
       [ Opcodes.i32_and ],
       [ Opcodes.if, valtypeBinary ],
@@ -5743,6 +5690,8 @@ const generateMember = (scope, decl, _global, _name) => {
 
   // todo/perf: use i32 object (and prop?) locals
   const { objectTmp, propertyTmp, objectGet, propertyGet } = memberTmpNames(scope);
+  const type = getNodeType(scope, object);
+  const known = knownType(scope, type);
 
   // todo: generate this array procedurally during builtinFuncs creation
   if (['size', 'description', 'byteLength', 'byteOffset', 'buffer', 'detached', 'resizable', 'growable', 'maxByteLength'].includes(decl.property.name)) {
@@ -5750,7 +5699,6 @@ const generateMember = (scope, decl, _global, _name) => {
     const bc = {};
     const cands = Object.keys(builtinFuncs).filter(x => x.startsWith('__') && x.endsWith('_prototype_' + decl.property.name + '$get'));
 
-    const known = knownType(scope, getNodeType(scope, object));
     if (cands.length > 0) {
       for (const x of cands) {
         const type = TYPES[x.split('_prototype_')[0].slice(2).toLowerCase()];
@@ -5786,64 +5734,10 @@ 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 useCoctc = coctcOffset(decl) > 0;
   const coctcObjTmp = useCoctc && localTmp(scope, '#coctc_obj' + uniqId(), Valtype.i32);
 
-  const out = typeSwitch(scope, getNodeType(scope, object), {
+  const out = typeSwitch(scope, type, {
     ...(decl.computed ? {
       [TYPES.array]: () => [
         propertyGet,
@@ -6009,22 +5903,17 @@ 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: () => [
-      // ...(useCoctc ? [
-      //   [ Opcodes.local_get, coctcObjTmp ],
-      //   number(TYPES.object, Valtype.i32)
-      // ] : [
-      //   objectGet,
-      //   Opcodes.i32_to,
-      //   ...getNodeType(scope, object)
-      // ]),
-
-      objectGet,
-      Opcodes.i32_to,
-      ...getNodeType(scope, object),
+      ...(useCoctc && known === TYPES.object ? [
+        [ Opcodes.local_get, coctcObjTmp ],
+        number(TYPES.object, Valtype.i32)
+      ] : [
+        objectGet,
+        Opcodes.i32_to,
+        ...type
+      ]),
 
       ...toPropertyKey(scope, [ propertyGet ], getNodeType(scope, property), decl.computed, true),
 
@@ -6044,7 +5933,7 @@ const generateMember = (scope, decl, _global, _name) => {
       ...generate(scope, object),
       [ Opcodes.local_tee, objectTmp ],
 
-      ...nullish(scope, [], getNodeType(scope, object), false, true),
+      ...nullish(scope, [], type, false, true),
       [ Opcodes.if, Blocktype.void ],
         ...setLastType(scope, TYPES.undefined),
         number(0),
@@ -6164,10 +6053,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 +6258,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 +6332,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;
@@ -7035,39 +6938,6 @@ export default program => {
     f.wasm = f.returns.map(x => number(0, x));
   }
 
-  // // remove never generated functions
-  // let indexDelta = 0;
-  // const funcRemap = new Map();
-  // for (let i = 0; i < funcs.length; i++) {
-  //   const f = funcs[i];
-  //   if (f.internal || f.wasm) {
-  //     if (indexDelta) {
-  //       funcRemap.set(f.index, f.index - indexDelta);
-  //       f.index -= indexDelta;
-  //     }
-  //     continue;
-  //   }
-
-  //   funcs.splice(i--, 1);
-  //   indexDelta++;
-  // }
-
-  // // remap call ops
-  // if (indexDelta) for (let i = 0; i < funcs.length; i++) {
-  //   const wasm = funcs[i].wasm;
-  //   for (let j = 0; j < wasm.length; j++) {
-  //     const op = wasm[j];
-  //     if (op[0] === Opcodes.call) {
-  //       let idx = op[1];
-  //       wasm[j] = [ Opcodes.call, funcRemap.get(idx) ?? idx ];
-  //     }
-
-  //     if (op[0] === Opcodes.const && op[2] === 'funcref') {
-  //       wasm[j] = [ Opcodes.const, funcRemap.get(op[1] + importedFuncs.length) - importedFuncs.length ];
-  //     }
-  //   }
-  // }
-
   // add indirect funcs to end of funcs
   for (let i = 0; i < indirectFuncs.length; i++) {
     const f = indirectFuncs[i];

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) {