porffor 0.35.0 → 0.35.2

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');
 
@@ -499,126 +502,19 @@ const performLogicOp = (scope, op, left, right, leftType, rightType) => {
   ];
 };
 
-const concatStrings = (scope, left, right, leftType, rightType, allBytestrings = false, skipTypeCheck = false) => {
-  // 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 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);
-
-  const leftPointer = localTmp(scope, 'concat_left_pointer', Valtype.i32);
-
-  // alloc/assign array
-  const out = localTmp(scope, 'concat_out_pointer', Valtype.i32);
-
-  if (!skipTypeCheck && !allBytestrings) includeBuiltin(scope, '__Porffor_bytestringToString');
+const concatStrings = (scope, left, right, leftType, rightType) => {
   return [
-    // setup pointers
-    ...(left.length === 0 ? [
-      Opcodes.i32_to_u,
-      [ Opcodes.local_set, rightPointer ],
-
-      Opcodes.i32_to_u,
-      [ Opcodes.local_set, leftPointer ],
-    ] : [
-      ...left,
-      Opcodes.i32_to_u,
-      [ Opcodes.local_set, leftPointer ],
-
-      ...right,
-      Opcodes.i32_to_u,
-      [ Opcodes.local_set, rightPointer ],
-    ]),
-
-    // setup out
-    [ Opcodes.i32_const, 1 ],
-    [ Opcodes.memory_grow, 0 ],
-    [ Opcodes.i32_const, ...signedLEB128(65536) ],
-    [ Opcodes.i32_mul ],
-    [ Opcodes.local_tee, out ],
-
-    // calculate length
-    [ Opcodes.local_get, leftPointer ],
-    [ Opcodes.i32_load, 0, 0 ],
-    [ Opcodes.local_tee, leftLength ],
-
-    [ Opcodes.local_get, rightPointer ],
-    [ Opcodes.i32_load, 0, 0 ],
-    [ Opcodes.local_tee, rightLength ],
-
-    [ Opcodes.i32_add ],
-
-    // store length
-    [ Opcodes.i32_store, Math.log2(ValtypeSize.i32) - 1, 0 ],
-
-    ...(skipTypeCheck || allBytestrings ? [] : [
-      ...leftType,
-      ...number(TYPES.bytestring, Valtype.i32),
-      [ Opcodes.i32_eq ],
-      [ Opcodes.if, Blocktype.void ],
-      [ Opcodes.local_get, leftPointer ],
-      [ Opcodes.local_get, leftLength ],
-      [ Opcodes.call, funcIndex.__Porffor_bytestringToString ],
-      [ Opcodes.local_set, leftPointer ],
-      [ Opcodes.end ],
-
-      ...rightType,
-      ...number(TYPES.bytestring, Valtype.i32),
-      [ Opcodes.i32_eq ],
-      [ Opcodes.if, Blocktype.void ],
-      [ Opcodes.local_get, rightPointer ],
-      [ Opcodes.local_get, rightLength ],
-      [ Opcodes.call, funcIndex.__Porffor_bytestringToString ],
-      [ Opcodes.local_set, rightPointer ],
-      [ Opcodes.end ]
-    ]),
-
-    // copy left
-    // dst = out pointer + length size
-    [ Opcodes.local_get, out ],
-    ...number(ValtypeSize.i32, Valtype.i32),
-    [ Opcodes.i32_add ],
-
-    // src = left pointer + length size
-    [ Opcodes.local_get, leftPointer ],
-    ...number(ValtypeSize.i32, Valtype.i32),
-    [ Opcodes.i32_add ],
-
-    // size = PageSize - length size. we do not need to calculate length as init value
-    ...number(pageSize - ValtypeSize.i32, Valtype.i32),
-    [ ...Opcodes.memory_copy, 0x00, 0x00 ],
-
-    // copy right
-    // dst = out pointer + length size + left length * sizeof valtype
-    [ Opcodes.local_get, out ],
-    ...number(ValtypeSize.i32, Valtype.i32),
-    [ Opcodes.i32_add ],
-
-    [ Opcodes.local_get, leftLength ],
-    ...number(allBytestrings ? ValtypeSize.i8 : ValtypeSize.i16, Valtype.i32),
-    [ Opcodes.i32_mul ],
-    [ Opcodes.i32_add ],
-
-    // src = right pointer + length size
-    [ Opcodes.local_get, rightPointer ],
-    ...number(ValtypeSize.i32, Valtype.i32),
-    [ Opcodes.i32_add ],
-
-    // size = right length * sizeof valtype
-    [ Opcodes.local_get, rightLength ],
-    ...number(allBytestrings ? ValtypeSize.i8 : ValtypeSize.i16, Valtype.i32),
-    [ Opcodes.i32_mul ],
-
-    [ ...Opcodes.memory_copy, 0x00, 0x00 ],
+    ...left,
+    ...(valtypeBinary === Valtype.i32 ? [ [ Opcodes.f64_convert_i32_s ] ] : []),
+    ...leftType,
 
-    ...setLastType(scope, allBytestrings ? TYPES.bytestring : TYPES.string),
+    ...right,
+    ...(valtypeBinary === Valtype.i32 ? [ [ Opcodes.f64_convert_i32_s ] ] : []),
+    ...rightType,
 
-    // return new string (page)
-    [ Opcodes.local_get, out ],
-    Opcodes.i32_from_u
+    [ Opcodes.call, includeBuiltin(scope, '__Porffor_concatStrings').index ],
+    ...setLastType(scope),
+    ...(valtypeBinary === Valtype.i32 ? [ Opcodes.i32_trunc_sat_f64_u ] : []),
   ];
 };
 
@@ -829,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 === '!==';
@@ -860,23 +756,16 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
   // todo: if equality op and an operand is undefined, return false
   // todo: niche null hell with 0
 
-  if (knownLeft === TYPES.string || knownRight === TYPES.string) {
+  if ((knownLeft === TYPES.string || knownRight === TYPES.string) ||
+      (knownLeft === TYPES.bytestring || knownRight === TYPES.bytestring)) {
     if (op === '+') {
       // string concat (a + b)
-      return [
-        ...left,
-        ...right,
-        ...concatStrings(scope, [], [], leftType, rightType, false, knownLeft === TYPES.string && knownRight === TYPES.string)
-      ];
+      return concatStrings(scope, left, right, leftType, rightType);
     }
 
     // not an equality op, NaN
     if (!eqOp) return number(NaN);
 
-    // else leave bool ops
-    // todo: convert string to number if string and number/bool
-    // todo: string (>|>=|<|<=) string
-
     // string comparison
     if (op === '===' || op === '==' || op === '!==' || op === '!=') {
       return [
@@ -884,32 +773,8 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
         ...(op === '!==' || op === '!=' ? [ [ Opcodes.i32_eqz ] ] : [])
       ];
     }
-  }
-
-  if (knownLeft === TYPES.bytestring || knownRight === TYPES.bytestring) {
-    if (op === '+') {
-      // string concat (a + b)
-      return [
-        ...left,
-        ...right,
-        ...concatStrings(scope, [], [], leftType, rightType, knownLeft === TYPES.bytestring && knownRight === TYPES.bytestring)
-      ];
-    }
-
-    // not an equality op, NaN
-    if (!eqOp) return number(NaN);
-
-    // else leave bool ops
-    // todo: convert string to number if string and number/bool
-    // todo: string (>|>=|<|<=) string
 
-    // string comparison
-    if (op === '===' || op === '==' || op === '!==' || op === '!=') {
-      return [
-        ...compareStrings(scope, left, right, leftType, rightType),
-        ...(op === '!==' || op === '!=' ? [ [ Opcodes.i32_eqz ] ] : [])
-      ];
-    }
+    // todo: proper >|>=|<|<=
   }
 
   let ops = operatorOpcode[valtype][op];
@@ -943,39 +808,19 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
     tmpRight = localTmp(scope, '__tmpop_right');
 
     ops.unshift(...stringOnly([
-      // if left is bytestring
-      ...leftType,
-      ...number(TYPES.bytestring, Valtype.i32),
-      [ Opcodes.i32_eq ],
-
-      // if right is bytestring
-      ...rightType,
-      ...number(TYPES.bytestring, Valtype.i32),
-      [ Opcodes.i32_eq ],
-
-      // if both are true
-      [ Opcodes.i32_and ],
-      [ Opcodes.if, Blocktype.void ],
-      ...concatStrings(scope, [ [ Opcodes.local_get, tmpLeft ] ], [ [ Opcodes.local_get, tmpRight ] ], leftType, rightType, true),
-      ...(op === '!==' || op === '!=' ? [ [ Opcodes.i32_eqz ] ] : []),
-      [ Opcodes.br, 1 ],
-      [ Opcodes.end ],
-
-      // if left is string or bytestring
+      // if left or right are string or bytestring
       ...leftType,
       ...number(TYPE_FLAGS.parity, Valtype.i32),
       [ Opcodes.i32_or ],
       ...number(TYPES.bytestring, Valtype.i32),
       [ Opcodes.i32_eq ],
 
-      // if right is string or bytestring
       ...rightType,
       ...number(TYPE_FLAGS.parity, Valtype.i32),
       [ Opcodes.i32_or ],
       ...number(TYPES.bytestring, Valtype.i32),
       [ Opcodes.i32_eq ],
 
-      // if either
       [ Opcodes.i32_or ],
       [ Opcodes.if, Blocktype.void ],
       ...concatStrings(scope, [ [ Opcodes.local_get, tmpLeft ] ], [ [ Opcodes.local_get, tmpRight ] ], leftType, rightType),
@@ -1371,6 +1216,7 @@ const setLastType = (scope, type = []) => [
 ];
 
 const getNodeType = (scope, node) => {
+  let guess = null;
   const ret = (() => {
     if (node._type) return node._type;
     if (node.type === 'Literal') {
@@ -1476,6 +1322,7 @@ const getNodeType = (scope, node) => {
     if (node.type === 'AssignmentExpression') {
       const op = node.operator.slice(0, -1) || '=';
       if (op === '=') return getNodeType(scope, node.right);
+      // if (op === '=') return getNodeType(scope, node.left);
 
       return getNodeType(scope, {
         type: ['||', '&&', '??'].includes(op) ? 'LogicalExpression' : 'BinaryExpression',
@@ -1495,14 +1342,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 === 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 != null || knownRight != null) && !(
+        (knownLeft === TYPES.string || knownRight === TYPES.string) ||
+        (knownLeft === TYPES.bytestring || knownRight === TYPES.bytestring)
+      )) return TYPES.number;
 
-      if (knownLeft != null || knownRight != null) return TYPES.number;
+      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);
 
@@ -1580,8 +1433,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) => {
@@ -2232,6 +2087,9 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
 
         // value
         i32_const: { imms: 1, args: [], returns: 0 },
+
+        // dst, src, size, _, _
+        memory_copy: { imms: 2, args: [ true, true, true ], returns: 0 }
       };
 
       const opName = name.slice('__Porffor_wasm_'.length);
@@ -2254,9 +2112,12 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
         // literals only
         const imms = decl.arguments.slice(op.args.length).map(x => x.value);
 
+        let opcode = Opcodes[opName];
+        if (!Array.isArray(opcode)) opcode = [ opcode ];
+
         return [
           ...argOut,
-          [ Opcodes[opName], ...imms ],
+          [ ...opcode, ...imms ],
           ...(new Array(op.returns).fill(Opcodes.i32_from))
         ];
       }
@@ -2705,6 +2566,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 = [];
@@ -2975,8 +2843,10 @@ const setLocalWithType = (scope, name, isGlobal, decl, tee = false, overrideType
   // todo: detect last type then i32 conversion op
   const lastOp = out.at(-1);
   if (lastOp[0] === Opcodes.local_set && lastOp[1] === scope.locals['#last_type']?.idx) {
-    out.pop();
+    // set last type -> tee last type
+    lastOp[0] = Opcodes.local_tee;
 
+    // still set last type due to side effects or type of decl gotten later
     const setOut = setType(scope, name, []);
     out.push(
       // drop if setType is empty
@@ -5809,6 +5679,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.0+8b2f7cee3",
+  "version": "0.35.2+e15887a34",
   "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.0+8b2f7cee3';
+globalThis.version = '0.35.2+e15887a34';
 
 // 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';