rest params

Author: alii

src/arc/compiler/emit.gleam

@@ -9,7 +9,7 @@ import arc/vm/opcode.{
   IrArraySpread, IrAsyncYieldStarNext, IrAsyncYieldStarResume, IrAwait, IrBinOp,
   IrCallApply, IrCallConstructor, IrCallConstructorApply, IrCallMethod,
   IrCallMethodApply, IrCallSuper, IrCallSuperApply, IrCreateArguments,
-  IrDeclareGlobalLex, IrDeclareGlobalVar, IrDefineAccessor,
+  IrCreateRestArray, IrDeclareGlobalLex, IrDeclareGlobalVar, IrDefineAccessor,
   IrDefineAccessorComputed, IrDefineField, IrDefineFieldComputed, IrDefineMethod,
   IrDefineMethodComputed, IrDeleteElem, IrDeleteField, IrDup, IrForInNext,
   IrForInStart, IrGetAsyncIterator, IrGetElem, IrGetElem2, IrGetField,
@@ -1300,6 +1300,18 @@ fn class_body_references_arguments(body: List(ast.ClassElement)) -> Bool {
   })
 }
 
+/// Split off a trailing rest parameter. Returns the fixed params (in order)
+/// and the rest target pattern (the binding inside `...`), if present. A rest
+/// element is only valid as the last parameter, so we only check the tail.
+fn split_trailing_rest(
+  params: List(ast.Pattern),
+) -> #(List(ast.Pattern), Option(ast.Pattern)) {
+  case list.reverse(params) {
+    [ast.RestElement(inner), ..rev_fixed] -> #(list.reverse(rev_fixed), Some(inner))
+    _ -> #(params, None)
+  }
+}
+
 /// Compile a function body into a CompiledChild.
 fn compile_function_body(
   parent: Emitter,
@@ -1342,9 +1354,17 @@ fn compile_function_body(
     False -> emit_op(e, DeclareThis)
   }
 
+  // A trailing rest parameter (`...rest`) is bound separately from the fixed
+  // params: the fixed ones bind positionally (arity counts only them, so
+  // build_locals leaves the rest slot undefined), then IrCreateRestArray
+  // collects the leftover args into an Array. `arity` excludes the rest param,
+  // which also gives the correct `fn.length` (§15.1.5).
+  let #(fixed_params, rest_param) = split_trailing_rest(params)
+  let arity = list.length(fixed_params)
+
   // Phase 1: Declare parameters (identifier or synthetic for destructuring)
   let #(e, destructured_params_rev) =
-    list.index_fold(params, #(e, []), fn(acc, param, idx) {
+    list.index_fold(fixed_params, #(e, []), fn(acc, param, idx) {
       let #(e, destr) = acc
       case param {
         ast.IdentifierPattern(pname) -> #(
@@ -1393,6 +1413,17 @@ fn compile_function_body(
       emit_destructuring_bind(e, pattern, LetBinding) |> result.unwrap(e)
     })
 
+  // Phase 2b: Bind the trailing rest parameter, if any. Build the array from
+  // the args at `arity` and beyond, then bind it (an identifier, or a nested
+  // destructuring target like `...[a, b]`). ParamBinding declares the slot.
+  let e = case rest_param {
+    None -> e
+    Some(rest_target) -> {
+      let e = emit_ir(e, IrCreateRestArray(arity))
+      emit_destructuring_bind(e, rest_target, ParamBinding) |> result.unwrap(e)
+    }
+  }
+
   // Hoisting for the function body
   let hoisted_vars = collect_hoisted_vars(stmts)
   let lex_names = collect_top_lex_names(stmts)
@@ -1442,7 +1473,7 @@ fn compile_function_body(
 
   CompiledChild(
     name:,
-    arity: list.length(params),
+    arity:,
     code:,
     constants:,
     constants_map:,

src/arc/compiler/resolve.gleam

@@ -10,7 +10,8 @@ import arc/vm/opcode.{
   IrArrayPushHole, IrArraySpread, IrAsyncYieldStarNext, IrAsyncYieldStarResume,
   IrAwait, IrBinOp, IrBoxLocal, IrCall, IrCallApply, IrCallConstructor,
   IrCallConstructorApply, IrCallEval, IrCallMethod, IrCallMethodApply,
-  IrCallSuper, IrCallSuperApply, IrCreateArguments, IrDeclareEvalVar,
+  IrCallSuper, IrCallSuperApply, IrCreateArguments, IrCreateRestArray,
+  IrDeclareEvalVar,
   IrDeclareGlobalLex, IrDeclareGlobalVar, IrDefineAccessor,
   IrDefineAccessorComputed, IrDefineField, IrDefineFieldComputed, IrDefineMethod,
   IrDefineMethodComputed, IrDeleteElem, IrDeleteField, IrDup, IrForInNext,
@@ -310,6 +311,9 @@ fn resolve_ops(
     [IrCreateArguments, ..rest] ->
       resolve_ops(rest, labels, [opcode.CreateArguments, ..acc])
 
+    [IrCreateRestArray(from_index), ..rest] ->
+      resolve_ops(rest, labels, [opcode.CreateRestArray(from_index), ..acc])
+
     // RegExp
     [IrNewRegExp, ..rest] ->
       resolve_ops(rest, labels, [opcode.NewRegExp, ..acc])

src/arc/vm/exec/interpreter.gleam

@@ -17,7 +17,8 @@ import arc/vm/opcode.{
   type Op, Add, ArrayFrom, ArrayFromWithHoles, ArrayPush, ArrayPushHole,
   ArraySpread, AsyncYieldStarNext, AsyncYieldStarResume, Await, BinOp, BoxLocal,
   Call, CallApply, CallConstructor, CallConstructorApply, CallEval, CallMethod,
-  CallMethodApply, CallSuper, CallSuperApply, CreateArguments, DeclareEvalVar,
+  CallMethodApply, CallSuper, CallSuperApply, CreateArguments, CreateRestArray,
+  DeclareEvalVar,
   DeclareGlobalLex, DeclareGlobalVar, DefineAccessor, DefineAccessorComputed,
   DefineField, DefineFieldComputed, DefineMethod, DefineMethodComputed,
   DeleteElem, DeleteField, Dup, ForInNext, ForInStart, GetAsyncIterator,
@@ -2738,6 +2739,22 @@ fn step(state: State, op: Op) -> Result(State, #(StepResult, JsValue, State)) {
       )
     }
 
+    CreateRestArray(from_index) -> {
+      // §10.4.4 rest parameter: a plain Array of the call args from
+      // `from_index` onward (the params before the rest are bound positionally).
+      let rest_args = list.drop(state.call_args, from_index)
+      let #(heap, ref) =
+        common.alloc_array(state.heap, rest_args, state.builtins.array.prototype)
+      Ok(
+        State(
+          ..state,
+          heap:,
+          stack: [JsObject(ref), ..state.stack],
+          pc: state.pc + 1,
+        ),
+      )
+    }
+
     // -- RegExp literal --
     NewRegExp -> {
       case state.stack {

src/arc/vm/opcode.gleam

@@ -204,6 +204,11 @@ pub type Op {
   /// Reads state.call_args, allocates ArgumentsObject, pushes ref onto stack.
   CreateArguments
 
+  /// Create a rest-parameter array from the current call's args, taking those
+  /// at index `from_index` and beyond. Reads state.call_args, allocates a plain
+  /// Array, pushes ref onto stack.
+  CreateRestArray(from_index: Int)
+
   // -- RegExp --
   /// Pop flags string, pop pattern string -> push new RegExp object.
   NewRegExp
@@ -371,6 +376,7 @@ pub type IrOp {
   IrAsyncYieldStarResume(next_label: Int)
   IrAwait
   IrCreateArguments
+  IrCreateRestArray(from_index: Int)
   IrNewRegExp
 
   // -- Global Environment Record --