re-enable list applies

Author: maksymilian-mozolewski

crates/bevy_mod_scripting_core/src/bindings/allocator.rs

@@ -170,7 +170,6 @@ impl ReflectAllocator {
     }
 
     pub fn remove(&mut self, id: &ReflectAllocationId) -> Option<ReflectAllocation> {
-        println!("removing {:?}", id);
         self.allocations.remove(id)
     }
 

crates/bevy_mod_scripting_core/src/bindings/function/from_ref.rs

@@ -1,6 +1,6 @@
 use std::{any::TypeId, ffi::OsString, path::PathBuf};
 
-use bevy::reflect::{DynamicEnum, DynamicTuple, DynamicVariant, PartialReflect};
+use bevy::reflect::{DynamicEnum, DynamicList, DynamicTuple, DynamicVariant, PartialReflect};
 
 use crate::{
     bindings::{function::from::FromScript, ReflectReference, WorldGuard},
@@ -71,25 +71,35 @@ impl FromScriptRef for Box<dyn PartialReflect> {
         if type_info.is_option() {
             let inner_type = type_info.option_inner_type().expect("invariant");
             let mut dynamic_enum = match value {
-                ScriptValue::Unit => {
-                    // build none variant
-                    let mut dynamic_enum = DynamicEnum::new("None", DynamicVariant::Unit);
-                    dynamic_enum
-                }
+                ScriptValue::Unit => DynamicEnum::new("None", DynamicVariant::Unit),
                 _ => {
                     let inner = Self::from_script_ref(inner_type, value, world)?;
-                    let mut dynamic_enum = DynamicEnum::new(
+                    DynamicEnum::new(
                         "Some",
                         DynamicVariant::Tuple(DynamicTuple::from_iter(vec![inner])),
-                    );
-                    dynamic_enum
+                    )
                 }
             };
 
             dynamic_enum.set_represented_type(Some(type_info));
             return Ok(Box::new(dynamic_enum));
         }
 
+        if type_info.is_list() {
+            let inner_type = type_info.list_inner_type().expect("invariant");
+
+            if let ScriptValue::List(vec) = value {
+                let mut dynamic_list = DynamicList::default();
+                for item in vec {
+                    let inner = Self::from_script_ref(inner_type, item, world.clone())?;
+                    dynamic_list.push_box(inner);
+                }
+
+                dynamic_list.set_represented_type(Some(type_info));
+                return Ok(Box::new(dynamic_list));
+            }
+        }
+
         match value {
             ScriptValue::Reference(reflect_reference) => reflect_reference.to_owned_value(world),
             value => Err(InteropError::value_mismatch(target, value)),

crates/bevy_mod_scripting_core/src/bindings/reference.rs

@@ -190,10 +190,6 @@ impl ReflectReference {
 
         if let ReflectBase::Owned(id) = &self.base.base_id {
             if self.reflect_path.is_empty() && id.strong_count() == 0 {
-                println!(
-                    "Trying to access allocation in owned value {}",
-                    self.display_value_with_world(world.clone())
-                );
                 let allocator = world.allocator();
                 let mut allocator = allocator.write();
                 let arc = allocator

crates/bevy_mod_scripting_functions/src/core.rs

@@ -167,7 +167,6 @@ fn register_world_functions(reg: &mut FunctionRegistry) -> Result<(), FunctionRe
                             value,
                             world.clone(),
                         )?;
-                        println!("Applying {:?} to {:?}", other, r);
 
                         r.try_apply(other.as_partial_reflect()).unwrap();
                         Ok::<_, InteropError>(())