porffor 0.2.0-fdf0fc5 → 0.14.0-1a571ec24

package/compiler/codegen.js

@@ -1,14 +1,14 @@
-import { Blocktype, Opcodes, Valtype, PageSize, ValtypeSize } from "./wasmSpec.js";
-import { ieee754_binary64, signedLEB128, unsignedLEB128, encodeVector } from "./encoding.js";
-import { operatorOpcode } from "./expression.js";
-import { BuiltinFuncs, BuiltinVars, importedFuncs, NULL, UNDEFINED } from "./builtins.js";
-import { PrototypeFuncs } from "./prototype.js";
-import { number, i32x4, enforceOneByte, enforceTwoBytes, enforceFourBytes, enforceEightBytes } from "./embedding.js";
-import { log } from "./log.js";
-import parse from "./parse.js";
-import * as Rhemyn from "../rhemyn/compile.js";
-import Prefs from './prefs.js';
+import { Blocktype, Opcodes, Valtype, PageSize, ValtypeSize } from './wasmSpec.js';
+import { ieee754_binary64, signedLEB128, unsignedLEB128, encodeVector } from './encoding.js';
+import { operatorOpcode } from './expression.js';
+import { BuiltinFuncs, BuiltinVars, importedFuncs, NULL, UNDEFINED } from './builtins.js';
+import { PrototypeFuncs } from './prototype.js';
+import { number } from './embedding.js';
 import { TYPES, TYPE_NAMES } from './types.js';
+import * as Rhemyn from '../rhemyn/compile.js';
+import parse from './parse.js';
+import { log } from './log.js';
+import Prefs from './prefs.js';
 
 let globals = {};
 let globalInd = 0;
@@ -19,24 +19,6 @@ let funcIndex = {};
 let currentFuncIndex = importedFuncs.length;
 let builtinFuncs = {}, builtinVars = {}, prototypeFuncs = {};
 
-const debug = str => {
-  const code = [];
-
-  const logChar = n => {
-    code.push(...number(n));
-
-    code.push([ Opcodes.call, 0 ]);
-  };
-
-  for (let i = 0; i < str.length; i++) {
-    logChar(str.charCodeAt(i));
-  }
-
-  logChar(10); // new line
-
-  return code;
-};
-
 class TodoError extends Error {
   constructor(message) {
     super(message);
@@ -76,10 +58,11 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
 
     case 'ArrowFunctionExpression':
     case 'FunctionDeclaration':
+    case 'FunctionExpression':
       const func = generateFunc(scope, decl);
 
       if (decl.type.endsWith('Expression')) {
-        return number(func.index);
+        return number(func.index - importedFuncs.length);
       }
 
       return [];
@@ -171,11 +154,6 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
         newFunc.export = true;
       }
 
-      // if (funcsBefore === funcs.length) throw new Error('no new func added in export');
-
-      // const newFunc = funcs[funcs.length - 1];
-      // newFunc.export = true;
-
       return [];
 
     case 'TaggedTemplateExpression': {
@@ -210,7 +188,7 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
             if (!Array.isArray(inst)) inst = [ inst ];
             const immediates = asm.slice(1).map(x => {
               const int = parseInt(x);
-              if (Number.isNaN(int)) return scope.locals[x]?.idx;
+              if (Number.isNaN(int)) return scope.locals[x]?.idx ?? globals[x].idx;
               return int;
             });
 
@@ -336,10 +314,10 @@ const generateIdent = (scope, decl) => {
 
     if (local?.idx === undefined) {
       // no local var with name
-      if (Object.hasOwn(importedFuncs, name)) return number(importedFuncs[name]);
-      if (Object.hasOwn(funcIndex, name)) return number(funcIndex[name]);
-
       if (Object.hasOwn(globals, name)) return [ [ Opcodes.global_get, globals[name].idx ] ];
+
+      if (Object.hasOwn(importedFuncs, name)) return number(importedFuncs[name] - importedFuncs.length);
+      if (Object.hasOwn(funcIndex, name)) return number(funcIndex[name] - importedFuncs.length);
     }
 
     if (local?.idx === undefined && rawName.startsWith('__')) {
@@ -373,9 +351,7 @@ const generateReturn = (scope, decl) => {
 
   return [
     ...generate(scope, decl.argument),
-    ...(scope.returnType != null ? [] : [
-      ...getNodeType(scope, decl.argument)
-    ]),
+    ...(scope.returnType != null ? [] : getNodeType(scope, decl.argument)),
     [ Opcodes.return ]
   ];
 };
@@ -858,31 +834,6 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
 
   // if strict (in)equal check types match
   if (strictOp) {
-    // startOut.push(
-    //   ...leftType,
-    //   ...rightType,
-    //   [ Opcodes.i32_eq ]
-    // );
-
-    // endOut.push(
-    //   [ Opcodes.i32_and ]
-    // );
-
-    // startOut.push(
-    //   [ Opcodes.block, Valtype.i32 ],
-    //   ...leftType,
-    //   ...rightType,
-    //   [ Opcodes.i32_ne ],
-    //   [ Opcodes.if, Blocktype.void ],
-    //   ...number(op === '===' ? 0 : 1, Valtype.i32),
-    //   [ Opcodes.br, 1 ],
-    //   [ Opcodes.end ]
-    // );
-
-    // endOut.push(
-    //   [ Opcodes.end ]
-    // );
-
     endOut.push(
       ...leftType,
       ...rightType,
@@ -1089,7 +1040,7 @@ const generateBinaryExp = (scope, decl, _global, _name) => {
 
 const asmFuncToAsm = (func, { name = '#unknown_asm_func', params = [], locals = [], returns = [], localInd = 0 }) => {
   return func({ name, params, locals, returns, localInd }, {
-    TYPES, TYPE_NAMES, typeSwitch, makeArray, makeString, allocPage,
+    TYPES, TYPE_NAMES, typeSwitch, makeArray, makeString, allocPage, internalThrow,
     builtin: name => {
       let idx = funcIndex[name] ?? importedFuncs[name];
       if (idx === undefined && builtinFuncs[name]) {
@@ -1248,7 +1199,7 @@ const setLastType = scope => {
 };
 
 const getNodeType = (scope, node) => {
-  const inner = () => {
+  const ret = (() => {
     if (node.type === 'Literal') {
       if (node.regex) return TYPES.regexp;
 
@@ -1291,7 +1242,6 @@ const getNodeType = (scope, node) => {
       const func = funcs.find(x => x.name === name);
 
       if (func) {
-        // console.log(scope, func, func.returnType);
         if (func.returnType) return func.returnType;
       }
 
@@ -1435,10 +1385,8 @@ const getNodeType = (scope, node) => {
     // presume
     // todo: warn here?
     return TYPES.number;
-  };
+  })();
 
-  const ret = inner();
-  // console.trace(node, ret);
   if (typeof ret === 'number') return number(ret, Valtype.i32);
   return ret;
 };
@@ -1501,6 +1449,10 @@ const countLeftover = wasm => {
             } else count--;
             if (func) count += func.returns.length;
           }
+        } else if (inst[0] === Opcodes.call_indirect) {
+          count--; // funcidx
+          count -= inst[1] * 2; // params * 2 (typed)
+          count += 2; // fixed return (value, type)
         } else count--;
 
     // console.log(count, decompile([ inst ]).slice(0, -1));
@@ -1577,15 +1529,6 @@ const RTArrayUtil = {
 };
 
 const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
-  /* const callee = decl.callee;
-  const args = decl.arguments;
-
-  return [
-    ...generate(args),
-    ...generate(callee),
-    Opcodes.call_indirect,
-  ]; */
-
   let name = mapName(decl.callee.name);
   if (isFuncType(decl.callee.type)) { // iife
     const func = generateFunc(scope, decl.callee);
@@ -1759,8 +1702,6 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
           continue;
         }
 
-        // const protoLocal = protoFunc.local ? localTmp(scope, `__${TYPE_NAMES[x]}_${protoName}_tmp`, protoFunc.local) : -1;
-        // const protoLocal2 = protoFunc.local2 ? localTmp(scope, `__${TYPE_NAMES[x]}_${protoName}_tmp2`, protoFunc.local2) : -1;
         const protoLocal = protoFunc.local ? localTmp(scope, `__${protoName}_tmp`, protoFunc.local) : -1;
         const protoLocal2 = protoFunc.local2 ? localTmp(scope, `__${protoName}_tmp2`, protoFunc.local2) : -1;
 
@@ -1837,22 +1778,6 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
 
     includeBuiltin(scope, name);
     idx = funcIndex[name];
-
-    // infer arguments types from builtins params
-    // const func = funcs.find(x => x.name === name);
-    // for (let i = 0; i < decl.arguments.length; i++) {
-    //   const arg = decl.arguments[i];
-    //   if (!arg.name) continue;
-
-    //   const local = scope.locals[arg.name];
-    //   if (!local) continue;
-
-    //   local.type = func.params[i];
-    //   if (local.type === Valtype.v128) {
-    //     // specify vec subtype inferred from last vec type in function name
-    //     local.vecType = name.split('_').reverse().find(x => x.includes('x'));
-    //   }
-    // }
   }
 
   if (idx === undefined && internalConstrs[name]) return internalConstrs[name].generate(scope, decl, _global, _name);
@@ -1909,7 +1834,45 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   }
 
   if (idx === undefined) {
-    if (scope.locals[name] !== undefined || globals[name] !== undefined || builtinVars[name] !== undefined) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, true);
+    if (scope.locals[name] !== undefined || globals[name] !== undefined || builtinVars[name] !== undefined) {
+      const [ local, global ] = lookupName(scope, name);
+      if (!Prefs.indirectCalls || local == null) return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, true);
+
+      // todo: only works when:
+      //   1. arg count matches arg count of function
+      //   2. function uses typedParams and typedReturns
+
+      funcs.table = true;
+
+      let args = decl.arguments;
+      let argWasm = [];
+
+      for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        argWasm = argWasm.concat(generate(scope, arg));
+
+        if (valtypeBinary !== Valtype.i32 && (
+          (builtinFuncs[name] && builtinFuncs[name].params[i * (typedParams ? 2 : 1)] === Valtype.i32) ||
+          (importedFuncs[name] && name.startsWith('profile'))
+        )) {
+          argWasm.push(Opcodes.i32_to);
+        }
+
+        argWasm = argWasm.concat(getNodeType(scope, arg));
+      }
+
+      return typeSwitch(scope, getNodeType(scope, decl.callee), {
+        [TYPES.function]: [
+          ...argWasm,
+          [ global ? Opcodes.global_get : Opcodes.local_get, local.idx ],
+          Opcodes.i32_to_u,
+          [ Opcodes.call_indirect, args.length, 0 ],
+          ...setLastType(scope)
+        ],
+        default: internalThrow(scope, 'TypeError', `${unhackName(name)} is not a function`, true)
+      });
+    }
+
     return internalThrow(scope, 'ReferenceError', `${unhackName(name)} is not defined`, true);
   }
 
@@ -1938,11 +1901,16 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
     const arg = args[i];
     out = out.concat(generate(scope, arg));
 
-    if (builtinFuncs[name] && builtinFuncs[name].params[i * (typedParams ? 2 : 1)] === Valtype.i32 && valtypeBinary !== Valtype.i32) {
-      out.push(Opcodes.i32_to);
+    if (i >= paramCount) {
+      // over param count of func, drop arg
+      out.push([ Opcodes.drop ]);
+      continue;
     }
 
-    if (importedFuncs[name] && name.startsWith('profile')) {
+    if (valtypeBinary !== Valtype.i32 && (
+      (builtinFuncs[name] && builtinFuncs[name].params[i * (typedParams ? 2 : 1)] === Valtype.i32) ||
+      (importedFuncs[name] && name.startsWith('profile'))
+    )) {
       out.push(Opcodes.i32_to);
     }
 
@@ -1987,6 +1955,11 @@ const generateNew = (scope, decl, _global, _name) => {
     }, _global, _name);
   }
 
+  if (
+    (builtinFuncs[name] && !builtinFuncs[name].constr) ||
+    (internalConstrs[name] && builtinFuncs[name].notConstr)
+  ) return internalThrow(scope, 'TypeError', `${name} is not a constructor`);
+
   if (!builtinFuncs[name]) return todo(scope, `new statement is not supported yet`); // return todo(scope, `new statement is not supported yet (new ${unhackName(name)})`);
 
   return generateCall(scope, decl, _global, _name);
@@ -2178,7 +2151,6 @@ const addVarMetadata = (scope, name, global = false, metadata = {}) => {
 const typeAnnoToPorfType = x => {
   if (!x) return null;
   if (TYPES[x.toLowerCase()] != null) return TYPES[x.toLowerCase()];
-  if (TYPES['_' + x.toLowerCase()] != null) return TYPES['_' + x.toLowerCase()];
 
   switch (x) {
     case 'i32':
@@ -2219,9 +2191,8 @@ const generateVar = (scope, decl) => {
 
   const topLevel = scope.name === 'main';
 
-  // global variable if in top scope (main) and var ..., or if wanted
-  const global = topLevel || decl._bare; // decl.kind === 'var';
-  const target = global ? globals : scope.locals;
+  // global variable if in top scope (main) or if internally wanted
+  const global = topLevel || decl._bare;
 
   for (const x of decl.declarations) {
     const name = mapName(x.id.name);
@@ -2235,7 +2206,6 @@ const generateVar = (scope, decl) => {
       continue;
     }
 
-    // console.log(name);
     if (topLevel && builtinVars[name]) {
       // cannot redeclare
       if (decl.kind !== 'var') return internalThrow(scope, 'SyntaxError', `Identifier '${unhackName(name)}' has already been declared`);
@@ -2255,6 +2225,22 @@ const generateVar = (scope, decl) => {
     }
 
     if (x.init) {
+      // if (isFuncType(x.init.type)) {
+      //   // let a = function () { ... }
+      //   x.init.id = { name };
+
+      //   const func = generateFunc(scope, x.init);
+
+      //   out.push(
+      //     ...number(func.index - importedFuncs.length),
+      //     [ global ? Opcodes.global_set : Opcodes.local_set, idx ],
+
+      //     ...setType(scope, name, TYPES.function)
+      //   );
+
+      //   continue;
+      // }
+
       const generated = generate(scope, x.init, global, name);
       if (scope.arrays?.get(name) != null) {
         // hack to set local as pointer before
@@ -2266,6 +2252,7 @@ const generateVar = (scope, decl) => {
         out = out.concat(generated);
         out.push([ global ? Opcodes.global_set : Opcodes.local_set, idx ]);
       }
+
       out.push(...setType(scope, name, getNodeType(scope, x.init)));
     }
 
@@ -2279,6 +2266,7 @@ const generateVar = (scope, decl) => {
 // todo: optimize this func for valueUnused
 const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
   const { type, name } = decl.left;
+  const [ local, isGlobal ] = lookupName(scope, name);
 
   if (type === 'ObjectPattern') {
     // hack: ignore object parts of `var a = {} = 2`
@@ -2288,8 +2276,18 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
   if (isFuncType(decl.right.type)) {
     // hack for a = function () { ... }
     decl.right.id = { name };
-    generateFunc(scope, decl.right);
-    return [];
+
+    const func = generateFunc(scope, decl.right);
+
+    return [
+      ...number(func.index - importedFuncs.length),
+      ...(local != null ? [
+        [ isGlobal ? Opcodes.global_set : Opcodes.local_set, local.idx ],
+        [ isGlobal ? Opcodes.global_get : Opcodes.local_get, local.idx ],
+
+        ...setType(scope, name, TYPES.function)
+      ] : [])
+    ];
   }
 
   const op = decl.operator.slice(0, -1) || '=';
@@ -2388,8 +2386,6 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
 
   if (!name) return todo(scope, 'destructuring is not supported yet', true);
 
-  const [ local, isGlobal ] = lookupName(scope, name);
-
   if (local === undefined) {
     // todo: this should be a sloppy mode only thing
 
@@ -2538,6 +2534,7 @@ const generateUnary = (scope, decl) => {
         [TYPES.string]: makeString(scope, 'string', false, '#typeof_result'),
         [TYPES.undefined]: makeString(scope, 'undefined', false, '#typeof_result'),
         [TYPES.function]: makeString(scope, 'function', false, '#typeof_result'),
+        [TYPES.symbol]: makeString(scope, 'symbol', false, '#typeof_result'),
 
         [TYPES.bytestring]: makeString(scope, 'string', false, '#typeof_result'),
 
@@ -3036,13 +3033,6 @@ const generateEmpty = (scope, decl) => {
   return [];
 };
 
-const generateAssignPat = (scope, decl) => {
-  // TODO
-  // if identifier declared, use that
-  // else, use default (right)
-  return todo(scope, 'assignment pattern (optional arg)');
-};
-
 let pages = new Map();
 const allocPage = (scope, reason, type) => {
   if (pages.has(reason)) return pages.get(reason).ind;
@@ -3455,8 +3445,11 @@ const generateFunc = (scope, decl) => {
   };
 
   if (typedInput && decl.returnType) {
-    innerScope.returnType = extractTypeAnnotation(decl.returnType).type;
-    innerScope.returns = [ valtypeBinary ];
+    const { type } = extractTypeAnnotation(decl.returnType);
+    if (type != null && !Prefs.indirectCalls) {
+      innerScope.returnType = type;
+      innerScope.returns = [ valtypeBinary ];
+    }
   }
 
   for (let i = 0; i < params.length; i++) {
@@ -3498,7 +3491,7 @@ const generateFunc = (scope, decl) => {
   if (name !== 'main' && wasm[wasm.length - 1]?.[0] !== Opcodes.return && countLeftover(wasm) === 0) {
     wasm.push(
       ...number(0),
-      ...number(TYPES.undefined, Valtype.i32),
+      ...(innerScope.returnType != null ? [] : number(TYPES.undefined, Valtype.i32)),
       [ Opcodes.return ]
     );
   }
@@ -3671,8 +3664,10 @@ const internalConstrs = {
           }),
 
           // print space
-          ...number(32),
-          [ Opcodes.call, importedFuncs.printChar ]
+          ...(i !== decl.arguments.length - 1 ? [
+            ...number(32),
+            [ Opcodes.call, importedFuncs.printChar ]
+          ] : [])
         );
       }
 
@@ -3682,6 +3677,8 @@ const internalConstrs = {
         [ Opcodes.call, importedFuncs.printChar ]
       );
 
+      out.push(...number(UNDEFINED));
+
       return out;
     },
     type: TYPES.undefined,

package/compiler/decompile.js

@@ -1,5 +1,5 @@
-import { Blocktype, Opcodes, Valtype } from "./wasmSpec.js";
-import { read_ieee754_binary64, read_signedLEB128, read_unsignedLEB128 } from "./encoding.js";
+import { Blocktype, Opcodes, Valtype } from './wasmSpec.js';
+import { read_ieee754_binary64, read_signedLEB128, read_unsignedLEB128 } from './encoding.js';
 
 const inv = (obj, keyMap = x => x) => Object.keys(obj).reduce((acc, x) => { acc[keyMap(obj[x])] = x; return acc; }, {});
 const invOpcodes = inv(Opcodes);
@@ -119,7 +119,7 @@ export const highlightAsm = asm => asm
   .replace(/(local|global|memory)\.[^\s]*/g, _ => `\x1B[31m${_}\x1B[0m`)
   .replace(/(i(8|16|32|64)x[0-9]+|v128)(\.[^\s]*)?/g, _ => `\x1B[34m${_}\x1B[0m`)
   .replace(/(i32|i64|f32|f64|drop)(\.[^\s]*)?/g, _ => `\x1B[36m${_}\x1B[0m`)
-  .replace(/(return_call|call|br_if|br|return|rethrow|throw)/g, _ => `\x1B[35m${_}\x1B[0m`)
+  .replace(/(return_call|call_indirect|call|br_if|br|return|rethrow|throw)/g, _ => `\x1B[35m${_}\x1B[0m`)
   .replace(/(block|loop|if|end|else|try|catch_all|catch|delegate)/g, _ => `\x1B[95m${_}\x1B[0m`)
   .replace(/unreachable/g, _ => `\x1B[91m${_}\x1B[0m`)
   .replace(/ \-?[0-9\.]+/g, _ => ` \x1B[33m${_.slice(1)}\x1B[0m`)

package/compiler/embedding.js

@@ -1,5 +1,5 @@
-import { Opcodes, Valtype } from "./wasmSpec.js";
-import { signedLEB128, ieee754_binary64 } from "./encoding.js";
+import { Opcodes, Valtype } from './wasmSpec.js';
+import { signedLEB128, ieee754_binary64 } from './encoding.js';
 
 export const number = (n, valtype = valtypeBinary) => {
   switch (valtype) {

package/compiler/encoding.js

@@ -7,21 +7,7 @@ export const codifyString = str => {
   return out;
 };
 
-// export const encodeString = str => [
-//   str.length,
-//   ...codifyString(str)
-// ];
 export const encodeString = str => unsignedLEB128(str.length).concat(codifyString(str));
-
-// export const encodeVector = data => [
-//   ...unsignedLEB128(data.length),
-//   ...data.flat()
-// ];
-// export const encodeVector = data => {
-//   const out = data.flat();
-//   out.unshift.apply(out, unsignedLEB128(data.length));
-//   return out;
-// };
 export const encodeVector = data => unsignedLEB128(data.length).concat(data.flat());
 
 export const encodeLocal = (count, type) => [

package/compiler/expression.js

@@ -1,4 +1,4 @@
-import { Opcodes } from "./wasmSpec.js";
+import { Opcodes } from './wasmSpec.js';
 
 export const operatorOpcode = {
   i32: {