porffor 0.55.36 → 0.56.1

package/compiler/codegen.js

@@ -93,7 +93,7 @@ const funcRef = func => {
     }
 
     const wasm = [];
-    const offset = func.constr ? 0 : 4;
+    const offset = func.constr ? 0 : (func.method ? 2 : 4);
     for (let i = 0; i < func.params.length; i++) {
       if (func.internal && func.name.includes('_prototype_') && i < 2) {
         // special case: use real this for prototype internals
@@ -456,7 +456,7 @@ const lookup = (scope, name, failEarly = false) => {
       // todo: not compliant
       let len = countLength(scope);
       const names = new Array(len);
-      const off = scope.constr ? 4 : 0;
+      const off = scope.constr ? 4 : (scope.method ? 2 : 0);
       for (const x in scope.locals) {
         const i = scope.locals[x].idx - off;
         if (i >= 0 && i % 2 === 0 && i < len * 2) {
@@ -809,12 +809,23 @@ const compareStrings = (scope, left, right, leftType, rightType, noConv = false)
 };
 
 const truthy = (scope, wasm, type, intIn = false, intOut = false, forceTruthyMode = undefined) => {
+  const truthyMode = forceTruthyMode ?? Prefs.truthy ?? 'full';
   if (isIntToFloatOp(wasm[wasm.length - 1])) return [
     ...wasm,
-    ...(!intIn && intOut ? [ Opcodes.i32_to_u ] : [])
+    ...(truthyMode === 'full' ? [
+      [ Opcodes.f64_const, 0 ],
+      [ Opcodes.f64_ne ],
+      ...(!intOut ? [ Opcodes.i32_from_u ] : [])
+    ] : [
+      ...(!intIn && intOut ? [ Opcodes.i32_to_u ] : [])
+    ])
   ];
   if (isIntOp(wasm[wasm.length - 1])) return [
     ...wasm,
+    ...(truthyMode === 'full' ? [
+      [ Opcodes.i32_eqz ],
+      [ Opcodes.i32_eqz ]
+    ] : []),
     ...(intOut ? [] : [ Opcodes.i32_from ]),
   ];
 
@@ -822,8 +833,6 @@ const truthy = (scope, wasm, type, intIn = false, intOut = false, forceTruthyMod
 
   const useTmp = knownType(scope, type) == null;
   const tmp = useTmp && localTmp(scope, `#logicinner_tmp${intIn ? '_int' : ''}`, intIn ? Valtype.i32 : valtypeBinary);
-
-  const truthyMode = forceTruthyMode ?? Prefs.truthy ?? 'full';
   const def = (() => {
     if (truthyMode === 'full') return [
       // if value != 0 or NaN
@@ -1059,21 +1068,9 @@ const performOp = (scope, op, left, right, leftType, rightType) => {
 
   let ops = operatorOpcode[valtype][op];
 
-  // some complex ops are implemented as builtin funcs
-  const builtinName = `${valtype}_${op}`;
-  if (!ops && builtinFuncs[builtinName]) {
-    includeBuiltin(scope, builtinName);
-    const idx = funcIndex[builtinName];
-
-    return finalize([
-      ...left,
-      ...right,
-      [ Opcodes.call, idx ]
-    ]);
-  }
-
+  // some complex ops are implemented in funcs
+  if (typeof ops === 'function') return finalize(asmFuncToAsm(scope, ops, { left, right }));
   if (!ops) return todo(scope, `operator ${op} not implemented yet`, true);
-
   if (!Array.isArray(ops)) ops = [ ops ];
   ops = [ ops ];
 
@@ -1244,7 +1241,7 @@ const generateBinaryExp = (scope, decl) => {
   return out;
 };
 
-const asmFuncToAsm = (scope, func) => {
+const asmFuncToAsm = (scope, func, extra) => {
   return func(scope, {
     Valtype, Opcodes, TYPES, TYPE_NAMES, usedTypes, typeSwitch, makeString, internalThrow,
     getNodeType, generate, generateIdent,
@@ -1325,7 +1322,7 @@ const asmFuncToAsm = (scope, func) => {
       return wasm;
     },
     allocPage: (scope, name) => allocPage({ scope, pages }, name)
-  });
+  }, extra);
 };
 
 const asmFunc = (name, { wasm, params = [], typedParams = false, locals: localTypes = [], globals: globalTypes = [], globalInits = [], returns = [], returnType, localNames = [], globalNames = [], table = false, constr = false, hasRestArgument = false, usesTag = false, usesImports = false, usedTypes = [] } = {}) => {
@@ -1719,7 +1716,7 @@ const getNodeType = (scope, node) => {
 
     if (node.type === 'ThisExpression') {
       if (scope.overrideThisType) return scope.overrideThisType;
-      if (!scope.constr) return getType(scope, 'globalThis');
+      if (!scope.constr && !scope.method) return getType(scope, 'globalThis');
       return [ [ Opcodes.local_get, scope.locals['#this#type'].idx ] ];
     }
 
@@ -2639,6 +2636,11 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     paramOffset += 4;
   }
 
+  if (func && func.method) {
+    out.push(...(decl._thisWasm ?? createThisArg(scope, decl)));
+    paramOffset += 2;
+  }
+
   if (func && args.length < paramCount) {
     // too little args, push undefineds
     const underflow = paramCount - (func.hasRestArgument ? 1 : 0) - args.length;
@@ -2723,7 +2725,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
 const generateThis = (scope, decl) => {
   if (scope.overrideThis) return scope.overrideThis;
 
-  if (!scope.constr) {
+  if (!scope.constr && !scope.method) {
     // this in a non-constructor context is a reference to globalThis
     return [
       ...generate(scope, { type: 'Identifier', name: 'globalThis' })
@@ -5530,7 +5532,10 @@ const generateObject = (scope, decl, global = false, name = '$undeclared') => {
 
     for (const x of decl.properties) {
       // method, shorthand are made into useful values by parser for us :)
-      let { type, argument, computed, kind, value } = x;
+      let { type, argument, computed, kind, value, method } = x;
+
+      // tag function as not a constructor
+      if (method) value._method = true;
 
       if (type === 'SpreadElement') {
         out.push(
@@ -5623,6 +5628,7 @@ const countParams = (func, name = undefined) => {
   name ??= func.name;
   let params = func.params.length;
   if (func.constr) params -= 4;
+  if (func.method) params -= 2;
   if (!func.internal || builtinFuncs[name]?.typedParams) params = Math.floor(params / 2);
 
   return func.argc = params;
@@ -6126,6 +6132,9 @@ const generateClass = (scope, decl) => {
     let { type, value, kind, static: _static, computed } = x;
     if (kind === 'constructor') continue;
 
+    // tag function as not a constructor
+    if (type === 'MethodDefinition') value._method = true;
+
     if (type === 'StaticBlock') {
       // todo: make this more compliant
       out.push(
@@ -6451,7 +6460,8 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
     name,
     index: currentFuncIndex++,
     arrow,
-    constr: !arrow && !decl.generator && !decl.async,
+    constr: !arrow && !decl.generator && !decl.async && !decl._method, // constructable
+    method: decl._method || decl.generator || decl.async, // has this but not constructable
     async: decl.async,
     subclass: decl._subclass, _onlyConstr: decl._onlyConstr, _onlyThisMethod: decl._onlyThisMethod,
     strict: scope.strict || decl.strict,
@@ -6682,6 +6692,7 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
 
   const args = [];
   if (func.constr) args.push({ name: '#newtarget' }, { name: '#this' });
+  if (func.method) args.push({ name: '#this' });
 
   let jsLength = 0;
   for (let i = 0; i < params.length; i++) {
@@ -6722,7 +6733,7 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
     args.push({ name, def, destr, type: typedInput && params[i].typeAnnotation });
   }
 
-  func.params = new Array((params.length + (func.constr ? 2 : 0)) * 2).fill(0).map((_, i) => i % 2 ? Valtype.i32 : valtypeBinary);
+  func.params = new Array((params.length + (func.constr ? 2 : (func.method ? 1 : 0))) * 2).fill(0).map((_, i) => i % 2 ? Valtype.i32 : valtypeBinary);
   func.jsLength = jsLength;
 
   // force generate for main

package/compiler/expression.js

@@ -1,4 +1,14 @@
-import { Opcodes } from './wasmSpec.js';
+import { Opcodes, Valtype } from './wasmSpec.js';
+import { TYPES } from './types.js';
+
+const f64ifyBitwise = op => (_1, _2, { left, right }) => [
+  ...left,
+  Opcodes.i32_trunc_sat_f64_s,
+  ...right,
+  Opcodes.i32_trunc_sat_f64_s,
+  [ op ],
+  [ Opcodes.f64_convert_i32_s ]
+];
 
 export const operatorOpcode = {
   i32: {
@@ -23,7 +33,17 @@ export const operatorOpcode = {
     '>': Opcodes.i32_gt_s,
     '>=': Opcodes.i32_ge_s,
     '<': Opcodes.i32_lt_s,
-    '<=': Opcodes.i32_le_s
+    '<=': Opcodes.i32_le_s,
+
+    '**': (_, { builtin }, { left, right }) => [
+      ...left,
+      [ Opcodes.f64_convert_i32_s ],
+      [ Opcodes.i32_const, TYPES.number ],
+      ...right,
+      [ Opcodes.f64_convert_i32_s ],
+      [ Opcodes.i32_const, TYPES.number ],
+      [ Opcodes.call, builtin('__Math_pow') ]
+    ]
   },
 
   i64: {
@@ -65,6 +85,38 @@ export const operatorOpcode = {
     '>': Opcodes.f64_gt,
     '>=': Opcodes.f64_ge,
     '<': Opcodes.f64_lt,
-    '<=': Opcodes.f64_le
+    '<=': Opcodes.f64_le,
+
+    '**': (_, { builtin }, { left, right }) => [
+      ...left,
+      [ Opcodes.i32_const, TYPES.number ],
+      ...right,
+      [ Opcodes.i32_const, TYPES.number ],
+      [ Opcodes.call, builtin('__Math_pow') ]
+    ],
+
+    '%': (_, { builtin, loc }, { left, right }) => [
+      // a - truncf(a / b) * b
+      ...left,
+      [ Opcodes.local_tee, loc('#math_a', Valtype.f64) ],
+      ...right,
+      [ Opcodes.local_tee, loc('#math_b', Valtype.f64) ],
+
+      [ Opcodes.local_get, loc('#math_a', Valtype.f64) ],
+      [ Opcodes.local_get, loc('#math_b', Valtype.f64) ],
+      [ Opcodes.f64_div ],
+      [ Opcodes.f64_trunc ],
+
+      [ Opcodes.f64_mul ],
+      [ Opcodes.f64_sub ]
+    ],
+
+    // add bitwise ops by converting operands to i32 first
+    '&': f64ifyBitwise(Opcodes.i32_and),
+    '|': f64ifyBitwise(Opcodes.i32_or),
+    '^': f64ifyBitwise(Opcodes.i32_xor),
+    '<<': f64ifyBitwise(Opcodes.i32_shl),
+    '>>': f64ifyBitwise(Opcodes.i32_shr_s),
+    '>>>': f64ifyBitwise(Opcodes.i32_shr_u)
   }
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "porffor",
   "description": "An ahead-of-time JavaScript compiler",
-  "version": "0.55.36",
+  "version": "0.56.1",
   "author": "Oliver Medhurst <honk@goose.icu>",
   "license": "MIT",
   "scripts": {},

package/r.cjs

@@ -1,8 +1,8 @@
-function* foo() {
-  yield* [1, 2, 3];
-}
+let obj = {
+  wow() {}
+};
 
-console.log(foo().next());
+console.log(obj.wow.prototype);
 
 // var EQUAL = 1;
 // var NOT_EQUAL = -1;

package/runner/index.js

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