array patterns

samples/array_pattern.tri

···
+proc main!() {
+    let x = [1, 2, 3, 4, 5];
+    let [1, ..y] = x;
+    let [..z, 5] = x;
+    let [1, ..m, 5] = x;
+    exit [..y, ..m, ..z];
+}

trilogy-codegen/src/pattern_match.rs

···
                     .unwrap();
                 write_pattern(context, rhs, on_fail);
             }
-            (Some(ir::Value::Builtin(Builtin::Array)), ..) => todo!(),
-            (Some(ir::Value::Builtin(Builtin::Record)), ..) => todo!(),
-            (Some(ir::Value::Builtin(Builtin::Set)), ..) => todo!(),
+            (None, ir::Value::Builtin(Builtin::Array), ir::Value::Pack(pack)) => {
+                let cleanup = context.labeler.unique_hint("array_cleanup");
+                let end = context.labeler.unique_hint("array_end");
+                let mut spread = None;
+                context.write_instruction(Instruction::Clone);
+                for element in &pack.values {
+                    if element.is_spread {
+                        spread = Some(&element.expression);
+                        continue;
+                    }
+                    // TODO: this could be way more efficient
+                    if spread.is_none() {
+                        context
+                            .write_instruction(Instruction::Copy)
+                            .write_instruction(Instruction::Const(0.into()))
+                            .write_instruction(Instruction::Access);
+                        write_pattern_match(context, &element.expression, &cleanup);
+                        context
+                            .write_instruction(Instruction::Const(1.into()))
+                            .write_instruction(Instruction::Skip);
+                    } else {
+                        context
+                            .write_instruction(Instruction::Copy)
+                            .write_instruction(Instruction::Length)
+                            .write_instruction(Instruction::Const(1.into()))
+                            .write_instruction(Instruction::Subtract)
+                            .write_instruction(Instruction::LoadRegister(1))
+                            .write_instruction(Instruction::LoadRegister(1))
+                            .write_instruction(Instruction::Access);
+                        write_pattern_match(context, &element.expression, &cleanup);
+                        context.write_instruction(Instruction::Take);
+                    }
+                }
+                if let Some(spread) = spread {
+                    write_pattern_match(context, spread, on_fail);
+                } else {
+                    context.write_instruction(Instruction::Pop);
+                }
+                context
+                    .jump(&end)
+                    .write_label(cleanup)
+                    .unwrap()
+                    .write_instruction(Instruction::Pop)
+                    .write_instruction(Instruction::Pop)
+                    .jump(on_fail)
+                    .write_label(end)
+                    .unwrap();
+            }
+            (None, ir::Value::Builtin(Builtin::Record), ..) => todo!(),
+            (None, ir::Value::Builtin(Builtin::Set), ..) => todo!(),
             what => panic!("not a pattern ({what:?})"),
         },
         ir::Value::Dynamic(dynamic) => {

trilogy-codegen/tests/samples.rs

···
         Value::from("worldworld")
     );
 }
+
+#[test]
+fn sample_array_pattern() {
+    let program = include_tri!("array_pattern.tri");
+    assert!(StructuralEq::eq(
+        &VirtualMachine::load(program).run().unwrap(),
+        &Value::from(vec![
+            Value::from(2),
+            3.into(),
+            4.into(),
+            5.into(),
+            2.into(),
+            3.into(),
+            4.into(),
+            1.into(),
+            2.into(),
+            3.into(),
+            4.into(),
+        ])
+    ));
+}

trilogy-vm/src/vm/virtual_machine.rs

···
                     ex.stack_push(value);
                 }
                 OpCode::Clone => {
-                    let value = ex.read_register(0)?;
+                    let value = ex.stack_pop()?;
                     ex.stack_push(value.structural_clone());
                 }
                 OpCode::TypeOf => {