Reorganize Visitor impls

Author: MrGVSV

crates/bevy_reflect/src/serde/de.rs

@@ -333,35 +333,55 @@ impl<'a, 'de> Visitor<'de> for TupleStructVisitor<'a> {
     }
 }
 
-struct ListVisitor<'a> {
-    list_info: &'a ListInfo,
+struct TupleVisitor<'a> {
+    tuple_info: &'a TupleInfo,
     registry: &'a TypeRegistry,
 }
 
-impl<'a, 'de> Visitor<'de> for ListVisitor<'a> {
-    type Value = DynamicList;
+impl<'a, 'de> Visitor<'de> for TupleVisitor<'a> {
+    type Value = DynamicTuple;
 
     fn expecting(&self, formatter: &mut Formatter) -> std::fmt::Result {
-        formatter.write_str("reflected list value")
+        formatter.write_str("reflected tuple value")
     }
 
     fn visit_seq<V>(self, mut seq: V) -> Result<Self::Value, V::Error>
     where
         V: SeqAccess<'de>,
     {
-        let mut list = DynamicList::default();
-        let type_info = get_type_info(
-            self.list_info.item_type_id(),
-            self.list_info.item_type_name(),
-            self.registry,
-        )?;
+        let mut tuple = DynamicTuple::default();
+        let mut index = 0usize;
+
+        let get_field_info = |index: usize| -> Result<&'a TypeInfo, V::Error> {
+            let field = self.tuple_info.field_at(index).ok_or_else(|| {
+                de::Error::custom(format_args!(
+                    "no field at index {} on tuple {}",
+                    index,
+                    self.tuple_info.type_name(),
+                ))
+            })?;
+            get_type_info(field.type_id(), field.type_name(), self.registry)
+        };
+
         while let Some(value) = seq.next_element_seed(TypedReflectDeserializer {
-            type_info,
+            type_info: get_field_info(index)?,
             registry: self.registry,
         })? {
-            list.push_box(value);
+            tuple.insert_boxed(value);
+            index += 1;
+            if index >= self.tuple_info.field_len() {
+                break;
+            }
         }
-        Ok(list)
+
+        if tuple.field_len() != self.tuple_info.field_len() {
+            return Err(Error::invalid_length(
+                tuple.field_len(),
+                &self.tuple_info.field_len().to_string().as_str(),
+            ));
+        }
+
+        Ok(tuple)
     }
 }
 
@@ -405,6 +425,38 @@ impl<'a, 'de> Visitor<'de> for ArrayVisitor<'a> {
     }
 }
 
+struct ListVisitor<'a> {
+    list_info: &'a ListInfo,
+    registry: &'a TypeRegistry,
+}
+
+impl<'a, 'de> Visitor<'de> for ListVisitor<'a> {
+    type Value = DynamicList;
+
+    fn expecting(&self, formatter: &mut Formatter) -> std::fmt::Result {
+        formatter.write_str("reflected list value")
+    }
+
+    fn visit_seq<V>(self, mut seq: V) -> Result<Self::Value, V::Error>
+    where
+        V: SeqAccess<'de>,
+    {
+        let mut list = DynamicList::default();
+        let type_info = get_type_info(
+            self.list_info.item_type_id(),
+            self.list_info.item_type_name(),
+            self.registry,
+        )?;
+        while let Some(value) = seq.next_element_seed(TypedReflectDeserializer {
+            type_info,
+            registry: self.registry,
+        })? {
+            list.push_box(value);
+        }
+        Ok(list)
+    }
+}
+
 struct MapVisitor<'a> {
     map_info: &'a MapInfo,
     registry: &'a TypeRegistry,
@@ -447,58 +499,6 @@ impl<'a, 'de> Visitor<'de> for MapVisitor<'a> {
     }
 }
 
-struct TupleVisitor<'a> {
-    tuple_info: &'a TupleInfo,
-    registry: &'a TypeRegistry,
-}
-
-impl<'a, 'de> Visitor<'de> for TupleVisitor<'a> {
-    type Value = DynamicTuple;
-
-    fn expecting(&self, formatter: &mut Formatter) -> std::fmt::Result {
-        formatter.write_str("reflected tuple value")
-    }
-
-    fn visit_seq<V>(self, mut seq: V) -> Result<Self::Value, V::Error>
-    where
-        V: SeqAccess<'de>,
-    {
-        let mut tuple = DynamicTuple::default();
-        let mut index = 0usize;
-
-        let get_field_info = |index: usize| -> Result<&'a TypeInfo, V::Error> {
-            let field = self.tuple_info.field_at(index).ok_or_else(|| {
-                de::Error::custom(format_args!(
-                    "no field at index {} on tuple {}",
-                    index,
-                    self.tuple_info.type_name(),
-                ))
-            })?;
-            get_type_info(field.type_id(), field.type_name(), self.registry)
-        };
-
-        while let Some(value) = seq.next_element_seed(TypedReflectDeserializer {
-            type_info: get_field_info(index)?,
-            registry: self.registry,
-        })? {
-            tuple.insert_boxed(value);
-            index += 1;
-            if index >= self.tuple_info.field_len() {
-                break;
-            }
-        }
-
-        if tuple.field_len() != self.tuple_info.field_len() {
-            return Err(Error::invalid_length(
-                tuple.field_len(),
-                &self.tuple_info.field_len().to_string().as_str(),
-            ));
-        }
-
-        Ok(tuple)
-    }
-}
-
 fn get_type_info<'a, E: de::Error>(
     type_id: TypeId,
     type_name: &'a str,
@@ -657,7 +657,9 @@ mod tests {
         let dynamic_output = reflect_deserializer
             .deserialize(&mut ron_deserializer)
             .unwrap();
-        let output = dynamic_output.take::<f32>().expect("underlying type should be f32");
+        let output = dynamic_output
+            .take::<f32>()
+            .expect("underlying type should be f32");
         assert_eq!(1.23, output);
     }