3 files changed, 778 insertions, 20 deletions

diff --git a/crates/test_utils/src/fixture.rs b/crates/test_utils/src/fixture.rs
index d0bddf7d8..44656267f 100644
--- a/crates/test_utils/src/fixture.rs
+++ b/crates/test_utils/src/fixture.rs
@@ -77,6 +77,11 @@ pub struct Fixture {
     pub introduce_new_source_root: bool,
 }
 
+pub struct MiniCore {
+    activated_flags: Vec<String>,
+    valid_flags: Vec<String>,
+}
+
 impl Fixture {
     /// Parses text which looks like this:
     ///
@@ -86,12 +91,28 @@ impl Fixture {
     ///  line 2
     ///  //- other meta
     ///  ```
-    pub fn parse(ra_fixture: &str) -> Vec<Fixture> {
+    ///
+    /// Fixture can also start with a minicore declaration:
+    ///
+    /// ```
+    /// //- minicore: sized
+    /// ```
+    ///
+    /// That will include a subset of `libcore` into the fixture, see
+    /// `minicore.rs` for what's available.
+    pub fn parse(ra_fixture: &str) -> (Option<MiniCore>, Vec<Fixture>) {
         let fixture = trim_indent(ra_fixture);
-
+        let mut fixture = fixture.as_str();
+        let mut mini_core = None;
         let mut res: Vec<Fixture> = Vec::new();
 
-        let default = if ra_fixture.contains("//-") { None } else { Some("//- /main.rs") };
+        if fixture.starts_with("//- minicore:") {
+            let first_line = fixture.split_inclusive('\n').next().unwrap();
+            mini_core = Some(MiniCore::parse(first_line));
+            fixture = &fixture[first_line.len()..];
+        }
+
+        let default = if fixture.contains("//-") { None } else { Some("//- /main.rs") };
 
         for (ix, line) in default.into_iter().chain(fixture.split_inclusive('\n')).enumerate() {
             if line.contains("//-") {
@@ -108,12 +129,22 @@ impl Fixture {
             if line.starts_with("//-") {
                 let meta = Fixture::parse_meta_line(line);
                 res.push(meta)
-            } else if let Some(entry) = res.last_mut() {
-                entry.text.push_str(line);
+            } else {
+                if line.starts_with("// ")
+                    && line.contains(':')
+                    && !line.contains("::")
+                    && line.chars().all(|it| !it.is_uppercase())
+                {
+                    panic!("looks like invalid metadata line: {:?}", line)
+                }
+
+                if let Some(entry) = res.last_mut() {
+                    entry.text.push_str(line);
+                }
             }
         }
 
-        res
+        (mini_core, res)
     }
 
     //- /lib.rs crate:foo deps:bar,baz cfg:foo=a,bar=b env:OUTDIR=path/to,OTHER=foo
@@ -123,7 +154,7 @@ impl Fixture {
         let components = meta.split_ascii_whitespace().collect::<Vec<_>>();
 
         let path = components[0].to_string();
-        assert!(path.starts_with('/'));
+        assert!(path.starts_with('/'), "fixture path does not start with `/`: {:?}", path);
 
         let mut krate = None;
         let mut deps = Vec::new();
@@ -133,7 +164,9 @@ impl Fixture {
         let mut env = FxHashMap::default();
         let mut introduce_new_source_root = false;
         for component in components[1..].iter() {
-            let (key, value) = component.split_once(':').unwrap();
+            let (key, value) = component
+                .split_once(':')
+                .unwrap_or_else(|| panic!("invalid meta line: {:?}", meta));
             match key {
                 "crate" => krate = Some(value.to_string()),
                 "deps" => deps = value.split(',').map(|it| it.to_string()).collect(),
@@ -172,6 +205,139 @@ impl Fixture {
     }
 }
 
+impl MiniCore {
+    fn has_flag(&self, flag: &str) -> bool {
+        self.activated_flags.iter().any(|it| it == flag)
+    }
+
+    #[track_caller]
+    fn assert_valid_flag(&self, flag: &str) {
+        if !self.valid_flags.iter().any(|it| it == flag) {
+            panic!("invalid flag: {:?}, valid flags: {:?}", flag, self.valid_flags);
+        }
+    }
+
+    fn parse(line: &str) -> MiniCore {
+        let mut res = MiniCore { activated_flags: Vec::new(), valid_flags: Vec::new() };
+
+        let line = line.strip_prefix("//- minicore:").unwrap().trim();
+        for entry in line.split(", ") {
+            if res.has_flag(entry) {
+                panic!("duplicate minicore flag: {:?}", entry)
+            }
+            res.activated_flags.push(entry.to_string())
+        }
+
+        res
+    }
+
+    /// Strips parts of minicore.rs which are flagged by inactive flags.
+    ///
+    /// This is probably over-engineered to support flags dependencies.
+    pub fn source_code(mut self) -> String {
+        let mut buf = String::new();
+        let raw_mini_core = include_str!("./minicore.rs");
+        let mut lines = raw_mini_core.split_inclusive('\n');
+
+        let mut parsing_flags = false;
+        let mut implications = Vec::new();
+
+        // Parse `//!` preamble and extract flags and dependencies.
+        for line in lines.by_ref() {
+            let line = match line.strip_prefix("//!") {
+                Some(it) => it,
+                None => {
+                    assert!(line.trim().is_empty());
+                    break;
+                }
+            };
+
+            if parsing_flags {
+                let (flag, deps) = line.split_once(':').unwrap();
+                let flag = flag.trim();
+                self.valid_flags.push(flag.to_string());
+                for dep in deps.split(", ") {
+                    let dep = dep.trim();
+                    if !dep.is_empty() {
+                        self.assert_valid_flag(dep);
+                        implications.push((flag, dep));
+                    }
+                }
+            }
+
+            if line.contains("Available flags:") {
+                parsing_flags = true;
+            }
+        }
+
+        for flag in &self.activated_flags {
+            self.assert_valid_flag(flag);
+        }
+
+        // Fixed point loop to compute transitive closure of flags.
+        loop {
+            let mut changed = false;
+            for &(u, v) in implications.iter() {
+                if self.has_flag(u) && !self.has_flag(v) {
+                    self.activated_flags.push(v.to_string());
+                    changed = true;
+                }
+            }
+            if !changed {
+                break;
+            }
+        }
+
+        let mut active_regions = Vec::new();
+        let mut seen_regions = Vec::new();
+        for line in lines {
+            let trimmed = line.trim();
+            if let Some(region) = trimmed.strip_prefix("// region:") {
+                active_regions.push(region);
+                continue;
+            }
+            if let Some(region) = trimmed.strip_prefix("// endregion:") {
+                let prev = active_regions.pop().unwrap();
+                assert_eq!(prev, region);
+                continue;
+            }
+
+            let mut line_region = false;
+            if let Some(idx) = trimmed.find("// :") {
+                line_region = true;
+                active_regions.push(&trimmed[idx + "// :".len()..]);
+            }
+
+            let mut keep = true;
+            for &region in &active_regions {
+                assert!(
+                    !region.starts_with(' '),
+                    "region marker starts with a space: {:?}",
+                    region
+                );
+                self.assert_valid_flag(region);
+                seen_regions.push(region);
+                keep &= self.has_flag(region);
+            }
+
+            if keep {
+                buf.push_str(line)
+            }
+            if line_region {
+                active_regions.pop().unwrap();
+            }
+        }
+
+        for flag in &self.valid_flags {
+            if !seen_regions.iter().any(|it| it == flag) {
+                panic!("unused minicore flag: {:?}", flag);
+            }
+        }
+        format!("{}", buf);
+        buf
+    }
+}
+
 #[test]
 #[should_panic]
 fn parse_fixture_checks_further_indented_metadata() {
@@ -189,12 +355,14 @@ fn parse_fixture_checks_further_indented_metadata() {
 
 #[test]
 fn parse_fixture_gets_full_meta() {
-    let parsed = Fixture::parse(
-        r"
-    //- /lib.rs crate:foo deps:bar,baz cfg:foo=a,bar=b,atom env:OUTDIR=path/to,OTHER=foo
-    mod m;
-    ",
+    let (mini_core, parsed) = Fixture::parse(
+        r#"
+//- minicore: coerce_unsized
+//- /lib.rs crate:foo deps:bar,baz cfg:foo=a,bar=b,atom env:OUTDIR=path/to,OTHER=foo
+mod m;
+"#,
     );
+    assert_eq!(mini_core.unwrap().activated_flags, vec!["coerce_unsized".to_string()]);
     assert_eq!(1, parsed.len());
 
     let meta = &parsed[0];
diff --git a/crates/test_utils/src/lib.rs b/crates/test_utils/src/lib.rs
index b2fe25f82..d9c22c180 100644
--- a/crates/test_utils/src/lib.rs
+++ b/crates/test_utils/src/lib.rs
@@ -11,6 +11,7 @@ mod fixture;
 mod assert_linear;
 
 use std::{
+    collections::BTreeMap,
     convert::{TryFrom, TryInto},
     env, fs,
     path::{Path, PathBuf},
@@ -23,7 +24,10 @@ use text_size::{TextRange, TextSize};
 pub use dissimilar::diff as __diff;
 pub use rustc_hash::FxHashMap;
 
-pub use crate::{assert_linear::AssertLinear, fixture::Fixture};
+pub use crate::{
+    assert_linear::AssertLinear,
+    fixture::{Fixture, MiniCore},
+};
 
 pub const CURSOR_MARKER: &str = "$0";
 pub const ESCAPED_CURSOR_MARKER: &str = "\\$0";
@@ -202,14 +206,25 @@ pub fn add_cursor(text: &str, offset: TextSize) -> String {
 ///
 /// // ^^^ first line
 /// //   | second line
+///
+/// Annotations point to the last line that actually was long enough for the
+/// range, not counting annotations themselves. So overlapping annotations are
+/// possible:
+/// ```no_run
+/// // stuff        other stuff
+/// // ^^ 'st'
+/// // ^^^^^ 'stuff'
+/// //              ^^^^^^^^^^^ 'other stuff'
+/// ```
 pub fn extract_annotations(text: &str) -> Vec<(TextRange, String)> {
     let mut res = Vec::new();
-    let mut prev_line_start: Option<TextSize> = Some(0.into());
+    // map from line length to beginning of last line that had that length
+    let mut line_start_map = BTreeMap::new();
     let mut line_start: TextSize = 0.into();
     let mut prev_line_annotations: Vec<(TextSize, usize)> = Vec::new();
     for line in text.split_inclusive('\n') {
         let mut this_line_annotations = Vec::new();
-        if let Some(idx) = line.find("//") {
+        let line_length = if let Some(idx) = line.find("//") {
             let annotation_offset = TextSize::of(&line[..idx + "//".len()]);
             for annotation in extract_line_annotations(&line[idx + "//".len()..]) {
                 match annotation {
@@ -219,7 +234,9 @@ pub fn extract_annotations(text: &str) -> Vec<(TextRange, String)> {
                         let range = if file {
                             TextRange::up_to(TextSize::of(text))
                         } else {
-                            range + prev_line_start.unwrap()
+                            let line_start = line_start_map.range(range.end()..).next().unwrap();
+
+                            range + line_start.1
                         };
                         res.push((range, content))
                     }
@@ -235,9 +252,14 @@ pub fn extract_annotations(text: &str) -> Vec<(TextRange, String)> {
                     }
                 }
             }
-        }
+            idx.try_into().unwrap()
+        } else {
+            TextSize::of(line)
+        };
+
+        line_start_map = line_start_map.split_off(&line_length);
+        line_start_map.insert(line_length, line_start);
 
-        prev_line_start = Some(line_start);
         line_start += TextSize::of(line);
 
         prev_line_annotations = this_line_annotations;
@@ -293,7 +315,7 @@ fn extract_line_annotations(mut line: &str) -> Vec<LineAnnotation> {
 }
 
 #[test]
-fn test_extract_annotations() {
+fn test_extract_annotations_1() {
     let text = stdx::trim_indent(
         r#"
 fn main() {
@@ -318,6 +340,25 @@ fn main() {
     assert_eq!(res[3].0.len(), 115);
 }
 
+#[test]
+fn test_extract_annotations_2() {
+    let text = stdx::trim_indent(
+        r#"
+fn main() {
+    (x,   y);
+   //^ a
+      //  ^ b
+  //^^^^^^^^ c
+}"#,
+    );
+    let res = extract_annotations(&text)
+        .into_iter()
+        .map(|(range, ann)| (&text[range], ann))
+        .collect::<Vec<_>>();
+
+    assert_eq!(res, [("x", "a".into()), ("y", "b".into()), ("(x,   y)", "c".into())]);
+}
+
 /// Returns `false` if slow tests should not run, otherwise returns `true` and
 /// also creates a file at `./target/.slow_tests_cookie` which serves as a flag
 /// that slow tests did run.
diff --git a/crates/test_utils/src/minicore.rs b/crates/test_utils/src/minicore.rs
new file mode 100644
index 000000000..ce6ad8541
--- /dev/null
+++ b/crates/test_utils/src/minicore.rs
@@ -0,0 +1,549 @@
+//! This is a fixture we use for tests that need lang items.
+//!
+//! We want to include the minimal subset of core for each test, so this file
+//! supports "conditional compilation". Tests use the following syntax to include minicore:
+//!
+//!  //- minicore: flag1, flag2
+//!
+//! We then strip all the code marked with other flags.
+//!
+//! Available flags:
+//!     sized:
+//!     unsize: sized
+//!     coerce_unsized: unsize
+//!     slice:
+//!     range:
+//!     deref: sized
+//!     deref_mut: deref
+//!     index: sized
+//!     fn:
+//!     pin:
+//!     future: pin
+//!     option:
+//!     result:
+//!     iterator: option
+//!     iterators: iterator, fn
+//!     default: sized
+//!     clone: sized
+//!     copy: clone
+//!     from: sized
+//!     eq: sized
+//!     ord: eq, option
+//!     derive:
+
+pub mod marker {
+    // region:sized
+    #[lang = "sized"]
+    #[fundamental]
+    #[rustc_specialization_trait]
+    pub trait Sized {}
+    // endregion:sized
+
+    // region:unsize
+    #[lang = "unsize"]
+    pub trait Unsize<T: ?Sized> {}
+    // endregion:unsize
+
+    // region:copy
+    #[lang = "copy"]
+    pub trait Copy: Clone {}
+    // region:derive
+    #[rustc_builtin_macro]
+    pub macro Copy($item:item) {}
+    // endregion:derive
+
+    mod copy_impls {
+        use super::Copy;
+
+        macro_rules! impl_copy {
+            ($($t:ty)*) => {
+                $(
+                    impl Copy for $t {}
+                )*
+            }
+        }
+
+        impl_copy! {
+            usize u8 u16 u32 u64 u128
+            isize i8 i16 i32 i64 i128
+            f32 f64
+            bool char
+        }
+
+        impl<T: ?Sized> Copy for *const T {}
+        impl<T: ?Sized> Copy for *mut T {}
+        impl<T: ?Sized> Copy for &T {}
+    }
+    // endregion:copy
+}
+
+// region:default
+pub mod default {
+    pub trait Default: Sized {
+        fn default() -> Self;
+    }
+}
+// endregion:default
+
+// region:clone
+pub mod clone {
+    #[lang = "clone"]
+    pub trait Clone: Sized {
+        fn clone(&self) -> Self;
+    }
+    // region:derive
+    #[rustc_builtin_macro]
+    pub macro Clone($item:item) {}
+    // endregion:derive
+}
+// endregion:clone
+
+// region:from
+pub mod convert {
+    pub trait From<T>: Sized {
+        fn from(_: T) -> Self;
+    }
+    pub trait Into<T>: Sized {
+        fn into(self) -> T;
+    }
+
+    impl<T, U> Into<U> for T
+    where
+        U: From<T>,
+    {
+        fn into(self) -> U {
+            U::from(self)
+        }
+    }
+
+    impl<T> From<T> for T {
+        fn from(t: T) -> T {
+            t
+        }
+    }
+}
+// endregion:from
+
+pub mod ops {
+    // region:coerce_unsized
+    mod unsize {
+        use crate::marker::Unsize;
+
+        #[lang = "coerce_unsized"]
+        pub trait CoerceUnsized<T: ?Sized> {}
+
+        impl<'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<&'a mut U> for &'a mut T {}
+        impl<'a, 'b: 'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<&'a U> for &'b mut T {}
+        impl<'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*mut U> for &'a mut T {}
+        impl<'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*const U> for &'a mut T {}
+
+        impl<'a, 'b: 'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<&'a U> for &'b T {}
+        impl<'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*const U> for &'a T {}
+
+        impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*mut U> for *mut T {}
+        impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*const U> for *mut T {}
+        impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<*const U> for *const T {}
+    }
+    pub use self::unsize::CoerceUnsized;
+    // endregion:coerce_unsized
+
+    // region:deref
+    mod deref {
+        #[lang = "deref"]
+        pub trait Deref {
+            #[lang = "deref_target"]
+            type Target: ?Sized;
+            fn deref(&self) -> &Self::Target;
+        }
+        // region:deref_mut
+        #[lang = "deref_mut"]
+        pub trait DerefMut: Deref {
+            fn deref_mut(&mut self) -> &mut Self::Target;
+        }
+        // endregion:deref_mut
+    }
+    pub use self::deref::{
+        Deref,
+        DerefMut, // :deref_mut
+    };
+    // 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"]
+        pub struct RangeFull;
+
+        #[lang = "Range"]
+        pub struct Range<Idx> {
+            pub start: Idx,
+            pub end: Idx,
+        }
+
+        #[lang = "RangeFrom"]
+        pub struct RangeFrom<Idx> {
+            pub start: Idx,
+        }
+
+        #[lang = "RangeTo"]
+        pub struct RangeTo<Idx> {
+            pub end: Idx,
+        }
+
+        #[lang = "RangeInclusive"]
+        pub struct RangeInclusive<Idx> {
+            pub(crate) start: Idx,
+            pub(crate) end: Idx,
+            pub(crate) exhausted: bool,
+        }
+
+        #[lang = "RangeToInclusive"]
+        pub struct RangeToInclusive<Idx> {
+            pub end: Idx,
+        }
+    }
+    pub use self::range::{Range, RangeFrom, RangeFull, RangeTo};
+    pub use self::range::{RangeInclusive, RangeToInclusive};
+    // endregion:range
+
+    // region:fn
+    mod function {
+        #[lang = "fn"]
+        #[fundamental]
+        pub trait Fn<Args>: FnMut<Args> {}
+
+        #[lang = "fn_mut"]
+        #[fundamental]
+        pub trait FnMut<Args>: FnOnce<Args> {}
+
+        #[lang = "fn_once"]
+        #[fundamental]
+        pub trait FnOnce<Args> {
+            #[lang = "fn_once_output"]
+            type Output;
+        }
+    }
+    pub use self::function::{Fn, FnMut, FnOnce};
+    // endregion:fn
+}
+
+// region:eq
+pub mod cmp {
+    #[lang = "eq"]
+    pub trait PartialEq<Rhs: ?Sized = Self> {
+        fn eq(&self, other: &Rhs) -> bool;
+    }
+
+    pub trait Eq: PartialEq<Self> {}
+
+    // region:derive
+    #[rustc_builtin_macro]
+    pub macro PartialEq($item:item) {}
+    #[rustc_builtin_macro]
+    pub macro Eq($item:item) {}
+    // endregion:derive
+
+    // region:ord
+    #[lang = "partial_ord"]
+    pub trait PartialOrd<Rhs: ?Sized = Self>: PartialEq<Rhs> {
+        fn partial_cmp(&self, other: &Rhs) -> Option<Ordering>;
+    }
+
+    pub trait Ord: Eq + PartialOrd<Self> {
+        fn cmp(&self, other: &Self) -> Ordering;
+    }
+
+    pub enum Ordering {
+        Less = -1,
+        Equal = 0,
+        Greater = 1,
+    }
+
+    // region:derive
+    #[rustc_builtin_macro]
+    pub macro PartialOrd($item:item) {}
+    #[rustc_builtin_macro]
+    pub macro Ord($item:item) {}
+    // endregion:derive
+
+    // endregion:ord
+}
+// endregion:eq
+
+// region:slice
+pub mod slice {
+    #[lang = "slice"]
+    impl<T> [T] {
+        pub fn len(&self) -> usize {
+            loop {}
+        }
+    }
+}
+// endregion:slice
+
+// region:option
+pub mod option {
+    pub enum Option<T> {
+        #[lang = "None"]
+        None,
+        #[lang = "Some"]
+        Some(T),
+    }
+}
+// endregion:option
+
+// region:result
+pub mod result {
+    pub enum Result<T, E> {
+        #[lang = "Ok"]
+        Ok(T),
+        #[lang = "Err"]
+        Err(E),
+    }
+}
+// endregion:result
+
+// region:pin
+pub mod pin {
+    #[lang = "pin"]
+    #[fundamental]
+    pub struct Pin<P> {
+        pointer: P,
+    }
+}
+// endregion:pin
+
+// region:future
+pub mod future {
+    use crate::{
+        pin::Pin,
+        task::{Context, Poll},
+    };
+
+    #[lang = "future_trait"]
+    pub trait Future {
+        type Output;
+        #[lang = "poll"]
+        fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>;
+    }
+}
+pub mod task {
+    pub enum Poll<T> {
+        #[lang = "Ready"]
+        Ready(T),
+        #[lang = "Pending"]
+        Pending,
+    }
+
+    pub struct Context<'a> {
+        waker: &'a (),
+    }
+}
+// endregion:future
+
+// region:iterator
+pub mod iter {
+    // region:iterators
+    mod adapters {
+        pub struct Take<I> {
+            iter: I,
+            n: usize,
+        }
+        impl<I> Iterator for Take<I>
+        where
+            I: Iterator,
+        {
+            type Item = <I as Iterator>::Item;
+
+            fn next(&mut self) -> Option<<I as Iterator>::Item> {
+                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;
+
+    mod sources {
+        mod repeat {
+            pub fn repeat<T>(elt: T) -> Repeat<T> {
+                loop {}
+            }
+
+            pub struct Repeat<A> {
+                element: A,
+            }
+
+            impl<A> Iterator for Repeat<A> {
+                type Item = A;
+
+                fn next(&mut self) -> Option<A> {
+                    loop {}
+                }
+            }
+        }
+        pub use self::repeat::{repeat, Repeat};
+    }
+    pub use self::sources::{repeat, Repeat};
+    // endregion:iterators
+
+    mod traits {
+        mod iterator {
+            use super::super::Take;
+
+            pub trait Iterator {
+                type Item;
+                #[lang = "next"]
+                fn next(&mut self) -> Option<Self::Item>;
+                fn nth(&mut self, n: usize) -> Option<Self::Item> {
+                    loop {}
+                }
+                fn by_ref(&mut self) -> &mut Self
+                where
+                    Self: Sized,
+                {
+                    self
+                }
+                // region:iterators
+                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 {
+                type Item = I::Item;
+                fn next(&mut self) -> Option<I::Item> {
+                    (**self).next()
+                }
+            }
+        }
+        pub use self::iterator::Iterator;
+
+        mod collect {
+            pub trait IntoIterator {
+                type Item;
+                type IntoIter: Iterator<Item = Self::Item>;
+                #[lang = "into_iter"]
+                fn into_iter(self) -> Self::IntoIter;
+            }
+            impl<I: Iterator> IntoIterator for I {
+                type Item = I::Item;
+                type IntoIter = I;
+                fn into_iter(self) -> I {
+                    self
+                }
+            }
+        }
+        pub use self::collect::IntoIterator;
+    }
+    pub use self::traits::{IntoIterator, Iterator};
+}
+// endregion:iterator
+
+// region:derive
+mod macros {
+    pub(crate) mod builtin {
+        #[rustc_builtin_macro]
+        pub macro derive($item:item) {
+            /* compiler built-in */
+        }
+    }
+}
+// endregion:derive
+
+pub mod prelude {
+    pub mod v1 {
+        pub use crate::{
+            clone::Clone,                       // :clone
+            cmp::{Eq, PartialEq},               // :eq
+            cmp::{Ord, PartialOrd},             // :ord
+            convert::{From, Into},              // :from
+            default::Default,                   // :default
+            iter::{IntoIterator, Iterator},     // :iterator
+            macros::builtin::derive,            // :derive
+            marker::Copy,                       // :copy
+            marker::Sized,                      // :sized
+            ops::{Fn, FnMut, FnOnce},           // :fn
+            option::Option::{self, None, Some}, // :option
+            result::Result::{self, Err, Ok},    // :result
+        };
+    }
+
+    pub mod rust_2015 {
+        pub use super::v1::*;
+    }
+
+    pub mod rust_2018 {
+        pub use super::v1::*;
+    }
+
+    pub mod rust_2021 {
+        pub use super::v1::*;
+    }
+}
+
+#[prelude_import]
+#[allow(unused)]
+use prelude::v1::*;