12 files changed, 337 insertions, 62 deletions

diff --git a/crates/ide_assists/src/handlers/add_turbo_fish.rs b/crates/ide_assists/src/handlers/add_turbo_fish.rs
index ee879c151..436767895 100644
--- a/crates/ide_assists/src/handlers/add_turbo_fish.rs
+++ b/crates/ide_assists/src/handlers/add_turbo_fish.rs
@@ -38,7 +38,7 @@ pub(crate) fn add_turbo_fish(acc: &mut Assists, ctx: &AssistContext) -> Option<(
         cov_mark::hit!(add_turbo_fish_one_fish_is_enough);
         return None;
     }
-    let name_ref = ast::NameRef::cast(ident.parent())?;
+    let name_ref = ast::NameRef::cast(ident.parent()?)?;
     let def = match NameRefClass::classify(&ctx.sema, &name_ref)? {
         NameRefClass::Definition(def) => def,
         NameRefClass::ExternCrate(_) | NameRefClass::FieldShorthand { .. } => return None,
diff --git a/crates/ide_assists/src/handlers/change_visibility.rs b/crates/ide_assists/src/handlers/change_visibility.rs
index ec99a5505..d7e39b2ae 100644
--- a/crates/ide_assists/src/handlers/change_visibility.rs
+++ b/crates/ide_assists/src/handlers/change_visibility.rs
@@ -41,7 +41,7 @@ fn add_vis(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
     });
 
     let (offset, target) = if let Some(keyword) = item_keyword {
-        let parent = keyword.parent();
+        let parent = keyword.parent()?;
         let def_kws = vec![CONST, STATIC, TYPE_ALIAS, FN, MODULE, STRUCT, ENUM, TRAIT];
         // Parent is not a definition, can't add visibility
         if !def_kws.iter().any(|&def_kw| def_kw == parent.kind()) {
diff --git a/crates/ide_assists/src/handlers/expand_glob_import.rs b/crates/ide_assists/src/handlers/expand_glob_import.rs
index 5fe617ba4..5b540df5c 100644
--- a/crates/ide_assists/src/handlers/expand_glob_import.rs
+++ b/crates/ide_assists/src/handlers/expand_glob_import.rs
@@ -48,7 +48,7 @@ pub(crate) fn expand_glob_import(acc: &mut Assists, ctx: &AssistContext) -> Opti
         _ => return None,
     };
 
-    let current_scope = ctx.sema.scope(&star.parent());
+    let current_scope = ctx.sema.scope(&star.parent()?);
     let current_module = current_scope.module()?;
 
     let refs_in_target = find_refs_in_mod(ctx, target_module, Some(current_module))?;
diff --git a/crates/ide_assists/src/handlers/extract_function.rs b/crates/ide_assists/src/handlers/extract_function.rs
index dd4501709..5fdc8bf38 100644
--- a/crates/ide_assists/src/handlers/extract_function.rs
+++ b/crates/ide_assists/src/handlers/extract_function.rs
@@ -16,7 +16,6 @@ use syntax::{
         edit::{AstNodeEdit, IndentLevel},
         AstNode,
     },
-    SyntaxElement,
     SyntaxKind::{self, BLOCK_EXPR, BREAK_EXPR, COMMENT, PATH_EXPR, RETURN_EXPR},
     SyntaxNode, SyntaxToken, TextRange, TextSize, TokenAtOffset, WalkEvent, T,
 };
@@ -62,7 +61,10 @@ pub(crate) fn extract_function(acc: &mut Assists, ctx: &AssistContext) -> Option
         return None;
     }
 
-    let node = element_to_node(node);
+    let node = match node {
+        syntax::NodeOrToken::Node(n) => n,
+        syntax::NodeOrToken::Token(t) => t.parent()?,
+    };
 
     let body = extraction_target(&node, ctx.frange.range)?;
 
@@ -560,14 +562,6 @@ impl HasTokenAtOffset for FunctionBody {
     }
 }
 
-/// node or token's parent
-fn element_to_node(node: SyntaxElement) -> SyntaxNode {
-    match node {
-        syntax::NodeOrToken::Node(n) => n,
-        syntax::NodeOrToken::Token(t) => t.parent(),
-    }
-}
-
 /// Try to guess what user wants to extract
 ///
 /// We have basically have two cases:
@@ -1246,7 +1240,7 @@ fn make_body(
             })
         }
         FlowHandler::If { .. } => {
-            let lit_false = ast::Literal::cast(make::tokens::literal("false").parent()).unwrap();
+            let lit_false = make::expr_literal("false");
             with_tail_expr(block, lit_false.into())
         }
         FlowHandler::IfOption { .. } => {
@@ -1420,9 +1414,7 @@ fn update_external_control_flow(handler: &FlowHandler, syntax: &SyntaxNode) -> S
 fn make_rewritten_flow(handler: &FlowHandler, arg_expr: Option<ast::Expr>) -> Option<ast::Expr> {
     let value = match handler {
         FlowHandler::None | FlowHandler::Try { .. } => return None,
-        FlowHandler::If { .. } => {
-            ast::Literal::cast(make::tokens::literal("true").parent()).unwrap().into()
-        }
+        FlowHandler::If { .. } => make::expr_literal("true").into(),
         FlowHandler::IfOption { .. } => {
             let expr = arg_expr.unwrap_or_else(|| make::expr_tuple(Vec::new()));
             let args = make::arg_list(iter::once(expr));
diff --git a/crates/ide_assists/src/handlers/flip_trait_bound.rs b/crates/ide_assists/src/handlers/flip_trait_bound.rs
index d419d263e..a868aa43d 100644
--- a/crates/ide_assists/src/handlers/flip_trait_bound.rs
+++ b/crates/ide_assists/src/handlers/flip_trait_bound.rs
@@ -23,7 +23,7 @@ pub(crate) fn flip_trait_bound(acc: &mut Assists, ctx: &AssistContext) -> Option
     let plus = ctx.find_token_syntax_at_offset(T![+])?;
 
     // Make sure we're in a `TypeBoundList`
-    if ast::TypeBoundList::cast(plus.parent()).is_none() {
+    if ast::TypeBoundList::cast(plus.parent()?).is_none() {
         return None;
     }
 
diff --git a/crates/ide_assists/src/handlers/generate_is_empty_from_len.rs b/crates/ide_assists/src/handlers/generate_is_empty_from_len.rs
new file mode 100644
index 000000000..b8834d283
--- /dev/null
+++ b/crates/ide_assists/src/handlers/generate_is_empty_from_len.rs
@@ -0,0 +1,272 @@
+use hir::{known, HasSource, Name};
+use syntax::{
+    ast::{self, NameOwner},
+    AstNode,
+};
+
+use crate::{
+    assist_context::{AssistContext, Assists},
+    AssistId, AssistKind,
+};
+
+// Assist: generate_is_empty_from_len
+//
+// Generates is_empty implementation from the len method.
+//
+// ```
+// struct MyStruct { data: Vec<String> }
+//
+// impl MyStruct {
+//     p$0ub fn len(&self) -> usize {
+//         self.data.len()
+//     }
+// }
+// ```
+// ->
+// ```
+// struct MyStruct { data: Vec<String> }
+//
+// impl MyStruct {
+//     pub fn len(&self) -> usize {
+//         self.data.len()
+//     }
+//
+//     pub fn is_empty(&self) -> bool {
+//         self.len() == 0
+//     }
+// }
+// ```
+pub(crate) fn generate_is_empty_from_len(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
+    let fn_node = ctx.find_node_at_offset::<ast::Fn>()?;
+    let fn_name = fn_node.name()?;
+
+    if fn_name.text() != "len" {
+        cov_mark::hit!(len_function_not_present);
+        return None;
+    }
+
+    if fn_node.param_list()?.params().next().is_some() {
+        cov_mark::hit!(len_function_with_parameters);
+        return None;
+    }
+
+    let impl_ = fn_node.syntax().ancestors().find_map(ast::Impl::cast)?;
+    let len_fn = get_impl_method(ctx, &impl_, &known::len)?;
+    if !len_fn.ret_type(ctx.sema.db).is_usize() {
+        cov_mark::hit!(len_fn_different_return_type);
+        return None;
+    }
+
+    if get_impl_method(ctx, &impl_, &known::is_empty).is_some() {
+        cov_mark::hit!(is_empty_already_implemented);
+        return None;
+    }
+
+    let node = len_fn.source(ctx.sema.db)?;
+    let range = node.syntax().value.text_range();
+
+    acc.add(
+        AssistId("generate_is_empty_from_len", AssistKind::Generate),
+        "Generate a is_empty impl from a len function",
+        range,
+        |builder| {
+            let code = r#"
+
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }"#
+            .to_string();
+            builder.insert(range.end(), code)
+        },
+    )
+}
+
+fn get_impl_method(
+    ctx: &AssistContext,
+    impl_: &ast::Impl,
+    fn_name: &Name,
+) -> Option<hir::Function> {
+    let db = ctx.sema.db;
+    let impl_def: hir::Impl = ctx.sema.to_def(impl_)?;
+
+    let scope = ctx.sema.scope(impl_.syntax());
+    let krate = impl_def.module(db).krate();
+    let ty = impl_def.target_ty(db);
+    let traits_in_scope = scope.traits_in_scope();
+    ty.iterate_method_candidates(db, krate, &traits_in_scope, Some(fn_name), |_, func| Some(func))
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::tests::{check_assist, check_assist_not_applicable};
+
+    use super::*;
+
+    #[test]
+    fn len_function_not_present() {
+        cov_mark::check!(len_function_not_present);
+        check_assist_not_applicable(
+            generate_is_empty_from_len,
+            r#"
+struct MyStruct { data: Vec<String> }
+
+impl MyStruct {
+    p$0ub fn test(&self) -> usize {
+            self.data.len()
+        }
+    }
+"#,
+        );
+    }
+
+    #[test]
+    fn len_function_with_parameters() {
+        cov_mark::check!(len_function_with_parameters);
+        check_assist_not_applicable(
+            generate_is_empty_from_len,
+            r#"
+struct MyStruct { data: Vec<String> }
+
+impl MyStruct {
+    p$0ub fn len(&self, _i: bool) -> usize {
+        self.data.len()
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn is_empty_already_implemented() {
+        cov_mark::check!(is_empty_already_implemented);
+        check_assist_not_applicable(
+            generate_is_empty_from_len,
+            r#"
+struct MyStruct { data: Vec<String> }
+
+impl MyStruct {
+    p$0ub fn len(&self) -> usize {
+        self.data.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn len_fn_different_return_type() {
+        cov_mark::check!(len_fn_different_return_type);
+        check_assist_not_applicable(
+            generate_is_empty_from_len,
+            r#"
+struct MyStruct { data: Vec<String> }
+
+impl MyStruct {
+    p$0ub fn len(&self) -> u32 {
+        self.data.len()
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn generate_is_empty() {
+        check_assist(
+            generate_is_empty_from_len,
+            r#"
+struct MyStruct { data: Vec<String> }
+
+impl MyStruct {
+    p$0ub fn len(&self) -> usize {
+        self.data.len()
+    }
+}
+"#,
+            r#"
+struct MyStruct { data: Vec<String> }
+
+impl MyStruct {
+    pub fn len(&self) -> usize {
+        self.data.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn multiple_functions_in_impl() {
+        check_assist(
+            generate_is_empty_from_len,
+            r#"
+struct MyStruct { data: Vec<String> }
+
+impl MyStruct {
+    pub fn new() -> Self {
+        Self { data: 0 }
+    }
+
+    p$0ub fn len(&self) -> usize {
+        self.data.len()
+    }
+
+    pub fn work(&self) -> Option<usize> {
+
+    }
+}
+"#,
+            r#"
+struct MyStruct { data: Vec<String> }
+
+impl MyStruct {
+    pub fn new() -> Self {
+        Self { data: 0 }
+    }
+
+    pub fn len(&self) -> usize {
+        self.data.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    pub fn work(&self) -> Option<usize> {
+
+    }
+}
+"#,
+        );
+    }
+
+    #[test]
+    fn multiple_impls() {
+        check_assist_not_applicable(
+            generate_is_empty_from_len,
+            r#"
+struct MyStruct { data: Vec<String> }
+
+impl MyStruct {
+    p$0ub fn len(&self) -> usize {
+        self.data.len()
+    }
+}
+
+impl MyStruct {
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+}
+"#,
+        );
+    }
+}
diff --git a/crates/ide_assists/src/handlers/invert_if.rs b/crates/ide_assists/src/handlers/invert_if.rs
index b131dc205..53612ec3f 100644
--- a/crates/ide_assists/src/handlers/invert_if.rs
+++ b/crates/ide_assists/src/handlers/invert_if.rs
@@ -30,7 +30,7 @@ use crate::{
 
 pub(crate) fn invert_if(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
     let if_keyword = ctx.find_token_syntax_at_offset(T![if])?;
-    let expr = ast::IfExpr::cast(if_keyword.parent())?;
+    let expr = ast::IfExpr::cast(if_keyword.parent()?)?;
     let if_range = if_keyword.text_range();
     let cursor_in_range = if_range.contains_range(ctx.frange.range);
     if !cursor_in_range {
diff --git a/crates/ide_assists/src/handlers/move_bounds.rs b/crates/ide_assists/src/handlers/move_bounds.rs
index cf260c6f8..48efa67ed 100644
--- a/crates/ide_assists/src/handlers/move_bounds.rs
+++ b/crates/ide_assists/src/handlers/move_bounds.rs
@@ -1,8 +1,6 @@
 use syntax::{
-    ast::{self, edit::AstNodeEdit, make, AstNode, NameOwner, TypeBoundsOwner},
+    ast::{self, edit_in_place::GenericParamsOwnerEdit, make, AstNode, NameOwner, TypeBoundsOwner},
     match_ast,
-    SyntaxKind::*,
-    T,
 };
 
 use crate::{AssistContext, AssistId, AssistKind, Assists};
@@ -23,7 +21,7 @@ use crate::{AssistContext, AssistId, AssistKind, Assists};
 // }
 // ```
 pub(crate) fn move_bounds_to_where_clause(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
-    let type_param_list = ctx.find_node_at_offset::<ast::GenericParamList>()?;
+    let type_param_list = ctx.find_node_at_offset::<ast::GenericParamList>()?.clone_for_update();
 
     let mut type_params = type_param_list.type_params();
     if type_params.all(|p| p.type_bound_list().is_none()) {
@@ -31,23 +29,7 @@ pub(crate) fn move_bounds_to_where_clause(acc: &mut Assists, ctx: &AssistContext
     }
 
     let parent = type_param_list.syntax().parent()?;
-    if parent.children_with_tokens().any(|it| it.kind() == WHERE_CLAUSE) {
-        return None;
-    }
-
-    let anchor = match_ast! {
-        match parent {
-            ast::Fn(it) => it.body()?.syntax().clone().into(),
-            ast::Trait(it) => it.assoc_item_list()?.syntax().clone().into(),
-            ast::Impl(it) => it.assoc_item_list()?.syntax().clone().into(),
-            ast::Enum(it) => it.variant_list()?.syntax().clone().into(),
-            ast::Struct(it) => {
-                it.syntax().children_with_tokens()
-                    .find(|it| it.kind() == RECORD_FIELD_LIST || it.kind() == T![;])?
-            },
-            _ => return None
-        }
-    };
+    let original_parent_range = parent.text_range();
 
     let target = type_param_list.syntax().text_range();
     acc.add(
@@ -55,29 +37,27 @@ pub(crate) fn move_bounds_to_where_clause(acc: &mut Assists, ctx: &AssistContext
         "Move to where clause",
         target,
         |edit| {
-            let new_params = type_param_list
-                .type_params()
-                .filter(|it| it.type_bound_list().is_some())
-                .map(|type_param| {
-                    let without_bounds = type_param.remove_bounds();
-                    (type_param, without_bounds)
-                });
-
-            let new_type_param_list = type_param_list.replace_descendants(new_params);
-            edit.replace_ast(type_param_list.clone(), new_type_param_list);
-
-            let where_clause = {
-                let predicates = type_param_list.type_params().filter_map(build_predicate);
-                make::where_clause(predicates)
+            let where_clause: ast::WhereClause = match_ast! {
+                match parent {
+                    ast::Fn(it) => it.get_or_create_where_clause(),
+                    // ast::Trait(it) => it.get_or_create_where_clause(),
+                    ast::Impl(it) => it.get_or_create_where_clause(),
+                    // ast::Enum(it) => it.get_or_create_where_clause(),
+                    ast::Struct(it) => it.get_or_create_where_clause(),
+                    _ => return,
+                }
             };
 
-            let to_insert = match anchor.prev_sibling_or_token() {
-                Some(ref elem) if elem.kind() == WHITESPACE => {
-                    format!("{} ", where_clause.syntax())
+            for type_param in type_param_list.type_params() {
+                if let Some(tbl) = type_param.type_bound_list() {
+                    if let Some(predicate) = build_predicate(type_param.clone()) {
+                        where_clause.add_predicate(predicate.clone_for_update())
+                    }
+                    tbl.remove()
                 }
-                _ => format!(" {}", where_clause.syntax()),
-            };
-            edit.insert(anchor.text_range().start(), to_insert);
+            }
+
+            edit.replace(original_parent_range, parent.to_string())
         },
     )
 }
diff --git a/crates/ide_assists/src/handlers/split_import.rs b/crates/ide_assists/src/handlers/split_import.rs
index 9319a4267..446f30544 100644
--- a/crates/ide_assists/src/handlers/split_import.rs
+++ b/crates/ide_assists/src/handlers/split_import.rs
@@ -17,7 +17,7 @@ use crate::{AssistContext, AssistId, AssistKind, Assists};
 // ```
 pub(crate) fn split_import(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
     let colon_colon = ctx.find_token_syntax_at_offset(T![::])?;
-    let path = ast::Path::cast(colon_colon.parent())?.qualifier()?;
+    let path = ast::Path::cast(colon_colon.parent()?)?.qualifier()?;
     let top_path = successors(Some(path.clone()), |it| it.parent_path()).last()?;
 
     let use_tree = top_path.syntax().ancestors().find_map(ast::UseTree::cast)?;
diff --git a/crates/ide_assists/src/handlers/unwrap_block.rs b/crates/ide_assists/src/handlers/unwrap_block.rs
index ed6f6177d..440639322 100644
--- a/crates/ide_assists/src/handlers/unwrap_block.rs
+++ b/crates/ide_assists/src/handlers/unwrap_block.rs
@@ -30,7 +30,7 @@ pub(crate) fn unwrap_block(acc: &mut Assists, ctx: &AssistContext) -> Option<()>
     let assist_label = "Unwrap block";
 
     let l_curly_token = ctx.find_token_syntax_at_offset(T!['{'])?;
-    let mut block = ast::BlockExpr::cast(l_curly_token.parent())?;
+    let mut block = ast::BlockExpr::cast(l_curly_token.parent()?)?;
     let target = block.syntax().text_range();
     let mut parent = block.syntax().parent()?;
     if ast::MatchArm::can_cast(parent.kind()) {
diff --git a/crates/ide_assists/src/lib.rs b/crates/ide_assists/src/lib.rs
index f1aab74d4..8c068a6c0 100644
--- a/crates/ide_assists/src/lib.rs
+++ b/crates/ide_assists/src/lib.rs
@@ -129,6 +129,7 @@ mod handlers {
     mod flip_trait_bound;
     mod generate_default_from_enum_variant;
     mod generate_default_from_new;
+    mod generate_is_empty_from_len;
     mod generate_derive;
     mod generate_enum_is_method;
     mod generate_enum_projection_method;
@@ -193,6 +194,7 @@ mod handlers {
             flip_trait_bound::flip_trait_bound,
             generate_default_from_enum_variant::generate_default_from_enum_variant,
             generate_default_from_new::generate_default_from_new,
+            generate_is_empty_from_len::generate_is_empty_from_len,
             generate_derive::generate_derive,
             generate_enum_is_method::generate_enum_is_method,
             generate_enum_projection_method::generate_enum_as_method,
diff --git a/crates/ide_assists/src/tests/generated.rs b/crates/ide_assists/src/tests/generated.rs
index 3f77edd8d..736027ff0 100644
--- a/crates/ide_assists/src/tests/generated.rs
+++ b/crates/ide_assists/src/tests/generated.rs
@@ -722,6 +722,35 @@ impl<T: Clone> Ctx<T> {
 }
 
 #[test]
+fn doctest_generate_is_empty_from_len() {
+    check_doc_test(
+        "generate_is_empty_from_len",
+        r#####"
+struct MyStruct { data: Vec<String> }
+
+impl MyStruct {
+    p$0ub fn len(&self) -> usize {
+        self.data.len()
+    }
+}
+"#####,
+        r#####"
+struct MyStruct { data: Vec<String> }
+
+impl MyStruct {
+    pub fn len(&self) -> usize {
+        self.data.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+}
+"#####,
+    )
+}
+
+#[test]
 fn doctest_generate_new() {
     check_doc_test(
         "generate_new",