1 files changed, 29 insertions, 13 deletions

diff --git a/vendor/indexmap/src/mutable_keys.rs b/vendor/indexmap/src/mutable_keys.rs
index 35a90c472..7efc779b1 100644
--- a/vendor/indexmap/src/mutable_keys.rs
+++ b/vendor/indexmap/src/mutable_keys.rs
@@ -1,8 +1,6 @@
 use core::hash::{BuildHasher, Hash};
 
-use super::{Equivalent, IndexMap};
-
-pub struct PrivateMarker {}
+use super::{Bucket, Entries, Equivalent, IndexMap};
 
 /// Opt-in mutable access to keys.
 ///
@@ -16,11 +14,15 @@ pub struct PrivateMarker {}
 /// implementing PartialEq, Eq, or Hash incorrectly would be).
 ///
 /// `use` this trait to enable its methods for `IndexMap`.
-pub trait MutableKeys {
+///
+/// This trait is sealed and cannot be implemented for types outside this crate.
+pub trait MutableKeys: private::Sealed {
     type Key;
     type Value;
 
     /// Return item index, mutable reference to key and value
+    ///
+    /// Computes in **O(1)** time (average).
     fn get_full_mut2<Q: ?Sized>(
         &mut self,
         key: &Q,
@@ -28,6 +30,13 @@ pub trait MutableKeys {
     where
         Q: Hash + Equivalent<Self::Key>;
 
+    /// Return mutable reference to key and value at an index.
+    ///
+    /// Valid indices are *0 <= index < self.len()*
+    ///
+    /// Computes in **O(1)** time.
+    fn get_index_mut2(&mut self, index: usize) -> Option<(&mut Self::Key, &mut Self::Value)>;
+
     /// Scan through each key-value pair in the map and keep those where the
     /// closure `keep` returns `true`.
     ///
@@ -38,11 +47,6 @@ pub trait MutableKeys {
     fn retain2<F>(&mut self, keep: F)
     where
         F: FnMut(&mut Self::Key, &mut Self::Value) -> bool;
-
-    /// This method is not useful in itself – it is there to “seal” the trait
-    /// for external implementation, so that we can add methods without
-    /// causing breaking changes.
-    fn __private_marker(&self) -> PrivateMarker;
 }
 
 /// Opt-in mutable access to keys.
@@ -55,11 +59,21 @@ where
 {
     type Key = K;
     type Value = V;
+
     fn get_full_mut2<Q: ?Sized>(&mut self, key: &Q) -> Option<(usize, &mut K, &mut V)>
     where
         Q: Hash + Equivalent<K>,
     {
-        self.get_full_mut2_impl(key)
+        if let Some(i) = self.get_index_of(key) {
+            let entry = &mut self.as_entries_mut()[i];
+            Some((i, &mut entry.key, &mut entry.value))
+        } else {
+            None
+        }
+    }
+
+    fn get_index_mut2(&mut self, index: usize) -> Option<(&mut K, &mut V)> {
+        self.as_entries_mut().get_mut(index).map(Bucket::muts)
     }
 
     fn retain2<F>(&mut self, keep: F)
@@ -68,8 +82,10 @@ where
     {
         self.retain_mut(keep)
     }
+}
 
-    fn __private_marker(&self) -> PrivateMarker {
-        PrivateMarker {}
-    }
+mod private {
+    pub trait Sealed {}
+
+    impl<K, V, S> Sealed for super::IndexMap<K, V, S> {}
 }