porffor 0.55.12 → 0.55.13

package/compiler/codegen.js

@@ -2037,15 +2037,18 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     name = func.name;
   }
 
-  if (!decl._new && name === 'eval') {
+  if (!decl._new && (name === 'eval' || (decl.callee.type === 'SequenceExpression' && decl.callee.expressions.at(-1)?.name === 'eval'))) {
     const known = knownValue(scope, decl.arguments[0]);
     if (known !== unknownValue) {
-      // known value literal eval hack
+      // eval('with known/literal string')
       const code = String(known);
 
       let parsed;
       try {
-        parsed = parse(code);
+        parsed = {
+          type: 'BlockStatement',
+          body: parse(code).body.map(objectHack)
+        };
       } catch (e) {
         if (e.name === 'SyntaxError') {
           // throw syntax errors of evals at runtime instead
@@ -2055,11 +2058,24 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
         throw e;
       }
 
+      if (decl.callee.type === 'SequenceExpression' || decl.optional) {
+        // indirect, use separate func+scope
+        const [ func ] = generateFunc({}, {
+          type: 'ArrowFunctionExpression',
+          body: parsed,
+          expression: true
+        }, true);
+
+        func.generate();
+
+        return [
+          [ Opcodes.call, func.index ],
+          ...setLastType(scope)
+        ];
+      }
+
       scope.inEval = true;
-      const out = generate(scope, {
-        type: 'BlockStatement',
-        body: parsed.body
-      });
+      const out = generate(scope, parsed);
       scope.inEval = false;
 
       out.push(...setLastType(scope, getNodeType(scope, getLastNode(parsed.body))));
@@ -2070,12 +2086,12 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   if (name === 'Function') {
     const known = knownValue(scope, decl.arguments[0]);
     if (known !== unknownValue) {
-      // known value literal Function hack
+      // new Function('with known/literal string')
       const code = String(known);
 
       let parsed;
       try {
-        parsed = parse(`(function(){${code}})`);
+        parsed = objectHack(parse(`(function(){${code}})`));
       } catch (e) {
         if (e.name === 'SyntaxError') {
           // throw syntax errors of evals at runtime instead
@@ -3512,12 +3528,7 @@ const generateVar = (scope, decl) => {
   return out;
 };
 
-const privateIDName = name => '.#.' + name;
-const privateIdentifierToIdentifier = decl => ({
-  type: 'Identifier',
-  name: privateIDName(decl.name)
-});
-
+const privateIDName = name => '__#' + name;
 const getProperty = (decl, forceValueStr = false) => {
   const prop = decl.property ?? decl.key;
   if (decl.computed) return prop;
@@ -6489,8 +6500,7 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
     start: decl.start,
     locals: {},
     localInd: 0,
-    // value, type
-    returns: [ valtypeBinary, Valtype.i32 ],
+    returns: [ valtypeBinary, Valtype.i32 ], // value, type
     name,
     index: currentFuncIndex++,
     arrow,

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.55.12",
+  "version": "0.55.13",
   "author": "CanadaHonk",
   "license": "MIT",
   "scripts": {},

package/r.cjs

@@ -0,0 +1,86 @@
+// 'use strict';
+function foo() {
+  'use strict';
+  console.log(this);
+  eval('console.log(this)');
+  (0, eval)('console.log(this)');
+  eval?.('console.log(this)');
+}
+
+foo();
+
+// let o = { set foo(x) { console.log('set foo', x); }, __proto__: { set bar(x) { console.log('set bar', x); } } };
+
+// o.foo = 1;
+// o.bar = 2;
+
+// class C {
+//   // static #method = () => 1;
+//   static #method() {
+//     return 'Test262';
+//   }
+
+//   static getPrivateMethod() {
+//     this.#method = () => 2;
+//     return this.#method();
+//   }
+// }
+
+// console.log(C.getPrivateMethod())
+
+// 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');
+// };
+
+// (function() {
+//   eval(
+//     '__assert_throws(ReferenceError, function() {\
+//       f;\
+//     }, "An initialized binding is not created prior to evaluation");\
+//     __assert_sameValue(\
+//       typeof f,\
+//       "undefined",\
+//       "An uninitialized binding is not created prior to evaluation"\
+//     );\
+//     \
+//     {\
+//     let f = 123;if (false) ; else function f() {  }}\
+//     \
+//     __assert_throws(ReferenceError, function() {\
+//       f;\
+//     }, "An initialized binding is not created following evaluation");\
+//     __assert_sameValue(\
+//       typeof f,\
+//       "undefined",\
+//       "An uninitialized binding is not created following evaluation"\
+//     );'
+//   );
+// }());

package/runner/index.js

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