improve iters to iter partial reflect or _clone (full Reflect)

Author: aggyomfg

assets/tests/iter/hashmap.lua

@@ -5,6 +5,8 @@ local map = res.string_map
 
 local count = 0
 local found_keys = {}
+
+--- Iterate over PartialReflect refs using pairs
 for key, value in pairs(map) do
     count = count + 1
     found_keys[key] = value

assets/tests/iter_clone/hashmap.lua

@@ -0,0 +1,21 @@
+local res_type = world.get_type_by_name("TestResourceWithVariousFields")
+local res = world.get_resource(res_type)
+
+local map = res.string_map
+
+local iterator = map:iter_clone()
+local count = 0
+local found_keys = {}
+
+local result = iterator()
+while result ~= nil do
+    local key = result[1]
+    local value = result[2]
+    count = count + 1
+    found_keys[key] = value
+    result = iterator()
+end
+
+assert(count == 2, "Expected 2 entries, got " .. count)
+assert(found_keys["foo"] == "bar", "Expected foo=>bar")
+assert(found_keys["zoo"] == "zed", "Expected zoo=>zed")

assets/tests/iter_clone/hashmap.rhai

@@ -0,0 +1,31 @@
+let res_type = world.get_type_by_name.call("TestResourceWithVariousFields");
+let res = world.get_resource.call(res_type);
+
+let map = res.string_map;
+
+let iterator = map.iter_clone();
+let count = 0;
+let found_keys = #{};
+
+loop {
+    let result = iterator.next();
+    
+    if result == () {
+        break;
+    }
+    
+    let key = result[0];
+    let value = result[1];
+    count += 1;
+    found_keys[key] = value;
+}
+
+if count != 2 {
+    throw `Expected 2 entries, got ${count}`;
+}
+if found_keys["foo"] != "bar" {
+    throw "Expected foo=>bar";
+}
+if found_keys["zoo"] != "zed" {
+    throw "Expected zoo=>zed";
+}

assets/tests/iter_clone/hashmap_pairs.lua

@@ -0,0 +1,23 @@
+local res_type = world.get_type_by_name("TestResourceWithVariousFields")
+local res = world.get_resource(res_type)
+
+local map = res.string_map
+
+local count = 0
+local found_keys = {}
+
+-- Use pairs_clone to loop over Reflect values
+for key, value in map:pairs_clone() do
+    count = count + 1
+    found_keys[key] = value
+end
+
+if count ~= 2 then
+    error(string.format("Expected 2 entries, got %d", count))
+end
+if found_keys["foo"] ~= "bar" then
+    error("Expected foo=>bar")
+end
+if found_keys["zoo"] ~= "zed" then
+    error("Expected zoo=>zed")
+end

assets/tests/iter_clone/vec.lua

@@ -0,0 +1,17 @@
+local res_type = world.get_type_by_name("TestResourceWithVariousFields")
+local res = world.get_resource(res_type)
+
+local iterated_vals = {}
+local iterator = res.vec_usize:iter_clone()
+local result = iterator()
+while result ~= nil do
+    iterated_vals[#iterated_vals + 1] = result
+    result = iterator()
+end
+
+assert(#iterated_vals == 5, "Length is not 5")
+assert(iterated_vals[1] == 1, "First value is not 1")
+assert(iterated_vals[2] == 2, "Second value is not 2")
+assert(iterated_vals[3] == 3, "Third value is not 3")
+assert(iterated_vals[4] == 4, "Fourth value is not 4")
+assert(iterated_vals[5] == 5, "Fifth value is not 5")

assets/tests/iter_clone/vec.rhai

@@ -0,0 +1,22 @@
+let res_type = world.get_type_by_name.call("TestResourceWithVariousFields");
+let res = world.get_resource.call(res_type);
+
+let iterated_vals = [];
+let iterator = res.vec_usize.iter_clone();
+
+loop {
+    let result = iterator.next();
+    
+    if result == () {
+        break;
+    }
+    
+    iterated_vals.push(result);
+}
+
+assert(iterated_vals.len == 5, "Length is not 5");
+assert(iterated_vals[0] == 1, "First value is not 1");
+assert(iterated_vals[1] == 2, "Second value is not 2");
+assert(iterated_vals[2] == 3, "Third value is not 3");
+assert(iterated_vals[3] == 4, "Fourth value is not 4");
+assert(iterated_vals[4] == 5, "Fifth value is not 5");

assets/tests/iter_clone/vec_pairs.lua

@@ -0,0 +1,14 @@
+local res_type = world.get_type_by_name("TestResourceWithVariousFields")
+local res = world.get_resource(res_type)
+
+local iterated_vals = {}
+for v in res.vec_usize:pairs_clone() do
+    iterated_vals[#iterated_vals + 1] = v
+end
+
+assert(#iterated_vals == 5, "Length is not 5")
+assert(iterated_vals[1] == 1, "First value is not 1")
+assert(iterated_vals[2] == 2, "Second value is not 2")
+assert(iterated_vals[3] == 3, "Third value is not 3")
+assert(iterated_vals[4] == 4, "Fourth value is not 4")
+assert(iterated_vals[5] == 5, "Fifth value is not 5")

crates/bevy_mod_scripting_bindings/src/reference.rs

@@ -788,6 +788,46 @@ impl ReflectRefIter {
         };
         (next, index)
     }
+
+    /// Returns the next element as a cloned value using `from_reflect`.
+    /// Returns a fully reflected value (Box<dyn Reflect>) instead of a reference.
+    /// Returns Ok(None) when the path is invalid (end of iteration).
+    pub fn next_cloned(&mut self, world: WorldGuard) -> Result<Option<ReflectReference>, InteropError> {
+        let index = match &mut self.index {
+            IterationKey::Index(i) => {
+                let idx = *i;
+                *i += 1;
+                idx
+            }
+        };
+
+        let element = self.base.with_reflect(world.clone(), |base_reflect| {
+            match base_reflect.reflect_ref() {
+                bevy_reflect::ReflectRef::List(list) => {
+                    list.get(index).map(|item| {
+                        <dyn PartialReflect>::from_reflect(item, world.clone())
+                    })
+                }
+                bevy_reflect::ReflectRef::Array(array) => {
+                    array.get(index).map(|item| {
+                        <dyn PartialReflect>::from_reflect(item, world.clone())
+                    })
+                }
+                _ => None,
+            }
+        })?;
+
+        match element {
+            Some(result) => {
+                let owned_value = result?;
+                let allocator = world.allocator();
+                let mut allocator_guard = allocator.write();
+                let value_ref = ReflectReference::new_allocated_boxed(owned_value, &mut *allocator_guard);
+                Ok(Some(value_ref))
+            }
+            None => Ok(None),
+        }
+    }
 }
 
 const fn list_index_access(index: usize) -> Access<'static> {
@@ -842,6 +882,49 @@ impl ReflectMapRefIter {
             }
         })?
     }
+
+    /// Returns the next map entry as a (key, value) tuple, cloning the values.
+    /// Returns Ok(None) when there are no more entries.
+    /// This uses `from_reflect` to clone the actual values instead of creating dynamic references.
+    /// Returns fully reflected values (Box<dyn Reflect>) like `map_get_clone` does.
+    pub fn next_cloned(&mut self, world: WorldGuard) -> Result<Option<(ReflectReference, ReflectReference)>, InteropError> {
+        let idx = self.index;
+        self.index += 1;
+        
+        // Access the map and get the entry at index
+        self.base.with_reflect(world.clone(), |reflect| {
+            match reflect.reflect_ref() {
+                ReflectRef::Map(map) => {
+                    if let Some((key, value)) = map.get_at(idx) {
+                        let allocator = world.allocator();
+                        let mut allocator_guard = allocator.write();
+                        
+                        let owned_key = <dyn PartialReflect>::from_reflect(key, world.clone())?;
+                        let key_ref = ReflectReference::new_allocated_boxed(
+                            owned_key,
+                            &mut *allocator_guard
+                        );
+                        
+                        let owned_value = <dyn PartialReflect>::from_reflect(value, world.clone())?;
+                        let value_ref = ReflectReference::new_allocated_boxed(
+                            owned_value,
+                            &mut *allocator_guard
+                        );
+                        
+                        drop(allocator_guard);
+                        Ok(Some((key_ref, value_ref)))
+                    } else {
+                        Ok(None)
+                    }
+                }
+                _ => Err(InteropError::unsupported_operation(
+                    reflect.get_represented_type_info().map(|ti| ti.type_id()),
+                    None,
+                    "map iteration on non-map type".to_owned(),
+                ))
+            }
+        })?
+    }
 }
 
 #[profiling::all_functions]

crates/bevy_mod_scripting_functions/src/core.rs

@@ -884,6 +884,71 @@ impl ReflectReference {
         }
     }
 
+    /// Iterates over the reference with cloned values, if the reference is an appropriate container type.
+    ///
+    /// This method clones the actual values using `from_reflect` instead of creating dynamic references.
+    /// Returns an "next" iterator function that returns fully reflected values (Box<dyn Reflect>).
+    ///
+    /// The iterator function should be called until it returns `nil` to signal the end of the iteration.
+    ///
+    /// Arguments:
+    /// * `ctxt`: The function call context.
+    /// * `reference`: The reference to iterate over.
+    /// Returns:
+    /// * `iter`: The iterator function that returns cloned values.
+    fn iter_clone(
+        ctxt: FunctionCallContext,
+        reference: ReflectReference,
+    ) -> Result<DynamicScriptFunctionMut, InteropError> {
+        profiling::function_scope!("iter_clone");
+        let world = ctxt.world()?;
+        let mut len = reference.len(world.clone())?.unwrap_or_default();
+        // Check if this is a Map type
+        let is_map = reference.with_reflect(world.clone(), |r| {
+            matches!(r.reflect_ref(), ReflectRef::Map(_))
+        })?;
+
+        if is_map {
+            // Use special map iterator that clones values
+            let mut map_iter = reference.into_map_iter();
+            let iter_function = move || {
+                if len == 0 {
+                    return Ok(ScriptValue::Unit);
+                }
+                len -= 1;
+                let world = ThreadWorldContainer.try_get_world()?;
+                match map_iter.next_cloned(world.clone())? {
+                    Some((key_ref, value_ref)) => {
+                        // Return both key and value as a List for Lua's pairs() to unpack
+                        let key_value = ReflectReference::into_script_ref(key_ref, world.clone())?;
+                        let value_value = ReflectReference::into_script_ref(value_ref, world)?;
+                        Ok(ScriptValue::List(vec![key_value, value_value]))
+                    }
+                    None => Ok(ScriptValue::Unit),
+                }
+            };
+            Ok(iter_function.into_dynamic_script_function_mut())
+        } else {
+            // Use cloning iterator for lists/arrays
+            let mut infinite_iter = reference.into_iter_infinite();
+            let iter_function = move || {
+                if len == 0 {
+                    return Ok(ScriptValue::Unit);
+                }
+                len -= 1;
+                let world = ThreadWorldContainer.try_get_world()?;
+                match infinite_iter.next_cloned(world.clone())? {
+                    Some(value_ref) => {
+                        // Convert the cloned value to a script value
+                        ReflectReference::into_script_ref(value_ref, world)
+                    }
+                    None => Ok(ScriptValue::Unit),
+                }
+            };
+            Ok(iter_function.into_dynamic_script_function_mut())
+        }
+    }
+
     /// Lists the functions available on the reference.
     ///
     /// Arguments:

crates/languages/bevy_mod_scripting_lua/src/bindings/reference.rs

@@ -323,7 +323,6 @@ impl UserData for LuaReflectReference {
 
             match result {
                 ScriptValue::FunctionMut(func) => {
-                    // Create a Lua function that wraps our iterator and unpacks List results
                     lua.create_function_mut(move |lua, _args: ()| {
                         let result = func
                             .call(vec![], LUA_CALLER_CONTEXT)
@@ -349,6 +348,50 @@ impl UserData for LuaReflectReference {
             }
         });
 
+        m.add_method("pairs_clone", |lua, s: &LuaReflectReference, _args: ()| {
+            profiling::function_scope!("pairs_clone");
+            let world = ThreadWorldContainer
+                .try_get_world()
+                .map_err(IntoMluaError::to_lua_error)?;
+
+            let iter_func = world
+                .lookup_function([TypeId::of::<ReflectReference>()], "iter_clone")
+                .map_err(|f| {
+                    InteropError::missing_function(f, TypeId::of::<ReflectReference>().into())
+                })
+                .map_err(IntoMluaError::to_lua_error)?;
+
+            let result = iter_func
+                .call(vec![ScriptValue::Reference(s.clone().into())], LUA_CALLER_CONTEXT)
+                .map_err(IntoMluaError::to_lua_error)?;
+            
+            match result {
+                ScriptValue::FunctionMut(func) => {
+                    lua.create_function_mut(move |lua, _args: ()| {
+                        let result = func
+                            .call(vec![], LUA_CALLER_CONTEXT)
+                            .map_err(IntoMluaError::to_lua_error)?;
+                        
+                        // If the result is a List with 2 elements, unpack it into multiple return values
+                        match result {
+                            ScriptValue::List(ref items) if items.len() == 2 => {
+                                // Return as tuple (key, value) which Lua unpacks automatically
+                                let key = LuaScriptValue(items[0].clone()).into_lua(lua)?;
+                                let value = LuaScriptValue(items[1].clone()).into_lua(lua)?;
+                                Ok((key, value))
+                            }
+                            _ => {
+                                // Single value or Unit - return as-is
+                                let val = LuaScriptValue(result).into_lua(lua)?;
+                                Ok((val, mlua::Value::Nil))
+                            }
+                        }
+                    })
+                }
+                _ => Err(mlua::Error::RuntimeError("iter_clone function did not return a FunctionMut".to_string()))
+            }
+        });
+
         m.add_meta_function(MetaMethod::ToString, |_, self_: LuaReflectReference| {
             profiling::function_scope!("MetaMethod::ToString");
             let world = ThreadWorldContainer