@@ -710,27 +710,28 @@ impl ExecutingFrame<'_> {
710710 self . push_value ( list_obj. into ( ) ) ;
711711 Ok ( None )
712712 }
713- bytecode:: Instruction :: BuildListUnpack { size } => {
714- let elements = self . unpack_elements ( vm, size. get ( arg) as usize ) ?;
713+ bytecode:: Instruction :: BuildListFromTuples { size } => {
714+ // SAFETY: compiler guarantees `size` tuples are on the stack
715+ let elements = unsafe { self . flatten_tuples ( size. get ( arg) as usize ) } ;
715716 let list_obj = vm. ctx . new_list ( elements) ;
716717 self . push_value ( list_obj. into ( ) ) ;
717718 Ok ( None )
718719 }
719720 bytecode:: Instruction :: BuildSet { size } => {
720721 let set = PySet :: new_ref ( & vm. ctx ) ;
721- {
722- for element in self . pop_multiple ( size. get ( arg) as usize ) {
723- set. add ( element, vm) ?;
724- }
722+ for element in self . pop_multiple ( size. get ( arg) as usize ) {
723+ set. add ( element, vm) ?;
725724 }
726725 self . push_value ( set. into ( ) ) ;
727726 Ok ( None )
728727 }
729- bytecode:: Instruction :: BuildSetUnpack { size } => {
728+ bytecode:: Instruction :: BuildSetFromTuples { size } => {
730729 let set = PySet :: new_ref ( & vm. ctx ) ;
731- {
732- for element in self . pop_multiple ( size. get ( arg) as usize ) {
733- vm. map_iterable_object ( & element, |x| set. add ( x, vm) ) ??;
730+ for element in self . pop_multiple ( size. get ( arg) as usize ) {
731+ // SAFETY: trust compiler
732+ let tup = unsafe { element. downcast_unchecked :: < PyTuple > ( ) } ;
733+ for item in tup. iter ( ) {
734+ set. add ( item. clone ( ) , vm) ?;
734735 }
735736 }
736737 self . push_value ( set. into ( ) ) ;
@@ -742,12 +743,21 @@ impl ExecutingFrame<'_> {
742743 self . push_value ( list_obj. into ( ) ) ;
743744 Ok ( None )
744745 }
745- bytecode:: Instruction :: BuildTupleUnpack { size } => {
746- let elements = self . unpack_elements ( vm, size. get ( arg) as usize ) ?;
746+ bytecode:: Instruction :: BuildTupleFromTuples { size } => {
747+ // SAFETY: compiler guarantees `size` tuples are on the stack
748+ let elements = unsafe { self . flatten_tuples ( size. get ( arg) as usize ) } ;
747749 let list_obj = vm. ctx . new_tuple ( elements) ;
748750 self . push_value ( list_obj. into ( ) ) ;
749751 Ok ( None )
750752 }
753+ bytecode:: Instruction :: BuildTupleFromIter => {
754+ if !self . top_value ( ) . class ( ) . is ( vm. ctx . types . tuple_type ) {
755+ let elements: Vec < _ > = self . pop_value ( ) . try_to_value ( vm) ?;
756+ let list_obj = vm. ctx . new_tuple ( elements) ;
757+ self . push_value ( list_obj. into ( ) ) ;
758+ }
759+ Ok ( None )
760+ }
751761 bytecode:: Instruction :: BuildMap { size } => self . execute_build_map ( vm, size. get ( arg) ) ,
752762 bytecode:: Instruction :: BuildMapForCall { size } => {
753763 self . execute_build_map_for_call ( vm, size. get ( arg) )
@@ -1234,14 +1244,14 @@ impl ExecutingFrame<'_> {
12341244 } )
12351245 }
12361246
1237- # [ cfg_attr ( feature = "flame-it" , flame ( "Frame" ) ) ]
1238- fn unpack_elements ( & mut self , vm : & VirtualMachine , size : usize ) -> PyResult < Vec < PyObjectRef > > {
1239- let mut result = Vec :: < PyObjectRef > :: new ( ) ;
1240- for element in self . pop_multiple ( size ) {
1241- let items : Vec < _ > = element . try_to_value ( vm ) ? ;
1242- result . extend ( items ) ;
1247+ unsafe fn flatten_tuples ( & mut self , size : usize ) -> Vec < PyObjectRef > {
1248+ let mut elements = Vec :: new ( ) ;
1249+ for tup in self . pop_multiple ( size ) {
1250+ // SAFETY: caller ensures that the elements are tuples
1251+ let tup = unsafe { tup . downcast_unchecked :: < PyTuple > ( ) } ;
1252+ elements . extend ( tup . iter ( ) . cloned ( ) ) ;
12431253 }
1244- Ok ( result )
1254+ elements
12451255 }
12461256
12471257 #[ cfg_attr( feature = "flame-it" , flame( "Frame" ) ) ]
@@ -1490,8 +1500,10 @@ impl ExecutingFrame<'_> {
14901500 } else {
14911501 IndexMap :: new ( )
14921502 } ;
1493- let args = self . pop_value ( ) ;
1494- let args = args. try_to_value ( vm) ?;
1503+ // SAFETY: trust compiler
1504+ let args = unsafe { self . pop_value ( ) . downcast_unchecked :: < PyTuple > ( ) }
1505+ . as_slice ( )
1506+ . to_vec ( ) ;
14951507 Ok ( FuncArgs { args, kwargs } )
14961508 }
14971509
0 commit comments