Add support for lists in bevy_proto_bsn parsing

Author: mmatvein

crates/bevy_proto_bsn/src/bsn_asset.rs

@@ -157,6 +157,8 @@ pub enum BsnValue {
     Call(String, Vec<BsnValue>),
     /// A tuple of values.
     Tuple(Vec<BsnValue>),
+    /// A list of values.
+    List(Vec<BsnValue>),
     /// An unknown expression.
     UnknownExpr(String),
 }
@@ -262,6 +264,7 @@ impl From<&Expr> for BsnValue {
             Expr::Struct(strct) => strct.into(),
             Expr::Call(call) => call.into(),
             Expr::Paren(paren) => paren.expr.as_ref().into(),
+            Expr::Array(array) => BsnValue::List(array.elems.iter().map(|e| e.into()).collect()),
             expr => BsnValue::UnknownExpr(expr.to_token_stream().to_string()),
         }
     }
@@ -419,6 +422,7 @@ impl ToBsnString for BsnValue {
                 format!("{}({})", path, args.joined(", "))
             }
             BsnValue::Tuple(fields) => format!("({})", fields.joined(", ")),
+            BsnValue::List(values) => format!("[{}]", values.joined(", ")),
             BsnValue::UnknownExpr(expr) => expr.clone(),
         }
     }

crates/bevy_proto_bsn/src/bsn_reflect.rs

@@ -9,9 +9,9 @@ use bevy::{
     },
     platform::hash::FixedState,
     reflect::{
-        DynamicEnum, DynamicStruct, DynamicTuple, DynamicTupleStruct, DynamicVariant, FromType,
-        NamedField, PartialReflect, Reflect, ReflectKind, StructInfo, StructVariantInfo, TypeInfo,
-        TypePath, TypeRegistration, TypeRegistry, TypeRegistryArc,
+        DynamicEnum, DynamicList, DynamicStruct, DynamicTuple, DynamicTupleStruct, DynamicVariant,
+        FromType, NamedField, PartialReflect, Reflect, ReflectKind, StructInfo, StructVariantInfo,
+        TypeInfo, TypePath, TypeRegistration, TypeRegistry, TypeRegistryArc,
     },
 };
 use thiserror::Error;
@@ -451,6 +451,11 @@ impl<'a, 'b> BsnReflector<'a, 'b> {
                 format!("{:?}", value),
                 ty.type_path().into(),
             )),
+            BsnValue::List(items) => self.reflect_list(items, ty),
+            _ => Err(ReflectError::UnexpectedType(
+                format!("{:?}", value),
+                ty.type_path().into(),
+            )),
         }
     }
 
@@ -517,6 +522,22 @@ impl<'a, 'b> BsnReflector<'a, 'b> {
         Ok(ReflectedValue::new(ty.type_id(), Box::new(dynamic_tuple)))
     }
 
+    fn reflect_list(&self, items: &[BsnValue], ty: &TypeInfo) -> ReflectResult<ReflectedValue> {
+        if let Ok(list_info) = ty.as_list() {
+            let mut dynamic_list = DynamicList::default();
+            let item_type_info = list_info.item_info().expect("Expected typed list");
+            for item in items.iter() {
+                dynamic_list.push_box(self.reflect_value(item, item_type_info)?.instance);
+            }
+            Ok(ReflectedValue::new(ty.type_id(), Box::new(dynamic_list)))
+        } else {
+            return Err(ReflectError::UnexpectedType(
+                format!("{:?}", items),
+                format!("{:?}", ty),
+            ));
+        }
+    }
+
     fn reflect_path(&self, path: &str, ty: Option<&TypeInfo>) -> ReflectResult<ReflectedValue> {
         let ty = match ty {
             Some(ty) => ty,