ugaemi
diff --git a/‎bytecode/src/bytecode.rs‎
Lines changed: 4 additions & 0 deletions b/‎bytecode/src/bytecode.rs‎
Lines changed: 4 additions & 0 deletions
diff --git a/‎compiler/src/peephole.rs‎
Lines changed: 38 additions & 20 deletions b/‎compiler/src/peephole.rs‎
Lines changed: 38 additions & 20 deletions
diff --git a/‎vm/src/frame.rs‎
Lines changed: 10 additions & 10 deletions b/‎vm/src/frame.rs‎
Lines changed: 10 additions & 10 deletions
@@ -219,6 +219,9 @@ pub enum Instruction {
         spec: String,
     },
     PopException,
+    Reverse {
+        amount: usize,
+    },
 }
 
 use self::Instruction::*;
@@ -438,6 +441,7 @@ impl Instruction {
             Unpack => w!(Unpack),
             FormatValue { spec, .. } => w!(FormatValue, spec), // TODO: write conversion
             PopException => w!(PopException),
+            Reverse { amount } => w!(Reverse, amount),
         }
     }
 }
 
@@ -10,8 +10,8 @@ struct InstructionMetadata {
     labels: Vec<Label>,
 }
 
-impl InstructionMetadata {
-    fn from_multiple(metas: Vec<Self>) -> Self {
+impl From<Vec<InstructionMetadata>> for InstructionMetadata {
+    fn from(metas: Vec<Self>) -> Self {
         debug_assert!(!metas.is_empty(), "`metas` must not be empty");
         InstructionMetadata {
             loc: metas[0].loc.clone(),
@@ -69,28 +69,28 @@ impl<O: OutputStream> PeepholeOptimizer<O> {
     }
 
     fn optimize(&mut self, instruction: Instruction, meta: InstructionMetadata) {
+        macro_rules! lc {
+            ($name:ident {$($field:tt)*}) => {
+                Instruction::LoadConst {
+                    value: bytecode::Constant::$name {$($field)*},
+                }
+            };
+            ($name:ident, $($value:tt)*) => {
+                lc!($name { value: $($value)* })
+            };
+        }
+        macro_rules! emitconst {
+            ([$($metas:expr),*], $($arg:tt)*) => {
+                self.emit(
+                    lc!($($arg)*),
+                    InstructionMetadata::from(vec![$($metas),*]),
+                )
+            };
+        }
         match instruction {
             Instruction::BinaryOperation { op, inplace } => {
                 let (rhs, rhs_meta) = self.pop();
                 let (lhs, lhs_meta) = self.pop();
-                macro_rules! lc {
-                    ($name:ident {$($field:tt)*}) => {
-                        Instruction::LoadConst {
-                            value: bytecode::Constant::$name {$($field)*},
-                        }
-                    };
-                    ($name:ident, $($value:tt)*) => {
-                        lc!($name { value: $($value)* })
-                    };
-                }
-                macro_rules! emitconst {
-                    ([$($metas:expr),*], $($arg:tt)*) => {
-                        self.emit(
-                            lc!($($arg)*),
-                            InstructionMetadata::from_multiple(vec![$($metas),*]),
-                        )
-                    };
-                }
                 macro_rules! op {
                     ($op:ident) => {
                         bytecode::BinaryOperator::$op
@@ -129,6 +129,24 @@ impl<O: OutputStream> PeepholeOptimizer<O> {
                     }
                 }
             }
+            Instruction::UnpackSequence { size } => {
+                let (arg, arg_meta) = self.pop();
+                match arg {
+                    Instruction::BuildTuple {
+                        size: tup_size,
+                        unpack,
+                    } if !unpack && tup_size == size => {
+                        self.emit(
+                            Instruction::Reverse { amount: size },
+                            vec![arg_meta, meta].into(),
+                        );
+                    }
+                    arg => {
+                        self.emit(arg, arg_meta);
+                        self.emit(instruction, meta);
+                    }
+                }
+            }
             other => self.emit(other, meta),
         }
     }
 
@@ -662,6 +662,12 @@ impl Frame {
                     panic!("Block type must be ExceptHandler here.")
                 }
             }
+            bytecode::Instruction::Reverse { amount } => {
+                let mut stack = self.stack.borrow_mut();
+                let stack_len = stack.len();
+                stack[stack_len - amount..stack_len].reverse();
+                Ok(None)
+            }
         }
     }
 
@@ -676,10 +682,7 @@ impl Frame {
         if unpack {
             let mut result: Vec<PyObjectRef> = vec![];
             for element in elements {
-                let expanded = vm.extract_elements(&element)?;
-                for inner in expanded {
-                    result.push(inner);
-                }
+                result.extend(vm.extract_elements(&element)?);
             }
             Ok(result)
         } else {
@@ -1170,12 +1173,9 @@ impl Frame {
     }
 
     fn pop_multiple(&self, count: usize) -> Vec<PyObjectRef> {
-        let mut objs: Vec<PyObjectRef> = Vec::new();
-        for _x in 0..count {
-            objs.push(self.pop_value());
-        }
-        objs.reverse();
-        objs
+        let mut stack = self.stack.borrow_mut();
+        let stack_len = stack.len();
+        stack.drain(stack_len - count..stack_len).collect()
     }
 
     fn last_value(&self) -> PyObjectRef {
Original file line number	Diff line number	Diff line change
`@@ -219,6 +219,9 @@ pub enum Instruction {`
`219`	`219`	`spec: String,`
`220`	`220`	`},`
`221`	`221`	`PopException,`
	`222`	`+ Reverse {`
	`223`	`+ amount: usize,`
	`224`	`+ },`
`222`	`225`	`}`
`223`	`226`
`224`	`227`	`use self::Instruction::*;`
`@@ -438,6 +441,7 @@ impl Instruction {`
`438`	`441`	`Unpack => w!(Unpack),`
`439`	`442`	`FormatValue { spec, .. } => w!(FormatValue, spec), // TODO: write conversion`
`440`	`443`	`PopException => w!(PopException),`
	`444`	`+ Reverse { amount } => w!(Reverse, amount),`
`441`	`445`	`}`
`442`	`446`	`}`
`443`	`447`	`}`
Original file line number	Diff line number	Diff line change
`@@ -662,6 +662,12 @@ impl Frame {`
`662`	`662`	`panic!("Block type must be ExceptHandler here.")`
`663`	`663`	`}`
`664`	`664`	`}`
	`665`	`+ bytecode::Instruction::Reverse { amount } => {`
	`666`	`+ let mut stack = self.stack.borrow_mut();`
	`667`	`+ let stack_len = stack.len();`
	`668`	`+ stack[stack_len - amount..stack_len].reverse();`
	`669`	`+ Ok(None)`
	`670`	`+ }`
`665`	`671`	`}`
`666`	`672`	`}`
`667`	`673`
`@@ -676,10 +682,7 @@ impl Frame {`
`676`	`682`	`if unpack {`
`677`	`683`	`let mut result: Vec<PyObjectRef> = vec![];`
`678`	`684`	`for element in elements {`
`679`		`- let expanded = vm.extract_elements(&element)?;`
`680`		`- for inner in expanded {`
`681`		`- result.push(inner);`
`682`		`- }`
	`685`	`+ result.extend(vm.extract_elements(&element)?);`
`683`	`686`	`}`
`684`	`687`	`Ok(result)`
`685`	`688`	`} else {`
`@@ -1170,12 +1173,9 @@ impl Frame {`
`1170`	`1173`	`}`
`1171`	`1174`
`1172`	`1175`	`fn pop_multiple(&self, count: usize) -> Vec<PyObjectRef> {`
`1173`		`- let mut objs: Vec<PyObjectRef> = Vec::new();`
`1174`		`- for _x in 0..count {`
`1175`		`- objs.push(self.pop_value());`
`1176`		`- }`
`1177`		`- objs.reverse();`
`1178`		`- objs`
	`1176`	`+ let mut stack = self.stack.borrow_mut();`
	`1177`	`+ let stack_len = stack.len();`
	`1178`	`+ stack.drain(stack_len - count..stack_len).collect()`
`1179`	`1179`	`}`
`1180`	`1180`
`1181`	`1181`	`fn last_value(&self) -> PyObjectRef {`