porffor 0.35.1 → 0.35.3

package/compiler/codegen.js

@@ -183,6 +183,9 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
     case 'AwaitExpression':
       return cacheAst(decl, generateAwait(scope, decl));
 
+    case 'TemplateLiteral':
+      return cacheAst(decl, generateTemplate(scope, decl));
+
     case 'ExportNamedDeclaration':
       if (!decl.declaration) return todo(scope, 'unsupported export declaration');
 
@@ -722,8 +725,8 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
     return performLogicOp(scope, op, left, right, leftType, rightType);
   }
 
-  const knownLeft = knownType(scope, leftType);
-  const knownRight = knownType(scope, rightType);
+  const knownLeft = knownTypeWithGuess(scope, leftType);
+  const knownRight = knownTypeWithGuess(scope, rightType);
 
   const eqOp = ['==', '===', '!=', '!==', '>', '>=', '<', '<='].includes(op);
   const strictOp = op === '===' || op === '!==';
@@ -881,30 +884,40 @@ const knownNullish = decl => {
 
 const generateBinaryExp = (scope, decl, _global, _name) => {
   if (decl.operator === 'instanceof') {
-    // very hacky basic instanceof
-    // todo: support dynamic right-hand side
-
-    const out = generate(scope, decl.left);
-    disposeLeftover(out);
-
+    // try hacky version for built-ins first
     const rightName = decl.right.name;
-    if (!rightName) return todo(scope, 'instanceof dynamic right-hand side is not supported yet', true);
-
-    const checkType = TYPES[rightName.toLowerCase()];
-    if (checkType == null || rightName !== TYPE_NAMES[checkType] || checkType === TYPES.undefined) return todo(scope, 'instanceof right-hand side type unsupported', true);
+    if (rightName) {
+      const checkType = TYPES[rightName.toLowerCase()];
+      if (checkType != null && rightName === TYPE_NAMES[checkType]) {
+        const out = generate(scope, decl.left);
+        disposeLeftover(out);
+
+        if ([TYPES.number, TYPES.boolean, TYPES.string].includes(checkType)) {
+          out.push(...number(0));
+        } else {
+          out.push(
+            ...getNodeType(scope, decl.left),
+            ...number(checkType, Valtype.i32),
+            [ Opcodes.i32_eq ],
+            Opcodes.i32_from_u
+          );
+        }
 
-    if ([TYPES.number, TYPES.boolean, TYPES.string, TYPES.symbol, TYPES.object].includes(checkType)) {
-      out.push(...number(0));
-    } else {
-      out.push(
-        ...getNodeType(scope, decl.left),
-        ...number(checkType, Valtype.i32),
-        [ Opcodes.i32_eq ],
-        Opcodes.i32_from_u
-      );
+        return out;
+      }
     }
 
-    return out;
+    return generate(scope, {
+      type: 'CallExpression',
+      callee: {
+        type: 'Identifier',
+        name: '__Porffor_object_instanceof'
+      },
+      arguments: [
+        decl.left,
+        decl.right
+      ]
+    });
   }
 
   if (decl.operator === 'in') {
@@ -1213,6 +1226,7 @@ const setLastType = (scope, type = []) => [
 ];
 
 const getNodeType = (scope, node) => {
+  let guess = null;
   const ret = (() => {
     if (node._type) return node._type;
     if (node.type === 'Literal') {
@@ -1338,17 +1352,20 @@ const getNodeType = (scope, node) => {
 
       const leftType = getNodeType(scope, node.left);
       const rightType = getNodeType(scope, node.right);
-      const knownLeft = knownType(scope, leftType);
-      const knownRight = knownType(scope, rightType);
+      const knownLeft = knownTypeWithGuess(scope, leftType);
+      const knownRight = knownTypeWithGuess(scope, rightType);
 
       if ((knownLeft != null || knownRight != null) && !(
         (knownLeft === TYPES.string || knownRight === TYPES.string) ||
         (knownLeft === TYPES.bytestring || knownRight === TYPES.bytestring)
       )) return TYPES.number;
 
-      // if (knownLeft === TYPES.string || knownRight === TYPES.string) return TYPES.string;
-      // if (knownLeft === TYPES.bytestring && knownRight === TYPES.bytestring) return TYPES.bytestring;
-      // if (knownLeft === TYPES.bytestring || knownRight === TYPES.bytestring) return TYPES.string;
+      if (knownLeft === TYPES.string || knownRight === TYPES.string)
+        return TYPES.string;
+
+      // guess bytestring, could really be bytestring or string
+      if (knownLeft === TYPES.bytestring || knownRight === TYPES.bytestring)
+        guess = TYPES.bytestring;
 
       if (scope.locals['#last_type']) return getLastType(scope);
 
@@ -1426,8 +1443,10 @@ const getNodeType = (scope, node) => {
     return TYPES.number;
   })();
 
-  if (typeof ret === 'number') return number(ret, Valtype.i32);
-  return ret;
+  const out = typeof ret === 'number' ? number(ret, Valtype.i32) : ret;
+  if (guess != null) out.guess = typeof guess === 'number' ? number(guess, Valtype.i32) : guess;
+
+  return out;
 };
 
 const generateLiteral = (scope, decl, global, name) => {
@@ -2557,6 +2576,13 @@ const knownType = (scope, type) => {
 
   return null;
 };
+const knownTypeWithGuess = (scope, type) => {
+  let known = knownType(scope, type);
+  if (known != null) return known;
+
+  if (type.guess != null) return knownType(scope, type.guess);
+  return known;
+};
 
 const brTable = (input, bc, returns) => {
   const out = [];
@@ -5663,6 +5689,38 @@ const generateClass = (scope, decl) => {
   return out;
 };
 
+export const generateTemplate = (scope, decl) => {
+  let current = null;
+  const append = val => {
+    // console.log(val);
+    if (!current) {
+      current = val;
+      return;
+    }
+
+    current = {
+      type: 'BinaryExpression',
+      operator: '+',
+      left: current,
+      right: val
+    };
+  };
+
+  const { expressions, quasis } = decl;
+  for (let i = 0; i < quasis.length; i++) {
+    append({
+      type: 'Literal',
+      value: quasis[i].value.cooked
+    });
+
+    if (i < expressions.length) {
+      append(expressions[i]);
+    }
+  }
+
+  return generate(scope, current);
+};
+
 globalThis._uniqId = 0;
 const uniqId = () => '_' + globalThis._uniqId++;
 

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.35.1+160a05475",
+  "version": "0.35.3+30564a39f",
   "author": "CanadaHonk",
   "license": "MIT",
   "scripts": {},

package/runner/index.js

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

package/runner/repl.js

@@ -61,7 +61,10 @@ const memoryToString = mem => {
       out += `  \x1B[34m${name}${' '.repeat(longestName - name.length)} \x1B[90m│\x1B[0m \x1B[36m${type}${' '.repeat(longestType - type.length)} \x1B[90m│\x1B[0m `;
     }
 
-    for (let j = 0; j < 40; j++) {
+    let j = 0;
+    if (i === 0) j = 16;
+    const end = j + 40;
+    for (; j < end; j++) {
       const val = buf[i * pageSize + j];
       // if (val === 0) out += '\x1B[2m';
       if (val === 0) out += '\x1B[90m';