porffor 0.24.12 → 0.24.14

package/compiler/codegen.js

@@ -91,6 +91,9 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
     case 'NewExpression':
       return cacheAst(decl, generateNew(scope, decl, global, name));
 
+    case 'ThisExpression':
+      return cacheAst(decl, generateThis(scope, decl, global, name));
+
     case 'Literal':
       return cacheAst(decl, generateLiteral(scope, decl, global, name));
 
@@ -351,22 +354,33 @@ const generateIdent = (scope, decl) => {
 };
 
 const generateReturn = (scope, decl) => {
-  if (decl.argument === null) {
-    // just bare "return"
-    return [
-      ...number(UNDEFINED), // "undefined" if func returns
-      ...(scope.returnType != null ? [] : [
-        ...number(TYPES.undefined, Valtype.i32) // type undefined
-      ]),
-      [ Opcodes.return ]
-    ];
+  const arg = decl.argument ?? DEFAULT_VALUE();
+
+  const out = [];
+  if (
+    scope.constr && // only do this in constructors
+    !globalThis.precompile // skip in precompiled built-ins, we should not require this and handle it ourselves
+  ) {
+    // ignore return value and return this if being constructed
+    out.push(
+      // ...truthy(scope, [ [ Opcodes.local_get, '#newtarget' ] ], [ [ Opcodes.local_get, '#newtarget#type' ] ], false, true),
+      [ Opcodes.local_get, '#newtarget' ],
+      Opcodes.i32_to_u,
+      [ Opcodes.if, Blocktype.void ],
+        [ Opcodes.local_get, '#this' ],
+        ...(scope.returnType != null ? [] : [ [ Opcodes.local_get, '#this#type' ] ]),
+        [ Opcodes.return ],
+      [ Opcodes.end ]
+    );
   }
 
-  return [
-    ...generate(scope, decl.argument),
-    ...(scope.returnType != null ? [] : getNodeType(scope, decl.argument)),
+  out.push(
+    ...generate(scope, arg),
+    ...(scope.returnType != null ? [] : getNodeType(scope, arg)),
     [ Opcodes.return ]
-  ];
+  );
+
+  return out;
 };
 
 const localTmp = (scope, name, type = valtypeBinary) => {
@@ -1303,26 +1317,6 @@ const asmFunc = (name, { wasm, params = [], typedParams = false, locals: localTy
     funcs.table = true;
   }
 
-  if (constr) {
-    func.params = [...func.params];
-    func.params.unshift(Valtype.i32);
-
-    // move all locals +1 idx (sigh)
-    func.localInd++;
-    const locals = func.locals;
-    for (const x in locals) {
-      locals[x].idx++;
-    }
-
-    locals['#newtarget'] = { idx: 0, type: Valtype.i32 };
-
-    for (const inst of wasm) {
-      if (inst[0] === Opcodes.local_get || inst[0] === Opcodes.local_set || inst[0] === Opcodes.local_tee) {
-        inst[1]++;
-      }
-    }
-  }
-
   if (hasRestArgument) func.hasRestArgument = true;
 
   func.wasm = wasm;
@@ -1605,6 +1599,22 @@ const getNodeType = (scope, node) => {
       }
     }
 
+    if (node.type == 'ThisExpression') {
+      if (!scope.constr) return getType(scope, 'globalThis');
+      return [ [ Opcodes.local_get, '#this#type' ] ];
+    }
+
+    if (node.type == 'MetaProperty') {
+      switch (`${node.meta.name}.${node.property.name}`) {
+        case 'new.target': {
+          return [ [ Opcodes.local_get, '#newtarget#type' ] ];
+        }
+
+        default:
+          return todo(scope, `meta property object ${node.meta.name} is not supported yet`, true);
+      }
+    }
+
     if (scope.locals['#last_type']) return getLastType(scope);
 
     // presume
@@ -1762,6 +1772,42 @@ const RTArrayUtil = {
   ]
 };
 
+const createNewTarget = (scope, decl, idx) => {
+  if (decl._new) {
+    return [
+      ...number(idx),
+      ...number(TYPES.function, Valtype.i32)
+    ];
+  }
+
+  return [
+    ...number(UNDEFINED),
+    ...number(TYPES.undefined, Valtype.i32)
+  ];
+};
+
+const createThisArg = (scope, decl, getFunc, knownThis = undefined) => {
+  if (knownThis) {
+    // todo: check compliance
+    return knownThis;
+  }
+
+  if (decl._new) {
+    // todo: created object should have .prototype = func.prototype
+    // todo: created object should have .constructor = func
+    return [
+      // create an empty object
+      ...generateObject(scope, { properties: [] }),
+      ...number(TYPES.object, Valtype.i32)
+    ];
+  } else {
+    return [
+      ...generate(scope, { type: 'Identifier', name: 'globalThis' }),
+      ...getType(scope, 'globalThis')
+    ];
+  }
+}
+
 const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   let name = mapName(decl.callee.name);
   if (isFuncType(decl.callee.type)) { // iife
@@ -1978,7 +2024,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
           getI32: () => RTArrayUtil.getLengthI32(getPointer),
           set: value => RTArrayUtil.setLength(getPointer, value),
           setI32: value => RTArrayUtil.setLengthI32(getPointer, value)
-        }, generate(scope, decl.arguments[0] ?? DEFAULT_VALUE), getNodeType(scope, decl.arguments[0] ?? DEFAULT_VALUE), protoLocal, protoLocal2, (length, itemType) => {
+        }, generate(scope, decl.arguments[0] ?? DEFAULT_VALUE()), getNodeType(scope, decl.arguments[0] ?? DEFAULT_VALUE()), protoLocal, protoLocal2, (length, itemType) => {
           return makeArray(scope, {
             rawElements: new Array(length)
           }, _global, _name, true, itemType, true);
@@ -2115,7 +2161,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
         const minArgc = Prefs.indirectCallMinArgc ?? 3;
 
         if (args.length < minArgc) {
-          args = args.concat(new Array(minArgc - args.length).fill(DEFAULT_VALUE));
+          args = args.concat(new Array(minArgc - args.length).fill(DEFAULT_VALUE()));
         }
       }
 
@@ -2182,6 +2228,26 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       const funcLocal = localTmp(scope, '#indirect_func', Valtype.i32);
       const flags = localTmp(scope, '#indirect_flags', Valtype.i32);
 
+      let knownThis = undefined;
+      let getCalleeObj = undefined;
+      let initCalleeObj = undefined;
+
+      // hack: this should be more thorough, Function.bind, etc.
+      if (decl.callee.type == 'MemberExpression') {
+        const callee = localTmp(scope, '#indirect_callee_obj', Valtype.f64);
+        initCalleeObj = [
+          ...generate(scope, decl.callee.object),
+          [ Opcodes.local_set, callee ]
+        ];
+        getCalleeObj = [
+          [ Opcodes.local_get, callee ]
+        ];
+        knownThis = [
+          [ Opcodes.local_get, callee ],
+          ...getNodeType(scope, decl.callee.object)
+        ];
+      }
+
       const gen = argc => {
         const argsOut = [];
         for (let i = 0; i < argc; i++) {
@@ -2202,43 +2268,39 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
           [ Opcodes.end ]
         ];
 
-        // pain.
-        // return checkFlag(0b10, [ // constr
-        //   [ Opcodes.i32_const, decl._new ? 1 : 0 ],
-        //   ...argsOut,
-        //   [ Opcodes.local_get, funcLocal ],
-        //   [ Opcodes.call_indirect, argc, 0, 'constr' ],
-        //   ...setLastType(scope),
-        // ], [
-        //   ...argsOut,
-        //   [ Opcodes.local_get, funcLocal ],
-        //   [ Opcodes.call_indirect, argc, 0 ],
-        //   ...setLastType(scope),
-        // ]);
-
-        return checkFlag(0b1, // no type return
-          checkFlag(0b10, [ // no type return & constr
-            [ Opcodes.i32_const, decl._new ? 1 : 0 ],
+        // todo: i'm sure this could be made better somehow, probably only with #96?
+        return checkFlag(0b1,
+          // no type return
+          checkFlag(0b10, [
+            // no type return & constr
+            ...createNewTarget(scope, decl),
+            ...createThisArg(scope, decl, [], knownThis),
             ...argsOut,
             [ Opcodes.local_get, funcLocal ],
-            [ Opcodes.call_indirect, argc, 0, 'no_type_return', 'constr' ],
+            [ Opcodes.call_indirect, argc + 2, 0, 'no_type_return' ],
           ], [
+            // no type return & not constr
             ...argsOut,
             [ Opcodes.local_get, funcLocal ],
             [ Opcodes.call_indirect, argc, 0, 'no_type_return' ]
           ]),
-          checkFlag(0b10, [ // type return & constr
-            [ Opcodes.i32_const, decl._new ? 1 : 0 ],
+
+          // type return
+          checkFlag(0b10, [
+            // type return & constr
+            ...createNewTarget(scope, decl),
+            ...createThisArg(scope, decl, [], knownThis),
             ...argsOut,
             [ Opcodes.local_get, funcLocal ],
-            [ Opcodes.call_indirect, argc, 0, 'constr' ],
+            [ Opcodes.call_indirect, argc + 2, 0 ],
             ...setLastType(scope),
           ], [
+            // type return
             ...argsOut,
             [ Opcodes.local_get, funcLocal ],
             [ Opcodes.call_indirect, argc, 0 ],
             ...setLastType(scope),
-          ]),
+          ])
         );
       };
 
@@ -2250,7 +2312,10 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
       // todo/perf: check if we should use br_table here or just generate our own big if..elses
 
       return [
-        ...generate(scope, decl.callee),
+        ...(getCalleeObj ? [
+          ...initCalleeObj,
+          ...generateMember(scope, decl.callee, false, undefined, getCalleeObj)
+        ]: generate(scope, decl.callee)),
         [ Opcodes.local_set, localTmp(scope, '#indirect_callee') ],
 
         ...typeSwitch(scope, getNodeType(scope, decl.callee), {
@@ -2298,26 +2363,28 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   const userFunc = func && !func.internal;
   const typedParams = userFunc || func?.typedParams;
   const typedReturns = (userFunc && func.returnType == null) || builtinFuncs[name]?.typedReturns;
-  let paramCount = func && (typedParams ? Math.floor(func.params.length / 2) : func.params.length);
+  let paramCount = countParams(func, name);
 
   let paramOffset = 0;
-  if (func && func.constr) {
-    // new.target arg
-    if (func.internal) paramOffset = 1;
-    if (!typedParams) paramCount--;
-    out.push([ Opcodes.i32_const, decl._new ? 1 : 0 ]);
-  } else if (decl._new)
+  if (decl._new && func && !func.constr) {
     return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a constructor`, true);
+  }
+
+  if (func && func.constr) {
+    out.push(...createNewTarget(scope, decl, idx - importedFuncs.length));
+    out.push(...createThisArg(scope, decl, func));
+    paramOffset += 4;
+  }
 
   let args = [...decl.arguments];
   if (func && !func.hasRestArgument && args.length < paramCount) {
     // too little args, push undefineds
-    args = args.concat(new Array(paramCount - args.length).fill(DEFAULT_VALUE));
+    args = args.concat(new Array(paramCount - args.length).fill(DEFAULT_VALUE()));
   }
 
   if (func && func.hasRestArgument) {
     if (args.length < paramCount) {
-      args = args.concat(new Array(paramCount - 1 - args.length).fill(DEFAULT_VALUE));
+      args = args.concat(new Array(paramCount - 1 - args.length).fill(DEFAULT_VALUE()));
     }
 
     const restArgs = args.slice(paramCount - 1);
@@ -2391,11 +2458,26 @@ const generateNew = (scope, decl, _global, _name) => generateCall(scope, {
   _new: true
 }, _global, _name);
 
+const generateThis = (scope, decl, _global, _name) => {
+  if (!scope.constr) {
+    // this in a non-constructor context is a reference to globalThis
+    return [
+      ...generate(scope, { type: 'Identifier', name: 'globalThis' }),
+      ...setLastType(scope, getType(scope, 'globalThis'))
+    ];
+  }
+
+  return [
+    [ Opcodes.local_get, '#this' ],
+    ...setLastType(scope, [ [ Opcodes.local_get, '#this#type' ] ])
+  ];
+};
+
 // bad hack for undefined and null working without additional logic
-const DEFAULT_VALUE = {
+const DEFAULT_VALUE = () => ({
   type: 'Identifier',
   name: 'undefined'
-};
+});
 
 const codeToSanitizedStr = code => {
   let out = '';
@@ -4128,7 +4210,7 @@ const generateThrow = (scope, decl) => {
       message = decl.argument.arguments[0];
     }
 
-    message ??= DEFAULT_VALUE;
+    message ??= DEFAULT_VALUE();
 
     if (tags.length === 0) tags.push({
       params: [ valtypeBinary, valtypeBinary, Valtype.i32 ],
@@ -4153,7 +4235,7 @@ const generateThrow = (scope, decl) => {
       message = decl.argument.arguments[0];
     }
 
-    message ??= DEFAULT_VALUE;
+    message ??= DEFAULT_VALUE();
 
     if (tags.length === 0) tags.push({
       params: [ Valtype.i32, valtypeBinary, Valtype.i32 ],
@@ -4209,18 +4291,15 @@ const generateEmpty = (scope, decl) => {
 };
 
 const generateMeta = (scope, decl) => {
-  if (decl.meta.name !== 'new') return todo(scope, `meta property object ${decl.meta.name} is not supported yet`, true);
-
   switch (`${decl.meta.name}.${decl.property.name}`) {
     case 'new.target': {
-      scope.constr = true;
-
       return [
-        [ Opcodes.local_get, -1 ],
-        Opcodes.i32_from_u,
-        ...setLastType(scope, TYPES.boolean)
+        [ Opcodes.local_get, '#newtarget' ],
       ];
     }
+
+    default:
+      return todo(scope, `meta property object ${decl.meta.name} is not supported yet`, true);
   }
 };
 
@@ -4641,7 +4720,25 @@ const wrapBC = (bc, { prelude = [], postlude = [] } = {}) => {
   return out;
 };
 
-const generateMember = (scope, decl, _global, _name) => {
+const countParams = (func, name = undefined) => {
+  if (!func) {
+    if (Object.hasOwn(importedFuncs, name)) {
+      // reverse lookup then normal lookup
+      func = importedFuncs[importedFuncs[name]];
+      if (func) return func.params?.length ?? func.params;
+    }
+    return;
+  }
+  if (func.argc) return func.argc;
+
+  let params = func.params.length;
+  if (func.constr) params -= 4;
+  if (!func.internal || builtinFuncs[func.name]?.typedParams) params = Math.floor(params / 2);
+
+  return func.argc = params;
+};
+
+const generateMember = (scope, decl, _global, _name, _objectWasm = undefined) => {
   const name = decl.object.name;
 
   // hack: .name
@@ -4659,12 +4756,9 @@ const generateMember = (scope, decl, _global, _name) => {
     // todo: support optional
 
     const func = funcs.find(x => x.name === name);
-    if (func) {
-      const typedParams = !func.internal || func.typedParams;
-      return withType(scope, number(typedParams ? Math.floor(func.params.length / 2) : (func.constr ? (func.params.length - 1) : func.params.length)), TYPES.number);
-    }
+    if (func) return withType(scope, number(countParams(func)), TYPES.number);
 
-    if (Object.hasOwn(builtinFuncs, name)) return withType(scope, number(builtinFuncs[name].typedParams ? Math.floor(builtinFuncs[name].params.length / 2) : (builtinFuncs[name].constr ? (builtinFuncs[name].params.length - 1) : builtinFuncs[name].params.length)), TYPES.number);
+    if (Object.hasOwn(builtinFuncs, name)) return withType(scope, number(countParams(builtinFuncs[name])), TYPES.number);
     if (Object.hasOwn(importedFuncs, name)) return withType(scope, number(importedFuncs[name].params.length ?? importedFuncs[name].params), TYPES.number);
     if (Object.hasOwn(internalConstrs, name)) return withType(scope, number(internalConstrs[name].length ?? 0), TYPES.number);
 
@@ -4954,7 +5048,7 @@ const generateMember = (scope, decl, _global, _name) => {
   if (decl.optional) {
     out.unshift(
       [ Opcodes.block, valtypeBinary ],
-      ...generate(scope, object),
+      ...(_objectWasm ? _objectWasm : generate(scope, object)),
       [ Opcodes.local_tee, localTmp(scope, '#member_obj') ],
 
       ...nullish(scope, [], getNodeType(scope, object), false, true),
@@ -4973,7 +5067,7 @@ const generateMember = (scope, decl, _global, _name) => {
     );
   } else {
     out.unshift(
-      ...generate(scope, object),
+      ...(_objectWasm ? _objectWasm : generate(scope, object)),
       [ Opcodes.local_set, localTmp(scope, '#member_obj') ],
 
       ...generate(scope, property, false, '#member_prop'),
@@ -4995,7 +5089,7 @@ const objectHack = node => {
       if (node.computed || node.optional) return;
 
       // hack: block these properties as they can be accessed on functions
-      if (node.property.name == "length" || node.property.name == "name") return;
+      if (node.property.name == 'length' || node.property.name == 'name') return;
 
       let objectName = node.object.name;
 
@@ -5045,7 +5139,8 @@ const generateFunc = (scope, decl) => {
     returns: [ valtypeBinary, Valtype.i32 ],
     throws: false,
     name,
-    index: currentFuncIndex++
+    index: currentFuncIndex++,
+    constr: decl.type && decl.type !== 'ArrowFunctionExpression' && decl.type !== 'Program'
   };
 
   funcIndex[name] = func.index;
@@ -5123,11 +5218,38 @@ const generateFunc = (scope, decl) => {
 
   // add end return if not found
   if (name !== 'main' && wasm[wasm.length - 1]?.[0] !== Opcodes.return && countLeftover(wasm) === 0) {
-    wasm.push(
-      ...number(0),
-      ...(func.returnType != null ? [] : number(TYPES.undefined, Valtype.i32)),
-      [ Opcodes.return ]
-    );
+    wasm.push(...generateReturn(func, {}));
+  }
+
+  if (func.constr) {
+    const locals = func.locals;
+    let idxOffset = 4;
+    func.params = [ valtypeBinary, Valtype.i32, valtypeBinary, Valtype.i32, ...func.params ];
+
+    // move all local indexes by idxOffset
+    func.localInd += idxOffset;
+    for (const x in locals) {
+      locals[x].idx += idxOffset;
+    }
+
+    let indexes = idxOffset;
+
+    locals['#this#type'] = { idx: --indexes, type: Valtype.i32 };
+    locals['#this'] = { idx: --indexes, type: valtypeBinary };
+    locals['#newtarget#type'] = { idx: --indexes, type: Valtype.i32 };
+    locals['#newtarget'] = { idx: --indexes, type: valtypeBinary };
+
+    for (let i = 0; i < wasm.length; i++) {
+      // note: these needs to be copied, even though they realistically shouldn't
+      const inst = wasm[i];
+      if (inst[0] === Opcodes.local_get || inst[0] === Opcodes.local_set || inst[0] === Opcodes.local_tee) {
+        if (typeof inst[1] == 'string') {
+          wasm[i] = [ inst[0], locals[inst[1]].idx ];
+        } else {
+          wasm[i] = [ inst[0], inst[1] + idxOffset ];
+        }
+      }
+    }
   }
 
   return func;
@@ -5156,7 +5278,7 @@ const internalConstrs = {
         rawElements: new Array(0)
       }, global, name, true, undefined, true, true);
 
-      const arg = decl.arguments[0] ?? DEFAULT_VALUE;
+      const arg = decl.arguments[0] ?? DEFAULT_VALUE();
 
       // todo: check in wasm instead of here
       const literalValue = arg.value ?? 0;
@@ -5232,7 +5354,7 @@ const internalConstrs = {
   Boolean: {
     generate: (scope, decl) => {
       // todo: boolean object when used as constructor
-      const arg = decl.arguments[0] ?? DEFAULT_VALUE;
+      const arg = decl.arguments[0] ?? DEFAULT_VALUE();
       return truthy(scope, generate(scope, arg), getNodeType(scope, arg), false, false, 'full');
     },
     type: TYPES.boolean,

package/compiler/precompile.js

@@ -209,11 +209,13 @@ ${funcs.map(x => {
     return `(scope, {${`${str.includes('allocPage(') ? 'allocPage,' : ''}${str.includes('glbl(') ? 'glbl,' : ''}${str.includes('loc(') ? 'loc,' : ''}${str.includes('builtin(') ? 'builtin,' : ''}${str.includes('internalThrow(') ? 'internalThrow,' : ''}`.slice(0, -1)}}) => ` + str;
   };
 
+  const locals = Object.entries(x.locals).sort((a,b) => a[1].idx - b[1].idx)
+
   return `  this.${x.name} = {
     wasm: ${rewriteWasm(x.wasm)},
     params: ${JSON.stringify(x.params)}, typedParams: 1,
     returns: ${JSON.stringify(x.returns)}, ${x.returnType != null ? `returnType: ${JSON.stringify(x.returnType)}` : 'typedReturns: 1'},
-    locals: ${JSON.stringify(Object.values(x.locals).slice(x.params.length).map(x => x.type))}, localNames: ${JSON.stringify(Object.keys(x.locals))},
+    locals: ${JSON.stringify(locals.slice(x.params.length).map(x => x[1].type))}, localNames: ${JSON.stringify(locals.map(x => x[0]))},
 ${x.globalInits ? `    globalInits: {${Object.keys(x.globalInits).map(y => `${y}: ${rewriteWasm(x.globalInits[y])}`).join(',')}},\n` : ''}${x.data && x.data.length > 0 ? `    data: [${x.data.map(x => `[${x.offset ?? 'null'},[${x.bytes.join(',')}]]`).join(',')}],` : ''}
 ${x.table ? `    table: 1,` : ''}${x.constr ? `    constr: 1,` : ''}${x.hasRestArgument ? `    hasRestArgument: 1,` : ''}
   };`.replaceAll('\n\n', '\n').replaceAll('\n\n', '\n').replaceAll('\n\n', '\n');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "porffor",
   "description": "a basic experimental wip aot optimizing js -> wasm engine/compiler/runtime in js",
-  "version": "0.24.12+276aa969c",
+  "version": "0.24.14+e5d79b96e",
   "author": "CanadaHonk",
   "license": "MIT",
   "scripts": {},

package/runner/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import fs from 'node:fs';
-globalThis.version = '0.24.12+276aa969c';
+globalThis.version = '0.24.14+e5d79b96e';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {