get rid of leaked abstraction 2

Author: aggyomfg

assets/tests/iter/vec.lua

@@ -1,14 +1,10 @@
 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()
-local result = iterator()
-while result ~= nil do
-    iterated_vals[#iterated_vals + 1] = result
-    result = iterator()
+iterated_vals = {}
+for v in pairs(res.vec_usize) 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")

assets/tests/iter/vec.rhai

@@ -2,16 +2,9 @@ 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();
 
-loop {
-    let result = iterator.next();
-    
-    if result == () {
-        break;
-    }
-    
-    iterated_vals.push(result);
+for v in res.vec_usize {
+    iterated_vals.push(v);
 }
 
 assert(iterated_vals.len == 5, "Length is not 5");

crates/bevy_mod_scripting_bindings/src/reference.rs

@@ -989,49 +989,9 @@ pub struct ReflectMapRefIter {
 
 #[profiling::all_functions]
 impl ReflectMapRefIter {
-    /// Returns the next map entry as a (key, value) tuple.
-    /// Returns Ok(None) when there are no more entries.
-    pub fn next_ref(&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 key_ref = ReflectReference::new_allocated_boxed_parial_reflect(
-                            key.to_dynamic(),
-                            &mut *allocator_guard
-                        )?;
-                        
-                        let value_ref = ReflectReference::new_allocated_boxed_parial_reflect(
-                            value.to_dynamic(),
-                            &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(),
-                ))
-            }
-        })?
-    }
-
     /// Returns the next map entry as a (key, value) tuple, cloning the values.
+    /// Uses `from_reflect` to create fully reflected clones that can be used with all operations.
     /// 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;

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

@@ -348,50 +348,6 @@ impl UserData for LuaReflectReference {
             }
         });
 
-        m.add_method("pairs", |lua, s: &LuaReflectReference, _args: ()| {
-            profiling::function_scope!("pairs");
-            let world = ThreadWorldContainer
-                .try_get_world()
-                .map_err(IntoMluaError::to_lua_error)?;
-
-            let iter_func = world
-                .lookup_function([TypeId::of::<ReflectReference>()], "iter")
-                .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 function did not return a FunctionMut".to_string()))
-            }
-        });
-
         m.add_method("ipairs", |lua, s: &LuaReflectReference, _args: ()| {
             profiling::function_scope!("ipairs");
             let world = ThreadWorldContainer

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

@@ -621,29 +621,6 @@ impl CustomType for RhaiReflectReference {
                     }
                     _ => Err(InteropError::invariant("iter function did not return a FunctionMut").into_rhai_error())
                 }
-            })
-            .with_fn("iter_clone", |self_: Self| {
-                let world = ThreadWorldContainer
-                    .try_get_world()
-                    .map_err(IntoRhaiError::into_rhai_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(IntoRhaiError::into_rhai_error)?;
-
-                let result = iter_func
-                    .call(vec![ScriptValue::Reference(self_.0)], RHAI_CALLER_CONTEXT)
-                    .map_err(IntoRhaiError::into_rhai_error)?;
-
-                match result {
-                    ScriptValue::FunctionMut(iter_fn) => {
-                        Ok(Dynamic::from(RhaiIterator { iter_fn }))
-                    }
-                    _ => Err(InteropError::invariant("iter_clone function did not return a FunctionMut").into_rhai_error())
-                }
             });
     }
 }