porffor 0.57.18 → 0.57.20

package/compiler/codegen.js

@@ -466,9 +466,22 @@ const lookup = (scope, name, failEarly = false) => {
         }
       }
 
-      return generateArray(scope, {
-        elements: names.map(x => ({ type: 'Identifier', name: x }))
-      }, false, '#arguments', true);
+      return [
+        [ Opcodes.local_get, localTmp(scope, '#arguments') ],
+        ...Opcodes.eqz,
+        [ Opcodes.if, Blocktype.void ],
+          ...generateObject(scope, {
+            properties: names.map((x, i) => ({
+              key: { type: 'Literal', value: i },
+              value: { type: 'Identifier', name: x },
+              kind: 'init'
+            }))
+          }, '#arguments', false),
+          [ Opcodes.local_set, localTmp(scope, '#arguments') ],
+        [ Opcodes.end ],
+
+        [ Opcodes.local_get, localTmp(scope, '#arguments') ]
+      ];
     }
 
     // no local var with name
@@ -1245,7 +1258,7 @@ const asmFuncToAsm = (scope, func, extra) => func(scope, {
   getNodeType, generate, generateIdent,
   builtin: (n, offset = false) => {
     let idx = importedFuncs[n] ?? funcIndex[n];
-    if (idx == null && builtinFuncs[n]) {
+    if (idx == null && Object.hasOwn(builtinFuncs, n)) {
       includeBuiltin(scope, n);
       idx = funcIndex[n];
     }
@@ -1260,7 +1273,7 @@ const asmFuncToAsm = (scope, func, extra) => func(scope, {
   },
   hasFunc: x => funcIndex[x] != null,
   funcRef: name => {
-    if (funcIndex[name] == null && builtinFuncs[name]) {
+    if (funcIndex[name] == null && Object.hasOwn(builtinFuncs, name)) {
       includeBuiltin(scope, name);
     }
 
@@ -1269,7 +1282,7 @@ const asmFuncToAsm = (scope, func, extra) => func(scope, {
   },
   glbl: (opcode, name, type) => {
     const globalName = '#porf#' + name; // avoid potential name clashing with user js
-    if (!globals[globalName]) {
+    if (!Object.hasOwn(globals, globalName)) {
       const idx = globals['#ind']++;
       globals[globalName] = { idx, type };
 
@@ -1298,7 +1311,7 @@ const asmFuncToAsm = (scope, func, extra) => func(scope, {
     return out;
   },
   loc: (name, type) => {
-    if (!scope.locals[name]) {
+    if (!Object.hasOwn(scope.locals, name)) {
       const idx = scope.localInd++;
       scope.locals[name] = { idx, type };
     }
@@ -1401,8 +1414,8 @@ const generateLogicExp = (scope, decl) =>
   performLogicOp(scope, decl.operator, generate(scope, decl.left), generate(scope, decl.right), getNodeType(scope, decl.left), getNodeType(scope, decl.right));
 
 const isExistingProtoFunc = name => {
-  if (name.startsWith('__Array_prototype')) return !!prototypeFuncs[TYPES.array][name.slice(18)];
-  if (name.startsWith('__String_prototype_')) return !!prototypeFuncs[TYPES.string][name.slice(19)];
+  if (name.startsWith('__Array_prototype')) return Object.hasOwn(prototypeFuncs[TYPES.array], name.slice(18));
+  if (name.startsWith('__String_prototype_')) return Object.hasOwn(prototypeFuncs[TYPES.string], name.slice(19));
 
   return false;
 };
@@ -1461,7 +1474,7 @@ const getType = (scope, name, failEarly = false) => {
   }
 
   if (global !== false && name === 'arguments' && !scope.arrow) {
-    return [ number(TYPES.array, Valtype.i32) ];
+    return [ number(TYPES.object, Valtype.i32) ];
   }
 
   if (metadata?.type != null) {
@@ -1475,12 +1488,10 @@ const getType = (scope, name, failEarly = false) => {
     [ global ? Opcodes.global_get : Opcodes.local_get, typeLocal.idx ]
   ];
 
-  if (hasFuncWithName(name)) {
+  if (hasFuncWithName(name) || isExistingProtoFunc(name)) {
     return [ number(TYPES.function, Valtype.i32) ];
   }
 
-  if (isExistingProtoFunc(name)) return [ number(TYPES.function, Valtype.i32) ];
-
   return fallback;
 };
 
@@ -2119,7 +2130,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     target.name = spl.slice(0, -1).join('_');
 
     if (builtinFuncs['__' + target.name + '_' + protoName]) protoName = null;
-      else if (lookupName(scope, target.name)[0] == null && !builtinFuncs[target.name]) {
+      else if (lookupName(scope, target.name)[0] == null && !Object.hasOwn(builtinFuncs, target.name)) {
         if (lookupName(scope, '__' + target.name)[0] != null || builtinFuncs['__' + target.name]) target.name = '__' + target.name;
           else protoName = null;
       }
@@ -2177,38 +2188,14 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
           ...generate(scope, decl.arguments[0] ?? DEFAULT_VALUE()),
           [ Opcodes.local_tee, valTmp ],
           ...getNodeType(scope, decl.arguments[0] ?? DEFAULT_VALUE()),
-          [ Opcodes.local_tee, typeTmp ],
-
-          // check not undefined or null if not in precompile
-          // todo: technically this should be allowed sometimes but for now, never
-          ...(globalThis.precompile ? [] : [
-            ...nullish(scope,
-              [ [ Opcodes.local_get, valTmp ] ],
-              [ [ Opcodes.local_get, typeTmp ] ],
-              false, true),
-            [ Opcodes.if, Blocktype.void ],
-            ...internalThrow(scope, 'TypeError', `Cannot use undefined or null as 'this'`),
-            [ Opcodes.end ]
-          ])
+          [ Opcodes.local_tee, typeTmp ]
         ],
         _thisWasmComponents: {
           _callValue: [
             ...generate(scope, decl.arguments[0] ?? DEFAULT_VALUE()),
             [ Opcodes.local_tee, valTmp ],
             ...getNodeType(scope, decl.arguments[0] ?? DEFAULT_VALUE()),
-            [ Opcodes.local_set, typeTmp ],
-
-            // check not undefined or null if not in precompile
-            // todo: technically this should be allowed sometimes but for now, never
-            ...(globalThis.precompile ? [] : [
-              ...nullish(scope,
-                [ [ Opcodes.local_get, valTmp ] ],
-                [ [ Opcodes.local_get, typeTmp ] ],
-                false, true),
-              [ Opcodes.if, Blocktype.void ],
-              ...internalThrow(scope, 'TypeError', `Cannot use undefined or null as 'this'`),
-              [ Opcodes.end ]
-            ])
+            [ Opcodes.local_set, typeTmp ]
           ],
           _callType: [ [ Opcodes.local_get, typeTmp ] ]
         }
@@ -2529,6 +2516,7 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     const wrapperArgc = Prefs.indirectWrapperArgc ?? 10;
     const underflow = wrapperArgc - args.length;
     for (let i = 0; i < underflow; i++) args.push(DEFAULT_VALUE());
+    if (args.length > wrapperArgc) args = args.slice(0, wrapperArgc);
 
     for (let i = 0; i < args.length; i++) {
       const arg = args[i];
@@ -2728,9 +2716,7 @@ const generateThis = (scope, decl) => {
 
   if (!scope.constr && !scope.method) {
     // this in a non-constructor context is a reference to globalThis
-    return [
-      ...generate(scope, { type: 'Identifier', name: 'globalThis' })
-    ];
+    return generate(scope, { type: 'Identifier', name: 'globalThis' });
   }
 
   // opt: do not check for pure constructors or strict mode
@@ -3282,7 +3268,7 @@ const generateVarDstr = (scope, kind, pattern, init, defaultValue, global) => {
       const [ _func, out ] = generateFunc(scope, init, true);
 
       const funcName = init.id?.name;
-      if (name !== funcName && funcIndex[funcName]) {
+      if (name !== funcName && Object.hasOwn(funcIndex, funcName)) {
         funcIndex[name] = funcIndex[funcName];
         delete funcIndex[funcName];
       }
@@ -5657,7 +5643,6 @@ const generateObject = (scope, decl, global = false, name = '$undeclared') => {
   }
 
   out.push(Opcodes.i32_from_u);
-
   return out;
 };
 
@@ -6402,7 +6387,7 @@ const generateTaggedTemplate = (scope, decl, global = false, name = undefined, v
         const immediates = asm.slice(1).map(x => {
           const n = parseFloat(x);
           if (Number.isNaN(n) && x !== 'NaN') {
-            if (builtinFuncs[x]) {
+            if (Object.hasOwn(builtinFuncs, x)) {
               if (funcIndex[x] == null) includeBuiltin(scope, x);
               return funcIndex[x];
             }
@@ -6441,7 +6426,7 @@ const generateTaggedTemplate = (scope, decl, global = false, name = undefined, v
   };
 
   const { quasis, expressions } = decl.quasi;
-  if (intrinsics[decl.tag.name]) {
+  if (Object.hasOwn(intrinsics, decl.tag.name)) {
     let str = quasis[0].value.raw;
 
     for (let i = 0; i < expressions.length; i++) {
@@ -6653,19 +6638,40 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
                 number(TYPES.string, Valtype.i32),
                 [ Opcodes.i32_ne ],
                 [ Opcodes.if, Blocktype.void ],
+                  [ Opcodes.local_get, func.locals[name].idx + 1 ],
+                  number(TYPE_FLAGS.parity, Valtype.i32),
+                  [ Opcodes.i32_or ],
+                  number(TYPES.undefined, Valtype.i32),
+                  [ Opcodes.i32_eq ],
+
+                  [ Opcodes.local_get, func.locals[name].idx + 1 ],
+                  number(TYPES.object, Valtype.i32),
+                  [ Opcodes.i32_eq ],
                   [ Opcodes.local_get, func.locals[name].idx ],
-                  [ Opcodes.f64_convert_i32_s ],
+                  ...Opcodes.eqz,
+                  [ Opcodes.i32_and ],
+
+                  [ Opcodes.i32_or ],
+                  [ Opcodes.if, Blocktype.void ],
+                    ...internalThrow(func, 'TypeError', `${unhackName(func.name)} expects 'this' to be non-nullish`),
+                  [ Opcodes.end ],
+
+                  [ Opcodes.local_get, func.locals[name].idx ],
+                  ...(valtypeBinary === Valtype.i32 ? [ [ Opcodes.f64_convert_i32_s ] ] : []),
                   [ Opcodes.local_get, func.locals[name].idx + 1 ],
                   [ Opcodes.call, includeBuiltin(scope, '__ecma262_ToString').index ],
                   [ Opcodes.local_set, func.locals[name].idx + 1 ],
-                  Opcodes.i32_trunc_sat_f64_s,
+                  ...(valtypeBinary === Valtype.i32 ? [ Opcodes.i32_trunc_sat_f64_s ] : []),
                   [ Opcodes.local_set, func.locals[name].idx ],
+
                   [ Opcodes.local_get, func.locals[name].idx + 1 ],
                   number(TYPES.bytestring, Valtype.i32),
                   [ Opcodes.i32_eq ],
                   [ Opcodes.if, Blocktype.void ],
                     [ Opcodes.local_get, func.locals[name].idx ],
+                    Opcodes.i32_to_u,
                     [ Opcodes.call, includeBuiltin(scope, '__Porffor_bytestringToString').index ],
+                    Opcodes.i32_from_u,
                     [ Opcodes.local_set, func.locals[name].idx ],
                   [ Opcodes.end ],
                 [ Opcodes.end ]

package/compiler/encoding.js

@@ -84,6 +84,28 @@ export const unsignedLEB128_length = n => {
   return length;
 };
 
+export const signedLEB128_length = n => {
+  if (n >= -64 && n <= 63) return 1;
+  if (n >= -8192 && n <= 8191) return 2;
+  if (n >= -1048576 && n <= 1048575) return 3;
+  if (n >= -134217728 && n <= 134217727) return 4;
+
+  let length = 0;
+  while (true) {
+    let byte = n & 0x7f;
+    n >>= 7;
+
+    if ((n === 0 && (byte & 0x40) === 0) || (n === -1 && (byte & 0x40) !== 0)) {
+      length++;
+      break;
+    } else {
+      length++;
+    }
+  }
+
+  return length;
+};
+
 export const big_signedLEB128 = n => {
   // just input for small numbers (for perf as common)
   if (n >= 0n && n <= 63n) return [ Number(n) ];

package/compiler/wrap.js

@@ -401,7 +401,7 @@ export default (source, module = undefined, customImports = {}, print = str => p
     const surrounding = Prefs.backtraceSurrounding ?? 10;
     let min = middleIndex - surrounding;
     let max = middleIndex + surrounding + 1;
-    if (Prefs.backtraceFunc || middleIndex == -1) {
+    if (Prefs.backtraceFunc || middleIndex === -1) {
       min = 0;
       max = func.wasm.length;
     }
@@ -415,7 +415,7 @@ export default (source, module = undefined, customImports = {}, print = str => p
       longest = Math.max(longest, noAnsi(disasm[j])?.length ?? 0);
     }
 
-    if (middleIndex != -1) {
+    if (middleIndex !== -1) {
       const middle = Math.floor(disasm.length / 2);
       disasm[middle] = `\x1B[47m\x1B[30m${noAnsi(disasm[middle])}${'\u00a0'.repeat(longest - noAnsi(disasm[middle]).length)}\x1B[0m`;
     }
@@ -429,47 +429,11 @@ export default (source, module = undefined, customImports = {}, print = str => p
     if (funcInd == null || blobOffset == null ||
         Number.isNaN(funcInd) || Number.isNaN(blobOffset) || Prefs.backtrace === false) return false;
 
-    // convert blob offset -> function wasm offset
-    const func = funcs.find(x => x.asmIndex === funcInd);
+    const func = funcs.find(x => (x.index - importDelta) === funcInd);
     if (!func) return false;
 
-    const { wasm: assembledWasmFlat, wasmNonFlat: assembledWasmOps, localDecl } = func.assembled;
-    const toFind = encodeVector(localDecl).concat(assembledWasmFlat.slice(0, 100));
-
-    let i = 0;
-    for (; i < wasm.length; i++) {
-      let mismatch = false;
-      for (let j = 0; j < toFind.length; j++) {
-        if (wasm[i + j] !== toFind[j]) {
-          mismatch = true;
-          break;
-        }
-      }
-
-      if (!mismatch) break;
-    }
-
-    if (i === wasm.length) {
-      printBacktrace(-1, func, funcs, globals, exceptions);
-      return false;
-    }
-
-    const offset = (blobOffset - i) - encodeVector(localDecl).length;
-
-    let cumLen = 0;
-    i = 0;
-    for (; i < assembledWasmOps.length; i++) {
-      cumLen += assembledWasmOps[i].filter(x => x != null && x <= 0xff).length;
-      if (cumLen === offset) break;
-    }
-
-    if (cumLen !== offset) {
-      printBacktrace(-1, func, funcs, globals, exceptions);
-      return false;
-    }
-
-    printBacktrace(i + 1, func, funcs, globals, exceptions);
-    return true;
+    printBacktrace(-1, func, funcs, globals, exceptions);
+    return false;
   };
 
   const t2 = performance.now();

package/foo.js

@@ -1 +1,17 @@
-console.log(process.argv);
+import compile from './compiler/wrap.js';
+import { Worker, isMainThread } from 'node:worker_threads';
+
+import { join } from 'node:path';
+const __dirname = import.meta.dirname;
+const __filename = join(__dirname, 'foo.js');
+
+if (isMainThread) {
+  const worker = new Worker(__filename);
+} else {
+  for (let i = 0; i < 500; i++) {
+    const js = `console.log(globalThis);`;
+    const out = compile(js);
+    out.exports.main();
+    console.log(i);
+  }
+}

package/package.json

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

package/r.js

@@ -0,0 +1,243 @@
+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;
+}
+
+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;
+}
+
+function verifyEqualTo(obj, name, value) {
+  if (!isSameValue(obj[name], value)) {
+    throw new Test262Error('propertyHelper verifyEqualTo failed');
+  }
+}
+
+function verifyWritable(obj, name, verifyProp, value) {
+  if (!verifyProp) {
+    if (!Object.getOwnPropertyDescriptor(obj, name).writable)
+      throw new Test262Error('propertyHelper verifyWritable failed');
+  }
+
+  if (!isWritable(obj, name, verifyProp, value)) {
+    throw new Test262Error('propertyHelper verifyWritable failed');
+  }
+}
+
+function verifyNotWritable(obj, name, verifyProp, value) {
+  if (!verifyProp) {
+    if (Object.getOwnPropertyDescriptor(obj, name).writable)
+      throw new Test262Error('propertyHelper verifyNotWritable failed');
+  }
+
+  if (isWritable(obj, name, verifyProp)) {
+    throw new Test262Error('propertyHelper verifyNotWritable failed');
+  }
+}
+
+function verifyEnumerable(obj, name) {
+  if (!isEnumerable(obj, name)) {
+    throw new Test262Error('propertyHelper verifyEnumerable failed');
+  }
+}
+
+function verifyNotEnumerable(obj, name) {
+  if (isEnumerable(obj, name)) {
+    throw new Test262Error('propertyHelper verifyNotEnumerable failed');
+  }
+}
+
+function verifyConfigurable(obj, name) {
+  if (!isConfigurable(obj, name)) {
+    throw new Test262Error('propertyHelper verifyConfigurable failed');
+  }
+}
+
+function verifyNotConfigurable(obj, name) {
+  if (isConfigurable(obj, name)) {
+    throw new Test262Error('propertyHelper verifyNotConfigurable failed');
+  }
+}
+var assert = mustBeTrue => {
+  if (mustBeTrue === true) {
+    return;
+  }
+
+  throw new Test262Error('assert failed');
+};
+assert; // idk why exactly but this fixes many tests by forcing indirect ref
+
+var __assert_throws = (expectedErrorConstructor, func) => {
+  if (typeof func !== 'function') {
+    throw new Test262Error('assert.throws invoked with a non-function value');
+  }
+
+  try {
+    func();
+  } catch {
+    return;
+  }
+
+  throw new Test262Error('assert.throws failed');
+};
+
+var __assert__isSameValue = (a, b) => {
+  if (a === b) {
+    // Handle +/-0 vs. -/+0
+    return a !== 0 || 1 / a === 1 / b;
+  }
+
+  // Handle NaN vs. NaN
+  return a !== a && b !== b;
+};
+
+var __assert_sameValue = (actual, expected) => {
+  if (assert._isSameValue(actual, expected)) {
+    return;
+  }
+
+  throw new Test262Error('assert.sameValue failed');
+};
+
+var __assert_notSameValue = (actual, unexpected) => {
+  if (!assert._isSameValue(actual, unexpected)) {
+    return;
+  }
+
+  throw new Test262Error('assert.notSameValue failed');
+};
+// define our $262 here too
+// var $262 = {
+//   global: globalThis,
+//   gc() { /* noop */ },
+//   detachArrayBuffer(buffer) {
+//     return Porffor.arraybuffer.detach(buffer);
+//   },
+//   getGlobal(name) {
+//     return globalThis[name];
+//   },
+//   // todo: setGlobal
+//   destroy() { /* noop */ },
+//   agent: {}
+// };
+
+// function Test262Error(message) {
+//   this.message = message;
+//   this.name = 'Test262Error';
+// }
+
+// var __Test262Error_thrower = message => {
+//   throw new Test262Error(message);
+// };
+
+var $DONOTEVALUATE = () => {
+  throw 'Test262: This statement should not be evaluated.';
+};
+// Copyright (C) 2019 Aleksey Shvayka. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+esid: sec-array-constructor
+description: >
+  Property descriptor of Array
+info: |
+  22.1.1 The Array Constructor
+
+  * is the initial value of the Array property of the global object.
+
+  17 ECMAScript Standard Built-in Objects
+
+  Every other data property described in clauses 18 through 26 and in Annex B.2
+  has the attributes { [[Writable]]: true, [[Enumerable]]: false,
+  [[Configurable]]: true } unless otherwise specified.
+includes: [propertyHelper.js]
+---*/
+
+verifyProperty(this, 'Array', {
+  value: Array,
+  writable: true,
+  enumerable: false,
+  configurable: true,
+});

package/runtime/index.js

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