Support for rest parameters in destructuring

Author: 0xe

rhino/src/main/java/org/mozilla/javascript/CodeGenerator.java

@@ -604,6 +604,49 @@ private void visitExpression(Node node, int contextFlags) {
                 stackChange(1);
                 break;
 
+            case Token.OBJECT_REST:
+                {
+                    // Handle object rest operation: {...rest} in destructuring
+                    visitExpression(child, 0); // source object
+                    Object[] excludedKeys = (Object[]) node.getProp(Node.OBJECT_IDS_PROP);
+
+                    // Count static vs computed keys and build static key indices array
+                    int computedKeyCount = 0;
+                    java.util.List<Integer> staticKeyIndices = new java.util.ArrayList<>();
+                    for (Object key : excludedKeys) {
+                        if (key instanceof Node) {
+                            computedKeyCount++;
+                        } else {
+                            String keyStr = key.toString();
+                            int keyIndex = strings.getOrDefault(keyStr, -1);
+                            if (keyIndex == -1) {
+                                keyIndex = strings.size();
+                                strings.put(keyStr, keyIndex);
+                            }
+                            staticKeyIndices.add(keyIndex);
+                        }
+                    }
+
+                    // Store static key indices in literalIds
+                    int staticKeysLiteralId = literalIds.size();
+                    int[] staticKeyArray = staticKeyIndices.stream().mapToInt(i -> i).toArray();
+                    literalIds.add(staticKeyArray);
+
+                    // Evaluate & push computed keys onto stack
+                    for (Object key : excludedKeys) {
+                        if (key instanceof Node) {
+                            visitExpression((Node) key, 0); // Evaluate computed key expression
+                        }
+                    }
+
+                    // Bytecode: [Icode_OBJECT_REST] [literalId:index] [computedKeyCount:uint8]
+                    addIndexOp(Icode_OBJECT_REST, staticKeysLiteralId);
+                    addUint8(computedKeyCount);
+
+                    stackChange(-computedKeyCount); // Computed keys removed from stack
+                }
+                break;
+
             case Token.REF_CALL:
             case Token.CALL:
             case Token.NEW:

rhino/src/main/java/org/mozilla/javascript/Icode.java

@@ -165,8 +165,11 @@ abstract class Icode {
             // spread
             Icode_SPREAD = Icode_DELPROP_SUPER - 1,
 
+            // object rest - create object excluding extracted keys
+            Icode_OBJECT_REST = Icode_SPREAD - 1,
+
             // Last icode
-            MIN_ICODE = Icode_SPREAD;
+            MIN_ICODE = Icode_OBJECT_REST;
 
     static String bytecodeName(int bytecode) {
         if (!validBytecode(bytecode)) {
@@ -358,6 +361,8 @@ static String bytecodeName(int bytecode) {
                 return "DELPROP_SUPER";
             case Icode_SPREAD:
                 return "SPREAD";
+            case Icode_OBJECT_REST:
+                return "OBJECT_REST";
         }
 
         // icode without name

rhino/src/main/java/org/mozilla/javascript/Interpreter.java

@@ -989,6 +989,27 @@ static <T extends ScriptOrFn<T>> void dumpICode(
                         out.println(tname + " \"" + str + '"');
                         break;
                     }
+                case Icode_OBJECT_REST:
+                    {
+                        // read key counts (static & computed)
+                        int staticKeyCount = getIndex(iCode, pc);
+                        pc += 2;
+                        int computedKeyCount = getIndex(iCode, pc);
+                        pc += 2;
+
+                        StringBuilder keys = new StringBuilder();
+                        keys.append("[static: ");
+                        for (int i = 0; i < staticKeyCount; i++) {
+                            if (i > 0) keys.append(", ");
+                            int keyIndex = getIndex(iCode, pc);
+                            pc += 2;
+                            keys.append("\"").append(strings[keyIndex]).append("\"");
+                        }
+                        keys.append("; computed: ").append(computedKeyCount).append("]");
+                        out.println(tname + " excluding " + keys);
+                        icodeLength = pc - old_pc;
+                        break;
+                    }
                 case Icode_REG_IND_C0:
                     indexReg = 0;
                     out.println(tname);
@@ -1727,6 +1748,7 @@ private abstract static class InstructionClass {
         instructionObjs[base + Icode_SCOPE_LOAD] = new DoScopeLoad();
         instructionObjs[base + Icode_SCOPE_SAVE] = new DoScopeSave();
         instructionObjs[base + Icode_SPREAD] = new DoSpread();
+        instructionObjs[base + Icode_OBJECT_REST] = new DoObjectRest();
         instructionObjs[base + Icode_CLOSURE_EXPR] = new DoClosureExpr();
         instructionObjs[base + Icode_METHOD_EXPR] = new DoMethodExpr();
         instructionObjs[base + Icode_CLOSURE_STMT] = new DoClosureStatement();
@@ -4478,6 +4500,46 @@ NewState execute(Context cx, CallFrame frame, InterpreterState state, int op) {
         }
     }
 
+    private static class DoObjectRest extends InstructionClass {
+        @Override
+        NewState execute(Context cx, CallFrame frame, InterpreterState state, int op) {
+            // indexReg contains the literalId for static key indices array
+            int computedKeyCount = frame.idata.itsICode[frame.pc++] & 0xFF;
+
+            // Get static key indices from literalIds using indexReg
+            int[] staticKeyIndices = (int[]) frame.idata.literalIds[state.indexReg];
+            int staticKeyCount = staticKeyIndices.length;
+
+            Object[] excludeKeys = new Object[staticKeyCount + computedKeyCount];
+
+            // Fill static keys from the strings table using stored indices
+            for (int i = 0; i < staticKeyCount; i++) {
+                excludeKeys[i] = frame.idata.itsStringTable[staticKeyIndices[i]];
+            }
+
+            // Pop computed keys from stack: [source, computed_key_1, ..., computed_key_N]
+            for (int i = computedKeyCount - 1; i >= 0; i--) {
+                Object computedKey = frame.stack[state.stackTop];
+                if (computedKey == DOUBLE_MARK) {
+                    computedKey = ScriptRuntime.wrapNumber(frame.sDbl[state.stackTop]);
+                }
+                excludeKeys[staticKeyCount + i] = ScriptRuntime.toString(computedKey);
+                state.stackTop--;
+            }
+
+            Object source = frame.stack[state.stackTop];
+            if (source == DOUBLE_MARK) {
+                source = ScriptRuntime.wrapNumber(frame.sDbl[state.stackTop]);
+            }
+
+            // Create rest object
+            Scriptable result = ScriptRuntime.doObjectRest(cx, frame.scope, source, excludeKeys);
+
+            frame.stack[state.stackTop] = result;
+            return null;
+        }
+    }
+
     private static class DoObjectLit extends InstructionClass {
         @Override
         NewState execute(Context cx, CallFrame frame, InterpreterState state, int op) {

rhino/src/main/java/org/mozilla/javascript/Node.java

@@ -69,7 +69,8 @@ public class Node implements Iterable<Node> {
             OPTIONAL_CHAINING = 30,
             SUPER_PROPERTY_ACCESS = 31,
             NUMBER_OF_SPREAD = 32,
-            LAST_PROP = NUMBER_OF_SPREAD,
+            OBJECT_REST_PROP = 33, // marks a CALL node as object rest operation
+            LAST_PROP = OBJECT_REST_PROP,
             FIRST_PROP = FUNCTION_PROP;
 
     // values of ISNUMBER_PROP to specify
@@ -457,6 +458,8 @@ static String propName(int propType) {
                 return "super_property_access";
             case NUMBER_OF_SPREAD:
                 return "number_of_spread";
+            case OBJECT_REST_PROP:
+                return "object_rest_prop";
 
             default:
                 Kit.codeBug();