porffor 0.55.28 → 0.55.31

package/compiler/codegen.js

@@ -3,7 +3,7 @@ import { number, ieee754_binary64, signedLEB128, unsignedLEB128, encodeVector, r
 import { operatorOpcode } from './expression.js';
 import { BuiltinFuncs, BuiltinVars, importedFuncs, NULL, UNDEFINED } from './builtins.js';
 import { PrototypeFuncs } from './prototype.js';
-import { TYPES, TYPE_FLAGS, TYPE_NAMES, typeHasFlag } from './types.js';
+import { TYPES, TYPE_FLAGS, TYPE_NAMES } from './types.js';
 import * as Rhemyn from '../rhemyn/compile.js';
 import parse from './parse.js';
 import { log } from './log.js';
@@ -1505,7 +1505,18 @@ const setType = (scope, name, type, noInfer = false) => {
 };
 
 const getLastType = scope => {
-  if (!scope.locals['#last_type']) return [ number(TYPES.number, Valtype.i32) ];
+  if (!scope.locals['#last_type']) return [
+    [ null, () => {
+      if (scope.locals['#last_type']) {
+        scope.gotLastType = true;
+        return [
+          [ Opcodes.local_get, localTmp(scope, '#last_type', Valtype.i32) ]
+        ];
+      }
+
+      return [ number(TYPES.number, Valtype.i32) ];
+    } ]
+  ];
 
   scope.gotLastType = true;
   return [
@@ -1664,7 +1675,7 @@ const getNodeType = (scope, node) => {
 
       const objectKnownType = knownType(scope, getNodeType(scope, node.object));
       if (objectKnownType != null) {
-        if (name === 'length' && typeHasFlag(objectKnownType, TYPE_FLAGS.length)) return TYPES.number;
+        if (name === 'length' && (objectKnownType & TYPE_FLAGS.length) !== 0) return TYPES.number;
 
         if (node.computed) {
           if (objectKnownType === TYPES.string) return TYPES.string;
@@ -3653,7 +3664,7 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
 
     const type = getNodeType(scope, decl.left.object);
     const known = knownType(scope, type);
-    if (known != null && typeHasFlag(known, TYPE_FLAGS.length)) return [
+    if (known != null && (known & TYPE_FLAGS.length) !== 0) return [
       ...out,
       ...optional([ Opcodes.local_tee, pointerTmp ]),
 
@@ -5678,7 +5689,7 @@ const generateMember = (scope, decl, _global, _name) => {
 
     const type = getNodeType(scope, object);
     const known = knownType(scope, type);
-    if (known != null && typeHasFlag(known, TYPE_FLAGS.length)) return [
+    if (known != null && (known & TYPE_FLAGS.length) !== 0) return [
       ...out,
 
       [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
@@ -6655,6 +6666,7 @@ const generateFunc = (scope, decl, forceNoExpr = false) => {
   if (typedInput && decl.returnType) {
     const { type } = extractTypeAnnotation(decl.returnType);
     if (type != null) {
+      typeUsed(func, type);
       func.returnType = type;
       func.returns = func.returnType === TYPES.undefined && !func.async && !func.generator ? [] : [ valtypeBinary ];
     }

package/compiler/types.js

@@ -30,10 +30,7 @@ export const TYPE_NAMES = {
   [TYPES.bigint]: 'BigInt'
 };
 
-export const typeHasFlag = (type, flag) => (type & flag) !== 0;
-
-export const INTERNAL_TYPE_BASE = 0x10;
-let internalTypeIndex = INTERNAL_TYPE_BASE;
+let internalTypeIndex = TYPES.object + 1;
 const registerInternalType = (name, flags = [], overrideType = undefined) => {
   let n = overrideType ?? internalTypeIndex++;
 
@@ -72,12 +69,13 @@ registerInternalType('BooleanObject');
 registerInternalType('NumberObject');
 registerInternalType('StringObject');
 
-for (const x of [ '', 'Aggregate', 'Type', 'Reference', 'Syntax', 'Range', 'Eval', 'URI', 'Test262', 'Todo' ])
-  registerInternalType(`${x}Error`);
-
 registerInternalType('__Porffor_Generator');
 registerInternalType('__Porffor_AsyncGenerator');
 
+// from here, remapped object types only
+for (const x of [ '', 'Aggregate', 'Type', 'Reference', 'Syntax', 'Range', 'Eval', 'URI', 'Test262' ])
+  registerInternalType(`${x}Error`);
+
 if (Prefs.largestTypes) {
   const typeKeys = Object.keys(TYPES);
   const typeVals = Object.values(TYPES);
@@ -88,11 +86,11 @@ if (Prefs.largestTypes) {
     return [ val, key ];
   };
 
-  const unflag = val => val & 0b00111111;
-
   const logType = (label, val, key) => console.log(`${label}    ${key} - ${val} (0x${val.toString(16)}, 0b${val.toString(2).padStart(8, '0')})`);
 
-  logType(`largest type:         `, ...largestType(typeVals.map(unflag), typeKeys));
+  const largestUnflagged = largestType(typeVals.map(x => x & 0b00111111), typeKeys);
+  logType(`largest type:         `, ...largestUnflagged);
   logType(`largest type w/ flags:`, ...largestType(typeVals, typeKeys));
+  console.log('types left:', 0b00111111 - largestUnflagged[0]);
   console.log();
 }

package/compiler/wrap.js

@@ -311,8 +311,7 @@ ${flags & 0b0001 ? `    get func idx: ${get}
     case TYPES.rangeerror:
     case TYPES.evalerror:
     case TYPES.urierror:
-    case TYPES.test262error:
-    case TYPES.todoerror: {
+    case TYPES.test262error: {
       const obj = porfToJSValue({ memory, funcs, pages }, value, TYPES.object);
       const err = new (globalThis[TYPE_NAMES[type]] ?? Error)(obj.message);
 

package/package.json

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

package/r.cjs

@@ -1,8 +1,257 @@
-function foo() {
-  return this;
+Foo.prototype.baz = function baz() {};
+
+function Foo() {
+  this.bar = 1;
 }
 
-console.log(foo());
+Foo.prototype.bar = function bar() {};
+
+
+
+// var EQUAL = 1;
+// var NOT_EQUAL = -1;
+// var UNKNOWN = 0;
+
+// function setCache(cache, left, right, result) {
+//   var otherCache;
+
+//   otherCache = cache.get(left);
+//   if (!otherCache) cache.set(left, otherCache = new Map());
+//   otherCache.set(right, result);
+
+//   otherCache = cache.get(right);
+//   if (!otherCache) cache.set(right, otherCache = new Map());
+//   otherCache.set(left, result);
+// }
+
+// function getCache(cache, left, right) {
+//   var otherCache;
+//   var result;
+
+//   otherCache = cache.get(left);
+//   result = otherCache && otherCache.get(right);
+//   if (result) return result;
+
+//   otherCache = cache.get(right);
+//   result = otherCache && otherCache.get(left);
+//   if (result) return result;
+
+//   return UNKNOWN;
+// }
+
+// function cacheComparison(a, b, compare, cache) {
+//   var result = compare(a, b, cache);
+//   if (cache && (result === EQUAL || result === NOT_EQUAL)) {
+//     setCache(cache, a, b, result);
+//   }
+//   return result;
+// }
+
+// function isBoxed(value) {
+//   return value instanceof String
+//     || value instanceof Number
+//     || value instanceof Boolean
+//     || value instanceof Symbol;
+// }
+
+// function fail() {
+//   return NOT_EQUAL;
+// }
+
+// function compareIf(a, b, test, compare, cache) {
+//   return !test(a)
+//     ? !test(b) ? UNKNOWN : NOT_EQUAL
+//     : !test(b) ? NOT_EQUAL : cacheComparison(a, b, compare, cache);
+// }
+
+// function compareEquality(a, b, cache) {
+//   return compareIf(a, b, isOptional, compareOptionality)
+//     || compareIf(a, b, isPrimitiveEquatable, comparePrimitiveEquality)
+//     || compareIf(a, b, isObjectEquatable, compareObjectEquality, cache)
+//     || NOT_EQUAL;
+// }
+
+// function tryCompareStrictEquality(a, b) {
+//   return a === b ? EQUAL : UNKNOWN;
+// }
+
+// function tryCompareTypeOfEquality(a, b) {
+//   return typeof a !== typeof b ? NOT_EQUAL : UNKNOWN;
+// }
+
+// function tryCompareToStringTagEquality(a, b) {
+//   var aTag = Symbol.toStringTag in a ? a[Symbol.toStringTag] : undefined;
+//   var bTag = Symbol.toStringTag in b ? b[Symbol.toStringTag] : undefined;
+//   return aTag !== bTag ? NOT_EQUAL : UNKNOWN;
+// }
+
+// function isOptional(value) {
+//   return value === undefined
+//     || value === null;
+// }
+
+// function compareOptionality(a, b) {
+//   return tryCompareStrictEquality(a, b)
+//     || NOT_EQUAL;
+// }
+
+// function isPrimitiveEquatable(value) {
+//   switch (typeof value) {
+//     case 'string':
+//     case 'number':
+//     case 'boolean':
+//     case 'symbol':
+//       return true;
+//     default:
+//       return isBoxed(value);
+//   }
+// }
+
+// function comparePrimitiveEquality(a, b) {
+//   if (isBoxed(a)) a = a.valueOf();
+//   if (isBoxed(b)) b = b.valueOf();
+
+//   return tryCompareStrictEquality(a, b)
+//     || tryCompareTypeOfEquality(a, b)
+//     || compareIf(a, b, isNaNEquatable, compareNaNEquality)
+//     || NOT_EQUAL;
+// }
+
+// function isNaNEquatable(value) {
+//   return typeof value === 'number';
+// }
+
+// function compareNaNEquality(a, b) {
+//   return isNaN(a) && isNaN(b) ? EQUAL : NOT_EQUAL;
+// }
+
+// function isObjectEquatable(value) {
+//   return typeof value === 'object';
+// }
+
+// function compareObjectEquality(a, b, cache) {
+//   if (!cache) cache = new Map();
+
+//   return getCache(cache, a, b)
+//     || setCache(cache, a, b, EQUAL) // consider equal for now
+//     || cacheComparison(a, b, tryCompareStrictEquality, cache)
+//     || cacheComparison(a, b, tryCompareToStringTagEquality, cache)
+//     || compareIf(a, b, isValueOfEquatable, compareValueOfEquality)
+//     || compareIf(a, b, isToStringEquatable, compareToStringEquality)
+//     || compareIf(a, b, isArrayLikeEquatable, compareArrayLikeEquality, cache)
+//     || compareIf(a, b, isStructurallyEquatable, compareStructuralEquality, cache)
+//     || compareIf(a, b, isIterableEquatable, compareIterableEquality, cache)
+//     || cacheComparison(a, b, fail, cache);
+// }
+
+// function isValueOfEquatable(value) {
+//   return value instanceof Date;
+// }
+
+// function compareValueOfEquality(a, b) {
+//   return compareIf(a.valueOf(), b.valueOf(), isPrimitiveEquatable, comparePrimitiveEquality)
+//     || NOT_EQUAL;
+// }
+
+// function isToStringEquatable(value) {
+//   return value instanceof RegExp;
+// }
+
+// function compareToStringEquality(a, b) {
+//   return compareIf(a.toString(), b.toString(), isPrimitiveEquatable, comparePrimitiveEquality)
+//     || NOT_EQUAL;
+// }
+
+// function isArrayLikeEquatable(value) {
+//   return Array.isArray(value)
+//     || value instanceof Uint8Array
+//     || value instanceof Uint8ClampedArray
+//     || value instanceof Uint16Array
+//     || value instanceof Uint32Array
+//     || value instanceof Int8Array
+//     || value instanceof Int16Array
+//     || value instanceof Int32Array
+//     || value instanceof Float32Array
+//     || value instanceof Float64Array;
+// }
+
+// function compareArrayLikeEquality(a, b, cache) {
+//   if (a.length !== b.length) return NOT_EQUAL;
+//   for (var i = 0; i < a.length; i++) {
+//     if (compareEquality(a[i], b[i], cache) === NOT_EQUAL) {
+//       return NOT_EQUAL;
+//     }
+//   }
+//   return EQUAL;
+// }
+
+// function isStructurallyEquatable(value) {
+//   return !(value instanceof Promise // only comparable by reference
+//     || value instanceof WeakMap // only comparable by reference
+//     || value instanceof WeakSet // only comparable by reference
+//     || value instanceof Map // comparable via @@iterator
+//     || value instanceof Set); // comparable via @@iterator
+// }
+
+// function compareStructuralEquality(a, b, cache) {
+//   var aKeys = [];
+//   for (var key in a) aKeys.push(key);
+
+//   var bKeys = [];
+//   for (var key in b) bKeys.push(key);
+
+//   if (aKeys.length !== bKeys.length) {
+//     return NOT_EQUAL;
+//   }
+
+//   aKeys.sort();
+//   bKeys.sort();
+
+//   for (var i = 0; i < aKeys.length; i++) {
+//     var aKey = aKeys[i];
+//     var bKey = bKeys[i];
+//     if (compareEquality(aKey, bKey, cache) === NOT_EQUAL) {
+//       return NOT_EQUAL;
+//     }
+//     if (compareEquality(a[aKey], b[bKey], cache) === NOT_EQUAL) {
+//       return NOT_EQUAL;
+//     }
+//   }
+
+//   return EQUAL;
+// }
+
+// // hack: do iterables via for..of
+// function isIterableEquatable(value) {
+//   try {
+//     for (const _ of value) { break; }
+//     return true;
+//   } catch {
+//     return false;
+//   }
+// }
+
+// function compareIterableEquality(a, b, cache) {
+//   let aValues = [];
+//   for (const x of a) aValues.push(x);
+
+//   let bValues = [];
+//   for (const x of b) bValues.push(x);
+
+//   return compareArrayLikeEquality(aValues, bValues, cache);
+// }
+
+// var __assert_deepEqual__compare = (a, b) => {
+//   return compareEquality(a, b) === EQUAL;
+// };
+
+// var __assert_deepEqual = (actual, expected) => {
+//   if (!assert.deepEqual._compare(actual, expected)) {
+//     throw new Test262Error('assert.deepEqual failed');
+//   }
+// };
+
+// __assert_deepEqual([], []);
 
 // let x = {};
 // x.__proto__ = { wow() { console.log(0); } };

package/runner/index.js

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