use default_get instead of map_get

Author: aggyomfg

assets/tests/iter/hashmap_ipairs.lua

@@ -6,7 +6,7 @@ local map = res.string_map
 local count = 0
 local found_keys = {}
 
-for key, value in map:pairs() do
+for key, value in pairs(map) do
     count = count + 1
     found_keys[key] = value
 end

assets/tests/iter/hashmap_pairs.lua

@@ -2,7 +2,7 @@ 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() do
+for v in pairs(res.vec_usize) do
     iterated_vals[#iterated_vals + 1] = v
 end
 

assets/tests/iter/vec_ipairs.lua

@@ -1,4 +1,4 @@
 local Resource = world.get_type_by_name("TestResourceWithVariousFields")
 local resource = world.get_resource(Resource)
 
-assert(resource.string_map:map_get("foo") == "bar", "Expected bar, got " .. resource.string_map:map_get("foo"))
+assert(resource.string_map["foo"] == "bar", "Expected bar, got " .. resource.string_map["foo"])

assets/tests/iter/vec_pairs.lua

@@ -1,4 +1,4 @@
 let Resource = world.get_type_by_name.call("TestResourceWithVariousFields");
 let resource = world.get_resource.call(Resource);
 
-assert(resource.string_map.map_get.call("foo") == "bar", "Expected bar, got " + resource.string_map.map_get.call("foo"));
+assert(resource.string_map["foo"] == "bar", "Expected bar, got " + resource.string_map["foo"]);

assets/tests/map_get/can_get_hashmap_value.lua

@@ -1,9 +1,9 @@
 //! All the switchable special functions used by language implementors
 use super::{FromScriptRef, FunctionCallContext, IntoScriptRef};
-use crate::{ReflectReference, ReflectionPathExt, ScriptValue, error::InteropError};
+use crate::{error::InteropError, PartialReflectExt, ReflectReference, ReflectionPathExt, ScriptValue};
 use bevy_mod_scripting_derive::DebugWithTypeInfo;
 use bevy_mod_scripting_display::OrFakeId;
-use bevy_reflect::{ParsedPath, PartialReflect};
+use bevy_reflect::{ParsedPath, PartialReflect, ReflectRef};
 
 /// A list of magic methods, these only have one replacable implementation, and apply to all `ReflectReferences`.
 /// It's up to the language implementer to call these in the right order (after any type specific overrides).
@@ -51,8 +51,6 @@ impl MagicFunctions {
     /// Indexes into the given reference and if the nested type is a reference type, returns a deeper reference, otherwise
     /// returns the concrete value.
     ///
-    /// Does not support map types at the moment, for maps see `map_get`
-    ///
     /// Arguments:
     /// * `ctxt`: The function call context.
     /// * `reference`: The reference to index into.
@@ -65,13 +63,57 @@ impl MagicFunctions {
         mut reference: ReflectReference,
         key: ScriptValue,
     ) -> Result<ScriptValue, InteropError> {
-        let mut path: ParsedPath = key.try_into()?;
-        if ctxt.convert_to_0_indexed() {
-            path.convert_to_0_indexed();
-        }
-        reference.index_path(path);
         let world = ctxt.world()?;
-        ReflectReference::into_script_ref(reference, world)
+        
+        // Check if the reference is a map type
+        let is_map = reference.with_reflect(world.clone(), |r| {
+            matches!(r.reflect_ref(), ReflectRef::Map(_))
+        })?;
+        
+        if is_map {
+            // Handle map indexing specially - need to get the key type and convert the script value
+            let key = <Box<dyn PartialReflect>>::from_script_ref(
+                reference.key_type_id(world.clone())?.ok_or_else(|| {
+                    InteropError::unsupported_operation(
+                        reference.tail_type_id(world.clone()).unwrap_or_default(),
+                        Some(Box::new(key.clone())),
+                        "Could not get key type id. Are you trying to index into a type that's not a map?".to_owned(),
+                    )
+                })?,
+                key,
+                world.clone(),
+            )?;
+            
+            reference.with_reflect(world.clone(), |s| match s.try_map_get(key.as_ref())? {
+                Some(value) => {
+                    let reference = {
+                        let allocator = world.allocator();
+                        let mut allocator = allocator.write();
+                        let owned_value = <dyn PartialReflect>::from_reflect(value, world.clone())?;
+                        ReflectReference::new_allocated_boxed(owned_value, &mut allocator)
+                    };
+                    ReflectReference::into_script_ref(reference, world)
+                }
+                None => {
+                    // Return None option if key doesn't exist
+                    let none_option: Option<()> = None;
+                    let reference = {
+                        let allocator = world.allocator();
+                        let mut allocator = allocator.write();
+                        ReflectReference::new_allocated_boxed(Box::new(none_option), &mut allocator)
+                    };
+                    ReflectReference::into_script_ref(reference, world)
+                }
+            })?
+        } else {
+            // Handle path-based indexing for non-map types
+            let mut path: ParsedPath = key.try_into()?;
+            if ctxt.convert_to_0_indexed() {
+                path.convert_to_0_indexed();
+            }
+            reference.index_path(path);
+            ReflectReference::into_script_ref(reference, world)
+        }
     }
 
     /// Sets the value under the specified path on the underlying value.

assets/tests/map_get/can_get_hashmap_value copy.rhai renamed to assets/tests/map_get/can_get_hashmap_value.rhai

@@ -605,47 +605,6 @@ impl ReflectReference {
         Ok(format!("{reference:#?}"))
     }
 
-    /// Gets and clones the value under the specified key if the underlying type is a map type.
-    /// Uses `from_reflect` to create a fully reflected clone that can be used with all operations.
-    ///
-    /// Arguments:
-    /// * `ctxt`: The function call context.
-    /// * `reference`: The reference to index into.
-    /// * `key`: The key to index with.
-    /// Returns:
-    /// * `value`: The value at the key, if the reference is a map.
-    fn map_get(
-        ctxt: FunctionCallContext,
-        reference: ReflectReference,
-        key: ScriptValue,
-    ) -> Result<Option<ScriptValue>, InteropError> {
-        profiling::function_scope!("map_get");
-        let world = ctxt.world()?;
-        let key = <Box<dyn PartialReflect>>::from_script_ref(
-            reference.key_type_id(world.clone())?.ok_or_else(|| {
-                InteropError::unsupported_operation(
-                    reference.tail_type_id(world.clone()).unwrap_or_default(),
-                    Some(Box::new(key.clone())),
-                    "Could not get key type id. Are you trying to index into a type that's not a map?".to_owned(),
-                )
-            })?,
-            key,
-            world.clone(),
-        )?;
-        reference.with_reflect(world.clone(), |s| match s.try_map_get(key.as_ref())? {
-            Some(value) => {
-                let reference = {
-                    let allocator = world.allocator();
-                    let mut allocator = allocator.write();
-                    let owned_value = <dyn PartialReflect>::from_reflect(value, world.clone())?;
-                    ReflectReference::new_allocated_boxed(owned_value, &mut allocator)
-                };
-                Ok(Some(ReflectReference::into_script_ref(reference, world)?))
-            }
-            None => Ok(None),
-        })?
-    }
-
     /// Pushes the value into the reference, if the reference is an appropriate container type.
     ///
     /// Arguments:

crates/bevy_mod_scripting_bindings/src/function/magic_functions.rs

@@ -348,50 +348,6 @@ impl UserData for LuaReflectReference {
             }
         });
 
-        m.add_method("ipairs", |lua, s: &LuaReflectReference, _args: ()| {
-            profiling::function_scope!("ipairs");
-            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) => {
-                    let mut index = 0i64;
-                    lua.create_function_mut(move |lua, _args: ()| {
-                        let result = func
-                            .call(vec![], LUA_CALLER_CONTEXT)
-                            .map_err(IntoMluaError::to_lua_error)?;
-                        
-                        match result {
-                            ScriptValue::Unit => {
-                                // End of iteration
-                                Ok((mlua::Value::Nil, mlua::Value::Nil))
-                            }
-                            _ => {
-                                // Return (index, value) tuple for ipairs
-                                index += 1;
-                                let idx = mlua::Value::Integer(index);
-                                let val = LuaScriptValue(result).into_lua(lua)?;
-                                Ok((idx, val))
-                            }
-                        }
-                    })
-                }
-                _ => Err(mlua::Error::RuntimeError("iter function did not return a FunctionMut".to_string()))
-            }
-        });
-
         m.add_meta_function(MetaMethod::ToString, |_, self_: LuaReflectReference| {
             profiling::function_scope!("MetaMethod::ToString");
             let world = ThreadWorldContainer