porffor 0.0.0-8c0bdaa → 0.0.0-c743344

package/README.md

@@ -76,6 +76,8 @@ these include some early (stage 1/0) and/or dead (last commit years ago) proposa
 - string member (char) access via `str[ind]` (eg `str[0]`)
 - string concat (`+`) (eg `'a' + 'b'`)
 - truthy/falsy (eg `!'' == true`)
+- string comparison (eg `'a' == 'a'`, `'a' != 'b'`)
+- nullish coalescing operator (`??`)
 
 ### built-ins
 
@@ -106,7 +108,6 @@ these include some early (stage 1/0) and/or dead (last commit years ago) proposa
   - arrays/strings inside arrays
 - strings
   - member setting
-  - equality
 - more math operators (`**`, etc)
 - `do { ... } while (...)`
 - exceptions
@@ -135,6 +136,7 @@ mostly for reducing size. do not really care about compiler perf/time as long as
 - `i64.extend_i32_s`, `i32.wrap_i64` -> ``
 - `f64.convert_i32_u`, `i32.trunc_sat_f64_s` -> ``
 - `return`, `end` -> `end`
+- change const, convert to const of converted valtype (eg `f64.const`, `i32.trunc_sat_f64_s -> `i32.const`)
 - remove some redundant sets/gets
 - remove unneeded single just used vars
 - remove unneeded blocks (no `br`s inside)

package/compiler/codeGen.js

@@ -35,7 +35,14 @@ const debug = str => {
 };
 
 const todo = msg => {
-  throw new Error(`todo: ${msg}`);
+  class TodoError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = 'TodoError';
+    }
+  }
+
+  throw new TodoError(`todo: ${msg}`);
 
   const code = [];
 
@@ -101,6 +108,9 @@ const generate = (scope, decl, global = false, name = undefined) => {
     case 'WhileStatement':
       return generateWhile(scope, decl);
 
+    /* case 'ForOfStatement':
+      return generateForOf(scope, decl); */
+
     case 'BreakStatement':
       return generateBreak(scope, decl);
 
@@ -164,7 +174,6 @@ const generate = (scope, decl, global = false, name = undefined) => {
         }
 
         if (asm[0] === 'memory') {
-          scope.memory = true;
           allocPage('asm instrinsic');
           // todo: add to store/load offset insts
           continue;
@@ -278,7 +287,7 @@ const generateReturn = (scope, decl) => {
     ];
   }
 
-  if (!scope.returnType) scope.returnType = getNodeType(scope, decl.argument);
+  scope.returnType = getNodeType(scope, decl.argument);
 
   return [
     ...generate(scope, decl.argument),
@@ -295,11 +304,11 @@ const localTmp = (scope, name, type = valtypeBinary) => {
   return idx;
 };
 
-const performLogicOp = (scope, op, left, right) => {
+const performLogicOp = (scope, op, left, right, leftType, rightType) => {
   const checks = {
-    '||': Opcodes.eqz,
-    '&&': [ Opcodes.i32_to ]
-    // todo: ??
+    '||': falsy,
+    '&&': truthy,
+    '??': nullish
   };
 
   if (!checks[op]) return todo(`logic operator ${op} not implemented yet`);
@@ -310,7 +319,8 @@ const performLogicOp = (scope, op, left, right) => {
   return [
     ...left,
     [ Opcodes.local_tee, localTmp(scope, 'logictmp') ],
-    ...checks[op],
+    ...checks[op](scope, [], leftType),
+    Opcodes.i32_to,
     [ Opcodes.if, valtypeBinary ],
     ...right,
     [ Opcodes.else ],
@@ -325,15 +335,13 @@ const concatStrings = (scope, left, right, global, name, assign) => {
   // todo: optimize by looking up names in arrays and using that if exists?
   // todo: optimize this if using literals/known lengths?
 
-  scope.memory = true;
-
-  const pointer = arrays.get(name ?? '$undeclared');
-
   const rightPointer = localTmp(scope, 'concat_right_pointer', Valtype.i32);
   const rightLength = localTmp(scope, 'concat_right_length', Valtype.i32);
   const leftLength = localTmp(scope, 'concat_left_length', Valtype.i32);
 
   if (assign) {
+    const pointer = arrays.get(name ?? '$undeclared');
+
     return [
       // setup right
       ...right,
@@ -384,15 +392,12 @@ const concatStrings = (scope, left, right, global, name, assign) => {
 
   const leftPointer = localTmp(scope, 'concat_left_pointer', Valtype.i32);
 
-  const newOut = makeArray(scope, {
+  // alloc/assign array
+  const [ , pointer ] = makeArray(scope, {
     rawElements: new Array(0)
   }, global, name, true, 'i16');
 
   return [
-    // setup new/out array
-    ...newOut,
-    [ Opcodes.drop ],
-
     // setup left
     ...left,
     Opcodes.i32_to_u,
@@ -458,75 +463,220 @@ const concatStrings = (scope, left, right, global, name, assign) => {
   ];
 };
 
-const falsy = (scope, wasm, type) => {
+const compareStrings = (scope, left, right) => {
+  // todo: this should be rewritten into a built-in/func: String.prototype.concat
+  // todo: convert left and right to strings if not
+  // todo: optimize by looking up names in arrays and using that if exists?
+  // todo: optimize this if using literals/known lengths?
+
+  const leftPointer = localTmp(scope, 'compare_left_pointer', Valtype.i32);
+  const leftLength = localTmp(scope, 'compare_left_length', Valtype.i32);
+  const rightPointer = localTmp(scope, 'compare_right_pointer', Valtype.i32);
+  const rightLength = localTmp(scope, 'compare_right_length', Valtype.i32);
+
+  const index = localTmp(scope, 'compare_index', Valtype.i32);
+  const indexEnd = localTmp(scope, 'compare_index_end', Valtype.i32);
+
+  return [
+    // setup left
+    ...left,
+    Opcodes.i32_to_u,
+    [ Opcodes.local_tee, leftPointer ],
+
+    // setup right
+    ...right,
+    Opcodes.i32_to_u,
+    [ Opcodes.local_tee, rightPointer ],
+
+    // fast path: check leftPointer == rightPointer
+    // use if (block) for everything after to "return" a value early
+    [ Opcodes.i32_ne ],
+    [ Opcodes.if, Valtype.i32 ],
+
+    // get lengths
+    [ Opcodes.local_get, leftPointer ],
+    [ Opcodes.i32_load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(0) ],
+    [ Opcodes.local_tee, leftLength ],
+
+    [ Opcodes.local_get, rightPointer ],
+    [ Opcodes.i32_load, Math.log2(ValtypeSize[valtype]) - 1, ...unsignedLEB128(0) ],
+    [ Opcodes.local_tee, rightLength ],
+
+    // fast path: check leftLength != rightLength
+    [ Opcodes.i32_ne ],
+    [ Opcodes.if, Blocktype.void ],
+    ...number(0, Valtype.i32),
+    [ Opcodes.br, 1 ],
+    [ Opcodes.end ],
+
+    // no fast path for length = 0 as it would probably be slower for most of the time?
+
+    // setup index end as length * sizeof i16 (2)
+    // we do this instead of having to do mul/div each iter for perf™
+    [ Opcodes.local_get, leftLength ],
+    ...number(ValtypeSize.i16, Valtype.i32),
+    [ Opcodes.i32_mul ],
+    [ Opcodes.local_set, indexEnd ],
+
+    // iterate over each char and check if eq
+    [ Opcodes.loop, Blocktype.void ],
+
+    // fetch left
+    [ Opcodes.local_get, index ],
+    [ Opcodes.local_get, leftPointer ],
+    [ Opcodes.i32_add ],
+    [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+
+    // fetch right
+    [ Opcodes.local_get, index ],
+    [ Opcodes.local_get, rightPointer ],
+    [ Opcodes.i32_add ],
+    [ Opcodes.i32_load16_u, Math.log2(ValtypeSize.i16) - 1, ...unsignedLEB128(ValtypeSize.i32) ],
+
+    // not equal, "return" false
+    [ Opcodes.i32_ne ],
+    [ Opcodes.if, Blocktype.void ],
+    ...number(0, Valtype.i32),
+    [ Opcodes.br, 2 ],
+    [ Opcodes.end ],
+
+    // index += sizeof i16 (2)
+    [ Opcodes.local_get, index ],
+    ...number(ValtypeSize.i16, Valtype.i32),
+    [ Opcodes.i32_add ],
+    [ Opcodes.local_tee, index ],
+
+    // if index != index end (length * sizeof 16), loop
+    [ Opcodes.local_get, indexEnd ],
+    [ Opcodes.i32_ne ],
+    [ Opcodes.br_if, 0 ],
+    [ Opcodes.end ],
+
+    // no failed checks, so true!
+    ...number(1, Valtype.i32),
+
+    // pointers match, so true
+    [ Opcodes.else ],
+    ...number(1, Valtype.i32),
+    [ Opcodes.end ],
+
+    // convert i32 result to valtype
+    // do not do as automatically added by binary exp gen for equality ops
+    // Opcodes.i32_from_u
+  ];
+};
+
+const truthy = (scope, wasm, type) => {
   // arrays are always truthy
   if (type === TYPES._array) return [
     ...wasm,
     [ Opcodes.drop ],
-    number(0)
+    ...number(1)
   ];
 
   if (type === TYPES.string) {
-    // if "" (length = 0)
+    // if not "" (length = 0)
     return [
       // pointer
       ...wasm,
+      Opcodes.i32_to_u,
 
       // get length
       [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
 
-      // if length == 0
-      [ Opcodes.i32_eqz ],
+      // if length != 0
+      /* [ Opcodes.i32_eqz ],
+      [ Opcodes.i32_eqz ], */
       Opcodes.i32_from_u
     ]
   }
 
-  // if = 0
+  // if != 0
   return [
     ...wasm,
 
-    ...Opcodes.eqz,
-    Opcodes.i32_from_u
+    /* Opcodes.eqz,
+    [ Opcodes.i32_eqz ],
+    Opcodes.i32_from */
   ];
 };
 
-const truthy = (scope, wasm, type) => {
+const falsy = (scope, wasm, type) => {
   // arrays are always truthy
   if (type === TYPES._array) return [
     ...wasm,
     [ Opcodes.drop ],
-    number(1)
+    ...number(0)
   ];
 
   if (type === TYPES.string) {
-    // if not "" (length = 0)
+    // if "" (length = 0)
     return [
       // pointer
       ...wasm,
+      Opcodes.i32_to_u,
 
       // get length
       [ Opcodes.i32_load, Math.log2(ValtypeSize.i32) - 1, 0 ],
 
-      // if length != 0
-      /* [ Opcodes.i32_eqz ],
-      [ Opcodes.i32_eqz ], */
+      // if length == 0
+      [ Opcodes.i32_eqz ],
       Opcodes.i32_from_u
     ]
   }
 
-  // if != 0
+  // if = 0
   return [
     ...wasm,
 
-    /* Opcodes.eqz,
-    [ Opcodes.i32_eqz ],
-    Opcodes.i32_from */
+    ...Opcodes.eqz,
+    Opcodes.i32_from_u
+  ];
+};
+
+const nullish = (scope, wasm, type) => {
+  // undefined
+  if (type === TYPES.undefined) return [
+    ...wasm,
+    [ Opcodes.drop ],
+    ...number(1)
+  ];
+
+  // null (if object and = "0")
+  if (type === TYPES.object) return [
+    ...wasm,
+    ...Opcodes.eqz,
+    Opcodes.i32_from_u
+  ];
+
+  // not
+  return [
+    ...wasm,
+    [ Opcodes.drop ],
+    ...number(0)
   ];
 };
 
-const performOp = (scope, op, left, right, leftType, rightType, _global = false, _name = '$unspecified', assign = false) => {
+const performOp = (scope, op, left, right, leftType, rightType, _global = false, _name = '$undeclared', assign = false) => {
   if (op === '||' || op === '&&' || op === '??') {
-    return performLogicOp(scope, op, left, right);
+    return performLogicOp(scope, op, left, right, leftType, rightType);
+  }
+
+  if (codeLog && (!leftType || !rightType)) log('codegen', 'untracked type in op', op, _name, '\n' + new Error().stack.split('\n').slice(1).join('\n'));
+
+  // if strict (in)equal and known types mismatch, return false (===)/true (!==)
+  if ((op === '===' || op === '!==') && leftType && rightType && leftType !== rightType) {
+    return [
+      ...left,
+      ...right,
+
+      // drop values
+      [ Opcodes.drop ],
+      [ Opcodes.drop ],
+
+      // return false (===)/true (!==)
+      ...number(op === '===' ? 0 : 1, Valtype.i32)
+    ];
   }
 
   if (leftType === TYPES.string || rightType === TYPES.string) {
@@ -539,8 +689,20 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
     if (!['==', '===', '!=', '!==', '>', '>=', '<', '<='].includes(op)) return number(NaN);
 
     // else leave bool ops
-    // todo: convert string to number if string and number or le/ge op
-    // todo: string equality
+    // todo: convert string to number if string and number/bool
+    // todo: string (>|>=|<|<=) string
+
+    // string comparison
+    if (op === '===' || op === '==') {
+      return compareStrings(scope, left, right);
+    }
+
+    if (op === '!==' || op === '!=') {
+      return [
+        ...compareStrings(scope, left, right),
+        [ Opcodes.i32_eqz ]
+      ];
+    }
   }
 
   let ops = operatorOpcode[valtype][op];
@@ -569,13 +731,17 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
   ];
 };
 
+let binaryExpDepth = 0;
 const generateBinaryExp = (scope, decl, _global, _name) => {
+  binaryExpDepth++;
+
   const out = [
     ...performOp(scope, decl.operator, generate(scope, decl.left), generate(scope, decl.right), getNodeType(scope, decl.left), getNodeType(scope, decl.right), _global, _name)
   ];
 
   if (valtype !== 'i32' && ['==', '===', '!=', '!==', '>', '>=', '<', '<='].includes(decl.operator)) out.push(Opcodes.i32_from_u);
 
+  binaryExpDepth--;
   return out;
 };
 
@@ -634,7 +800,7 @@ const includeBuiltin = (scope, builtin) => {
 };
 
 const generateLogicExp = (scope, decl) => {
-  return performLogicOp(scope, decl.operator, generate(scope, decl.left), generate(scope, decl.right));
+  return performLogicOp(scope, decl.operator, generate(scope, decl.left), generate(scope, decl.right), getNodeType(scope, decl.left), getNodeType(scope, decl.right));
 };
 
 const TYPES = {
@@ -682,6 +848,7 @@ const getType = (scope, _name) => {
 
 const getNodeType = (scope, node) => {
   if (node.type === 'Literal') {
+    if (['number', 'boolean', 'string', 'undefined', 'object', 'function', 'symbol', 'bigint'].includes(node.value)) return TYPES.number;
     return TYPES[typeof node.value];
   }
 
@@ -696,7 +863,7 @@ const getNodeType = (scope, node) => {
   if (node.type === 'CallExpression' || node.type === 'NewExpression') {
     const name = node.callee.name;
     const func = funcs.find(x => x.name === name);
-    if (func) return func.returnType ?? TYPES.number;
+    if (func) return func.returnType;
 
     if (builtinFuncs[name]) return TYPES[builtinFuncs[name].returnType ?? 'number'];
     if (internalConstrs[name]) return internalConstrs[name].type;
@@ -721,9 +888,7 @@ const getNodeType = (scope, node) => {
       protoFunc = prototypeFuncs[baseType]?.[func];
     }
 
-    if (protoFunc) return protoFunc.returnType ?? TYPES.number;
-
-    return TYPES.number;
+    if (protoFunc) return protoFunc.returnType;
   }
 
   if (node.type === 'ExpressionStatement') {
@@ -755,9 +920,6 @@ const getNodeType = (scope, node) => {
 
     if (objectType === TYPES.string && node.computed) return TYPES.string;
   }
-
-  // default to number
-  return TYPES.number;
 };
 
 const generateLiteral = (scope, decl, global, name) => {
@@ -792,7 +954,7 @@ const generateLiteral = (scope, decl, global, name) => {
 
       return makeArray(scope, {
         rawElements
-      }, global, name, false, 'i16');
+      }, global, name, false, 'i16')[0];
 
     default:
       return todo(`cannot generate literal of type ${typeof decl.value}`);
@@ -802,7 +964,8 @@ const generateLiteral = (scope, decl, global, name) => {
 const countLeftover = wasm => {
   let count = 0, depth = 0;
 
-  for (const inst of wasm) {
+  for (let i = 0; i < wasm.length; i++) {
+    const inst = wasm[i];
     if (depth === 0 && (inst[0] === Opcodes.if || inst[0] === Opcodes.block || inst[0] === Opcodes.loop)) {
       if (inst[0] === Opcodes.if) count--;
       if (inst[1] !== Blocktype.void) count++;
@@ -906,7 +1069,7 @@ const generateCall = (scope, decl, _global, _name) => {
   }
 
   let out = [];
-  let protoFunc, protoName, baseType, baseName = '$undeclared';
+  let protoFunc, protoName, baseType, baseName;
   // ident.func()
   if (name && name.startsWith('__')) {
     const spl = name.slice(2).split('_');
@@ -929,11 +1092,11 @@ const generateCall = (scope, decl, _global, _name) => {
 
     out = generate(scope, decl.callee.object);
     out.push([ Opcodes.drop ]);
+
+    baseName = [...arrays.keys()].pop();
   }
 
   if (protoFunc) {
-    scope.memory = true;
-
     let pointer = arrays.get(baseName);
 
     if (pointer == null) {
@@ -941,10 +1104,9 @@ const generateCall = (scope, decl, _global, _name) => {
       if (codeLog) log('codegen', 'cloning unknown dynamic pointer');
 
       // register array
-      makeArray(scope, {
+      0, [ , pointer ] = makeArray(scope, {
         rawElements: new Array(0)
       }, _global, baseName, true, baseType === TYPES.string ? 'i16' : valtype);
-      pointer = arrays.get(baseName);
 
       const [ local, isGlobal ] = lookupName(scope, baseName);
 
@@ -980,10 +1142,9 @@ const generateCall = (scope, decl, _global, _name) => {
         set: value => arrayUtil.setLength(pointer, value),
         setI32: value => arrayUtil.setLengthI32(pointer, value)
       }, generate(scope, decl.arguments[0] ?? DEFAULT_VALUE), protoLocal, (length, itemType) => {
-        const out = makeArray(scope, {
+        return makeArray(scope, {
           rawElements: new Array(length)
         }, _global, _name, true, itemType);
-        return [ out, arrays.get(_name ?? '$undeclared') ];
       }),
       [ Opcodes.end ]
     ];
@@ -1041,7 +1202,6 @@ const generateCall = (scope, decl, _global, _name) => {
     args = args.slice(0, func.params.length);
   }
 
-  if (func && func.memory) scope.memory = true;
   if (func && func.throws) scope.throws = true;
 
   for (const arg of args) {
@@ -1057,7 +1217,7 @@ const generateNew = (scope, decl, _global, _name) => {
   // hack: basically treat this as a normal call for builtins for now
   const name = mapName(decl.callee.name);
   if (internalConstrs[name]) return internalConstrs[name].generate(scope, decl, _global, _name);
-  if (!builtinFuncs[name]) return todo(`new statement is not supported yet (new ${unhackName(name)})`);
+  if (!builtinFuncs[name]) return todo(`new statement is not supported yet`); // return todo(`new statement is not supported yet (new ${unhackName(name)})`);
 
   return generateCall(scope, decl, _global, _name);
 };
@@ -1165,8 +1325,6 @@ const generateAssign = (scope, decl) => {
     const name = decl.left.object.name;
     const pointer = arrays.get(name);
 
-    scope.memory = true;
-
     const aotPointer = pointer != null;
 
     const newValueTmp = localTmp(scope, '__length_setter_tmp');
@@ -1217,8 +1375,27 @@ const generateAssign = (scope, decl) => {
     ];
   }
 
+  const op = decl.operator.slice(0, -1);
+  if (op === '||' || op === '&&' || op === '??') {
+    // todo: is this needed?
+    // for logical assignment ops, it is not left @= right ~= left = left @ right
+    // instead, left @ (left = right)
+    // eg, x &&= y ~= x && (x = y)
+
+    return [
+      ...performOp(scope, op, [
+        [ isGlobal ? Opcodes.global_get : Opcodes.local_get, local.idx ]
+      ], [
+        ...generate(scope, decl.right),
+        [ isGlobal ? Opcodes.global_set : Opcodes.local_set, local.idx ],
+        [ isGlobal ? Opcodes.global_get : Opcodes.local_get, local.idx ]
+      ], getType(scope, name), getNodeType(scope, decl.right), isGlobal, name, true),
+      [ isGlobal ? Opcodes.global_get : Opcodes.local_get, local.idx ]
+    ];
+  }
+
   return [
-    ...performOp(scope, decl.operator.slice(0, -1), [ [ isGlobal ? Opcodes.global_get : Opcodes.local_get, local.idx ] ], generate(scope, decl.right), getType(scope, name), getNodeType(scope, decl.right), isGlobal, name, true),
+    ...performOp(scope, op, [ [ isGlobal ? Opcodes.global_get : Opcodes.local_get, local.idx ] ], generate(scope, decl.right), getType(scope, name), getNodeType(scope, decl.right), isGlobal, name, true),
     [ isGlobal ? Opcodes.global_set : Opcodes.local_set, local.idx ],
     [ isGlobal ? Opcodes.global_get : Opcodes.local_get, local.idx ]
   ];
@@ -1245,13 +1422,14 @@ const generateUnary = (scope, decl) => {
 
     case '!':
       // !=
-      return falsy(scope, generate(scope, decl.argument));
+      return falsy(scope, generate(scope, decl.argument), getNodeType(scope, decl.argument));
 
     case '~':
+      // todo: does not handle Infinity properly (should convert to 0) (but opt const converting saves us sometimes)
       return [
         ...generate(scope, decl.argument),
         Opcodes.i32_to,
-        [ Opcodes.i32_const, signedLEB128(-1) ],
+        [ Opcodes.i32_const, ...signedLEB128(-1) ],
         [ Opcodes.i32_xor ],
         Opcodes.i32_from
       ];
@@ -1289,7 +1467,7 @@ const generateUnary = (scope, decl) => {
       return out;
 
     case 'typeof':
-      const type = getNodeType(scope, decl.argument);
+      const type = getNodeType(scope, decl.argument) ?? TYPES.number;
 
       // for custom types, just return object
       if (type > 0xffffffffffff7) return number(TYPES.object);
@@ -1422,9 +1600,28 @@ const generateWhile = (scope, decl) => {
   return out;
 };
 
+const generateForOf = (scope, decl) => {
+  const out = [];
+
+  out.push([ Opcodes.loop, Blocktype.void ]);
+  depth.push('while');
+
+  out.push(...generate(scope, decl.test));
+  out.push(Opcodes.i32_to, [ Opcodes.if, Blocktype.void ]);
+  depth.push('if');
+
+  out.push(...generate(scope, decl.body));
+
+  out.push([ Opcodes.br, 1 ]);
+  out.push([ Opcodes.end ], [ Opcodes.end ]);
+  depth.pop(); depth.pop();
+
+  return out;
+};
+
 const getNearestLoop = () => {
   for (let i = depth.length - 1; i >= 0; i--) {
-    if (depth[i] === 'while' || depth[i] === 'for') return i;
+    if (depth[i] === 'while' || depth[i] === 'for' || depth[i] === 'forof') return i;
   }
 
   return -1;
@@ -1514,7 +1711,16 @@ const allocPage = reason => {
   let ind = pages.size;
   pages.set(reason, ind);
 
-  if (codeLog) log('codegen', `allocated new page of memory (${ind}) | ${reason}`);
+  if (allocLog) log('alloc', `allocated new page of memory (${ind}) | ${reason}`);
+
+  return ind;
+};
+
+const freePage = reason => {
+  let ind = pages.get(reason);
+  pages.delete(reason);
+
+  if (allocLog) log('alloc', `freed page of memory (${ind}) | ${reason}`);
 
   return ind;
 };
@@ -1576,14 +1782,12 @@ const makeArray = (scope, decl, global = false, name = '$undeclared', initEmpty
   // local value as pointer
   out.push(...number(pointer));
 
-  scope.memory = true;
-
-  return out;
+  return [ out, pointer ];
 };
 
 let arrays = new Map();
 const generateArray = (scope, decl, global = false, name = '$undeclared', initEmpty = false) => {
-  return makeArray(scope, decl, global, name, initEmpty, valtype);
+  return makeArray(scope, decl, global, name, initEmpty, valtype)[0];
 };
 
 export const generateMember = (scope, decl, _global, _name) => {
@@ -1596,8 +1800,6 @@ export const generateMember = (scope, decl, _global, _name) => {
     const name = decl.object.name;
     const pointer = arrays.get(name);
 
-    scope.memory = true;
-
     const aotPointer = pointer != null;
 
     return [
@@ -1617,8 +1819,6 @@ export const generateMember = (scope, decl, _global, _name) => {
   const name = decl.object.name;
   const pointer = arrays.get(name);
 
-  scope.memory = true;
-
   const aotPointer = pointer != null;
 
   if (type === TYPES._array) {
@@ -1644,10 +1844,9 @@ export const generateMember = (scope, decl, _global, _name) => {
 
   // string
 
-  const newOut = makeArray(scope, {
+  const [ newOut, newPointer ] = makeArray(scope, {
     rawElements: new Array(1)
   }, _global, _name, true, 'i16');
-  const newPointer = arrays.get(_name ?? '$undeclared');
 
   return [
     // setup new/out array
@@ -1729,6 +1928,7 @@ const generateFunc = (scope, decl) => {
     locals: {},
     localInd: 0,
     returns: [ valtypeBinary ],
+    returnType: null,
     memory: false,
     throws: false,
     name
@@ -1753,9 +1953,8 @@ const generateFunc = (scope, decl) => {
     name,
     params: Object.values(innerScope.locals).slice(0, params.length).map(x => x.type),
     returns: innerScope.returns,
-    returnType: innerScope.returnType ?? TYPES.number,
+    returnType: innerScope.returnType,
     locals: innerScope.locals,
-    memory: innerScope.memory,
     throws: innerScope.throws,
     index: currentFuncIndex++
   };
@@ -1770,6 +1969,8 @@ const generateFunc = (scope, decl) => {
 
   if (name !== 'main' && func.returns.length !== 0 && wasm[wasm.length - 1]?.[0] !== Opcodes.return && countLeftover(wasm) === 0) {
     wasm.push(...number(0), [ Opcodes.return ]);
+
+    if (func.returnType === null) func.returnType = TYPES.undefined;
   }
 
   // change v128 params into many <type> (i32x4 -> i32/etc) instead as unsupported param valtype
@@ -1780,9 +1981,7 @@ const generateFunc = (scope, decl) => {
     if (local.type === Valtype.v128) {
       vecParams++;
 
-      /* func.memory = true; // mark func as using memory
-
-      wasm.unshift( // add v128 load for param
+      /* wasm.unshift( // add v128 load for param
         [ Opcodes.i32_const, 0 ],
         [ ...Opcodes.v128_load, 0, i * 16 ],
         [ Opcodes.local_set, local.idx ]
@@ -1912,10 +2111,9 @@ const internalConstrs = {
 
       // new Array(n)
 
-      makeArray(scope, {
+      const [ , pointer ] = makeArray(scope, {
         rawElements: new Array(0)
       }, global, name, true);
-      const pointer = arrays.get(name ?? '$undeclared');
 
       const arg = decl.arguments[0] ?? DEFAULT_VALUE;
 

package/compiler/decompile.js

@@ -42,8 +42,8 @@ export default (wasm, name = '', ind = 0, locals = {}, params = [], returns = []
       out += ` ${read_ieee754_binary64(inst.slice(1))}`;
     } else if (inst[0] === Opcodes.i32_const || inst[0] === Opcodes.i64_const) {
       out += ` ${read_signedLEB128(inst.slice(1))}`;
-    } else if (inst[0] === Opcodes.i32_load || inst[0] === Opcodes.i64_load || inst[0] === Opcodes.f64_load || inst[0] === Opcodes.i32_store || inst[0] === Opcodes.i64_store || inst[0] === Opcodes.f64_store) {
-      out += ` ${inst[1]} ${read_unsignedLEB128(inst.slice(2))}`
+    } else if (inst[0] === Opcodes.i32_load || inst[0] === Opcodes.i64_load || inst[0] === Opcodes.f64_load || inst[0] === Opcodes.i32_store || inst[0] === Opcodes.i64_store || inst[0] === Opcodes.f64_store || inst[0] === Opcodes.i32_store16 || inst[0] === Opcodes.i32_load16_u) {
+      out += ` ${inst[1]} ${read_unsignedLEB128(inst.slice(2))}`;
     } else for (const operand of inst.slice(1)) {
       if (inst[0] === Opcodes.if || inst[0] === Opcodes.loop || inst[0] === Opcodes.block) {
         if (operand === Blocktype.void) continue;

package/compiler/encoding.js

@@ -22,15 +22,15 @@ export const encodeLocal = (count, type) => [
   type
 ];
 
+// todo: this only works with integers within 32 bit range
 export const signedLEB128 = n => {
-  // todo: this only works with integers within 32 bit range
+  n |= 0;
 
   // just input for small numbers (for perf as common)
   if (n >= 0 && n <= 63) return [ n ];
   if (n >= -64 && n <= 0) return [ 128 + n ];
 
   const buffer = [];
-  n |= 0;
 
   while (true) {
     let byte = n & 0x7f;
@@ -50,6 +50,8 @@ export const signedLEB128 = n => {
 };
 
 export const unsignedLEB128 = n => {
+  n |= 0;
+
   // just input for small numbers (for perf as common)
   if (n >= 0 && n <= 127) return [ n ];
 

package/compiler/index.js

@@ -14,7 +14,8 @@ const bold = x => `\u001b[1m${x}\u001b[0m`;
 const areaColors = {
   codegen: [ 20, 80, 250 ],
   opt: [ 250, 20, 80 ],
-  sections: [ 20, 250, 80 ]
+  sections: [ 20, 250, 80 ],
+  alloc: [ 250, 250, 20 ]
 };
 
 globalThis.log = (area, ...args) => console.log(`\u001b[90m[\u001b[0m${rgb(...areaColors[area], area)}\u001b[90m]\u001b[0m`, ...args);
@@ -38,6 +39,7 @@ const logFuncs = (funcs, globals, exceptions) => {
 export default (code, flags) => {
   globalThis.optLog = process.argv.includes('-opt-log');
   globalThis.codeLog = process.argv.includes('-code-log');
+  globalThis.allocLog = process.argv.includes('-alloc-log');
 
   for (const x in BuiltinPreludes) {
     if (code.indexOf(x + '(') !== -1) code = BuiltinPreludes[x] + code;
@@ -63,5 +65,12 @@ export default (code, flags) => {
   const sections = produceSections(funcs, globals, tags, pages, flags);
   if (flags.includes('info')) console.log(`4. produced sections in ${(performance.now() - t3).toFixed(2)}ms`);
 
+  if (allocLog) {
+    const wasmPages = Math.ceil((pages.size * pageSize) / 65536);
+    const bytes = wasmPages * 65536;
+    log('alloc', `\x1B[1mallocated ${bytes / 1024}KiB\x1B[0m for ${pages.size} things using ${wasmPages} Wasm page${wasmPages === 1 ? '' : 's'}`);
+    // console.log([...pages.keys()].map(x => `\x1B[36m - ${x}\x1B[0m`).join('\n'));
+  }
+
   return { wasm: sections, funcs, globals, tags, exceptions, pages };
 };

package/compiler/opt.js

@@ -1,5 +1,6 @@
 import { Opcodes, Valtype } from "./wasmSpec.js";
 import { number } from "./embedding.js";
+import { read_signedLEB128, read_ieee754_binary64 } from "./encoding.js";
 
 // deno compat
 if (typeof process === 'undefined' && typeof Deno !== 'undefined') {
@@ -20,7 +21,7 @@ export default (funcs, globals) => {
   if (optLevel === 0) return;
 
   const tailCall = process.argv.includes('-tail-call');
-  if (tailCall) log('opt', 'tail call proposal is not widely implemented! (you used -tail-call)');
+  if (tailCall) log('opt', 'warning: tail call proposal is not widely implemented! (you used -tail-call)');
 
   if (optLevel >= 2 && !process.argv.includes('-opt-no-inline')) {
     // inline pass (very WIP)
@@ -95,7 +96,6 @@ export default (funcs, globals) => {
         }
 
         if (t.index > c.index) t.index--; // adjust index if after removed func
-        if (c.memory) t.memory = true;
       }
 
       funcs.splice(funcs.indexOf(c), 1); // remove func from funcs
@@ -213,9 +213,9 @@ export default (funcs, globals) => {
         // i32.const 0
         // drop
         // -->
-        // <nothing>>
+        // <nothing>
 
-        wasm.splice(i - 1, 2); // remove this inst
+        wasm.splice(i - 1, 2); // remove these inst
         i -= 2;
         continue;
       }
@@ -259,6 +259,36 @@ export default (funcs, globals) => {
         continue;
       }
 
+      if (lastInst[0] === Opcodes.const && (inst === Opcodes.i32_to || inst === Opcodes.i32_to_u)) {
+        // change const and immediate i32 convert to i32 const
+        // f64.const 0
+        // i32.trunc_sat_f64_s || i32.trunc_sat_f64_u
+        // -->
+        // i32.const 0
+
+        wasm[i - 1] = number((valtype === 'f64' ? read_ieee754_binary64 : read_signedLEB128)(lastInst.slice(1)), Valtype.i32)[0]; // f64.const -> i32.const
+
+        wasm.splice(i, 1); // remove this inst
+        i--;
+        if (optLog) log('opt', `converted const -> i32 convert into i32 const`);
+        continue;
+      }
+
+      if (lastInst[0] === Opcodes.i32_const && (inst === Opcodes.i32_from || inst === Opcodes.i32_from_u)) {
+        // change i32 const and immediate convert to const (opposite way of previous)
+        // i32.const 0
+        // f64.convert_i32_s || f64.convert_i32_u
+        // -->
+        // f64.const 0
+
+        wasm[i - 1] = number(read_signedLEB128(lastInst.slice(1)))[0]; // i32.const -> f64.const
+
+        wasm.splice(i, 1); // remove this inst
+        i--;
+        if (optLog) log('opt', `converted i32 const -> convert into const`);
+        continue;
+      }
+
       if (tailCall && lastInst[0] === Opcodes.call && inst[0] === Opcodes.return) {
         // replace call, return with tail calls (return_call)
         // call X

package/compiler/prototype.js

@@ -25,7 +25,6 @@ export const PrototypeFuncs = function() {
 
   this[TYPES._array] = {
     // lX = local accessor of X ({ get, set }), iX = local index of X, wX = wasm ops of X
-    // todo: out of bounds (>) properly
     at: (pointer, length, wIndex, iTmp) => [
       ...wIndex,
       Opcodes.i32_to,
@@ -147,7 +146,6 @@ export const PrototypeFuncs = function() {
   this[TYPES._array].push.noArgRetLength = true;
 
   this[TYPES.string] = {
-    // todo: out of bounds properly
     at: (pointer, length, wIndex, iTmp, arrayShell) => {
       const [ newOut, newPointer ] = arrayShell(1, 'i16');
 
@@ -157,9 +155,9 @@ export const PrototypeFuncs = function() {
         [ Opcodes.drop ],
 
         ...number(0, Valtype.i32), // base 0 for store later
-        Opcodes.i32_to_u,
 
         ...wIndex,
+        Opcodes.i32_to_u,
         [ Opcodes.local_tee, iTmp ],
 
         // if index < 0: access index + array length
@@ -265,7 +263,7 @@ export const PrototypeFuncs = function() {
     },
   };
 
-  this[TYPES.string].at.local = valtypeBinary;
+  this[TYPES.string].at.local = Valtype.i32;
   this[TYPES.string].at.returnType = TYPES.string;
   this[TYPES.string].charAt.returnType = TYPES.string;
   this[TYPES.string].charCodeAt.local = Valtype.i32;

package/compiler/sections.js

@@ -36,7 +36,7 @@ export default (funcs, globals, tags, pages, flags) => {
     // tree shake imports
     for (const f of funcs) {
       for (const inst of f.wasm) {
-        if (inst[0] === Opcodes.call && inst[1] < importedFuncs.length) {
+        if ((inst[0] === Opcodes.call || inst[0] === Opcodes.return_call) && inst[1] < importedFuncs.length) {
           const idx = inst[1];
           const func = importedFuncs[idx];
 
@@ -51,10 +51,11 @@ export default (funcs, globals, tags, pages, flags) => {
     // fix call indexes for non-imports
     const delta = importedFuncs.length - importFuncs.length;
     for (const f of funcs) {
+      f.originalIndex = f.index;
       f.index -= delta;
 
       for (const inst of f.wasm) {
-        if (inst[0] === Opcodes.call && inst[1] >= importedFuncs.length) {
+        if ((inst[0] === Opcodes.call || inst[0] === Opcodes.return_call) && inst[1] >= importedFuncs.length) {
           inst[1] -= delta;
         }
       }

package/compiler/wrap.js

@@ -1,6 +1,6 @@
 import compile from './index.js';
 import decompile from './decompile.js';
-// import fs from 'node:fs';
+import fs from 'node:fs';
 
 const bold = x => `\u001b[1m${x}\u001b[0m`;
 
@@ -27,7 +27,7 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
 
   if (source.includes('export function')) flags.push('module');
 
-  // fs.writeFileSync('out.wasm', Buffer.from(wasm));
+  fs.writeFileSync('out.wasm', Buffer.from(wasm));
 
   times.push(performance.now() - t1);
   if (flags.includes('info')) console.log(bold(`compiled in ${times[0].toFixed(2)}ms`));
@@ -90,6 +90,15 @@ export default async (source, flags = [ 'module' ], customImports = {}, print =
             return Array.from(new Uint16Array(memory.buffer, pointer + 4, length)).map(x => String.fromCharCode(x)).join('');
           }
 
+          case 'function': {
+            // wasm func index, including all imports
+            const func = funcs.find(x => (x.originalIndex ?? x.index) === ret);
+            if (!func) return ret;
+
+            // make fake empty func for repl/etc
+            return {[func.name]() {}}[func.name];
+          }
+
           default: return ret;
         }
       } catch (e) {

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.0.0-8c0bdaa",
+  "version": "0.0.0-c743344",
   "author": "CanadaHonk",
   "license": "MIT",
   "dependencies": {

package/publish.js

@@ -6,6 +6,8 @@ const rev = fs.readFileSync('.git/refs/heads/main', 'utf8').trim().slice(0, 7);
 const packageJson = fs.readFileSync('package.json', 'utf8');
 fs.writeFileSync('package.json', packageJson.replace('"0.0.0"', `"0.0.0-${rev}"`));
 
+console.log(rev, packageJson);
+
 execSync(`npm publish`, { stdio: 'inherit' });
 
-execSync(`git checkout HEAD -- package.json`, { stdio: 'inherit' });
+fs.writeFileSync('package.json', packageJson);

package/runner/index.js

@@ -5,6 +5,12 @@ import fs from 'node:fs';
 
 const file = process.argv.slice(2).find(x => x[0] !== '-');
 if (!file) {
+  if (process.argv.includes('-v')) {
+    // just print version
+    console.log((await import('./version.js')).default);
+    process.exit(0);
+  }
+
   // run repl if no file given
   await import('./repl.js');
 
@@ -30,5 +36,6 @@ try {
   exports.main();
   if (cache) process.stdout.write(cache);
 } catch (e) {
+  if (cache) process.stdout.write(cache);
   console.error(`${e.constructor.name}: ${e.message}`);
 }

package/runner/repl.js

@@ -1,14 +1,7 @@
 import compile from '../compiler/wrap.js';
+import rev from './version.js';
 
 import repl from 'node:repl';
-import fs from 'node:fs';
-
-let rev = 'unknown';
-try {
-  rev = fs.readFileSync(new URL('../.git/refs/heads/main', import.meta.url), 'utf8').trim().slice(0, 7);
-} catch {
-  rev = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version.split('-')[1];
-}
 
 // process.argv.push('-O0'); // disable opts
 
@@ -17,7 +10,7 @@ globalThis.valtype = 'f64';
 const valtypeOpt = process.argv.find(x => x.startsWith('-valtype='));
 if (valtypeOpt) valtype = valtypeOpt.split('=')[1];
 
-console.log(`welcome to porffor rev ${rev}`);
+console.log(`welcome to porffor rev ${rev.slice(0, 7)}`);
 console.log(`info: using opt ${process.argv.find(x => x.startsWith('-O')) ?? '-O1'} and valtype ${valtype}`);
 console.log();
 
@@ -48,15 +41,17 @@ const memoryToString = mem => {
   return out;
 };
 
+const alwaysPrev = process.argv.includes('-prev');
+
 let prev = '';
 const run = async (source, _context, _filename, callback, run = true) => {
   let toRun = prev + source.trim();
-  prev = toRun + ';\n';
+  if (alwaysPrev) prev = toRun + ';\n';
 
   const { exports, wasm, pages } = await compile(toRun, []);
-  fs.writeFileSync('out.wasm', Buffer.from(wasm));
+  // fs.writeFileSync('out.wasm', Buffer.from(wasm));
 
-  if (exports.$) {
+  if (run && exports.$) {
     lastMemory = exports.$;
     lastPages = [...pages.keys()];
   }
@@ -64,7 +59,7 @@ const run = async (source, _context, _filename, callback, run = true) => {
   const ret = run ? exports.main() : undefined;
   callback(null, ret);
 
-  // if (source.includes(' = ') || source.includes('let ') || source.includes('var ') || source.includes('const ')) prev += source + ';\n';
+  if (!alwaysPrev && (source.includes(' = ') || source.includes('let ') || source.includes('var ') || source.includes('const ') || source.includes('function '))) prev = toRun + ';\n';
   // prev = toRun + ';\n';
 };
 

package/runner/transform.js

@@ -5,32 +5,10 @@ const file = process.argv.slice(2).find(x => x[0] !== '-');
 
 const source = fs.readFileSync(file, 'utf8');
 
-const underline = x => `\u001b[4m\u001b[1m${x}\u001b[0m`;
-const bold = x => `\u001b[1m${x}\u001b[0m`;
-
-let cache = '';
-const print = str => {
-  cache += str;
-
-  if (str === '\n') {
-    process.stdout.write(cache);
-    cache = '';
-  }
-};
-
 const { wasm } = await compile(source);
 
-if (!raw && typeof Deno === 'undefined') fs.writeFileSync('out.wasm', Buffer.from(wasm));
-
-if (!process.argv.includes('-no-run')) {
-  console.log(`\n\n${underline('output')}`);
-  const t2 = performance.now();
-
-  exports.main();
-  print('\n');
-
-  if (!raw) console.log(bold(`\n\nexecuted in ${(performance.now() - t2).toFixed(2)}ms`));
-}
+// const out = `(async () => { const print = str => process.stdout.write(str); (await WebAssembly.instantiate(Uint8Array.from([${wasm.toString()}]), {'': { p: i => print(i.toString()), c: i => print(String.fromCharCode(i))}})).instance.exports.m()})()`;
+const out = `new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([${wasm.toString()}])),{'':{p:i=>process.stdout.write(i.toString())}}).exports.m()`;
 
-if (!raw) console.log(bold(`wasm binary is ${wasm.byteLength} bytes`));
-if (!raw) console.log(`total: ${(performance.now() - t0).toFixed(2)}ms`);
+console.log(out);
+eval(out);

package/runner/version.js

@@ -0,0 +1,10 @@
+import fs from 'node:fs';
+
+let rev = 'unknown';
+try {
+  rev = fs.readFileSync(new URL('../.git/refs/heads/main', import.meta.url), 'utf8').trim().slice(0, 7);
+} catch {
+  rev = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version.split('-')[1].slice(0, 7);
+}
+
+export default rev;

package/t.js

@@ -0,0 +1,31 @@
+let assert = Object();
+
+assert._isSameValue = function (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;
+
+  // return a === b;
+};
+
+assert.sameValue = function (actual, expected) {
+  /* try {
+    if (assert._isSameValue(actual, expected)) {
+      return;
+    }
+  } catch (error) {
+    throw new Test262Error('_isSameValue operation threw');
+  } */
+
+  if (assert._isSameValue(actual, expected)) {
+    return;
+  }
+
+  throw new Test262Error('assert.sameValue failed');
+};
+
+assert.sameValue("lego".charAt(), "l");