porffor 0.40.1 → 0.40.3

package/compiler/codegen.js

@@ -293,21 +293,7 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
   }
 };
 
-const mapName = x => {
-  if (!x) return x;
-
-  if (x.startsWith('__globalThis_')) {
-    const key = x.slice('__globalThis_'.length);
-    // hack: this will not work properly
-    return key.includes('_') ? ('__' + key) : key;
-  }
-
-  return x;
-};
-
-const lookupName = (scope, _name) => {
-  const name = mapName(_name);
-
+const lookupName = (scope, name) => {
   if (Object.hasOwn(scope.locals, name)) return [ scope.locals[name], false ];
   if (Object.hasOwn(globals, name)) return [ globals[name], true ];
 
@@ -335,9 +321,8 @@ const internalThrow = (scope, constructor, message, expectsValue = Prefs.alwaysV
 ];
 
 const generateIdent = (scope, decl) => {
-  const lookup = (rawName, failEarly = false) => {
-    const name = mapName(rawName);
-    let local = scope.locals[rawName];
+  const lookup = (name, failEarly = false) => {
+    let local = scope.locals[name];
 
     if (Object.hasOwn(builtinVars, name)) {
       if (builtinVars[name].floatOnly && valtype[0] === 'i') throw new Error(`Cannot use ${unhackName(name)} with integer valtype`);
@@ -371,9 +356,9 @@ const generateIdent = (scope, decl) => {
       if (Object.hasOwn(funcIndex, name)) return funcRef(funcByName(name));
     }
 
-    if (local?.idx === undefined && rawName.startsWith('__')) {
+    if (local?.idx === undefined && name.startsWith('__')) {
       // return undefined if unknown key in already known var
-      let parent = rawName.slice(2).split('_').slice(0, -1).join('_');
+      let parent = name.slice(2).split('_').slice(0, -1).join('_');
       if (parent.includes('_')) parent = '__' + parent;
 
       const parentLookup = lookup(parent, true);
@@ -385,7 +370,7 @@ const generateIdent = (scope, decl) => {
 
       return [ [ null, () => {
         // try generating again at the end
-        return lookup(rawName, true);
+        return lookup(name, true);
       }, 1 ] ];
     }
 
@@ -1170,13 +1155,11 @@ const isExistingProtoFunc = name => {
   return false;
 };
 
-const getType = (scope, _name, failEarly = false) => {
+const getType = (scope, name, failEarly = false) => {
   const fallback = failEarly ? number(TYPES.undefined, Valtype.i32) : [ [ null, () => {
-    return getType(scope, _name, true);
+    return getType(scope, name, true);
   }, 1 ] ];
 
-  const name = mapName(_name);
-
   if (Object.hasOwn(builtinVars, name)) return number(builtinVars[name].type ?? TYPES.number, Valtype.i32);
 
   if (Object.hasOwn(scope.locals, name)) {
@@ -1212,11 +1195,9 @@ const getType = (scope, _name, failEarly = false) => {
   return fallback;
 };
 
-const setType = (scope, _name, type) => {
+const setType = (scope, name, type) => {
   typeUsed(scope, knownType(scope, type));
 
-  const name = mapName(_name);
-
   const out = typeof type === 'number' ? number(type, Valtype.i32) : type;
 
   if (Object.hasOwn(scope.locals, name)) {
@@ -1749,7 +1730,7 @@ const aliasPrimObjsBC = bc => {
 };
 
 const createThisArg = (scope, decl) => {
-  const name = mapName(decl.callee?.name);
+  const name = decl.callee?.name;
   if (decl._new) {
     // if precompiling or builtin func, just make it null as unused
     if (globalThis.precompile || Object.hasOwn(builtinFuncs, name)) return [
@@ -1823,7 +1804,7 @@ const createThisArg = (scope, decl) => {
 
 const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   let out = [];
-  let name = mapName(decl.callee.name);
+  let name = decl.callee.name;
 
   // opt: virtualize iifes
   if (isFuncType(decl.callee.type)) {
@@ -1883,8 +1864,8 @@ 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] && !builtinFuncs[target.name]) {
-        if (lookupName(scope, '__' + target.name)[0] || builtinFuncs['__' + target.name]) target.name = '__' + target.name;
+      else if (lookupName(scope, target.name)[0] == null && !builtinFuncs[target.name]) {
+        if (lookupName(scope, '__' + target.name)[0] != null || builtinFuncs['__' + target.name]) target.name = '__' + target.name;
           else protoName = null;
       }
   }
@@ -3075,9 +3056,11 @@ const generateVarDstr = (scope, kind, pattern, init, defaultValue, global) => {
     pattern = { type: 'Identifier', name: pattern };
   }
 
+  // todo: handle globalThis.foo = ...
+
   if (pattern.type === 'Identifier') {
     let out = [];
-    const name = mapName(pattern.name);
+    const name = pattern.name;
 
     if (init && isFuncType(init.type)) {
       // hack for let a = function () { ... }
@@ -3353,6 +3336,19 @@ const getProperty = (decl, forceValueStr = false) => {
   return prop;
 };
 
+const isIdentAssignable = (scope, name, op = '=') => {
+  // not in strict mode and op is =, so ignore
+  if (!scope.strict && op === '=') return true;
+
+  // local exists
+  if (lookupName(scope, name)[0] != null) return true;
+
+  // function with name exists and is not current function
+  if (hasFuncWithName(name) && scope.name !== name) return true;
+
+  return false;
+};
+
 // todo: optimize this func for valueUnused
 const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
   const { type, name } = decl.left;
@@ -3678,7 +3674,7 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
 
   if (local === undefined) {
     // only allow = for this, or if in strict mode always throw
-    if (op !== '=' || scope.strict) return internalThrow(scope, 'ReferenceError', `${unhackName(name)} is not defined`, true);
+    if (!isIdentAssignable(scope, name, op)) return internalThrow(scope, 'ReferenceError', `${unhackName(name)} is not defined`, true);
 
     if (type != 'Identifier') {
       const tmpName = '#rhs' + uniqId();
@@ -4095,7 +4091,7 @@ const generateForOf = (scope, decl) => {
   // setup local for left
   let setVar;
   if (decl.left.type === 'Identifier') {
-    if (scope.strict) return internalThrow(scope, 'ReferenceError', `${decl.left.name} is not defined`);
+    if (!isIdentAssignable(scope, decl.left.name)) return internalThrow(scope, 'ReferenceError', `${decl.left.name} is not defined`);
     setVar = generateVarDstr(scope, 'var', decl.left, { type: 'Identifier', name: tmpName }, undefined, true);
   } else {
     // todo: verify this is correct
@@ -4453,7 +4449,7 @@ const generateForIn = (scope, decl) => {
 
   let setVar;
   if (decl.left.type === 'Identifier') {
-    if (scope.strict) return internalThrow(scope, 'ReferenceError', `${decl.left.name} is not defined`);
+    if (!isIdentAssignable(scope, decl.left.name)) return internalThrow(scope, 'ReferenceError', `${decl.left.name} is not defined`);
     setVar = generateVarDstr(scope, 'var', decl.left, { type: 'Identifier', name: tmpName }, undefined, true);
   } else {
     // todo: verify this is correct
@@ -5331,6 +5327,8 @@ const generateMember = (scope, decl, _global, _name, _objectWasm = undefined) =>
   let final = [], finalEnd, extraBC = {};
   const name = decl.object.name;
 
+  // todo: handle globalThis.foo
+
   // hack: .name
   if (decl.property.name === 'name' && hasFuncWithName(name) && !scope.noFastFuncMembers) {
     let nameProp = name;

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.40.1+5e139c5e1",
+  "version": "0.40.3+5f310db4d",
   "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.40.1+5e139c5e1';
+globalThis.version = '0.40.3+5f310db4d';
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {