porffor 0.55.35 → 0.56.0

package/compiler/codegen.js

@@ -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
@@ -995,22 +1004,29 @@ const performOp = (scope, op, left, right, leftType, rightType) => {
   const finalize = out => startOut.concat(out, endOut);
 
   // if strict (in)equal check types match, skip if known
-  if (strictOp && !(knownLeft && knownLeft === knownRight)) {
-    endOut.push(
-      ...leftType,
-      number(TYPE_FLAGS.parity, Valtype.i32),
-      [ Opcodes.i32_or ],
-      ...rightType,
-      number(TYPE_FLAGS.parity, Valtype.i32),
-      [ Opcodes.i32_or ],
-      ...(op === '===' ? [
-        [ Opcodes.i32_eq ],
-        [ Opcodes.i32_and ]
-      ] : [
-        [ Opcodes.i32_ne ],
-        [ Opcodes.i32_or ]
-      ])
-    );
+  if (strictOp) {
+    if (knownLeft != null && knownRight != null) {
+      if ((knownLeft | TYPE_FLAGS.parity) !== (knownRight | TYPE_FLAGS.parity)) endOut.push(
+        number(op === '===' ? 0 : 1, Valtype.i32),
+        [ op === '===' ? Opcodes.i32_and : Opcodes.i32_or ]
+      );
+    } else {
+      endOut.push(
+        ...leftType,
+        number(TYPE_FLAGS.parity, Valtype.i32),
+        [ Opcodes.i32_or ],
+        ...rightType,
+        number(TYPE_FLAGS.parity, Valtype.i32),
+        [ Opcodes.i32_or ],
+        ...(op === '===' ? [
+          [ Opcodes.i32_eq ],
+          [ Opcodes.i32_and ]
+        ] : [
+          [ Opcodes.i32_ne ],
+          [ Opcodes.i32_or ]
+        ])
+      );
+    }
   }
 
   if (!eqOp && (knownLeft === TYPES.bigint || knownRight === TYPES.bigint) && !(knownLeft === TYPES.bigint && knownRight === TYPES.bigint)) {
@@ -1041,10 +1057,10 @@ const performOp = (scope, op, left, right, leftType, rightType) => {
 
     // string comparison
     if (op === '===' || op === '==' || op === '!==' || op === '!=') {
-      return [
+      return finalize([
         ...compareStrings(scope, left, right, leftType, rightType, knownLeftStr && knownRightStr),
         ...(op === '!==' || op === '!=' ? [ [ Opcodes.i32_eqz ] ] : [])
-      ];
+      ]);
     }
 
     // todo: proper >|>=|<|<=
@@ -1052,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 ];
 
@@ -1237,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,
@@ -1318,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 = [] } = {}) => {

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.35",
+  "version": "0.56.0",
   "author": "Oliver Medhurst <honk@goose.icu>",
   "license": "MIT",
   "scripts": {},

package/r.cjs

@@ -1,8 +1,107 @@
-function* foo() {
-  yield* [1, 2, 3];
+var assert = mustBeTrue => {
+  if (mustBeTrue === true) {
+    return;
+  }
+
+  throw new Test262Error('assert failed');
+};
+
+function isConfigurable(obj, name) {
+  if (Object.hasOwn(obj, name)) return Object.getOwnPropertyDescriptor(obj, name).configurable;
+  return true;
+}
+
+function isEnumerable(obj, name) {
+  return Object.hasOwn(obj, name) && Object.getOwnPropertyDescriptor(obj, name).enumerable;
+}
+
+function isSameValue(a, b) {
+  if (a === 0 && b === 0) return 1 / a === 1 / b;
+  if (a !== a && b !== b) return true;
+
+  return a === b;
+}
+
+function isWritable(obj, name, verifyProp, value) {
+  if (Object.hasOwn(obj, name) && Object.getOwnPropertyDescriptor(obj, name).writable != null) return Object.getOwnPropertyDescriptor(obj, name).writable;
+  if (!Object.hasOwn(obj, name) && Object.isExtensible(obj)) return true;
+
+  var unlikelyValue = Array.isArray(obj) && name === "length" ?
+    Math.pow(2, 32) - 1 :
+    "unlikelyValue";
+  var newValue = value || unlikelyValue;
+  var hadValue = Object.hasOwn(obj, name);
+  var oldValue = obj[name];
+  var writeSucceeded;
+
+  try {
+    obj[name] = newValue;
+  } catch {}
+
+  writeSucceeded = isSameValue(obj[verifyProp || name], newValue);
+
+  if (writeSucceeded) {
+    if (hadValue) {
+      obj[name] = oldValue;
+    } else {
+      delete obj[name];
+    }
+  }
+
+  return writeSucceeded;
 }
 
-console.log(foo().next());
+function verifyProperty(obj, name, desc, options) {
+  var originalDesc = Object.getOwnPropertyDescriptor(obj, name);
+
+  if (desc === undefined) {
+    if (originalDesc !== undefined) {
+      throw new Test262Error('verifyProperty: expected undefined descriptor');
+    }
+
+    return true;
+  }
+
+  if (!Object.hasOwn(obj, name)) throw new Test262Error('verifyProperty: obj should have own property');
+
+  if (Object.hasOwn(desc, 'value')) {
+    const v = desc.value;
+    if (!isSameValue(originalDesc.value, v)) throw new Test262Error('verifyProperty: descriptor value mismatch');
+    // if (!isSameValue(obj[name], v)) throw new Test262Error('verifyProperty: object value mismatch');
+  }
+
+  if (Object.hasOwn(desc, 'enumerable')) {
+    if (desc.enumerable !== originalDesc.enumerable ||
+        desc.enumerable !== isEnumerable(obj, name)) {
+      throw new Test262Error('enumerable fail');
+    }
+  }
+
+  if (Object.hasOwn(desc, 'writable')) {
+    if (desc.writable !== originalDesc.writable ||
+        desc.writable !== isWritable(obj, name)) {
+      throw new Test262Error('writable fail');
+    }
+  }
+
+  if (Object.hasOwn(desc, 'configurable')) {
+    if (desc.configurable !== originalDesc.configurable ||
+        desc.configurable !== isConfigurable(obj, name)) {
+      throw new Test262Error('configurable fail');
+    }
+  }
+
+  if (options && options.restore) {
+    Object.defineProperty(obj, name, originalDesc);
+  }
+
+  return true;
+}
+
+const desc = { enumerable: true, configurable: true, writable: true };
+const obj = Object.defineProperty({}, 'wow', desc);
+assert(verifyProperty(obj, 'wow', desc));
+
 
 // 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.35';
+globalThis.version = '0.56.0';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {