porffor 0.17.0-55999d22b → 0.17.0-589ace465

package/compiler/codegen.js

@@ -4,7 +4,7 @@ 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 { TYPES, TYPE_FLAGS, TYPE_NAMES, typeHasFlag } from './types.js';
 import * as Rhemyn from '../rhemyn/compile.js';
 import parse from './parse.js';
 import { log } from './log.js';
@@ -72,6 +72,9 @@ const generate = (scope, decl, global = false, name = undefined, valueUnused = f
     case 'ExpressionStatement':
       return generateExp(scope, decl);
 
+    case 'SequenceExpression':
+      return generateSequence(scope, decl);
+
     case 'CallExpression':
       return generateCall(scope, decl, global, name, valueUnused);
 
@@ -264,10 +267,12 @@ const internalThrow = (scope, constructor, message, expectsValue = Prefs.alwaysV
     argument: {
       type: 'NewExpression',
       callee: {
+        type: 'Identifier',
         name: constructor
       },
       arguments: [
         {
+          type: 'Literal',
           value: message
         }
       ]
@@ -289,12 +294,13 @@ const generateIdent = (scope, decl) => {
       return wasm.slice();
     }
 
-    if (Object.hasOwn(builtinFuncs, name) || Object.hasOwn(internalConstrs, name)) {
-      // todo: return an actual something
-      return number(1);
-    }
+    // todo: enable this by default in future
+    // if (!Object.hasOwn(funcIndex, name) && Object.hasOwn(builtinFuncs, name)) {
+    //   includeBuiltin(scope, name);
+    //   return number(funcIndex[name] - importedFuncs.length);
+    // }
 
-    if (isExistingProtoFunc(name)) {
+    if (isExistingProtoFunc(name) || Object.hasOwn(internalConstrs, name) || Object.hasOwn(builtinFuncs, name)) {
       // todo: return an actual something
       return number(1);
     }
@@ -973,6 +979,33 @@ const performOp = (scope, op, left, right, leftType, rightType, _global = false,
 };
 
 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);
+
+    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 ([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;
+  }
+
   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);
@@ -1279,7 +1312,7 @@ const getNodeType = (scope, node) => {
     }
 
     if (node.type === 'BinaryExpression') {
-      if (['==', '===', '!=', '!==', '>', '>=', '<', '<='].includes(node.operator)) return TYPES.boolean;
+      if (['==', '===', '!=', '!==', '>', '>=', '<', '<=', 'instanceof'].includes(node.operator)) return TYPES.boolean;
       if (node.operator !== '+') return TYPES.number;
 
       const knownLeft = knownType(scope, getNodeType(scope, node.left));
@@ -1312,7 +1345,7 @@ const getNodeType = (scope, node) => {
       const objectKnownType = knownType(scope, getNodeType(scope, node.object));
       if (objectKnownType != null) {
         if (name === 'length') {
-          if ([ TYPES.string, TYPES.bytestring, TYPES.array ].includes(objectKnownType)) return TYPES.number;
+          if (typeHasFlag(objectKnownType, TYPE_FLAGS.length)) return TYPES.number;
             else return TYPES.undefined;
         }
 
@@ -1424,6 +1457,18 @@ const generateExp = (scope, decl) => {
   return out;
 };
 
+const generateSequence = (scope, decl) => {
+  let out = [];
+
+  const exprs = decl.expressions;
+  for (let i = 0; i < exprs.length; i++) {
+    if (i > 0) disposeLeftover(out);
+    out.push(...generate(scope, exprs[i]));
+  }
+
+  return out;
+};
+
 const CTArrayUtil = {
   getLengthI32: pointer => [
     ...number(0, Valtype.i32),
@@ -2012,7 +2057,7 @@ const unhackName = name => {
 
 const knownType = (scope, type) => {
   if (type.length === 1 && type[0][0] === Opcodes.i32_const) {
-    return type[0][1];
+    return read_signedLEB128(type[0].slice(1));
   }
 
   if (typedInput && type.length === 1 && type[0][0] === Opcodes.local_get) {
@@ -2299,11 +2344,6 @@ 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`
-    return generate(scope, decl.right);
-  }
-
   if (isFuncType(decl.right.type)) {
     // hack for a = function () { ... }
     decl.right.id = { name };
@@ -2376,10 +2416,160 @@ const generateAssign = (scope, decl, _global, _name, valueUnused = false) => {
             [ Opcodes.i32_load8_u, 0, ValtypeSize.i32 + ValtypeSize[valtype] ]
           ], getNodeType(scope, decl.right), false, name, true)),
           [ Opcodes.local_tee, newValueTmp ],
-
           [ Opcodes.store, 0, ValtypeSize.i32 ]
         ],
 
+        ...wrapBC({
+          [TYPES.uint8array]: [
+            [ Opcodes.i32_add ],
+            ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+
+            ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+              [ Opcodes.local_get, pointerTmp ],
+              [ Opcodes.i32_load8_u, 0, 4 ],
+              Opcodes.i32_from_u
+            ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
+            [ Opcodes.local_tee, newValueTmp ],
+
+            Opcodes.i32_to_u,
+            [ Opcodes.i32_store8, 0, 4 ]
+          ],
+          [TYPES.uint8clampedarray]: [
+            [ Opcodes.i32_add ],
+            ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+
+            ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+              [ Opcodes.local_get, pointerTmp ],
+              [ Opcodes.i32_load8_u, 0, 4 ],
+              Opcodes.i32_from_u
+            ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
+            [ Opcodes.local_tee, newValueTmp ],
+
+            ...number(0),
+            [ Opcodes.f64_max ],
+            ...number(255),
+            [ Opcodes.f64_min ],
+            Opcodes.i32_to_u,
+            [ Opcodes.i32_store8, 0, 4 ]
+          ],
+          [TYPES.int8array]: [
+            [ Opcodes.i32_add ],
+            ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+
+            ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+              [ Opcodes.local_get, pointerTmp ],
+              [ Opcodes.i32_load8_s, 0, 4 ],
+              Opcodes.i32_from
+            ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
+            [ Opcodes.local_tee, newValueTmp ],
+
+            Opcodes.i32_to,
+            [ Opcodes.i32_store8, 0, 4 ]
+          ],
+          [TYPES.uint16array]: [
+            ...number(2, Valtype.i32),
+            [ Opcodes.i32_mul ],
+            [ Opcodes.i32_add ],
+            ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+
+            ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+              [ Opcodes.local_get, pointerTmp ],
+              [ Opcodes.i32_load16_u, 0, 4 ],
+              Opcodes.i32_from_u
+            ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
+            [ Opcodes.local_tee, newValueTmp ],
+
+            Opcodes.i32_to_u,
+            [ Opcodes.i32_store16, 0, 4 ]
+          ],
+          [TYPES.int16array]: [
+            ...number(2, Valtype.i32),
+            [ Opcodes.i32_mul ],
+            [ Opcodes.i32_add ],
+            ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+
+            ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+              [ Opcodes.local_get, pointerTmp ],
+              [ Opcodes.i32_load16_s, 0, 4 ],
+              Opcodes.i32_from
+            ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
+            [ Opcodes.local_tee, newValueTmp ],
+
+            Opcodes.i32_to,
+            [ Opcodes.i32_store16, 0, 4 ]
+          ],
+          [TYPES.uint32array]: [
+            ...number(4, Valtype.i32),
+            [ Opcodes.i32_mul ],
+            [ Opcodes.i32_add ],
+            ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+
+            ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+              [ Opcodes.local_get, pointerTmp ],
+              [ Opcodes.i32_load, 0, 4 ],
+              Opcodes.i32_from_u
+            ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
+            [ Opcodes.local_tee, newValueTmp ],
+
+            Opcodes.i32_to_u,
+            [ Opcodes.i32_store, 0, 4 ]
+          ],
+          [TYPES.int32array]: [
+            ...number(4, Valtype.i32),
+            [ Opcodes.i32_mul ],
+            [ Opcodes.i32_add ],
+            ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+
+            ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+              [ Opcodes.local_get, pointerTmp ],
+              [ Opcodes.i32_load, 0, 4 ],
+              Opcodes.i32_from
+            ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
+            [ Opcodes.local_tee, newValueTmp ],
+
+            Opcodes.i32_to,
+            [ Opcodes.i32_store, 0, 4 ]
+          ],
+          [TYPES.float32array]: [
+            ...number(4, Valtype.i32),
+            [ Opcodes.i32_mul ],
+            [ Opcodes.i32_add ],
+            ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+
+            ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+              [ Opcodes.local_get, pointerTmp ],
+              [ Opcodes.f32_load, 0, 4 ],
+              [ Opcodes.f64_promote_f32 ]
+            ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
+            [ Opcodes.local_tee, newValueTmp ],
+
+            [ Opcodes.f32_demote_f64 ],
+            [ Opcodes.f32_store, 0, 4 ]
+          ],
+          [TYPES.float64array]: [
+            ...number(8, Valtype.i32),
+            [ Opcodes.i32_mul ],
+            [ Opcodes.i32_add ],
+            ...(op === '=' ? [] : [ [ Opcodes.local_tee, pointerTmp ] ]),
+
+            ...(op === '=' ? generate(scope, decl.right) : performOp(scope, op, [
+              [ Opcodes.local_get, pointerTmp ],
+              [ Opcodes.f64_load, 0, 4 ]
+            ], generate(scope, decl.right), number(TYPES.number, Valtype.i32), getNodeType(scope, decl.right), false, name, true)),
+            [ Opcodes.local_tee, newValueTmp ],
+
+            [ Opcodes.f64_store, 0, 4 ]
+          ],
+        }, {
+          prelude: [
+            ...generate(scope, decl.left.object),
+            Opcodes.i32_to_u,
+            ...generate(scope, decl.left.property),
+            Opcodes.i32_to_u,
+          ],
+          postlude: setLastType(scope, TYPES.number)
+        }),
+
         default: internalThrow(scope, 'TypeError', `Cannot assign member with non-array`)
       }, Blocktype.void),
 
@@ -2957,6 +3147,7 @@ const generateForOf = (scope, decl) => {
       [ Opcodes.end ],
       [ Opcodes.end ]
     ],
+    // todo: typed arrays
     default: internalThrow(scope, 'TypeError', `Tried for..of on non-iterable type`)
   }, Blocktype.void));
 
@@ -3029,32 +3220,102 @@ const generateLabel = (scope, decl) => {
 const generateThrow = (scope, decl) => {
   scope.throws = true;
 
-  let message = decl.argument.value, constructor = null;
+  const exceptionMode = Prefs.exceptionMode ?? 'lut';
+  if (exceptionMode === 'lut') {
+    let message = decl.argument.value, constructor = null;
+
+    // support `throw (new)? Error(...)`
+    if (!message && (decl.argument.type === 'NewExpression' || decl.argument.type === 'CallExpression')) {
+      constructor = decl.argument.callee.name;
+      message = decl.argument.arguments[0]?.value ?? '';
+    }
+
+    if (tags.length === 0) tags.push({
+      params: [ Valtype.i32 ],
+      results: [],
+      idx: tags.length
+    });
+
+    let exceptId = exceptions.findIndex(x => x.constructor === constructor && x.message === message);
+    if (exceptId === -1) exceptId = exceptions.push({ constructor, message }) - 1;
+
+    scope.exceptions ??= [];
+    scope.exceptions.push(exceptId);
 
-  // hack: throw new X("...") -> throw "..."
-  if (!message && (decl.argument.type === 'NewExpression' || decl.argument.type === 'CallExpression')) {
-    constructor = decl.argument.callee.name;
-    message = decl.argument.arguments[0]?.value ?? '';
+    return [
+      ...number(exceptId, Valtype.i32),
+      [ Opcodes.throw, tags[0].idx ]
+    ];
   }
 
-  if (tags.length === 0) tags.push({
-    params: [ Valtype.i32 ],
-    results: [],
-    idx: tags.length
-  });
+  if (exceptionMode === 'stack') {
+    if (tags.length === 0) tags.push({
+      params: [ valtypeBinary, Valtype.i32 ],
+      results: [],
+      idx: tags.length
+    });
 
-  let exceptId = exceptions.push({ constructor, message }) - 1;
-  let tagIdx = tags[0].idx;
+    return [
+      ...generate(scope, decl.argument),
+      ...getNodeType(scope, decl.argument),
+      [ Opcodes.throw, tags[0].idx ]
+    ];
+  }
 
-  scope.exceptions ??= [];
-  scope.exceptions.push(exceptId);
+  if (exceptionMode === 'stackest') {
+    let message = decl.argument, constructor = null;
 
-  // todo: write a description of how this works lol
+    // support `throw (new)? Error(...)`
+    if (message.type === 'NewExpression' || message.type === 'CallExpression') {
+      constructor = decl.argument.callee;
+      message = decl.argument.arguments[0];
+    }
 
-  return [
-    [ Opcodes.i32_const, signedLEB128(exceptId) ],
-    [ Opcodes.throw, tagIdx ]
-  ];
+    message ??= DEFAULT_VALUE;
+
+    if (tags.length === 0) tags.push({
+      params: [ valtypeBinary, valtypeBinary, Valtype.i32 ],
+      results: [],
+      idx: tags.length
+    });
+
+    return [
+      ...(constructor == null ? number(-1) : generate(scope, constructor)),
+      ...generate(scope, message),
+      ...getNodeType(scope, message),
+      [ Opcodes.throw, tags[0].idx ]
+    ];
+  }
+
+  if (exceptionMode === 'partial') {
+    let message = decl.argument, constructor = null;
+
+    // support `throw (new)? Error(...)`
+    if (message.type === 'NewExpression' || message.type === 'CallExpression') {
+      constructor = decl.argument.callee.name;
+      message = decl.argument.arguments[0];
+    }
+
+    message ??= DEFAULT_VALUE;
+
+    if (tags.length === 0) tags.push({
+      params: [ Valtype.i32, valtypeBinary, Valtype.i32 ],
+      results: [],
+      idx: tags.length
+    });
+
+    let exceptId = exceptions.push({ constructor }) - 1;
+
+    scope.exceptions ??= [];
+    scope.exceptions.push(exceptId);
+
+    return [
+      ...number(exceptId, Valtype.i32),
+      ...generate(scope, message),
+      ...getNodeType(scope, message),
+      [ Opcodes.throw, tags[0].idx ]
+    ];
+  }
 };
 
 const generateTry = (scope, decl) => {
@@ -3407,6 +3668,19 @@ const withType = (scope, wasm, type) => [
   ...setLastType(scope, type)
 ];
 
+const wrapBC = (bc, { prelude = [], postlude = [] } = {}) => {
+  const out = {};
+  for (const x in bc) {
+    out[x] = [
+      ...prelude,
+      ...bc[x],
+      ...postlude
+    ];
+  }
+
+  return out;
+};
+
 const generateMember = (scope, decl, _global, _name) => {
   const name = decl.object.name;
 
@@ -3460,7 +3734,7 @@ const generateMember = (scope, decl, _global, _name) => {
     const type = getNodeType(scope, decl.object);
     const known = knownType(scope, type);
     if (known != null) {
-      if ([ TYPES.string, TYPES.bytestring, TYPES.array ].includes(known)) return [
+      if (typeHasFlag(known, TYPE_FLAGS.length)) return [
         ...generate(scope, decl.object),
         Opcodes.i32_to_u,
 
@@ -3472,7 +3746,9 @@ const generateMember = (scope, decl, _global, _name) => {
     }
 
     return [
-      ...typeIsOneOf(getNodeType(scope, decl.object), [ TYPES.string, TYPES.bytestring, TYPES.array ]),
+      ...getNodeType(scope, decl.object),
+      ...number(TYPE_FLAGS.length, Valtype.i32),
+      [ Opcodes.i32_and ],
       [ Opcodes.if, valtypeBinary ],
         ...generate(scope, decl.object),
         Opcodes.i32_to_u,
@@ -3521,7 +3797,9 @@ const generateMember = (scope, decl, _global, _name) => {
   // // todo: we should only do this for strings but we don't know at compile-time :(
   // hack: this is naughty and will break things!
   let newOut = number(0, Valtype.i32), newPointer = number(0, Valtype.i32);
-  if (pages.hasAnyString && knownType(scope, getNodeType(scope, decl.object)) !== TYPES.array) {
+
+  const known = knownType(scope, getNodeType(scope, decl.object));
+  if ((known === TYPES.string || known === TYPES.bytestring) || (pages.hasAnyString && known == null)) {
     // todo: we use i16 even for bytestrings which should not make a bad thing happen, just be confusing for debugging?
     0, [ newOut, newPointer ] = makeArray(scope, {
       rawElements: new Array(0)
@@ -3595,6 +3873,82 @@ const generateMember = (scope, decl, _global, _name) => {
       ...setLastType(scope, TYPES.bytestring)
     ],
 
+    ...wrapBC({
+      [TYPES.uint8array]: [
+        [ Opcodes.i32_add ],
+
+        [ Opcodes.i32_load8_u, 0, 4 ],
+        Opcodes.i32_from_u
+      ],
+      [TYPES.uint8clampedarray]: [
+        [ Opcodes.i32_add ],
+
+        [ Opcodes.i32_load8_u, 0, 4 ],
+        Opcodes.i32_from_u
+      ],
+      [TYPES.int8array]: [
+        [ Opcodes.i32_add ],
+
+        [ Opcodes.i32_load8_s, 0, 4 ],
+        Opcodes.i32_from
+      ],
+      [TYPES.uint16array]: [
+        ...number(2, Valtype.i32),
+        [ Opcodes.i32_mul ],
+        [ Opcodes.i32_add ],
+
+        [ Opcodes.i32_load16_u, 0, 4 ],
+        Opcodes.i32_from_u
+      ],
+      [TYPES.int16array]: [
+        ...number(2, Valtype.i32),
+        [ Opcodes.i32_mul ],
+        [ Opcodes.i32_add ],
+
+        [ Opcodes.i32_load16_s, 0, 4 ],
+        Opcodes.i32_from
+      ],
+      [TYPES.uint32array]: [
+        ...number(4, Valtype.i32),
+        [ Opcodes.i32_mul ],
+        [ Opcodes.i32_add ],
+
+        [ Opcodes.i32_load, 0, 4 ],
+        Opcodes.i32_from_u
+      ],
+      [TYPES.int32array]: [
+        ...number(4, Valtype.i32),
+        [ Opcodes.i32_mul ],
+        [ Opcodes.i32_add ],
+
+        [ Opcodes.i32_load, 0, 4 ],
+        Opcodes.i32_from
+      ],
+      [TYPES.float32array]: [
+        ...number(4, Valtype.i32),
+        [ Opcodes.i32_mul ],
+        [ Opcodes.i32_add ],
+
+        [ Opcodes.f32_load, 0, 4 ],
+        [ Opcodes.f64_promote_f32 ]
+      ],
+      [TYPES.float64array]: [
+        ...number(8, Valtype.i32),
+        [ Opcodes.i32_mul ],
+        [ Opcodes.i32_add ],
+
+        [ Opcodes.f64_load, 0, 4 ]
+      ],
+    }, {
+      prelude: [
+        ...object,
+        Opcodes.i32_to_u,
+        ...property,
+        Opcodes.i32_to_u
+      ],
+      postlude: setLastType(scope, TYPES.number)
+    }),
+
     default: internalThrow(scope, 'TypeError', 'Member expression is not supported for non-string non-array yet', true)
   });
 };
@@ -3772,7 +4126,7 @@ const internalConstrs = {
 
       // todo: check in wasm instead of here
       const literalValue = arg.value ?? 0;
-      if (literalValue < 0 || !Number.isFinite(literalValue) || literalValue > 4294967295) return internalThrow(scope, 'RangeThrow', 'Invalid array length', true);
+      if (literalValue < 0 || !Number.isFinite(literalValue) || literalValue > 4294967295) return internalThrow(scope, 'RangeError', 'Invalid array length', true);
 
       return [
         ...out,