porffor 0.17.0-c2dd8f88f → 0.17.0-cbb73d209

package/compiler/codegen.js

@@ -2083,12 +2083,24 @@ const generateCall = (scope, decl, _global, _name, unusedValue = false) => {
   } else if (decl._new)
     return internalThrow(scope, 'TypeError', `${unhackName(name)} is not a constructor`, true);
 
-  let args = decl.arguments;
-  if (func && args.length < paramCount) {
+  let args = [...decl.arguments];
+  if (func && !func.hasRestArgument && args.length < paramCount) {
     // too little args, push undefineds
     args = args.concat(new Array(paramCount - args.length).fill(DEFAULT_VALUE));
   }
 
+  if (func && func.hasRestArgument) {
+    if (args.length < paramCount) {
+      args = args.concat(new Array(paramCount - 1 - args.length).fill(DEFAULT_VALUE));
+    } 
+    const restArgs = args.slice(paramCount - 1);
+    args = args.slice(0, paramCount - 1);
+    args.push({
+      type: 'ArrayExpression',
+      elements: restArgs
+    })
+  }
+
   if (func && args.length > paramCount) {
     // too many args, slice extras off
     args = args.slice(0, paramCount);
@@ -2403,9 +2415,120 @@ const generateVar = (scope, decl) => {
   const global = topLevel || decl._bare;
 
   for (const x of decl.declarations) {
-    const name = mapName(x.id.name);
+    if (x.id.type === 'ArrayPattern') {
+      const decls = [];
+      const tmpName = '#destructure' + randId();
+
+      let i = 0;
+      const elements = [...x.id.elements];
+      for (const e of elements) {
+        switch (e?.type) {
+          case 'RestElement': { // let [ ...foo ] = []
+            if (e.argument.type === 'ArrayPattern') {
+              // let [ ...[a, b, c] ] = []
+              elements.push(...e.argument.elements);
+            } else {
+              decls.push({
+                type: 'VariableDeclarator',
+                id: { type: 'Identifier', name: e.argument.name },
+                init: {
+                  type: 'CallExpression',
+                  callee: {
+                    type: 'Identifier',
+                    name: '__Array_prototype_slice'
+                  },
+                  arguments: [
+                    { type: 'Identifier', name: tmpName },
+                    { type: 'Literal', value: i },
+                    {
+                      type: 'MemberExpression',
+                      object: { type: 'Identifier', name: tmpName, },
+                      property: { type: 'Identifier', name: 'length', }
+                    }
+                  ]
+                }
+              });
+            }
+
+            continue; // skip i++
+          }
+
+          case 'Identifier': { // let [ foo ] = []
+            decls.push({
+              type: 'VariableDeclarator',
+              id: e,
+              init: {
+                type: 'MemberExpression',
+                object: { type: 'Identifier', name: tmpName },
+                property: { type: 'Literal', value: i }
+              }
+            });
 
-    if (!name) return todo(scope, 'destructuring is not supported yet');
+            break;
+          }
+
+          case 'AssignmentPattern': { // let [ foo = defaultValue ] = []
+            decls.push({
+              type: 'VariableDeclarator',
+              id: e.left,
+              init: {
+                type: 'LogicalExpression',
+                operator: '??',
+                left: {
+                  type: 'MemberExpression',
+                  object: { type: 'Identifier', name: tmpName },
+                  property: { type: 'Literal', value: i }
+                },
+                right: e.right
+              }
+            });
+
+            break;
+          }
+
+          case 'ArrayPattern': { // let [ [ foo, bar ] ] = []
+            decls.push({
+              type: 'VariableDeclarator',
+              id: e,
+              init: {
+                type: 'MemberExpression',
+                object: { type: 'Identifier', name: tmpName },
+                property: { type: 'Literal', value: i }
+              }
+            });
+
+            break;
+          }
+
+          case 'ObjectPattern':
+            return todo(scope, 'object destructuring is not supported yet')
+        }
+
+        i++;
+      }
+
+      out = out.concat([
+        ...generateVar(scope, {
+          type: 'VariableDeclaration',
+          declarations: [{
+            type: 'VariableDeclarator',
+            id: { type: 'Identifier', name: tmpName },
+            init: x.init
+          }],
+          kind: decl.kind
+        }),
+        ...generateVar(scope, {
+          type: 'VariableDeclaration',
+          declarations: decls,
+          kind: decl.kind
+        })
+      ]);
+
+      continue;
+    }
+
+    const name = mapName(x.id.name);
+    if (!name) return todo(scope, 'object destructuring is not supported yet')
 
     if (x.init && isFuncType(x.init.type)) {
       // hack for let a = function () { ... }
@@ -2440,7 +2563,9 @@ const generateVar = (scope, decl) => {
         // hack to set local as pointer before
         out.push(...number(scope.arrays.get(name)), [ global ? Opcodes.global_set : Opcodes.local_set, idx ]);
         if (generated.at(-1) == Opcodes.i32_from_u) generated.pop();
-        generated.pop();
+        // generated.pop();
+        generated.push([ Opcodes.drop ]);
+
         out = out.concat(generated);
       } else {
         out = out.concat(generated);
@@ -4277,6 +4402,12 @@ const generateFunc = (scope, decl) => {
         defaultValues[name] = x.right;
         break;
       }
+      
+      case 'RestElement': {
+        name = x.argument.name;
+        func.hasRestArgument = true;
+        break;
+      }
     }
 
     // if (name == null) return todo('non-identifier args are not supported');

package/compiler/opt.js

@@ -203,6 +203,9 @@ export default (funcs, globals, pages, tags, exceptions) => {
           if (type === 'Array') missing = !pages.hasArray;
           if (type === 'String') missing = !pages.hasString;
           if (type === 'ByteString') missing = !pages.hasByteString;
+          if (['Set', 'Uint8Array', 'Int8Array', 'Uint8ClampedArray', 'Uint16Array', 'Int16Array', 'Uint32Array', 'Int32Array', 'Float32Array', 'Float64Array'].includes(type)) {
+            missing = funcs.find(x => x.name === type) == null;
+          }
 
           if (missing) {
             let j = i, depth = 0;

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.17.0-c2dd8f88f",
+  "version": "0.17.0-cbb73d209",
   "author": "CanadaHonk",
   "license": "MIT",
   "scripts": {},