5 files changed, 210 insertions, 210 deletions

diff --git a/crates/ide_assists/src/handlers/convert_iter_for_each_to_for.rs b/crates/ide_assists/src/handlers/convert_iter_for_each_to_for.rs
index 4e75a7b14..7fd73d4c7 100644
--- a/crates/ide_assists/src/handlers/convert_iter_for_each_to_for.rs
+++ b/crates/ide_assists/src/handlers/convert_iter_for_each_to_for.rs
@@ -77,9 +77,11 @@ fn validate_method_call_expr(
     expr: ast::MethodCallExpr,
 ) -> Option<(ast::Expr, ast::Expr)> {
     let name_ref = expr.name_ref()?;
-    if name_ref.syntax().text_range().intersect(ctx.frange.range).is_none()
-        || name_ref.text() != "for_each"
-    {
+    if name_ref.syntax().text_range().intersect(ctx.frange.range).is_none() {
+        cov_mark::hit!(test_for_each_not_applicable_invalid_cursor_pos);
+        return None;
+    }
+    if name_ref.text() != "for_each" {
         return None;
     }
 
@@ -98,59 +100,27 @@ fn validate_method_call_expr(
 
 #[cfg(test)]
 mod tests {
-    use crate::tests::{self, check_assist};
+    use crate::tests::{check_assist, check_assist_not_applicable};
 
     use super::*;
 
-    const EMPTY_ITER_FIXTURE: &'static str = r"
-//- /lib.rs deps:core crate:empty_iter
-pub struct EmptyIter;
-impl Iterator for EmptyIter {
-    type Item = usize;
-    fn next(&mut self) -> Option<Self::Item> { None }
-}
-pub struct Empty;
-impl Empty {
-    pub fn iter(&self) -> EmptyIter { EmptyIter }
-}
-";
-
-    fn check_assist_with_fixtures(before: &str, after: &str) {
-        let before = &format!(
-            "//- /main.rs crate:main deps:core,empty_iter{}{}{}",
-            before,
-            EMPTY_ITER_FIXTURE,
-            FamousDefs::FIXTURE,
-        );
-        check_assist(convert_iter_for_each_to_for, before, after);
-    }
-
-    fn check_assist_not_applicable(before: &str) {
-        let before = &format!(
-            "//- /main.rs crate:main deps:core,empty_iter{}{}{}",
-            before,
-            EMPTY_ITER_FIXTURE,
-            FamousDefs::FIXTURE,
-        );
-        tests::check_assist_not_applicable(convert_iter_for_each_to_for, before);
-    }
-
     #[test]
     fn test_for_each_in_method_stmt() {
-        check_assist_with_fixtures(
+        check_assist(
+            convert_iter_for_each_to_for,
             r#"
-use empty_iter::*;
+//- minicore: iterators
 fn main() {
-    let x = Empty;
-    x.iter().$0for_each(|(x, y)| {
+    let it = core::iter::repeat(92);
+    it.$0for_each(|(x, y)| {
         println!("x: {}, y: {}", x, y);
     });
-}"#,
+}
+"#,
             r#"
-use empty_iter::*;
 fn main() {
-    let x = Empty;
-    for (x, y) in x.iter() {
+    let it = core::iter::repeat(92);
+    for (x, y) in it {
         println!("x: {}, y: {}", x, y);
     }
 }
@@ -160,43 +130,21 @@ fn main() {
 
     #[test]
     fn test_for_each_in_method() {
-        check_assist_with_fixtures(
+        check_assist(
+            convert_iter_for_each_to_for,
             r#"
-use empty_iter::*;
+//- minicore: iterators
 fn main() {
-    let x = Empty;
-    x.iter().$0for_each(|(x, y)| {
+    let it = core::iter::repeat(92);
+    it.$0for_each(|(x, y)| {
         println!("x: {}, y: {}", x, y);
     })
-}"#,
-            r#"
-use empty_iter::*;
-fn main() {
-    let x = Empty;
-    for (x, y) in x.iter() {
-        println!("x: {}, y: {}", x, y);
-    }
 }
 "#,
-        )
-    }
-
-    #[test]
-    fn test_for_each_in_iter_stmt() {
-        check_assist_with_fixtures(
-            r#"
-use empty_iter::*;
-fn main() {
-    let x = Empty.iter();
-    x.$0for_each(|(x, y)| {
-        println!("x: {}, y: {}", x, y);
-    });
-}"#,
             r#"
-use empty_iter::*;
 fn main() {
-    let x = Empty.iter();
-    for (x, y) in x {
+    let it = core::iter::repeat(92);
+    for (x, y) in it {
         println!("x: {}, y: {}", x, y);
     }
 }
@@ -206,18 +154,19 @@ fn main() {
 
     #[test]
     fn test_for_each_without_braces_stmt() {
-        check_assist_with_fixtures(
+        check_assist(
+            convert_iter_for_each_to_for,
             r#"
-use empty_iter::*;
+//- minicore: iterators
 fn main() {
-    let x = Empty;
-    x.iter().$0for_each(|(x, y)| println!("x: {}, y: {}", x, y));
-}"#,
+    let it = core::iter::repeat(92);
+    it.$0for_each(|(x, y)| println!("x: {}, y: {}", x, y));
+}
+"#,
             r#"
-use empty_iter::*;
 fn main() {
-    let x = Empty;
-    for (x, y) in x.iter() {
+    let it = core::iter::repeat(92);
+    for (x, y) in it {
         println!("x: {}, y: {}", x, y)
     }
 }
@@ -228,7 +177,9 @@ fn main() {
     #[test]
     fn test_for_each_not_applicable() {
         check_assist_not_applicable(
+            convert_iter_for_each_to_for,
             r#"
+//- minicore: iterators
 fn main() {
     ().$0for_each(|x| println!("{}", x));
 }"#,
@@ -237,11 +188,13 @@ fn main() {
 
     #[test]
     fn test_for_each_not_applicable_invalid_cursor_pos() {
+        cov_mark::check!(test_for_each_not_applicable_invalid_cursor_pos);
         check_assist_not_applicable(
+            convert_iter_for_each_to_for,
             r#"
-use empty_iter::*;
+//- minicore: iterators
 fn main() {
-    Empty.iter().for_each(|(x, y)| $0println!("x: {}, y: {}", x, y));
+    core::iter::repeat(92).for_each(|(x, y)| $0println!("x: {}, y: {}", x, y));
 }"#,
         )
     }
diff --git a/crates/ide_assists/src/handlers/fill_match_arms.rs b/crates/ide_assists/src/handlers/fill_match_arms.rs
index 5a43bdd6f..cd0f6dba9 100644
--- a/crates/ide_assists/src/handlers/fill_match_arms.rs
+++ b/crates/ide_assists/src/handlers/fill_match_arms.rs
@@ -278,8 +278,6 @@ fn build_pat(db: &RootDatabase, module: hir::Module, var: ExtendedVariant) -> Op
 
 #[cfg(test)]
 mod tests {
-    use ide_db::helpers::FamousDefs;
-
     use crate::tests::{
         check_assist, check_assist_not_applicable, check_assist_target, check_assist_unresolved,
     };
@@ -716,7 +714,10 @@ fn main() {
 
     #[test]
     fn fill_match_arms_tuple_of_enum_partial_with_wildcards() {
-        let ra_fixture = r#"
+        check_assist(
+            fill_match_arms,
+            r#"
+//- minicore: option
 fn main() {
     let a = Some(1);
     let b = Some(());
@@ -725,10 +726,7 @@ fn main() {
         (None, Some(_)) => {}
     }
 }
-"#;
-        check_assist(
-            fill_match_arms,
-            &format!("//- /main.rs crate:main deps:core{}{}", ra_fixture, FamousDefs::FIXTURE),
+"#,
             r#"
 fn main() {
     let a = Some(1);
@@ -746,17 +744,17 @@ fn main() {
     #[test]
     fn fill_match_arms_partial_with_deep_pattern() {
         // Fixme: cannot handle deep patterns
-        let ra_fixture = r#"
+        check_assist_not_applicable(
+            fill_match_arms,
+            r#"
+//- minicore: option
 fn main() {
     match $0Some(true) {
         Some(true) => {}
         None => {}
     }
 }
-"#;
-        check_assist_not_applicable(
-            fill_match_arms,
-            &format!("//- /main.rs crate:main deps:core{}{}", ra_fixture, FamousDefs::FIXTURE),
+"#,
         );
     }
 
@@ -1007,17 +1005,15 @@ fn foo(a: A) {
     #[test]
     fn option_order() {
         cov_mark::check!(option_order);
-        let before = r#"
+        check_assist(
+            fill_match_arms,
+            r#"
+//- minicore: option
 fn foo(opt: Option<i32>) {
     match opt$0 {
     }
 }
-"#;
-        let before = &format!("//- /main.rs crate:main deps:core{}{}", before, FamousDefs::FIXTURE);
-
-        check_assist(
-            fill_match_arms,
-            before,
+"#,
             r#"
 fn foo(opt: Option<i32>) {
     match opt {
diff --git a/crates/ide_assists/src/handlers/generate_deref.rs b/crates/ide_assists/src/handlers/generate_deref.rs
index 4998ff7a4..4e10fdb85 100644
--- a/crates/ide_assists/src/handlers/generate_deref.rs
+++ b/crates/ide_assists/src/handlers/generate_deref.rs
@@ -182,23 +182,17 @@ impl std::ops::Deref for B {
         );
     }
 
-    fn check_not_applicable(ra_fixture: &str) {
-        let fixture = format!(
-            "//- /main.rs crate:main deps:core,std\n{}\n{}",
-            ra_fixture,
-            FamousDefs::FIXTURE
-        );
-        check_assist_not_applicable(generate_deref, &fixture)
-    }
-
     #[test]
     fn test_generate_record_deref_not_applicable_if_already_impl() {
         cov_mark::check!(test_add_record_deref_impl_already_exists);
-        check_not_applicable(
-            r#"struct A { }
+        check_assist_not_applicable(
+            generate_deref,
+            r#"
+//- minicore: deref
+struct A { }
 struct B { $0a: A }
 
-impl std::ops::Deref for B {
+impl core::ops::Deref for B {
     type Target = A;
 
     fn deref(&self) -> &Self::Target {
@@ -211,11 +205,14 @@ impl std::ops::Deref for B {
     #[test]
     fn test_generate_field_deref_not_applicable_if_already_impl() {
         cov_mark::check!(test_add_field_deref_impl_already_exists);
-        check_not_applicable(
-            r#"struct A { }
+        check_assist_not_applicable(
+            generate_deref,
+            r#"
+//- minicore: deref
+struct A { }
 struct B($0A)
 
-impl std::ops::Deref for B {
+impl core::ops::Deref for B {
     type Target = A;
 
     fn deref(&self) -> &Self::Target {
diff --git a/crates/ide_assists/src/handlers/move_module_to_file.rs b/crates/ide_assists/src/handlers/move_module_to_file.rs
index 93f702c55..cfc54be8d 100644
--- a/crates/ide_assists/src/handlers/move_module_to_file.rs
+++ b/crates/ide_assists/src/handlers/move_module_to_file.rs
@@ -1,5 +1,8 @@
+use std::iter;
+
 use ast::edit::IndentLevel;
 use ide_db::base_db::AnchoredPathBuf;
+use itertools::Itertools;
 use stdx::format_to;
 use syntax::{
     ast::{self, edit::AstNodeEdit, NameOwner},
@@ -34,7 +37,10 @@ pub(crate) fn move_module_to_file(acc: &mut Assists, ctx: &AssistContext) -> Opt
 
     let module_name = module_ast.name()?;
 
-    let module_def = ctx.sema.to_def(&module_ast)?;
+    // get to the outermost module syntax so we can grab the module of file we are in
+    let outermost_mod_decl =
+        iter::successors(Some(module_ast.clone()), |module| module.parent()).last()?;
+    let module_def = ctx.sema.to_def(&outermost_mod_decl)?;
     let parent_module = module_def.parent(ctx.db())?;
 
     acc.add(
@@ -43,11 +49,19 @@ pub(crate) fn move_module_to_file(acc: &mut Assists, ctx: &AssistContext) -> Opt
         target,
         |builder| {
             let path = {
-                let dir = match parent_module.name(ctx.db()) {
-                    Some(name) if !parent_module.is_mod_rs(ctx.db()) => format!("{}/", name),
-                    _ => String::new(),
-                };
-                format!("./{}{}.rs", dir, module_name)
+                let mut buf = String::from("./");
+                match parent_module.name(ctx.db()) {
+                    Some(name) if !parent_module.is_mod_rs(ctx.db()) => {
+                        format_to!(buf, "{}/", name)
+                    }
+                    _ => (),
+                }
+                let segments = iter::successors(Some(module_ast.clone()), |module| module.parent())
+                    .filter_map(|it| it.name())
+                    .collect::<Vec<_>>();
+                format_to!(buf, "{}", segments.into_iter().rev().format("/"));
+                format_to!(buf, ".rs");
+                buf
             };
             let contents = {
                 let items = module_items.dedent(IndentLevel(1)).to_string();
@@ -59,14 +73,13 @@ pub(crate) fn move_module_to_file(acc: &mut Assists, ctx: &AssistContext) -> Opt
                 items
             };
 
-            let mut buf = String::new();
-            format_to!(buf, "mod {};", module_name);
+            let buf = format!("mod {};", module_name);
 
-            let replacement_start = if let Some(mod_token) = module_ast.mod_token() {
-                mod_token.text_range().start()
-            } else {
-                module_ast.syntax().text_range().start()
-            };
+            let replacement_start = match module_ast.mod_token() {
+                Some(mod_token) => mod_token.text_range(),
+                None => module_ast.syntax().text_range(),
+            }
+            .start();
 
             builder.replace(
                 TextRange::new(replacement_start, module_ast.syntax().text_range().end()),
@@ -212,4 +225,30 @@ mod tests;
 "#,
         );
     }
+
+    #[test]
+    fn extract_nested() {
+        check_assist(
+            move_module_to_file,
+            r#"
+//- /lib.rs
+mod foo;
+//- /foo.rs
+mod bar {
+    mod baz {
+        mod qux$0 {}
+    }
+}
+"#,
+            r#"
+//- /foo.rs
+mod bar {
+    mod baz {
+        mod qux;
+    }
+}
+//- /foo/bar/baz/qux.rs
+"#,
+        );
+    }
 }
diff --git a/crates/ide_assists/src/handlers/replace_for_loop_with_for_each.rs b/crates/ide_assists/src/handlers/replace_for_loop_with_for_each.rs
index 50b05ab0b..5f2aa016f 100644
--- a/crates/ide_assists/src/handlers/replace_for_loop_with_for_each.rs
+++ b/crates/ide_assists/src/handlers/replace_for_loop_with_for_each.rs
@@ -85,38 +85,48 @@ fn is_ref_and_impls_iter_method(
     let krate = scope.module()?.krate();
     let traits_in_scope = scope.traits_in_scope();
     let iter_trait = FamousDefs(sema, Some(krate)).core_iter_Iterator()?;
-    let has_wanted_method = typ.iterate_method_candidates(
-        sema.db,
-        krate,
-        &traits_in_scope,
-        Some(&wanted_method),
-        |_, func| {
-            if func.ret_type(sema.db).impls_trait(sema.db, iter_trait, &[]) {
-                return Some(());
-            }
-            None
-        },
-    );
-    has_wanted_method.and(Some((expr_behind_ref, wanted_method)))
+
+    let has_wanted_method = typ
+        .iterate_method_candidates(
+            sema.db,
+            krate,
+            &traits_in_scope,
+            Some(&wanted_method),
+            |_, func| {
+                if func.ret_type(sema.db).impls_trait(sema.db, iter_trait, &[]) {
+                    return Some(());
+                }
+                None
+            },
+        )
+        .is_some();
+    if !has_wanted_method {
+        return None;
+    }
+
+    Some((expr_behind_ref, wanted_method))
 }
 
 /// Whether iterable implements core::Iterator
 fn impls_core_iter(sema: &hir::Semantics<ide_db::RootDatabase>, iterable: &ast::Expr) -> bool {
-    let it_typ = if let Some(i) = sema.type_of_expr(iterable) {
-        i
-    } else {
-        return false;
+    let it_typ = match sema.type_of_expr(iterable) {
+        Some(it) => it,
+        None => return false,
     };
-    let module = if let Some(m) = sema.scope(iterable.syntax()).module() {
-        m
-    } else {
-        return false;
+
+    let module = match sema.scope(iterable.syntax()).module() {
+        Some(it) => it,
+        None => return false,
     };
+
     let krate = module.krate();
-    if let Some(iter_trait) = FamousDefs(sema, Some(krate)).core_iter_Iterator() {
-        return it_typ.impls_trait(sema.db, iter_trait, &[]);
+    match FamousDefs(sema, Some(krate)).core_iter_Iterator() {
+        Some(iter_trait) => {
+            cov_mark::hit!(test_already_impls_iterator);
+            it_typ.impls_trait(sema.db, iter_trait, &[])
+        }
+        None => false,
     }
-    false
 }
 
 #[cfg(test)]
@@ -125,33 +135,6 @@ mod tests {
 
     use super::*;
 
-    const EMPTY_ITER_FIXTURE: &'static str = r"
-//- /lib.rs deps:core crate:empty_iter
-pub struct EmptyIter;
-impl Iterator for EmptyIter {
-    type Item = usize;
-    fn next(&mut self) -> Option<Self::Item> { None }
-}
-
-pub struct Empty;
-impl Empty {
-    pub fn iter(&self) -> EmptyIter { EmptyIter }
-    pub fn iter_mut(&self) -> EmptyIter { EmptyIter }
-}
-
-pub struct NoIterMethod;
-";
-
-    fn check_assist_with_fixtures(before: &str, after: &str) {
-        let before = &format!(
-            "//- /main.rs crate:main deps:core,empty_iter{}{}{}",
-            before,
-            FamousDefs::FIXTURE,
-            EMPTY_ITER_FIXTURE
-        );
-        check_assist(replace_for_loop_with_for_each, before, after);
-    }
-
     #[test]
     fn test_not_for() {
         check_assist_not_applicable(
@@ -201,33 +184,50 @@ fn main() {
 
     #[test]
     fn test_for_borrowed() {
-        check_assist_with_fixtures(
-            r"
-use empty_iter::*;
+        check_assist(
+            replace_for_loop_with_for_each,
+            r#"
+//- minicore: iterators
+use core::iter::{Repeat, repeat};
+
+struct S;
+impl S {
+    fn iter(&self) -> Repeat<i32> { repeat(92) }
+    fn iter_mut(&mut self) -> Repeat<i32> { repeat(92) }
+}
+
 fn main() {
-    let x = Empty;
+    let x = S;
     for $0v in &x {
         let a = v * 2;
     }
 }
-",
-            r"
-use empty_iter::*;
+"#,
+            r#"
+use core::iter::{Repeat, repeat};
+
+struct S;
+impl S {
+    fn iter(&self) -> Repeat<i32> { repeat(92) }
+    fn iter_mut(&mut self) -> Repeat<i32> { repeat(92) }
+}
+
 fn main() {
-    let x = Empty;
+    let x = S;
     x.iter().for_each(|v| {
         let a = v * 2;
     });
 }
-",
+"#,
         )
     }
 
     #[test]
     fn test_for_borrowed_no_iter_method() {
-        check_assist_with_fixtures(
+        check_assist(
+            replace_for_loop_with_for_each,
             r"
-use empty_iter::*;
+struct NoIterMethod;
 fn main() {
     let x = NoIterMethod;
     for $0v in &x {
@@ -236,7 +236,7 @@ fn main() {
 }
 ",
             r"
-use empty_iter::*;
+struct NoIterMethod;
 fn main() {
     let x = NoIterMethod;
     (&x).into_iter().for_each(|v| {
@@ -249,25 +249,41 @@ fn main() {
 
     #[test]
     fn test_for_borrowed_mut() {
-        check_assist_with_fixtures(
-            r"
-use empty_iter::*;
+        check_assist(
+            replace_for_loop_with_for_each,
+            r#"
+//- minicore: iterators
+use core::iter::{Repeat, repeat};
+
+struct S;
+impl S {
+    fn iter(&self) -> Repeat<i32> { repeat(92) }
+    fn iter_mut(&mut self) -> Repeat<i32> { repeat(92) }
+}
+
 fn main() {
-    let x = Empty;
+    let x = S;
     for $0v in &mut x {
         let a = v * 2;
     }
 }
-",
-            r"
-use empty_iter::*;
+"#,
+            r#"
+use core::iter::{Repeat, repeat};
+
+struct S;
+impl S {
+    fn iter(&self) -> Repeat<i32> { repeat(92) }
+    fn iter_mut(&mut self) -> Repeat<i32> { repeat(92) }
+}
+
 fn main() {
-    let x = Empty;
+    let x = S;
     x.iter_mut().for_each(|v| {
         let a = v * 2;
     });
 }
-",
+"#,
         )
     }
 
@@ -296,21 +312,20 @@ fn main() {
 
     #[test]
     fn test_already_impls_iterator() {
-        check_assist_with_fixtures(
+        cov_mark::check!(test_already_impls_iterator);
+        check_assist(
+            replace_for_loop_with_for_each,
             r#"
-use empty_iter::*;
+//- minicore: iterators
 fn main() {
-    let x = Empty;
-    for$0 a in x.iter().take(1) {
+    for$0 a in core::iter::repeat(92).take(1) {
         println!("{}", a);
     }
 }
 "#,
             r#"
-use empty_iter::*;
 fn main() {
-    let x = Empty;
-    x.iter().take(1).for_each(|a| {
+    core::iter::repeat(92).take(1).for_each(|a| {
         println!("{}", a);
     });
 }