13 files changed, 983 insertions, 93 deletions

diff --git a/crates/ide_assists/src/handlers/apply_demorgan.rs b/crates/ide_assists/src/handlers/apply_demorgan.rs
index ed4d11455..6997ea048 100644
--- a/crates/ide_assists/src/handlers/apply_demorgan.rs
+++ b/crates/ide_assists/src/handlers/apply_demorgan.rs
@@ -7,18 +7,17 @@ use crate::{utils::invert_boolean_expression, AssistContext, AssistId, AssistKin
 // Apply https://en.wikipedia.org/wiki/De_Morgan%27s_laws[De Morgan's law].
 // This transforms expressions of the form `!l || !r` into `!(l && r)`.
 // This also works with `&&`. This assist can only be applied with the cursor
-// on either `||` or `&&`, with both operands being a negation of some kind.
-// This means something of the form `!x` or `x != y`.
+// on either `||` or `&&`.
 //
 // ```
 // fn main() {
-//     if x != 4 ||$0 !y {}
+//     if x != 4 ||$0 y < 3.14 {}
 // }
 // ```
 // ->
 // ```
 // fn main() {
-//     if !(x == 4 && y) {}
+//     if !(x == 4 && !(y < 3.14)) {}
 // }
 // ```
 pub(crate) fn apply_demorgan(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
@@ -33,11 +32,11 @@ pub(crate) fn apply_demorgan(acc: &mut Assists, ctx: &AssistContext) -> Option<(
 
     let lhs = expr.lhs()?;
     let lhs_range = lhs.syntax().text_range();
-    let not_lhs = invert_boolean_expression(lhs);
+    let not_lhs = invert_boolean_expression(&ctx.sema, lhs);
 
     let rhs = expr.rhs()?;
     let rhs_range = rhs.syntax().text_range();
-    let not_rhs = invert_boolean_expression(rhs);
+    let not_rhs = invert_boolean_expression(&ctx.sema, rhs);
 
     acc.add(
         AssistId("apply_demorgan", AssistKind::RefactorRewrite),
@@ -62,10 +61,77 @@ fn opposite_logic_op(kind: ast::BinOp) -> Option<&'static str> {
 
 #[cfg(test)]
 mod tests {
+    use ide_db::helpers::FamousDefs;
+
     use super::*;
 
     use crate::tests::{check_assist, check_assist_not_applicable};
 
+    const ORDABLE_FIXTURE: &'static str = r"
+//- /lib.rs deps:core crate:ordable
+struct NonOrderable;
+struct Orderable;
+impl core::cmp::Ord for Orderable {}
+";
+
+    fn check(ra_fixture_before: &str, ra_fixture_after: &str) {
+        let before = &format!(
+            "//- /main.rs crate:main deps:core,ordable\n{}\n{}{}",
+            ra_fixture_before,
+            FamousDefs::FIXTURE,
+            ORDABLE_FIXTURE
+        );
+        check_assist(apply_demorgan, before, &format!("{}\n", ra_fixture_after));
+    }
+
+    #[test]
+    fn demorgan_handles_leq() {
+        check(
+            r"use ordable::Orderable;
+fn f() {
+    Orderable < Orderable &&$0 Orderable <= Orderable
+}",
+            r"use ordable::Orderable;
+fn f() {
+    !(Orderable >= Orderable || Orderable > Orderable)
+}",
+        );
+        check(
+            r"use ordable::NonOrderable;
+fn f() {
+    NonOrderable < NonOrderable &&$0 NonOrderable <= NonOrderable
+}",
+            r"use ordable::NonOrderable;
+fn f() {
+    !(!(NonOrderable < NonOrderable) || !(NonOrderable <= NonOrderable))
+}",
+        );
+    }
+
+    #[test]
+    fn demorgan_handles_geq() {
+        check(
+            r"use ordable::Orderable;
+fn f() {
+    Orderable > Orderable &&$0 Orderable >= Orderable
+}",
+            r"use ordable::Orderable;
+fn f() {
+    !(Orderable <= Orderable || Orderable < Orderable)
+}",
+        );
+        check(
+            r"use ordable::NonOrderable;
+fn f() {
+    Orderable > Orderable &&$0 Orderable >= Orderable
+}",
+            r"use ordable::NonOrderable;
+fn f() {
+    !(!(Orderable > Orderable) || !(Orderable >= Orderable))
+}",
+        );
+    }
+
     #[test]
     fn demorgan_turns_and_into_or() {
         check_assist(apply_demorgan, "fn f() { !x &&$0 !x }", "fn f() { !(x || x) }")
diff --git a/crates/ide_assists/src/handlers/auto_import.rs b/crates/ide_assists/src/handlers/auto_import.rs
index e93901cb3..dc38f90e9 100644
--- a/crates/ide_assists/src/handlers/auto_import.rs
+++ b/crates/ide_assists/src/handlers/auto_import.rs
@@ -33,9 +33,9 @@ use crate::{AssistContext, AssistId, AssistKind, Assists, GroupLabel};
 // use super::AssistContext;
 // ```
 //
-// .Merge Behaviour
+// .Merge Behavior
 //
-// It is possible to configure how use-trees are merged with the `importMergeBehaviour` setting.
+// It is possible to configure how use-trees are merged with the `importMergeBehavior` setting.
 // It has the following configurations:
 //
 // - `full`: This setting will cause auto-import to always completely merge use-trees that share the
@@ -46,7 +46,7 @@ use crate::{AssistContext, AssistId, AssistKind, Assists, GroupLabel};
 // - `none`: This setting will cause auto-import to never merge use-trees keeping them as simple
 //  paths.
 //
-// In `VS Code` the configuration for this is `rust-analyzer.assist.importMergeBehaviour`.
+// In `VS Code` the configuration for this is `rust-analyzer.assist.importMergeBehavior`.
 //
 // .Import Prefix
 //
diff --git a/crates/ide_assists/src/handlers/early_return.rs b/crates/ide_assists/src/handlers/early_return.rs
index 6b87c3c05..9e0918477 100644
--- a/crates/ide_assists/src/handlers/early_return.rs
+++ b/crates/ide_assists/src/handlers/early_return.rs
@@ -111,7 +111,7 @@ pub(crate) fn convert_to_guarded_return(acc: &mut Assists, ctx: &AssistContext)
                     let new_expr = {
                         let then_branch =
                             make::block_expr(once(make::expr_stmt(early_expression).into()), None);
-                        let cond = invert_boolean_expression(cond_expr);
+                        let cond = invert_boolean_expression(&ctx.sema, cond_expr);
                         make::expr_if(make::condition(cond, None), then_branch, None)
                             .indent(if_indent_level)
                     };
diff --git a/crates/ide_assists/src/handlers/flip_comma.rs b/crates/ide_assists/src/handlers/flip_comma.rs
index 18cf64a34..7f5e75d34 100644
--- a/crates/ide_assists/src/handlers/flip_comma.rs
+++ b/crates/ide_assists/src/handlers/flip_comma.rs
@@ -1,4 +1,4 @@
-use syntax::{algo::non_trivia_sibling, Direction, T};
+use syntax::{algo::non_trivia_sibling, Direction, SyntaxKind, T};
 
 use crate::{AssistContext, AssistId, AssistKind, Assists};
 
@@ -28,6 +28,12 @@ pub(crate) fn flip_comma(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
         return None;
     }
 
+    // Don't apply a "flip" inside the macro call
+    // since macro input are just mere tokens
+    if comma.ancestors().any(|it| it.kind() == SyntaxKind::MACRO_CALL) {
+        return None;
+    }
+
     acc.add(
         AssistId("flip_comma", AssistKind::RefactorRewrite),
         "Flip comma",
@@ -43,7 +49,7 @@ pub(crate) fn flip_comma(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
 mod tests {
     use super::*;
 
-    use crate::tests::{check_assist, check_assist_target};
+    use crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
 
     #[test]
     fn flip_comma_works_for_function_parameters() {
@@ -81,4 +87,20 @@ mod tests {
             ",",
         );
     }
+
+    #[test]
+    fn flip_comma_works() {
+        check_assist(
+            flip_comma,
+            r#"fn main() {((1, 2),$0 (3, 4));}"#,
+            r#"fn main() {((3, 4), (1, 2));}"#,
+        )
+    }
+
+    #[test]
+    fn flip_comma_not_applicable_for_macro_input() {
+        // "Flip comma" assist shouldn't be applicable inside the macro call
+        // See https://github.com/rust-analyzer/rust-analyzer/issues/7693
+        check_assist_not_applicable(flip_comma, r#"bar!(a,$0 b)"#);
+    }
 }
diff --git a/crates/ide_assists/src/handlers/generate_enum_match_method.rs b/crates/ide_assists/src/handlers/generate_enum_is_method.rs
index aeb887e71..7e181a480 100644
--- a/crates/ide_assists/src/handlers/generate_enum_match_method.rs
+++ b/crates/ide_assists/src/handlers/generate_enum_is_method.rs
@@ -1,14 +1,13 @@
-use stdx::{format_to, to_lower_snake_case};
+use stdx::to_lower_snake_case;
 use syntax::ast::VisibilityOwner;
 use syntax::ast::{self, AstNode, NameOwner};
-use test_utils::mark;
 
 use crate::{
-    utils::{find_impl_block_end, find_struct_impl, generate_impl_text},
+    utils::{add_method_to_adt, find_struct_impl},
     AssistContext, AssistId, AssistKind, Assists,
 };
 
-// Assist: generate_enum_match_method
+// Assist: generate_enum_is_method
 //
 // Generate an `is_` method for an enum variant.
 //
@@ -34,79 +33,52 @@ use crate::{
 //     }
 // }
 // ```
-pub(crate) fn generate_enum_match_method(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+pub(crate) fn generate_enum_is_method(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
     let variant = ctx.find_node_at_offset::<ast::Variant>()?;
     let variant_name = variant.name()?;
-    let parent_enum = variant.parent_enum();
-    if !matches!(variant.kind(), ast::StructKind::Unit) {
-        mark::hit!(test_gen_enum_match_on_non_unit_variant_not_implemented);
-        return None;
-    }
+    let parent_enum = ast::Adt::Enum(variant.parent_enum());
+    let pattern_suffix = match variant.kind() {
+        ast::StructKind::Record(_) => " { .. }",
+        ast::StructKind::Tuple(_) => "(..)",
+        ast::StructKind::Unit => "",
+    };
 
     let enum_lowercase_name = to_lower_snake_case(&parent_enum.name()?.to_string());
-    let fn_name = to_lower_snake_case(&variant_name.to_string());
+    let fn_name = format!("is_{}", &to_lower_snake_case(variant_name.text()));
 
     // Return early if we've found an existing new fn
-    let impl_def = find_struct_impl(
-        &ctx,
-        &ast::Adt::Enum(parent_enum.clone()),
-        format!("is_{}", fn_name).as_str(),
-    )?;
+    let impl_def = find_struct_impl(&ctx, &parent_enum, &fn_name)?;
 
     let target = variant.syntax().text_range();
     acc.add(
-        AssistId("generate_enum_match_method", AssistKind::Generate),
+        AssistId("generate_enum_is_method", AssistKind::Generate),
         "Generate an `is_` method for an enum variant",
         target,
         |builder| {
-            let mut buf = String::with_capacity(512);
-
-            if impl_def.is_some() {
-                buf.push('\n');
-            }
-
             let vis = parent_enum.visibility().map_or(String::new(), |v| format!("{} ", v));
-            format_to!(
-                buf,
+            let method = format!(
                 "    /// Returns `true` if the {} is [`{}`].
-    {}fn is_{}(&self) -> bool {{
-        matches!(self, Self::{})
+    {}fn {}(&self) -> bool {{
+        matches!(self, Self::{}{})
     }}",
-                enum_lowercase_name,
-                variant_name,
-                vis,
-                fn_name,
-                variant_name
+                enum_lowercase_name, variant_name, vis, fn_name, variant_name, pattern_suffix,
             );
 
-            let start_offset = impl_def
-                .and_then(|impl_def| find_impl_block_end(impl_def, &mut buf))
-                .unwrap_or_else(|| {
-                    buf = generate_impl_text(&ast::Adt::Enum(parent_enum.clone()), &buf);
-                    parent_enum.syntax().text_range().end()
-                });
-
-            builder.insert(start_offset, buf);
+            add_method_to_adt(builder, &parent_enum, impl_def, &method);
         },
     )
 }
 
 #[cfg(test)]
 mod tests {
-    use test_utils::mark;
-
     use crate::tests::{check_assist, check_assist_not_applicable};
 
     use super::*;
 
-    fn check_not_applicable(ra_fixture: &str) {
-        check_assist_not_applicable(generate_enum_match_method, ra_fixture)
-    }
-
     #[test]
-    fn test_generate_enum_match_from_variant() {
+    fn test_generate_enum_is_from_variant() {
         check_assist(
-            generate_enum_match_method,
+            generate_enum_is_method,
             r#"
 enum Variant {
     Undefined,
@@ -129,8 +101,9 @@ impl Variant {
     }
 
     #[test]
-    fn test_generate_enum_match_already_implemented() {
-        check_not_applicable(
+    fn test_generate_enum_is_already_implemented() {
+        check_assist_not_applicable(
+            generate_enum_is_method,
             r#"
 enum Variant {
     Undefined,
@@ -147,22 +120,59 @@ impl Variant {
     }
 
     #[test]
-    fn test_add_from_impl_no_element() {
-        mark::check!(test_gen_enum_match_on_non_unit_variant_not_implemented);
-        check_not_applicable(
+    fn test_generate_enum_is_from_tuple_variant() {
+        check_assist(
+            generate_enum_is_method,
             r#"
 enum Variant {
     Undefined,
     Minor(u32)$0,
     Major,
 }"#,
+            r#"enum Variant {
+    Undefined,
+    Minor(u32),
+    Major,
+}
+
+impl Variant {
+    /// Returns `true` if the variant is [`Minor`].
+    fn is_minor(&self) -> bool {
+        matches!(self, Self::Minor(..))
+    }
+}"#,
+        );
+    }
+
+    #[test]
+    fn test_generate_enum_is_from_record_variant() {
+        check_assist(
+            generate_enum_is_method,
+            r#"
+enum Variant {
+    Undefined,
+    Minor { foo: i32 }$0,
+    Major,
+}"#,
+            r#"enum Variant {
+    Undefined,
+    Minor { foo: i32 },
+    Major,
+}
+
+impl Variant {
+    /// Returns `true` if the variant is [`Minor`].
+    fn is_minor(&self) -> bool {
+        matches!(self, Self::Minor { .. })
+    }
+}"#,
         );
     }
 
     #[test]
-    fn test_generate_enum_match_from_variant_with_one_variant() {
+    fn test_generate_enum_is_from_variant_with_one_variant() {
         check_assist(
-            generate_enum_match_method,
+            generate_enum_is_method,
             r#"enum Variant { Undefi$0ned }"#,
             r#"
 enum Variant { Undefined }
@@ -177,9 +187,9 @@ impl Variant {
     }
 
     #[test]
-    fn test_generate_enum_match_from_variant_with_visibility_marker() {
+    fn test_generate_enum_is_from_variant_with_visibility_marker() {
         check_assist(
-            generate_enum_match_method,
+            generate_enum_is_method,
             r#"
 pub(crate) enum Variant {
     Undefined,
@@ -202,9 +212,9 @@ impl Variant {
     }
 
     #[test]
-    fn test_multiple_generate_enum_match_from_variant() {
+    fn test_multiple_generate_enum_is_from_variant() {
         check_assist(
-            generate_enum_match_method,
+            generate_enum_is_method,
             r#"
 enum Variant {
     Undefined,
diff --git a/crates/ide_assists/src/handlers/generate_enum_projection_method.rs b/crates/ide_assists/src/handlers/generate_enum_projection_method.rs
new file mode 100644
index 000000000..871bcab50
--- /dev/null
+++ b/crates/ide_assists/src/handlers/generate_enum_projection_method.rs
@@ -0,0 +1,331 @@
+use itertools::Itertools;
+use stdx::to_lower_snake_case;
+use syntax::ast::VisibilityOwner;
+use syntax::ast::{self, AstNode, NameOwner};
+
+use crate::{
+    utils::{add_method_to_adt, find_struct_impl},
+    AssistContext, AssistId, AssistKind, Assists,
+};
+
+// Assist: generate_enum_try_into_method
+//
+// Generate an `try_into_` method for an enum variant.
+//
+// ```
+// enum Value {
+//  Number(i32),
+//  Text(String)$0,
+// }
+// ```
+// ->
+// ```
+// enum Value {
+//  Number(i32),
+//  Text(String),
+// }
+//
+// impl Value {
+//     fn try_into_text(self) -> Result<String, Self> {
+//         if let Self::Text(v) = self {
+//             Ok(v)
+//         } else {
+//             Err(self)
+//         }
+//     }
+// }
+// ```
+pub(crate) fn generate_enum_try_into_method(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    generate_enum_projection_method(
+        acc,
+        ctx,
+        "generate_enum_try_into_method",
+        "Generate an `try_into_` method for an enum variant",
+        ProjectionProps {
+            fn_name_prefix: "try_into",
+            self_param: "self",
+            return_prefix: "Result<",
+            return_suffix: ", Self>",
+            happy_case: "Ok",
+            sad_case: "Err(self)",
+        },
+    )
+}
+
+// Assist: generate_enum_as_method
+//
+// Generate an `as_` method for an enum variant.
+//
+// ```
+// enum Value {
+//  Number(i32),
+//  Text(String)$0,
+// }
+// ```
+// ->
+// ```
+// enum Value {
+//  Number(i32),
+//  Text(String),
+// }
+//
+// impl Value {
+//     fn as_text(&self) -> Option<&String> {
+//         if let Self::Text(v) = self {
+//             Some(v)
+//         } else {
+//             None
+//         }
+//     }
+// }
+// ```
+pub(crate) fn generate_enum_as_method(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    generate_enum_projection_method(
+        acc,
+        ctx,
+        "generate_enum_as_method",
+        "Generate an `as_` method for an enum variant",
+        ProjectionProps {
+            fn_name_prefix: "as",
+            self_param: "&self",
+            return_prefix: "Option<&",
+            return_suffix: ">",
+            happy_case: "Some",
+            sad_case: "None",
+        },
+    )
+}
+
+struct ProjectionProps {
+    fn_name_prefix: &'static str,
+    self_param: &'static str,
+    return_prefix: &'static str,
+    return_suffix: &'static str,
+    happy_case: &'static str,
+    sad_case: &'static str,
+}
+
+fn generate_enum_projection_method(
+    acc: &mut Assists,
+    ctx: &AssistContext,
+    assist_id: &'static str,
+    assist_description: &str,
+    props: ProjectionProps,
+) -> Option<()> {
+    let variant = ctx.find_node_at_offset::<ast::Variant>()?;
+    let variant_name = variant.name()?;
+    let parent_enum = ast::Adt::Enum(variant.parent_enum());
+
+    let (pattern_suffix, field_type, bound_name) = match variant.kind() {
+        ast::StructKind::Record(record) => {
+            let (field,) = record.fields().collect_tuple()?;
+            let name = field.name()?.to_string();
+            let ty = field.ty()?;
+            let pattern_suffix = format!(" {{ {} }}", name);
+            (pattern_suffix, ty, name)
+        }
+        ast::StructKind::Tuple(tuple) => {
+            let (field,) = tuple.fields().collect_tuple()?;
+            let ty = field.ty()?;
+            ("(v)".to_owned(), ty, "v".to_owned())
+        }
+        ast::StructKind::Unit => return None,
+    };
+
+    let fn_name = format!("{}_{}", props.fn_name_prefix, &to_lower_snake_case(variant_name.text()));
+
+    // Return early if we've found an existing new fn
+    let impl_def = find_struct_impl(&ctx, &parent_enum, &fn_name)?;
+
+    let target = variant.syntax().text_range();
+    acc.add(AssistId(assist_id, AssistKind::Generate), assist_description, target, |builder| {
+        let vis = parent_enum.visibility().map_or(String::new(), |v| format!("{} ", v));
+        let method = format!(
+            "    {0}fn {1}({2}) -> {3}{4}{5} {{
+        if let Self::{6}{7} = self {{
+            {8}({9})
+        }} else {{
+            {10}
+        }}
+    }}",
+            vis,
+            fn_name,
+            props.self_param,
+            props.return_prefix,
+            field_type.syntax(),
+            props.return_suffix,
+            variant_name,
+            pattern_suffix,
+            props.happy_case,
+            bound_name,
+            props.sad_case,
+        );
+
+        add_method_to_adt(builder, &parent_enum, impl_def, &method);
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::tests::{check_assist, check_assist_not_applicable};
+
+    use super::*;
+
+    #[test]
+    fn test_generate_enum_try_into_tuple_variant() {
+        check_assist(
+            generate_enum_try_into_method,
+            r#"
+enum Value {
+    Number(i32),
+    Text(String)$0,
+}"#,
+            r#"enum Value {
+    Number(i32),
+    Text(String),
+}
+
+impl Value {
+    fn try_into_text(self) -> Result<String, Self> {
+        if let Self::Text(v) = self {
+            Ok(v)
+        } else {
+            Err(self)
+        }
+    }
+}"#,
+        );
+    }
+
+    #[test]
+    fn test_generate_enum_try_into_already_implemented() {
+        check_assist_not_applicable(
+            generate_enum_try_into_method,
+            r#"enum Value {
+    Number(i32),
+    Text(String)$0,
+}
+
+impl Value {
+    fn try_into_text(self) -> Result<String, Self> {
+        if let Self::Text(v) = self {
+            Ok(v)
+        } else {
+            Err(self)
+        }
+    }
+}"#,
+        );
+    }
+
+    #[test]
+    fn test_generate_enum_try_into_unit_variant() {
+        check_assist_not_applicable(
+            generate_enum_try_into_method,
+            r#"enum Value {
+    Number(i32),
+    Text(String),
+    Unit$0,
+}"#,
+        );
+    }
+
+    #[test]
+    fn test_generate_enum_try_into_record_with_multiple_fields() {
+        check_assist_not_applicable(
+            generate_enum_try_into_method,
+            r#"enum Value {
+    Number(i32),
+    Text(String),
+    Both { first: i32, second: String }$0,
+}"#,
+        );
+    }
+
+    #[test]
+    fn test_generate_enum_try_into_tuple_with_multiple_fields() {
+        check_assist_not_applicable(
+            generate_enum_try_into_method,
+            r#"enum Value {
+    Number(i32),
+    Text(String, String)$0,
+}"#,
+        );
+    }
+
+    #[test]
+    fn test_generate_enum_try_into_record_variant() {
+        check_assist(
+            generate_enum_try_into_method,
+            r#"enum Value {
+    Number(i32),
+    Text { text: String }$0,
+}"#,
+            r#"enum Value {
+    Number(i32),
+    Text { text: String },
+}
+
+impl Value {
+    fn try_into_text(self) -> Result<String, Self> {
+        if let Self::Text { text } = self {
+            Ok(text)
+        } else {
+            Err(self)
+        }
+    }
+}"#,
+        );
+    }
+
+    #[test]
+    fn test_generate_enum_as_tuple_variant() {
+        check_assist(
+            generate_enum_as_method,
+            r#"
+enum Value {
+    Number(i32),
+    Text(String)$0,
+}"#,
+            r#"enum Value {
+    Number(i32),
+    Text(String),
+}
+
+impl Value {
+    fn as_text(&self) -> Option<&String> {
+        if let Self::Text(v) = self {
+            Some(v)
+        } else {
+            None
+        }
+    }
+}"#,
+        );
+    }
+
+    #[test]
+    fn test_generate_enum_as_record_variant() {
+        check_assist(
+            generate_enum_as_method,
+            r#"enum Value {
+    Number(i32),
+    Text { text: String }$0,
+}"#,
+            r#"enum Value {
+    Number(i32),
+    Text { text: String },
+}
+
+impl Value {
+    fn as_text(&self) -> Option<&String> {
+        if let Self::Text { text } = self {
+            Some(text)
+        } else {
+            None
+        }
+    }
+}"#,
+        );
+    }
+}
diff --git a/crates/ide_assists/src/handlers/invert_if.rs b/crates/ide_assists/src/handlers/invert_if.rs
index 5b69dafd4..b131dc205 100644
--- a/crates/ide_assists/src/handlers/invert_if.rs
+++ b/crates/ide_assists/src/handlers/invert_if.rs
@@ -50,7 +50,7 @@ pub(crate) fn invert_if(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
     };
 
     acc.add(AssistId("invert_if", AssistKind::RefactorRewrite), "Invert if", if_range, |edit| {
-        let flip_cond = invert_boolean_expression(cond.clone());
+        let flip_cond = invert_boolean_expression(&ctx.sema, cond.clone());
         edit.replace_ast(cond, flip_cond);
 
         let else_node = else_block.syntax();
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
new file mode 100644
index 000000000..27da28bc0
--- /dev/null
+++ b/crates/ide_assists/src/handlers/replace_for_loop_with_for_each.rs
@@ -0,0 +1,321 @@
+use ast::LoopBodyOwner;
+use hir::known;
+use ide_db::helpers::FamousDefs;
+use stdx::format_to;
+use syntax::{ast, AstNode};
+use test_utils::mark;
+
+use crate::{AssistContext, AssistId, AssistKind, Assists};
+
+// Assist: replace_for_loop_with_for_each
+//
+// Converts a for loop into a for_each loop on the Iterator.
+//
+// ```
+// fn main() {
+//     let x = vec![1, 2, 3];
+//     for$0 v in x {
+//         let y = v * 2;
+//     }
+// }
+// ```
+// ->
+// ```
+// fn main() {
+//     let x = vec![1, 2, 3];
+//     x.into_iter().for_each(|v| {
+//         let y = v * 2;
+//     });
+// }
+// ```
+pub(crate) fn replace_for_loop_with_for_each(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let for_loop = ctx.find_node_at_offset::<ast::ForExpr>()?;
+    let iterable = for_loop.iterable()?;
+    let pat = for_loop.pat()?;
+    let body = for_loop.loop_body()?;
+    if body.syntax().text_range().start() < ctx.offset() {
+        mark::hit!(not_available_in_body);
+        return None;
+    }
+
+    acc.add(
+        AssistId("replace_for_loop_with_for_each", AssistKind::RefactorRewrite),
+        "Replace this for loop with `Iterator::for_each`",
+        for_loop.syntax().text_range(),
+        |builder| {
+            let mut buf = String::new();
+
+            if let Some((expr_behind_ref, method)) =
+                is_ref_and_impls_iter_method(&ctx.sema, &iterable)
+            {
+                // We have either "for x in &col" and col implements a method called iter
+                //             or "for x in &mut col" and col implements a method called iter_mut
+                format_to!(buf, "{}.{}()", expr_behind_ref, method);
+            } else if impls_core_iter(&ctx.sema, &iterable) {
+                format_to!(buf, "{}", iterable);
+            } else {
+                if let ast::Expr::RefExpr(_) = iterable {
+                    format_to!(buf, "({}).into_iter()", iterable);
+                } else {
+                    format_to!(buf, "{}.into_iter()", iterable);
+                }
+            }
+
+            format_to!(buf, ".for_each(|{}| {});", pat, body);
+
+            builder.replace(for_loop.syntax().text_range(), buf)
+        },
+    )
+}
+
+/// If iterable is a reference where the expression behind the reference implements a method
+/// returning an Iterator called iter or iter_mut (depending on the type of reference) then return
+/// the expression behind the reference and the method name
+fn is_ref_and_impls_iter_method(
+    sema: &hir::Semantics<ide_db::RootDatabase>,
+    iterable: &ast::Expr,
+) -> Option<(ast::Expr, hir::Name)> {
+    let ref_expr = match iterable {
+        ast::Expr::RefExpr(r) => r,
+        _ => return None,
+    };
+    let wanted_method = if ref_expr.mut_token().is_some() { known::iter_mut } else { known::iter };
+    let expr_behind_ref = ref_expr.expr()?;
+    let typ = sema.type_of_expr(&expr_behind_ref)?;
+    let scope = sema.scope(iterable.syntax());
+    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)))
+}
+
+/// 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 module = if let Some(m) = sema.scope(iterable.syntax()).module() {
+        m
+    } else {
+        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, &[]);
+    }
+    false
+}
+
+#[cfg(test)]
+mod tests {
+    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 }
+    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(
+            replace_for_loop_with_for_each,
+            r"
+let mut x = vec![1, 2, 3];
+x.iter_mut().$0for_each(|v| *v *= 2);
+        ",
+        )
+    }
+
+    #[test]
+    fn test_simple_for() {
+        check_assist(
+            replace_for_loop_with_for_each,
+            r"
+fn main() {
+    let x = vec![1, 2, 3];
+    for $0v in x {
+        v *= 2;
+    }
+}",
+            r"
+fn main() {
+    let x = vec![1, 2, 3];
+    x.into_iter().for_each(|v| {
+        v *= 2;
+    });
+}",
+        )
+    }
+
+    #[test]
+    fn not_available_in_body() {
+        mark::check!(not_available_in_body);
+        check_assist_not_applicable(
+            replace_for_loop_with_for_each,
+            r"
+fn main() {
+    let x = vec![1, 2, 3];
+    for v in x {
+        $0v *= 2;
+    }
+}",
+        )
+    }
+
+    #[test]
+    fn test_for_borrowed() {
+        check_assist_with_fixtures(
+            r"
+use empty_iter::*;
+fn main() {
+    let x = Empty;
+    for $0v in &x {
+        let a = v * 2;
+    }
+}
+",
+            r"
+use empty_iter::*;
+fn main() {
+    let x = Empty;
+    x.iter().for_each(|v| {
+        let a = v * 2;
+    });
+}
+",
+        )
+    }
+
+    #[test]
+    fn test_for_borrowed_no_iter_method() {
+        check_assist_with_fixtures(
+            r"
+use empty_iter::*;
+fn main() {
+    let x = NoIterMethod;
+    for $0v in &x {
+        let a = v * 2;
+    }
+}
+",
+            r"
+use empty_iter::*;
+fn main() {
+    let x = NoIterMethod;
+    (&x).into_iter().for_each(|v| {
+        let a = v * 2;
+    });
+}
+",
+        )
+    }
+
+    #[test]
+    fn test_for_borrowed_mut() {
+        check_assist_with_fixtures(
+            r"
+use empty_iter::*;
+fn main() {
+    let x = Empty;
+    for $0v in &mut x {
+        let a = v * 2;
+    }
+}
+",
+            r"
+use empty_iter::*;
+fn main() {
+    let x = Empty;
+    x.iter_mut().for_each(|v| {
+        let a = v * 2;
+    });
+}
+",
+        )
+    }
+
+    #[test]
+    fn test_for_borrowed_mut_behind_var() {
+        check_assist(
+            replace_for_loop_with_for_each,
+            r"
+fn main() {
+    let x = vec![1, 2, 3];
+    let y = &mut x;
+    for $0v in y {
+        *v *= 2;
+    }
+}",
+            r"
+fn main() {
+    let x = vec![1, 2, 3];
+    let y = &mut x;
+    y.into_iter().for_each(|v| {
+        *v *= 2;
+    });
+}",
+        )
+    }
+
+    #[test]
+    fn test_already_impls_iterator() {
+        check_assist_with_fixtures(
+            r#"
+use empty_iter::*;
+fn main() {
+    let x = Empty;
+    for$0 a in x.iter().take(1) {
+        println!("{}", a);
+    }
+}
+"#,
+            r#"
+use empty_iter::*;
+fn main() {
+    let x = Empty;
+    x.iter().take(1).for_each(|a| {
+        println!("{}", a);
+    });
+}
+"#,
+        );
+    }
+}
diff --git a/crates/ide_assists/src/handlers/replace_let_with_if_let.rs b/crates/ide_assists/src/handlers/replace_let_with_if_let.rs
index 5a27ada6b..be7e724b5 100644
--- a/crates/ide_assists/src/handlers/replace_let_with_if_let.rs
+++ b/crates/ide_assists/src/handlers/replace_let_with_if_let.rs
@@ -1,5 +1,6 @@
 use std::iter::once;
 
+use ide_db::ty_filter::TryEnum;
 use syntax::{
     ast::{
         self,
@@ -10,7 +11,6 @@ use syntax::{
 };
 
 use crate::{AssistContext, AssistId, AssistKind, Assists};
-use ide_db::ty_filter::TryEnum;
 
 // Assist: replace_let_with_if_let
 //
diff --git a/crates/ide_assists/src/lib.rs b/crates/ide_assists/src/lib.rs
index b9799b9d5..9c8148462 100644
--- a/crates/ide_assists/src/lib.rs
+++ b/crates/ide_assists/src/lib.rs
@@ -128,11 +128,12 @@ mod handlers {
     mod flip_trait_bound;
     mod generate_default_from_enum_variant;
     mod generate_derive;
-    mod generate_enum_match_method;
+    mod generate_enum_is_method;
+    mod generate_enum_projection_method;
     mod generate_from_impl_for_enum;
     mod generate_function;
-    mod generate_getter;
     mod generate_getter_mut;
+    mod generate_getter;
     mod generate_impl;
     mod generate_new;
     mod generate_setter;
@@ -155,6 +156,7 @@ mod handlers {
     mod reorder_fields;
     mod reorder_impl;
     mod replace_derive_with_manual_impl;
+    mod replace_for_loop_with_for_each;
     mod replace_if_let_with_match;
     mod replace_impl_trait_with_generic;
     mod replace_let_with_if_let;
@@ -180,7 +182,6 @@ mod handlers {
             convert_comment_block::convert_comment_block,
             early_return::convert_to_guarded_return,
             expand_glob_import::expand_glob_import,
-            move_module_to_file::move_module_to_file,
             extract_struct_from_enum_variant::extract_struct_from_enum_variant,
             fill_match_arms::fill_match_arms,
             fix_visibility::fix_visibility,
@@ -189,11 +190,13 @@ mod handlers {
             flip_trait_bound::flip_trait_bound,
             generate_default_from_enum_variant::generate_default_from_enum_variant,
             generate_derive::generate_derive,
-            generate_enum_match_method::generate_enum_match_method,
+            generate_enum_is_method::generate_enum_is_method,
+            generate_enum_projection_method::generate_enum_as_method,
+            generate_enum_projection_method::generate_enum_try_into_method,
             generate_from_impl_for_enum::generate_from_impl_for_enum,
             generate_function::generate_function,
-            generate_getter::generate_getter,
             generate_getter_mut::generate_getter_mut,
+            generate_getter::generate_getter,
             generate_impl::generate_impl,
             generate_new::generate_new,
             generate_setter::generate_setter,
@@ -207,6 +210,7 @@ mod handlers {
             move_bounds::move_bounds_to_where_clause,
             move_guard::move_arm_cond_to_match_guard,
             move_guard::move_guard_to_arm_body,
+            move_module_to_file::move_module_to_file,
             pull_assignment_up::pull_assignment_up,
             qualify_path::qualify_path,
             raw_string::add_hash,
@@ -218,6 +222,7 @@ mod handlers {
             reorder_fields::reorder_fields,
             reorder_impl::reorder_impl,
             replace_derive_with_manual_impl::replace_derive_with_manual_impl,
+            replace_for_loop_with_for_each::replace_for_loop_with_for_each,
             replace_if_let_with_match::replace_if_let_with_match,
             replace_if_let_with_match::replace_match_with_if_let,
             replace_impl_trait_with_generic::replace_impl_trait_with_generic,
diff --git a/crates/ide_assists/src/tests.rs b/crates/ide_assists/src/tests.rs
index 384eb7eee..b7f616760 100644
--- a/crates/ide_assists/src/tests.rs
+++ b/crates/ide_assists/src/tests.rs
@@ -190,8 +190,8 @@ fn assist_order_field_struct() {
     let mut assists = assists.iter();
 
     assert_eq!(assists.next().expect("expected assist").label, "Change visibility to pub(crate)");
-    assert_eq!(assists.next().expect("expected assist").label, "Generate a getter method");
     assert_eq!(assists.next().expect("expected assist").label, "Generate a mut getter method");
+    assert_eq!(assists.next().expect("expected assist").label, "Generate a getter method");
     assert_eq!(assists.next().expect("expected assist").label, "Generate a setter method");
     assert_eq!(assists.next().expect("expected assist").label, "Add `#[derive]`");
 }
diff --git a/crates/ide_assists/src/tests/generated.rs b/crates/ide_assists/src/tests/generated.rs
index 0516deaff..4f007aa48 100644
--- a/crates/ide_assists/src/tests/generated.rs
+++ b/crates/ide_assists/src/tests/generated.rs
@@ -147,12 +147,12 @@ fn doctest_apply_demorgan() {
         "apply_demorgan",
         r#####"
 fn main() {
-    if x != 4 ||$0 !y {}
+    if x != 4 ||$0 y < 3.14 {}
 }
 "#####,
         r#####"
 fn main() {
-    if !(x == 4 && y) {}
+    if !(x == 4 && !(y < 3.14)) {}
 }
 "#####,
     )
@@ -460,9 +460,38 @@ struct Point {
 }
 
 #[test]
-fn doctest_generate_enum_match_method() {
+fn doctest_generate_enum_as_method() {
     check_doc_test(
-        "generate_enum_match_method",
+        "generate_enum_as_method",
+        r#####"
+enum Value {
+ Number(i32),
+ Text(String)$0,
+}
+"#####,
+        r#####"
+enum Value {
+ Number(i32),
+ Text(String),
+}
+
+impl Value {
+    fn as_text(&self) -> Option<&String> {
+        if let Self::Text(v) = self {
+            Some(v)
+        } else {
+            None
+        }
+    }
+}
+"#####,
+    )
+}
+
+#[test]
+fn doctest_generate_enum_is_method() {
+    check_doc_test(
+        "generate_enum_is_method",
         r#####"
 enum Version {
  Undefined,
@@ -488,6 +517,35 @@ impl Version {
 }
 
 #[test]
+fn doctest_generate_enum_try_into_method() {
+    check_doc_test(
+        "generate_enum_try_into_method",
+        r#####"
+enum Value {
+ Number(i32),
+ Text(String)$0,
+}
+"#####,
+        r#####"
+enum Value {
+ Number(i32),
+ Text(String),
+}
+
+impl Value {
+    fn try_into_text(self) -> Result<String, Self> {
+        if let Self::Text(v) = self {
+            Ok(v)
+        } else {
+            Err(self)
+        }
+    }
+}
+"#####,
+    )
+}
+
+#[test]
 fn doctest_generate_from_impl_for_enum() {
     check_doc_test(
         "generate_from_impl_for_enum",
@@ -1099,6 +1157,29 @@ impl Debug for S {
 }
 
 #[test]
+fn doctest_replace_for_loop_with_for_each() {
+    check_doc_test(
+        "replace_for_loop_with_for_each",
+        r#####"
+fn main() {
+    let x = vec![1, 2, 3];
+    for$0 v in x {
+        let y = v * 2;
+    }
+}
+"#####,
+        r#####"
+fn main() {
+    let x = vec![1, 2, 3];
+    x.into_iter().for_each(|v| {
+        let y = v * 2;
+    });
+}
+"#####,
+    )
+}
+
+#[test]
 fn doctest_replace_if_let_with_match() {
     check_doc_test(
         "replace_if_let_with_match",
diff --git a/crates/ide_assists/src/utils.rs b/crates/ide_assists/src/utils.rs
index 0074da741..880ab6fe3 100644
--- a/crates/ide_assists/src/utils.rs
+++ b/crates/ide_assists/src/utils.rs
@@ -3,8 +3,11 @@
 use std::ops;
 
 use ast::TypeBoundsOwner;
-use hir::{Adt, HasSource};
-use ide_db::{helpers::SnippetCap, RootDatabase};
+use hir::{Adt, HasSource, Semantics};
+use ide_db::{
+    helpers::{FamousDefs, SnippetCap},
+    RootDatabase,
+};
 use itertools::Itertools;
 use stdx::format_to;
 use syntax::{
@@ -18,7 +21,7 @@ use syntax::{
 };
 
 use crate::{
-    assist_context::AssistContext,
+    assist_context::{AssistBuilder, AssistContext},
     ast_transform::{self, AstTransform, QualifyPaths, SubstituteTypeParams},
 };
 
@@ -205,23 +208,36 @@ pub(crate) fn vis_offset(node: &SyntaxNode) -> TextSize {
         .unwrap_or_else(|| node.text_range().start())
 }
 
-pub(crate) fn invert_boolean_expression(expr: ast::Expr) -> ast::Expr {
-    if let Some(expr) = invert_special_case(&expr) {
+pub(crate) fn invert_boolean_expression(
+    sema: &Semantics<RootDatabase>,
+    expr: ast::Expr,
+) -> ast::Expr {
+    if let Some(expr) = invert_special_case(sema, &expr) {
         return expr;
     }
     make::expr_prefix(T![!], expr)
 }
 
-fn invert_special_case(expr: &ast::Expr) -> Option<ast::Expr> {
+fn invert_special_case(sema: &Semantics<RootDatabase>, expr: &ast::Expr) -> Option<ast::Expr> {
     match expr {
         ast::Expr::BinExpr(bin) => match bin.op_kind()? {
             ast::BinOp::NegatedEqualityTest => bin.replace_op(T![==]).map(|it| it.into()),
             ast::BinOp::EqualityTest => bin.replace_op(T![!=]).map(|it| it.into()),
-            // Parenthesize composite boolean expressions before prefixing `!`
-            ast::BinOp::BooleanAnd | ast::BinOp::BooleanOr => {
-                Some(make::expr_prefix(T![!], make::expr_paren(expr.clone())))
+            // Swap `<` with `>=`, `<=` with `>`, ... if operands `impl Ord`
+            ast::BinOp::LesserTest if bin_impls_ord(sema, bin) => {
+                bin.replace_op(T![>=]).map(|it| it.into())
+            }
+            ast::BinOp::LesserEqualTest if bin_impls_ord(sema, bin) => {
+                bin.replace_op(T![>]).map(|it| it.into())
+            }
+            ast::BinOp::GreaterTest if bin_impls_ord(sema, bin) => {
+                bin.replace_op(T![<=]).map(|it| it.into())
+            }
+            ast::BinOp::GreaterEqualTest if bin_impls_ord(sema, bin) => {
+                bin.replace_op(T![<]).map(|it| it.into())
             }
-            _ => None,
+            // Parenthesize other expressions before prefixing `!`
+            _ => Some(make::expr_prefix(T![!], make::expr_paren(expr.clone()))),
         },
         ast::Expr::MethodCallExpr(mce) => {
             let receiver = mce.receiver()?;
@@ -250,6 +266,22 @@ fn invert_special_case(expr: &ast::Expr) -> Option<ast::Expr> {
     }
 }
 
+fn bin_impls_ord(sema: &Semantics<RootDatabase>, bin: &ast::BinExpr) -> bool {
+    match (
+        bin.lhs().and_then(|lhs| sema.type_of_expr(&lhs)),
+        bin.rhs().and_then(|rhs| sema.type_of_expr(&rhs)),
+    ) {
+        (Some(lhs_ty), Some(rhs_ty)) if lhs_ty == rhs_ty => {
+            let krate = sema.scope(bin.syntax()).module().map(|it| it.krate());
+            let ord_trait = FamousDefs(sema, krate).core_cmp_Ord();
+            ord_trait.map_or(false, |ord_trait| {
+                lhs_ty.autoderef(sema.db).any(|ty| ty.impls_trait(sema.db, ord_trait, &[]))
+            })
+        }
+        _ => false,
+    }
+}
+
 pub(crate) fn next_prev() -> impl Iterator<Item = Direction> {
     [Direction::Next, Direction::Prev].iter().copied()
 }
@@ -432,3 +464,25 @@ fn generate_impl_text_inner(adt: &ast::Adt, trait_text: Option<&str>, code: &str
 
     buf
 }
+
+pub(crate) fn add_method_to_adt(
+    builder: &mut AssistBuilder,
+    adt: &ast::Adt,
+    impl_def: Option<ast::Impl>,
+    method: &str,
+) {
+    let mut buf = String::with_capacity(method.len() + 2);
+    if impl_def.is_some() {
+        buf.push('\n');
+    }
+    buf.push_str(method);
+
+    let start_offset = impl_def
+        .and_then(|impl_def| find_impl_block_end(impl_def, &mut buf))
+        .unwrap_or_else(|| {
+            buf = generate_impl_text(&adt, &buf);
+            adt.syntax().text_range().end()
+        });
+
+    builder.insert(start_offset, buf);
+}