sthagen
diff --git a/‎vm/src/obj/objdict.rs‎
Lines changed: 9 additions & 9 deletions b/‎vm/src/obj/objdict.rs‎
Lines changed: 9 additions & 9 deletions
diff --git a/‎vm/src/obj/objobject.rs‎
Lines changed: 1 addition & 1 deletion b/‎vm/src/obj/objobject.rs‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎vm/src/stdlib/json.rs‎
Lines changed: 1 addition & 1 deletion b/‎vm/src/stdlib/json.rs‎
Lines changed: 1 addition & 1 deletion
@@ -237,34 +237,34 @@ impl ItemProtocol for PyDictRef {
 // Implement IntoIterator so that we can easily iterate dictionaries from rust code.
 impl IntoIterator for PyDictRef {
     type Item = (PyObjectRef, PyObjectRef);
-    type IntoIter = DictIterator;
+    type IntoIter = DictIter;
 
     fn into_iter(self) -> Self::IntoIter {
-        DictIterator::new(self)
+        DictIter::new(self)
     }
 }
 
 impl IntoIterator for &PyDictRef {
     type Item = (PyObjectRef, PyObjectRef);
-    type IntoIter = DictIterator;
+    type IntoIter = DictIter;
 
     fn into_iter(self) -> Self::IntoIter {
-        DictIterator::new(self.clone())
+        DictIter::new(self.clone())
     }
 }
 
-pub struct DictIterator {
+pub struct DictIter {
     dict: PyDictRef,
     position: usize,
 }
 
-impl DictIterator {
-    pub fn new(dict: PyDictRef) -> DictIterator {
-        DictIterator { dict, position: 0 }
+impl DictIter {
+    pub fn new(dict: PyDictRef) -> DictIter {
+        DictIter { dict, position: 0 }
     }
 }
 
-impl Iterator for DictIterator {
+impl Iterator for DictIter {
     type Item = (PyObjectRef, PyObjectRef);
 
     fn next(&mut self) -> Option<Self::Item> {
 
@@ -237,7 +237,7 @@ pub fn get_attributes(obj: &PyObjectRef) -> PyAttributes {
 
     // Get instance attributes:
     if let Some(dict) = &obj.dict {
-        for (key, value) in dict.into_iter() {
+        for (key, value) in dict {
             attributes.insert(key.to_string(), value.clone());
         }
     }
 
@@ -64,7 +64,7 @@ impl<'s> serde::Serialize for PyObjectSerializer<'s> {
             serialize_seq_elements(serializer, &elements)
         } else if objtype::isinstance(self.pyobject, &self.vm.ctx.dict_type()) {
             let dict: PyDictRef = self.pyobject.clone().downcast().unwrap();
-            let pairs: Vec<(PyObjectRef, PyObjectRef)> = dict.into_iter().collect();
+            let pairs: Vec<_> = dict.into_iter().collect();
             let mut map = serializer.serialize_map(Some(pairs.len()))?;
             for (key, e) in pairs.iter() {
                 map.serialize_entry(&self.clone_with_object(key), &self.clone_with_object(&e))?;
Original file line number	Diff line number	Diff line change
`@@ -237,34 +237,34 @@ impl ItemProtocol for PyDictRef {`
`237`	`237`	`// Implement IntoIterator so that we can easily iterate dictionaries from rust code.`
`238`	`238`	`impl IntoIterator for PyDictRef {`
`239`	`239`	`type Item = (PyObjectRef, PyObjectRef);`
`240`		`- type IntoIter = DictIterator;`
	`240`	`+ type IntoIter = DictIter;`
`241`	`241`
`242`	`242`	`fn into_iter(self) -> Self::IntoIter {`
`243`		`- DictIterator::new(self)`
	`243`	`+ DictIter::new(self)`
`244`	`244`	`}`
`245`	`245`	`}`
`246`	`246`
`247`	`247`	`impl IntoIterator for &PyDictRef {`
`248`	`248`	`type Item = (PyObjectRef, PyObjectRef);`
`249`		`- type IntoIter = DictIterator;`
	`249`	`+ type IntoIter = DictIter;`
`250`	`250`
`251`	`251`	`fn into_iter(self) -> Self::IntoIter {`
`252`		`- DictIterator::new(self.clone())`
	`252`	`+ DictIter::new(self.clone())`
`253`	`253`	`}`
`254`	`254`	`}`
`255`	`255`
`256`		`-pub struct DictIterator {`
	`256`	`+pub struct DictIter {`
`257`	`257`	`dict: PyDictRef,`
`258`	`258`	`position: usize,`
`259`	`259`	`}`
`260`	`260`
`261`		`-impl DictIterator {`
`262`		`- pub fn new(dict: PyDictRef) -> DictIterator {`
`263`		`- DictIterator { dict, position: 0 }`
	`261`	`+impl DictIter {`
	`262`	`+ pub fn new(dict: PyDictRef) -> DictIter {`
	`263`	`+ DictIter { dict, position: 0 }`
`264`	`264`	`}`
`265`	`265`	`}`
`266`	`266`
`267`		`-impl Iterator for DictIterator {`
	`267`	`+impl Iterator for DictIter {`
`268`	`268`	`type Item = (PyObjectRef, PyObjectRef);`
`269`	`269`
`270`	`270`	`fn next(&mut self) -> Option<Self::Item> {`
Original file line number	Diff line number	Diff line change
`@@ -237,7 +237,7 @@ pub fn get_attributes(obj: &PyObjectRef) -> PyAttributes {`
`237`	`237`
`238`	`238`	`// Get instance attributes:`
`239`	`239`	`if let Some(dict) = &obj.dict {`
`240`		`- for (key, value) in dict.into_iter() {`
	`240`	`+ for (key, value) in dict {`
`241`	`241`	`attributes.insert(key.to_string(), value.clone());`
`242`	`242`	`}`
`243`	`243`	`}`