Fix PartialReflect::apply for maps, remove get_at/_mut from Map trait (#19802)

# Objective

- Fixes #14328
- `DynamicMap::drain` was broken (indices weren't cleared, causing a
panic when reading later)
- `PartialReflect::apply` was broken for maps and sets, because they
don't remove entries from the `self` map that aren't in the applied map.
- I discovered this bug when implementing MapEntities on a Component
containing a `HashMap<Entity, _>`. Because `apply` is used to reapply
the changes to the reflected map, the map ended up littered with a ton
of outdated entries.

## Solution

- Remove the separate `Vec` in `DynamicMap` and use the `HashTable`
directly, like it is in `DynamicSet`.
- Replace `MapIter` by `Box<dyn Iterator>` (like for `DynamicSet`), and
`Map::get_at` and `Map::get_at_mut` which are now unused.
- Now assume `DynamicMap` types are unordered and adjust documentation
accordingly.
- Fix documentation of `DynamicSet` (ordered -> unordered)
- Added `Map::retain` and `Set::retain`, and use them to remove excess
entries in `PartialReflect::apply` implementations.

## Testing

- Added `map::tests::apply` and `set::tests::apply` to validate
`<DynamicMap as PartialReflect>::apply` and `<DynamicSet as
PartialReflect>::apply`

Author: Azorlogh

crates/bevy_reflect/src/impls/alloc/collections/btree/map.rs

@@ -2,7 +2,7 @@ use crate::{
     error::ReflectCloneError,
     generics::{Generics, TypeParamInfo},
     kind::{ReflectKind, ReflectMut, ReflectOwned, ReflectRef},
-    map::{map_apply, map_partial_eq, map_try_apply, Map, MapInfo, MapIter},
+    map::{map_apply, map_partial_eq, map_try_apply, Map, MapInfo},
     prelude::*,
     reflect::{impl_full_reflect, ApplyError},
     type_info::{MaybeTyped, TypeInfo, Typed},
@@ -31,27 +31,15 @@ where
             .map(|value| value as &mut dyn PartialReflect)
     }
 
-    fn get_at(&self, index: usize) -> Option<(&dyn PartialReflect, &dyn PartialReflect)> {
-        self.iter()
-            .nth(index)
-            .map(|(key, value)| (key as &dyn PartialReflect, value as &dyn PartialReflect))
-    }
-
-    fn get_at_mut(
-        &mut self,
-        index: usize,
-    ) -> Option<(&dyn PartialReflect, &mut dyn PartialReflect)> {
-        self.iter_mut()
-            .nth(index)
-            .map(|(key, value)| (key as &dyn PartialReflect, value as &mut dyn PartialReflect))
-    }
-
     fn len(&self) -> usize {
         Self::len(self)
     }
 
-    fn iter(&self) -> MapIter {
-        MapIter::new(self)
+    fn iter(&self) -> Box<dyn Iterator<Item = (&dyn PartialReflect, &dyn PartialReflect)> + '_> {
+        Box::new(
+            self.iter()
+                .map(|(k, v)| (k as &dyn PartialReflect, v as &dyn PartialReflect)),
+        )
     }
 
     fn drain(&mut self) -> Vec<(Box<dyn PartialReflect>, Box<dyn PartialReflect>)> {
@@ -68,6 +56,10 @@ where
         result
     }
 
+    fn retain(&mut self, f: &mut dyn FnMut(&dyn PartialReflect, &mut dyn PartialReflect) -> bool) {
+        self.retain(move |k, v| f(k, v));
+    }
+
     fn insert_boxed(
         &mut self,
         key: Box<dyn PartialReflect>,

crates/bevy_reflect/src/impls/macros/map.rs

@@ -19,27 +19,12 @@ macro_rules! impl_reflect_for_hashmap {
                         .map(|value| value as &mut dyn $crate::reflect::PartialReflect)
                 }
 
-                fn get_at(&self, index: usize) -> Option<(&dyn $crate::reflect::PartialReflect, &dyn $crate::reflect::PartialReflect)> {
-                    self.iter()
-                        .nth(index)
-                        .map(|(key, value)| (key as &dyn $crate::reflect::PartialReflect, value as &dyn $crate::reflect::PartialReflect))
-                }
-
-                fn get_at_mut(
-                    &mut self,
-                    index: usize,
-                ) -> Option<(&dyn $crate::reflect::PartialReflect, &mut dyn $crate::reflect::PartialReflect)> {
-                    self.iter_mut().nth(index).map(|(key, value)| {
-                        (key as &dyn $crate::reflect::PartialReflect, value as &mut dyn $crate::reflect::PartialReflect)
-                    })
-                }
-
                 fn len(&self) -> usize {
                     Self::len(self)
                 }
 
-                fn iter(&self) -> $crate::map::MapIter {
-                    $crate::map::MapIter::new(self)
+                fn iter(&self) -> bevy_platform::prelude::Box<dyn Iterator<Item = (&dyn $crate::reflect::PartialReflect, &dyn $crate::reflect::PartialReflect)> + '_> {
+                    bevy_platform::prelude::Box::new(self.iter().map(|(k, v)| (k as &dyn $crate::reflect::PartialReflect, v as &dyn $crate::reflect::PartialReflect)))
                 }
 
                 fn drain(&mut self) -> bevy_platform::prelude::Vec<(bevy_platform::prelude::Box<dyn $crate::reflect::PartialReflect>, bevy_platform::prelude::Box<dyn $crate::reflect::PartialReflect>)> {
@@ -53,6 +38,10 @@ macro_rules! impl_reflect_for_hashmap {
                         .collect()
                 }
 
+                fn retain(&mut self, f: &mut dyn FnMut(&dyn $crate::reflect::PartialReflect, &mut dyn $crate::reflect::PartialReflect) -> bool) {
+                    self.retain(move |key, value| f(key, value));
+                }
+
                 fn to_dynamic_map(&self) -> $crate::map::DynamicMap {
                     let mut dynamic_map = $crate::map::DynamicMap::default();
                     dynamic_map.set_represented_type($crate::reflect::PartialReflect::get_represented_type_info(self));

crates/bevy_reflect/src/impls/macros/set.rs

@@ -28,6 +28,10 @@ macro_rules! impl_reflect_for_hashset {
                         .collect()
                 }
 
+                fn retain(&mut self, f: &mut dyn FnMut(&dyn $crate::reflect::PartialReflect) -> bool) {
+                    self.retain(move |value| f(value));
+                }
+
                 fn insert_boxed(&mut self, value: bevy_platform::prelude::Box<dyn $crate::reflect::PartialReflect>) -> bool {
                     let value = V::take_from_reflect(value).unwrap_or_else(|value| {
                         panic!(

crates/bevy_reflect/src/lib.rs

@@ -1583,7 +1583,6 @@ mod tests {
         foo.apply(&foo_patch);
 
         let mut hash_map = <HashMap<_, _>>::default();
-        hash_map.insert(1, 1);
         hash_map.insert(2, 3);
         hash_map.insert(3, 4);