porffor 0.60.9 → 0.60.11

package/compiler/codegen.js

@@ -73,23 +73,12 @@ export const allocStr = (scope, str, bytestring) => {
   return allocBytes(scope, str, bytes);
 };
 
-const todo = (scope, msg, expectsValue = undefined) => {
-  msg = `todo: ${msg}`;
-
-  switch (Prefs.todoTime ?? 'runtime') {
-    case 'compile':
-      throw new Error(msg);
-
-    case 'runtime':
-      return internalThrow(scope, 'Error', msg, expectsValue);
-  }
-};
 
 const isFuncType = type =>
   type === 'FunctionDeclaration' || type === 'FunctionExpression' || type === 'ArrowFunctionExpression' ||
   type === 'ClassDeclaration' || type === 'ClassExpression';
 const hasFuncWithName = name =>
-  Object.hasOwn(funcIndex, name) || Object.hasOwn(builtinFuncs, name) || Object.hasOwn(importedFuncs, name) || Object.hasOwn(internalConstrs, name);
+  name in funcIndex || name in builtinFuncs || name in importedFuncs || name in internalConstrs;
 
 const astCache = new WeakMap();
 const cacheAst = (decl, wasm) => {
@@ -443,7 +432,7 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
       return cacheAst(decl, generateTaggedTemplate(scope, decl, global, name, valueUnused));
 
     case 'ExportNamedDeclaration':
-      if (!decl.declaration) return todo(scope, 'unsupported export declaration', true);
+      if (!decl.declaration) return internalThrow(scope, 'Error', 'porffor: unsupported export declaration', true);
 
       const funcsBefore = funcs.map(x => x.name);
       generate(scope, decl.declaration);
@@ -469,6 +458,12 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
       if (Prefs.d) log.warning('codegen', 'with is not supported, treating as expression');
       return cacheAst(decl, generate(scope, decl.body));
 
+    case 'PrivateIdentifier':
+      return cacheAst(decl, generate(scope, {
+        type: 'Literal',
+        value: privateIDName(decl.name)
+      }));
+
     case 'TSEnumDeclaration':
       return cacheAst(decl, generateEnum(scope, decl));
 
@@ -479,7 +474,7 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
         return cacheAst(decl, [ number(UNDEFINED) ]);
       }
 
-      return cacheAst(decl, todo(scope, `no generation for ${decl.type}!`, true));
+      return cacheAst(decl, internalThrow(scope, 'Error', `porffor: no generation for ${decl.type}`, true));
   }
 };
 
@@ -541,8 +536,8 @@ const generateEnum = (scope, decl) => {
 const optional = (op, clause = op.at(-1)) => clause || clause === 0 ? (Array.isArray(op[0]) ? op : [ op ]) : [];
 
 const lookupName = (scope, name) => {
-  if (Object.hasOwn(scope.locals, name)) return [ scope.locals[name], false ];
-  if (Object.hasOwn(globals, name)) return [ globals[name], true ];
+  if (name in scope.locals) return [ scope.locals[name], false ];
+  if (name in globals) return [ globals[name], true ];
 
   return [ undefined, undefined ];
 };
@@ -608,7 +603,7 @@ const hoistLookupType = (scope, name) => {
 const lookup = (scope, name, failEarly = false) => {
   let local = scope.locals[name];
 
-  if (Object.hasOwn(builtinVars, name)) {
+  if (name in builtinVars) {
     let wasm = builtinVars[name];
     if (wasm.usesImports) scope.usesImports = true;
 
@@ -616,9 +611,9 @@ const lookup = (scope, name, failEarly = false) => {
     return wasm.slice();
   }
 
-  if (!Object.hasOwn(funcIndex, name) && Object.hasOwn(builtinFuncs, name)) {
+  if (!(name in funcIndex) && name in builtinFuncs) {
     includeBuiltin(scope, name);
-  } else if (Object.hasOwn(internalConstrs, name)) {
+  } else if (name in internalConstrs) {
     // todo: return an actual something
     return [ number(1) ];
   }
@@ -662,16 +657,16 @@ const lookup = (scope, name, failEarly = false) => {
     }
 
     // no local var with name
-    if (Object.hasOwn(globals, name)) return [ [ Opcodes.global_get, globals[name].idx ] ];
-    if (Object.hasOwn(funcIndex, name)) return funcRef(funcByName(name));
-    if (Object.hasOwn(importedFuncs, name)) return [ number(importedFuncs[name] - importedFuncs.length) ];
+    if (name in globals) return [ [ Opcodes.global_get, globals[name].idx ] ];
+    if (name in funcIndex) return funcRef(funcByName(name));
+    if (name in importedFuncs) return [ number(importedFuncs[name] - importedFuncs.length) ];
 
     if (name.startsWith('__')) {
       // return undefined if unknown key in already known var
       let parent = name.slice(2).split('_').slice(0, -1).join('_');
       if (parent.includes('_')) parent = '__' + parent;
 
-      if (Object.hasOwn(builtinFuncs, name + '$get')) {
+      if ((name + '$get') in builtinFuncs) {
         // hack: force error as accessors should only be used with objects anyway
         return internalThrow(scope, 'TypeError', 'Accessor called without object');
       }
@@ -905,8 +900,6 @@ const performLogicOp = (scope, op, left, right, leftType, rightType) => {
     '??': nullish
   };
 
-  if (!checks[op]) return todo(scope, `logic operator ${op} not implemented yet`, true);
-
   // generic structure for {a} OP {b}
   // _ = {a}; if (OP_CHECK) {b} else _
 
@@ -1286,7 +1279,6 @@ const performOp = (scope, op, left, right, leftType, rightType) => {
 
   // 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 ];
 
@@ -1474,7 +1466,7 @@ const asmFuncToAsm = (scope, func, extra) => func(scope, {
   },
   glbl: (opcode, name, type) => {
     const globalName = '#porf#' + name; // avoid potential name clashing with user js
-    if (!Object.hasOwn(globals, globalName)) {
+    if (!(globalName in globals)) {
       const idx = globals['#ind']++;
       globals[globalName] = { idx, type };
 
@@ -1509,7 +1501,7 @@ const asmFuncToAsm = (scope, func, extra) => func(scope, {
     return out;
   },
   loc: (name, type) => {
-    if (!Object.hasOwn(scope.locals, name)) {
+    if (!(name in scope.locals)) {
       const idx = scope.localInd++;
       scope.locals[name] = { idx, type };
     }
@@ -1551,7 +1543,7 @@ const asmFunc = (name, func) => {
   if (existing) return existing;
 
   const allLocals = params.concat(localTypes);
-  const locals = {};
+  const locals = Object.create(null);
   for (let i = 0; i < allLocals.length; i++) {
     locals[localNames[i] ?? `l${i}`] = { idx: i, type: allLocals[i] };
   }
@@ -1646,14 +1638,14 @@ const getType = (scope, name, failEarly = false) => {
     [ null, () => hoistLookupType(scope, name) ]
   ];
 
-  if (Object.hasOwn(builtinVars, name)) return [ number(builtinVars[name].type ?? TYPES.number, Valtype.i32) ];
+  if (name in builtinVars) return [ number(builtinVars[name].type ?? TYPES.number, Valtype.i32) ];
 
   let metadata, typeLocal, global = null;
-  if (Object.hasOwn(scope.locals, name)) {
+  if (name in scope.locals) {
     metadata = scope.locals[name].metadata;
     typeLocal = scope.locals[name + '#type'];
     global = false;
-  } else if (Object.hasOwn(globals, name)) {
+  } else if (name in globals) {
     metadata = globals[name].metadata;
     typeLocal = globals[name + '#type'];
     global = true;
@@ -1687,10 +1679,10 @@ const setType = (scope, name, type, noInfer = false) => {
   const out = typeof type === 'number' ? [ number(type, Valtype.i32) ] : type;
 
   let metadata, typeLocal, global = false;
-  if (Object.hasOwn(scope.locals, name)) {
+  if (name in scope.locals) {
     metadata = scope.locals[name].metadata;
     typeLocal = scope.locals[name + '#type'];
-  } else if (Object.hasOwn(globals, name)) {
+  } else if (name in globals) {
     metadata = globals[name].metadata;
     typeLocal = globals[name + '#type'];
     global = true;
@@ -1797,8 +1789,8 @@ const getNodeType = (scope, node) => {
         if (func.returnType != null) return func.returnType;
       }
 
-      if (Object.hasOwn(builtinFuncs, name) && builtinFuncs[name].returnType != null) return builtinFuncs[name].returnType;
-      if (Object.hasOwn(internalConstrs, name) && internalConstrs[name].type != null) return internalConstrs[name].type;
+      if (name in builtinFuncs && builtinFuncs[name].returnType != null) return builtinFuncs[name].returnType;
+      if (name in internalConstrs && internalConstrs[name].type != null) return internalConstrs[name].type;
 
       if (name.startsWith('__Porffor_wasm_')) {
         // todo: return undefined for non-returning ops
@@ -1950,6 +1942,13 @@ const getNodeType = (scope, node) => {
       return getNodeType(scope, node.body);
     }
 
+    if (node.type === 'PrivateIdentifier') {
+      return getNodeType(scope, {
+        type: 'Literal',
+        value: privateIDName(node.name)
+      });
+    }
+
     if (node.type.endsWith('Statement') || node.type.endsWith('Declaration')) {
       return TYPES.undefined;
     }
@@ -2021,8 +2020,6 @@ const generateLiteral = (scope, decl, global, name) => {
       ]
     });
   }
-
-  return todo(scope, `cannot generate literal of type ${typeof decl.value}`, true);
 };
 
 const generateExp = (scope, decl) => {
@@ -2171,7 +2168,7 @@ const createThisArg = (scope, decl) => {
   const name = decl.callee?.name;
   if (decl._new) {
     // if precompiling or builtin func, just make it null as unused
-    if (!decl._forceCreateThis && (globalThis.precompile || Object.hasOwn(builtinFuncs, name))) return [
+    if (!decl._forceCreateThis && (globalThis.precompile || name in builtinFuncs)) return [
       number(NULL),
       number(TYPES.object, Valtype.i32)
     ];
@@ -2338,7 +2335,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 && !Object.hasOwn(builtinFuncs, target.name)) {
+      else if (lookupName(scope, target.name)[0] == null && !(target.name in builtinFuncs)) {
         if (lookupName(scope, '__' + target.name)[0] != null || builtinFuncs['__' + target.name]) target.name = '__' + target.name;
           else protoName = null;
       }
@@ -2478,18 +2475,18 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   let idx;
   if (decl._funcIdx) {
     idx = decl._funcIdx;
-  } else if (Object.hasOwn(internalConstrs, name) && !decl._noInternalConstr) {
+  } else if (name in internalConstrs && !decl._noInternalConstr) {
     if (decl._new && internalConstrs[name].notConstr) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a constructor`, true);
     return internalConstrs[name].generate(scope, decl, _global, _name);
-  } else if (Object.hasOwn(funcIndex, name)) {
+  } else if (name in funcIndex) {
     idx = funcIndex[name];
   } else if (scope.name === name) {
     // fallback for own func but with a different var/id name
     idx = scope.index;
-  } else if (Object.hasOwn(importedFuncs, name)) {
+  } else if (name in importedFuncs) {
     idx = importedFuncs[name];
     scope.usesImports = true;
-  } else if (Object.hasOwn(builtinFuncs, name)) {
+  } else if (name in builtinFuncs) {
     if (decl._new && !builtinFuncs[name].constr) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a constructor`, true);
 
     includeBuiltin(scope, name);
@@ -3136,7 +3133,7 @@ const allocVar = (scope, name, global = false, type = true, redecl = false, i32
   const target = global ? globals : scope.locals;
 
   // already declared
-  if (Object.hasOwn(target, name)) {
+  if (name in target) {
     if (redecl) {
       // force change old local name(s)
       target['#redecl_' + name + uniqId()] = target[name];
@@ -3332,7 +3329,7 @@ const generateVarDstr = (scope, kind, pattern, init, defaultValue, global) => {
       const [ _func, out ] = generateFunc(scope, init, true);
 
       const funcName = init.id?.name;
-      if (name !== funcName && Object.hasOwn(funcIndex, funcName)) {
+      if (name !== funcName && funcName in funcIndex) {
         funcIndex[name] = funcIndex[funcName];
         delete funcIndex[funcName];
       }
@@ -3347,7 +3344,7 @@ const generateVarDstr = (scope, kind, pattern, init, defaultValue, global) => {
     }
 
     let out = [];
-    if (topLevel && Object.hasOwn(builtinVars, name)) {
+    if (topLevel && name in builtinVars) {
       // cannot redeclare
       if (kind !== 'var') return internalThrow(scope, 'SyntaxError', `Identifier '${unhackName(name)}' has already been declared`);
 
@@ -3395,7 +3392,7 @@ const generateVarDstr = (scope, kind, pattern, init, defaultValue, global) => {
       }
 
       if (globalThis.precompile && global) {
-        scope.globalInits ??= {};
+        scope.globalInits ??= Object.create(null);
         scope.globalInits[name] = newOut;
       }
     } else {
@@ -3525,8 +3522,6 @@ const generateVarDstr = (scope, kind, pattern, init, defaultValue, global) => {
             ]
           }, undefined, global)
         );
-      } else {
-        return todo(scope, `${prop.type} is not supported in object patterns`);
       }
     }
 
@@ -3567,8 +3562,6 @@ const generateVarDstr = (scope, kind, pattern, init, defaultValue, global) => {
     }),
     [ Opcodes.drop ]
   ];
-
-  return todo(scope, `variable declarators of type ${pattern.type} are not supported yet`);
 }
 
 const generateVar = (scope, decl) => {
@@ -4214,7 +4207,7 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
       ];
     }
 
-    if (Object.hasOwn(builtinVars, name)) {
+    if (name in builtinVars) {
       if (scope.strict) return internalThrow(scope, 'TypeError', `Cannot assign to non-writable global ${name}`, true);
 
       // just return rhs (eg `NaN = 2`)
@@ -4437,8 +4430,6 @@ const generateUnary = (scope, decl) => {
       return out;
     }
   }
-
-  return todo(scope, `unary operator ${decl.operator} not implemented yet`, true);
 };
 
 const generateUpdate = (scope, decl, _global, _name, valueUnused = false) => {
@@ -5564,7 +5555,8 @@ const generateMeta = (scope, decl) => {
     return [ number(UNDEFINED) ];
   }
 
-  return todo(scope, `meta property object ${decl.meta.name} is not supported yet`, true);
+  // todo: import.meta
+  return internalThrow(scope, 'Error', `porffor: meta property ${decl.meta.name}.${decl.property.name} is not supported yet`, true);
 };
 
 const compileBytes = (val, itemType) => {
@@ -5845,7 +5837,7 @@ const wrapBC = (bc, { prelude = [], postlude = [] } = {}) => {
 
 const countParams = (func, name = undefined) => {
   if (!func) {
-    if (Object.hasOwn(importedFuncs, name)) {
+    if (name in importedFuncs) {
       // reverse lookup then normal lookup
       func = importedFuncs[importedFuncs[name]];
       if (func) return func.params?.length ?? func.params;
@@ -6577,6 +6569,7 @@ const generateTemplate = (scope, decl) => {
 
 const generateTaggedTemplate = (scope, decl, global = false, name = undefined, valueUnused = false) => {
   const intrinsics = {
+    __proto__: null,
     __Porffor_wasm: str => {
       let out = [];
 
@@ -6603,12 +6596,12 @@ 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 (Object.hasOwn(builtinFuncs, x)) {
+            if (x in builtinFuncs) {
               if (funcIndex[x] == null) includeBuiltin(scope, x);
               return funcIndex[x];
             }
 
-            if (Object.hasOwn(importedFuncs, x)) {
+            if (x in importedFuncs) {
               scope.usesImports = true;
               return importedFuncs[x];
             }
@@ -6648,7 +6641,7 @@ const generateTaggedTemplate = (scope, decl, global = false, name = undefined, v
   };
 
   const { quasis, expressions } = decl.quasi;
-  if (Object.hasOwn(intrinsics, decl.tag.name)) {
+  if (decl.tag.name in intrinsics) {
     let str = quasis[0].value.raw;
 
     for (let i = 0; i < expressions.length; i++) {
@@ -6732,7 +6725,7 @@ const objectHack = node => {
       if (objectName !== 'Object_prototype' && (node.property.name === 'propertyIsEnumerable' || node.property.name === 'hasOwnProperty' || node.property.name === 'isPrototypeOf')) return abortOut;
 
       const name = '__' + objectName + '_' + node.property.name;
-      if ((!hasFuncWithName(name) && !Object.hasOwn(builtinVars, name) && !hasFuncWithName(name + '$get')) && (hasFuncWithName(objectName) || Object.hasOwn(builtinVars, objectName) || hasFuncWithName('__' + objectName) || Object.hasOwn(builtinVars, '__' + objectName))) return abortOut;
+      if ((!hasFuncWithName(name) && !(name in builtinVars) && !hasFuncWithName(name + '$get')) && (hasFuncWithName(objectName) || objectName in builtinVars || hasFuncWithName('__' + objectName) || ('__' + objectName) in builtinVars)) return abortOut;
 
       if (Prefs.codeLog) log('codegen', `object hack! ${node.object.name}.${node.property.name} -> ${name}`);
 
@@ -6795,7 +6788,7 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
   const arrow = decl.type === 'ArrowFunctionExpression' || decl.type === 'Program';
   const func = {
     start: decl.start,
-    locals: {},
+    locals: Object.create(null),
     localInd: 0,
     returns: [ valtypeBinary, Valtype.i32 ], // value, type
     name,
@@ -7005,7 +6998,7 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
         wasm.push(...getNodeType(func, getLastNode(decl.body.body)));
 
         // inject promise job runner func at the end of main if promises are made
-        if (Object.hasOwn(funcIndex, 'Promise') || Object.hasOwn(funcIndex, '__Promise_resolve') || Object.hasOwn(funcIndex, '__Promise_reject')) {
+        if (('Promise' in funcIndex) || ('__Promise_resolve' in funcIndex) || ('__Promise_reject' in funcIndex)) {
           wasm.push(
             [ Opcodes.call, includeBuiltin(func, '__Porffor_promise_runJobs').index ]
           );
@@ -7180,6 +7173,7 @@ const generateBlock = (scope, decl) => {
 };
 
 const internalConstrs = {
+  __proto__: null,
   __Array_of: {
     // this is not a constructor but best fits internal structure here
     generate: (scope, decl, global, name) => {
@@ -7369,7 +7363,8 @@ const internalConstrs = {
 
 let globals, tags, exceptions, funcs, indirectFuncs, funcIndex, currentFuncIndex, depth, pages, data, typeswitchDepth, usedTypes, coctc, globalInfer, builtinFuncs, builtinVars, lastValtype;
 export default program => {
-  globals = { ['#ind']: 0 };
+  globals = Object.create(null);
+  globals['#ind'] = 0;
   tags = [];
   exceptions = [];
   funcs = []; indirectFuncs = [];
@@ -7377,7 +7372,7 @@ export default program => {
     return indirectFuncs._bytesPerFuncLut ??=
       Math.min(Math.floor((pageSize * 2) / indirectFuncs.length), indirectFuncs.reduce((acc, x) => x.name.length > acc ? x.name.length : acc, 0) + 8);
   };
-  funcIndex = {};
+  funcIndex = Object.create(null);
   depth = [];
   pages = new Map();
   data = [];
@@ -7404,8 +7399,8 @@ export default program => {
   // keep builtins between compiles as much as possible
   if (lastValtype !== valtypeBinary) {
     lastValtype = valtypeBinary;
-    builtinFuncs = new BuiltinFuncs();
-    builtinVars = new BuiltinVars({ builtinFuncs });
+    builtinFuncs = BuiltinFuncs();
+    builtinVars = BuiltinVars({ builtinFuncs });
 
     const getObjectName = x => x.startsWith('__') && x.slice(2, x.indexOf('_', 2));
     objectHackers = ['assert', 'compareArray', 'Test262Error', ...new Set(Object.keys(builtinFuncs).map(getObjectName).concat(Object.keys(builtinVars).map(getObjectName)).filter(x => x))];

package/compiler/precompile.js

@@ -57,7 +57,7 @@ const compile = async (file, _funcs) => {
     first = source.slice(0, source.indexOf('\n'));
   }
 
-  let args = ['--module', '--todo-time=compile', '--truthy=no_nan_negative', '--no-rm-unused-types', '--fast-length', '--parse-types', '--opt-types', '--no-passive-data', '--active-data', '--no-treeshake-wasm-imports', '--no-coctc'];
+  let args = ['--module', '--truthy=no_nan_negative', '--no-rm-unused-types', '--fast-length', '--parse-types', '--opt-types', '--no-passive-data', '--active-data', '--no-treeshake-wasm-imports', '--no-coctc'];
   if (first.startsWith('// @porf')) {
     args = first.slice('// @porf '.length).split(' ').concat(args);
   }
@@ -237,7 +237,7 @@ const precompile = async () => {
   return `// autogenerated by compiler/precompile.js
 import { number } from './encoding.js';
 
-export const BuiltinFuncs = function() {
+export const BuiltinFuncs = x => {
 ${funcs.map(x => {
   const rewriteWasm = wasm => {
     const str = JSON.stringify(wasm.filter(x => x.length && (x[0] != null || typeof x[1] === 'string')), (k, v) => {
@@ -278,7 +278,7 @@ ${funcs.map(x => {
   const name = x.name.includes('#') ? `['${x.name}']` : `.${x.name}`;
 
   const returnTypes = [...(x.returnTypes ?? [])].filter(x => ![ TYPES.undefined, TYPES.number, TYPES.boolean, TYPES.function ].includes(x));
-  return `this${name} = {
+  return `x${name}={
 wasm:${rewriteWasm(x.wasm)},
 params:${JSON.stringify(x.params)},typedParams:1,returns:${JSON.stringify(x.returns)},${x.returnType != null ? `returnType:${JSON.stringify(x.returnType)},` : ''}${returnTypes.length > 0 ? `returnTypes:${JSON.stringify(returnTypes)},` : ''}jsLength:${x.jsLength},
 locals:${JSON.stringify(locals.slice(x.params.length).map(x => x[1].type))},localNames:${JSON.stringify(locals.map(x => x[0]))},

package/foo.js

@@ -0,0 +1,15 @@
+let count = 0;
+
+class Class {
+  #method() {
+    count += 1;
+  }
+
+  static isNameIn(value) {
+    return #method in value;
+  }
+}
+
+console.log(Class.isNameIn({}), false);
+console.log(Class.isNameIn(new Class()), true);
+console.log(count, 0);

package/package.json

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

package/runtime/index.js

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