1 files changed, 67 insertions, 2 deletions

diff --git a/crates/test_utils/src/minicore.rs b/crates/test_utils/src/minicore.rs
index 769028580..ce6ad8541 100644
--- a/crates/test_utils/src/minicore.rs
+++ b/crates/test_utils/src/minicore.rs
@@ -15,13 +15,14 @@
 //!     range:
 //!     deref: sized
 //!     deref_mut: deref
+//!     index: sized
 //!     fn:
 //!     pin:
 //!     future: pin
 //!     option:
 //!     result:
 //!     iterator: option
-//!     iterators: iterator
+//!     iterators: iterator, fn
 //!     default: sized
 //!     clone: sized
 //!     copy: clone
@@ -167,6 +168,48 @@ pub mod ops {
     };
     // endregion:deref
 
+    // region:index
+    mod index {
+        #[lang = "index"]
+        pub trait Index<Idx: ?Sized> {
+            type Output: ?Sized;
+            fn index(&self, index: Idx) -> &Self::Output;
+        }
+        #[lang = "index_mut"]
+        pub trait IndexMut<Idx: ?Sized>: Index<Idx> {
+            fn index_mut(&mut self, index: Idx) -> &mut Self::Output;
+        }
+
+        // region:slice
+        impl<T, I> Index<I> for [T]
+        where
+            I: SliceIndex<[T]>,
+        {
+            type Output = I::Output;
+            fn index(&self, index: I) -> &I::Output {
+                loop {}
+            }
+        }
+        impl<T, I> IndexMut<I> for [T]
+        where
+            I: SliceIndex<[T]>,
+        {
+            fn index_mut(&mut self, index: I) -> &mut I::Output {
+                loop {}
+            }
+        }
+
+        pub unsafe trait SliceIndex<T: ?Sized> {
+            type Output: ?Sized;
+        }
+        unsafe impl<T> SliceIndex<[T]> for usize {
+            type Output = T;
+        }
+        // endregion:slice
+    }
+    pub use self::index::{Index, IndexMut};
+    // endregion:index
+
     // region:range
     mod range {
         #[lang = "RangeFull"]
@@ -347,7 +390,6 @@ pub mod iter {
             iter: I,
             n: usize,
         }
-
         impl<I> Iterator for Take<I>
         where
             I: Iterator,
@@ -358,6 +400,22 @@ pub mod iter {
                 loop {}
             }
         }
+
+        pub struct FilterMap<I, F> {
+            iter: I,
+            f: F,
+        }
+        impl<B, I: Iterator, F> Iterator for FilterMap<I, F>
+        where
+            F: FnMut(I::Item) -> Option<B>,
+        {
+            type Item = B;
+
+            #[inline]
+            fn next(&mut self) -> Option<B> {
+                loop {}
+            }
+        }
     }
     pub use self::adapters::Take;
 
@@ -405,6 +463,13 @@ pub mod iter {
                 fn take(self, n: usize) -> crate::iter::Take<Self> {
                     loop {}
                 }
+                fn filter_map<B, F>(self, f: F) -> crate::iter::FilterMap<Self, F>
+                where
+                    Self: Sized,
+                    F: FnMut(Self::Item) -> Option<B>,
+                {
+                    loop {}
+                }
                 // endregion:iterators
             }
             impl<I: Iterator + ?Sized> Iterator for &mut I {