13 files changed, 420 insertions, 342 deletions

diff --git a/crates/hir/src/lib.rs b/crates/hir/src/lib.rs
index ac23e385e..c9ef4b420 100644
--- a/crates/hir/src/lib.rs
+++ b/crates/hir/src/lib.rs
@@ -2071,6 +2071,10 @@ impl Type {
         Some(adt.into())
     }
 
+    pub fn as_builtin(&self) -> Option<BuiltinType> {
+        self.ty.as_builtin().map(|inner| BuiltinType { inner })
+    }
+
     pub fn as_dyn_trait(&self) -> Option<Trait> {
         self.ty.dyn_trait().map(Into::into)
     }
diff --git a/crates/hir_ty/src/chalk_ext.rs b/crates/hir_ty/src/chalk_ext.rs
index 8c4542956..5232a7d80 100644
--- a/crates/hir_ty/src/chalk_ext.rs
+++ b/crates/hir_ty/src/chalk_ext.rs
@@ -1,8 +1,10 @@
 //! Various extensions traits for Chalk types.
 
-use chalk_ir::Mutability;
+use chalk_ir::{FloatTy, IntTy, Mutability, Scalar, UintTy};
 use hir_def::{
-    type_ref::Rawness, AssocContainerId, FunctionId, GenericDefId, HasModule, Lookup, TraitId,
+    builtin_type::{BuiltinFloat, BuiltinInt, BuiltinType, BuiltinUint},
+    type_ref::Rawness,
+    AssocContainerId, FunctionId, GenericDefId, HasModule, Lookup, TraitId,
 };
 
 use crate::{
@@ -18,6 +20,7 @@ pub trait TyExt {
     fn is_unknown(&self) -> bool;
 
     fn as_adt(&self) -> Option<(hir_def::AdtId, &Substitution)>;
+    fn as_builtin(&self) -> Option<BuiltinType>;
     fn as_tuple(&self) -> Option<&Substitution>;
     fn as_fn_def(&self, db: &dyn HirDatabase) -> Option<FunctionId>;
     fn as_reference(&self) -> Option<(&Ty, Lifetime, Mutability)>;
@@ -59,6 +62,35 @@ impl TyExt for Ty {
         }
     }
 
+    fn as_builtin(&self) -> Option<BuiltinType> {
+        match self.kind(&Interner) {
+            TyKind::Str => Some(BuiltinType::Str),
+            TyKind::Scalar(Scalar::Bool) => Some(BuiltinType::Bool),
+            TyKind::Scalar(Scalar::Char) => Some(BuiltinType::Char),
+            TyKind::Scalar(Scalar::Float(fty)) => Some(BuiltinType::Float(match fty {
+                FloatTy::F64 => BuiltinFloat::F64,
+                FloatTy::F32 => BuiltinFloat::F32,
+            })),
+            TyKind::Scalar(Scalar::Int(ity)) => Some(BuiltinType::Int(match ity {
+                IntTy::Isize => BuiltinInt::Isize,
+                IntTy::I8 => BuiltinInt::I8,
+                IntTy::I16 => BuiltinInt::I16,
+                IntTy::I32 => BuiltinInt::I32,
+                IntTy::I64 => BuiltinInt::I64,
+                IntTy::I128 => BuiltinInt::I128,
+            })),
+            TyKind::Scalar(Scalar::Uint(ity)) => Some(BuiltinType::Uint(match ity {
+                UintTy::Usize => BuiltinUint::Usize,
+                UintTy::U8 => BuiltinUint::U8,
+                UintTy::U16 => BuiltinUint::U16,
+                UintTy::U32 => BuiltinUint::U32,
+                UintTy::U64 => BuiltinUint::U64,
+                UintTy::U128 => BuiltinUint::U128,
+            })),
+            _ => None,
+        }
+    }
+
     fn as_tuple(&self) -> Option<&Substitution> {
         match self.kind(&Interner) {
             TyKind::Tuple(_, substs) => Some(substs),
diff --git a/crates/ide/src/references.rs b/crates/ide/src/references.rs
index 11ca7ec6b..ae492a264 100644
--- a/crates/ide/src/references.rs
+++ b/crates/ide/src/references.rs
@@ -65,7 +65,7 @@ pub(crate) fn find_all_refs(
             (find_def(&sema, &syntax, position)?, false)
         };
 
-    let mut usages = def.usages(sema).set_scope(search_scope).all();
+    let mut usages = def.usages(sema).set_scope(search_scope).include_self_refs().all();
     if is_literal_search {
         // filter for constructor-literals
         let refs = usages.references.values_mut();
@@ -1163,22 +1163,76 @@ fn foo<const FOO$0: usize>() -> usize {
     }
 
     #[test]
-    fn test_find_self_ty_in_trait_def() {
+    fn test_trait() {
         check(
             r#"
-trait Foo {
-    fn f() -> Self$0;
+trait Foo$0 where Self: {}
+
+impl Foo for () {}
+"#,
+            expect![[r#"
+                Foo Trait FileId(0) 0..24 6..9
+
+                FileId(0) 31..34
+            "#]],
+        );
+    }
+
+    #[test]
+    fn test_trait_self() {
+        check(
+            r#"
+trait Foo where Self$0 {
+    fn f() -> Self;
 }
+
+impl Foo for () {}
 "#,
             expect![[r#"
                 Self TypeParam FileId(0) 6..9 6..9
 
-                FileId(0) 26..30
+                FileId(0) 16..20
+                FileId(0) 37..41
             "#]],
         );
     }
 
     #[test]
+    fn test_self_ty() {
+        check(
+            r#"
+        struct $0Foo;
+
+        impl Foo where Self: {
+            fn f() -> Self;
+        }
+        "#,
+            expect![[r#"
+                Foo Struct FileId(0) 0..11 7..10
+
+                FileId(0) 18..21
+                FileId(0) 28..32
+                FileId(0) 50..54
+            "#]],
+        );
+        check(
+            r#"
+struct Foo;
+
+impl Foo where Self: {
+    fn f() -> Self$0;
+}
+"#,
+            expect![[r#"
+                impl Impl FileId(0) 13..57 18..21
+
+                FileId(0) 18..21
+                FileId(0) 28..32
+                FileId(0) 50..54
+            "#]],
+        );
+    }
+    #[test]
     fn test_self_variant_with_payload() {
         check(
             r#"
diff --git a/crates/ide/src/references/rename.rs b/crates/ide/src/references/rename.rs
index 175e7a31d..2bf953305 100644
--- a/crates/ide/src/references/rename.rs
+++ b/crates/ide/src/references/rename.rs
@@ -1888,4 +1888,21 @@ impl Foo {
             "error: Cannot rename `Self`",
         );
     }
+
+    #[test]
+    fn test_rename_ignores_self_ty() {
+        check(
+            "Fo0",
+            r#"
+struct $0Foo;
+
+impl Foo where Self: {}
+"#,
+            r#"
+struct Fo0;
+
+impl Fo0 where Self: {}
+"#,
+        );
+    }
 }
diff --git a/crates/ide_assists/src/handlers/convert_tuple_struct_to_named_struct.rs b/crates/ide_assists/src/handlers/convert_tuple_struct_to_named_struct.rs
index b5b5ada5e..70949ca35 100644
--- a/crates/ide_assists/src/handlers/convert_tuple_struct_to_named_struct.rs
+++ b/crates/ide_assists/src/handlers/convert_tuple_struct_to_named_struct.rs
@@ -107,7 +107,7 @@ fn edit_struct_references(
     names: &[ast::Name],
 ) {
     let strukt_def = Definition::ModuleDef(hir::ModuleDef::Adt(hir::Adt::Struct(strukt)));
-    let usages = strukt_def.usages(&ctx.sema).include_self_kw_refs(true).all();
+    let usages = strukt_def.usages(&ctx.sema).include_self_refs().all();
 
     let edit_node = |edit: &mut AssistBuilder, node: SyntaxNode| -> Option<()> {
         match_ast! {
diff --git a/crates/ide_assists/src/handlers/extract_function.rs b/crates/ide_assists/src/handlers/extract_function.rs
index 93b28370c..4116985ae 100644
--- a/crates/ide_assists/src/handlers/extract_function.rs
+++ b/crates/ide_assists/src/handlers/extract_function.rs
@@ -10,7 +10,6 @@ use ide_db::{
 use itertools::Itertools;
 use stdx::format_to;
 use syntax::{
-    algo::SyntaxRewriter,
     ast::{
         self,
         edit::{AstNodeEdit, IndentLevel},
@@ -1362,7 +1361,8 @@ fn rewrite_body_segment(
     syntax: &SyntaxNode,
 ) -> SyntaxNode {
     let syntax = fix_param_usages(ctx, params, syntax);
-    update_external_control_flow(handler, &syntax)
+    update_external_control_flow(handler, &syntax);
+    syntax
 }
 
 /// change all usages to account for added `&`/`&mut` for some params
@@ -1415,75 +1415,65 @@ fn fix_param_usages(ctx: &AssistContext, params: &[Param], syntax: &SyntaxNode)
     res
 }
 
-fn update_external_control_flow(handler: &FlowHandler, syntax: &SyntaxNode) -> SyntaxNode {
-    let mut rewriter = SyntaxRewriter::default();
-
+fn update_external_control_flow(handler: &FlowHandler, syntax: &SyntaxNode) {
     let mut nested_loop = None;
     let mut nested_scope = None;
     for event in syntax.preorder() {
-        let node = match event {
-            WalkEvent::Enter(e) => {
-                match e.kind() {
-                    SyntaxKind::LOOP_EXPR | SyntaxKind::WHILE_EXPR | SyntaxKind::FOR_EXPR => {
-                        if nested_loop.is_none() {
-                            nested_loop = Some(e.clone());
-                        }
+        match event {
+            WalkEvent::Enter(e) => match e.kind() {
+                SyntaxKind::LOOP_EXPR | SyntaxKind::WHILE_EXPR | SyntaxKind::FOR_EXPR => {
+                    if nested_loop.is_none() {
+                        nested_loop = Some(e.clone());
                     }
-                    SyntaxKind::FN
-                    | SyntaxKind::CONST
-                    | SyntaxKind::STATIC
-                    | SyntaxKind::IMPL
-                    | SyntaxKind::MODULE => {
-                        if nested_scope.is_none() {
-                            nested_scope = Some(e.clone());
-                        }
+                }
+                SyntaxKind::FN
+                | SyntaxKind::CONST
+                | SyntaxKind::STATIC
+                | SyntaxKind::IMPL
+                | SyntaxKind::MODULE => {
+                    if nested_scope.is_none() {
+                        nested_scope = Some(e.clone());
                     }
-                    _ => {}
                 }
-                e
-            }
+                _ => {}
+            },
             WalkEvent::Leave(e) => {
+                if nested_scope.is_none() {
+                    if let Some(expr) = ast::Expr::cast(e.clone()) {
+                        match expr {
+                            ast::Expr::ReturnExpr(return_expr) if nested_scope.is_none() => {
+                                let expr = return_expr.expr();
+                                if let Some(replacement) = make_rewritten_flow(handler, expr) {
+                                    ted::replace(return_expr.syntax(), replacement.syntax())
+                                }
+                            }
+                            ast::Expr::BreakExpr(break_expr) if nested_loop.is_none() => {
+                                let expr = break_expr.expr();
+                                if let Some(replacement) = make_rewritten_flow(handler, expr) {
+                                    ted::replace(break_expr.syntax(), replacement.syntax())
+                                }
+                            }
+                            ast::Expr::ContinueExpr(continue_expr) if nested_loop.is_none() => {
+                                if let Some(replacement) = make_rewritten_flow(handler, None) {
+                                    ted::replace(continue_expr.syntax(), replacement.syntax())
+                                }
+                            }
+                            _ => {
+                                // do nothing
+                            }
+                        }
+                    }
+                }
+
                 if nested_loop.as_ref() == Some(&e) {
                     nested_loop = None;
                 }
                 if nested_scope.as_ref() == Some(&e) {
                     nested_scope = None;
                 }
-                continue;
             }
         };
-        if nested_scope.is_some() {
-            continue;
-        }
-        let expr = match ast::Expr::cast(node) {
-            Some(e) => e,
-            None => continue,
-        };
-        match expr {
-            ast::Expr::ReturnExpr(return_expr) if nested_scope.is_none() => {
-                let expr = return_expr.expr();
-                if let Some(replacement) = make_rewritten_flow(handler, expr) {
-                    rewriter.replace_ast(&return_expr.into(), &replacement);
-                }
-            }
-            ast::Expr::BreakExpr(break_expr) if nested_loop.is_none() => {
-                let expr = break_expr.expr();
-                if let Some(replacement) = make_rewritten_flow(handler, expr) {
-                    rewriter.replace_ast(&break_expr.into(), &replacement);
-                }
-            }
-            ast::Expr::ContinueExpr(continue_expr) if nested_loop.is_none() => {
-                if let Some(replacement) = make_rewritten_flow(handler, None) {
-                    rewriter.replace_ast(&continue_expr.into(), &replacement);
-                }
-            }
-            _ => {
-                // do nothing
-            }
-        }
     }
-
-    rewriter.rewrite(syntax)
 }
 
 fn make_rewritten_flow(handler: &FlowHandler, arg_expr: Option<ast::Expr>) -> Option<ast::Expr> {
@@ -1502,7 +1492,7 @@ fn make_rewritten_flow(handler: &FlowHandler, arg_expr: Option<ast::Expr>) -> Op
             make::expr_call(make::expr_path(make_path_from_text("Err")), args)
         }
     };
-    Some(make::expr_return(Some(value)))
+    Some(make::expr_return(Some(value)).clone_for_update())
 }
 
 #[cfg(test)]
diff --git a/crates/ide_assists/src/handlers/pull_assignment_up.rs b/crates/ide_assists/src/handlers/pull_assignment_up.rs
index 04bae4e58..28d14b9c3 100644
--- a/crates/ide_assists/src/handlers/pull_assignment_up.rs
+++ b/crates/ide_assists/src/handlers/pull_assignment_up.rs
@@ -1,6 +1,6 @@
 use syntax::{
-    ast::{self, edit::AstNodeEdit, make},
-    AstNode,
+    ast::{self, make},
+    ted, AstNode,
 };
 
 use crate::{
@@ -37,103 +37,101 @@ use crate::{
 // ```
 pub(crate) fn pull_assignment_up(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
     let assign_expr = ctx.find_node_at_offset::<ast::BinExpr>()?;
-    let name_expr = if assign_expr.op_kind()? == ast::BinOp::Assignment {
-        assign_expr.lhs()?
-    } else {
+
+    let op_kind = assign_expr.op_kind()?;
+    if op_kind != ast::BinOp::Assignment {
+        cov_mark::hit!(test_cant_pull_non_assignments);
         return None;
+    }
+
+    let mut collector = AssignmentsCollector {
+        sema: &ctx.sema,
+        common_lhs: assign_expr.lhs()?,
+        assignments: Vec::new(),
     };
 
-    let (old_stmt, new_stmt) = if let Some(if_expr) = ctx.find_node_at_offset::<ast::IfExpr>() {
-        (
-            ast::Expr::cast(if_expr.syntax().to_owned())?,
-            exprify_if(&if_expr, &ctx.sema, &name_expr)?.indent(if_expr.indent_level()),
-        )
+    let tgt: ast::Expr = if let Some(if_expr) = ctx.find_node_at_offset::<ast::IfExpr>() {
+        collector.collect_if(&if_expr)?;
+        if_expr.into()
     } else if let Some(match_expr) = ctx.find_node_at_offset::<ast::MatchExpr>() {
-        (
-            ast::Expr::cast(match_expr.syntax().to_owned())?,
-            exprify_match(&match_expr, &ctx.sema, &name_expr)?,
-        )
+        collector.collect_match(&match_expr)?;
+        match_expr.into()
     } else {
         return None;
     };
 
-    let expr_stmt = make::expr_stmt(new_stmt);
-
     acc.add(
         AssistId("pull_assignment_up", AssistKind::RefactorExtract),
         "Pull assignment up",
-        old_stmt.syntax().text_range(),
+        tgt.syntax().text_range(),
         move |edit| {
-            edit.replace(old_stmt.syntax().text_range(), format!("{} = {};", name_expr, expr_stmt));
+            let assignments: Vec<_> = collector
+                .assignments
+                .into_iter()
+                .map(|(stmt, rhs)| (edit.make_ast_mut(stmt), rhs.clone_for_update()))
+                .collect();
+
+            let tgt = edit.make_ast_mut(tgt);
+
+            for (stmt, rhs) in assignments {
+                ted::replace(stmt.syntax(), rhs.syntax());
+            }
+            let assign_expr = make::expr_assignment(collector.common_lhs, tgt.clone());
+            let assign_stmt = make::expr_stmt(assign_expr);
+
+            ted::replace(tgt.syntax(), assign_stmt.syntax().clone_for_update());
         },
     )
 }
 
-fn exprify_match(
-    match_expr: &ast::MatchExpr,
-    sema: &hir::Semantics<ide_db::RootDatabase>,
-    name: &ast::Expr,
-) -> Option<ast::Expr> {
-    let new_arm_list = match_expr
-        .match_arm_list()?
-        .arms()
-        .map(|arm| {
-            if let ast::Expr::BlockExpr(block) = arm.expr()? {
-                let new_block = exprify_block(&block, sema, name)?.indent(block.indent_level());
-                Some(arm.replace_descendant(block, new_block))
-            } else {
-                None
-            }
-        })
-        .collect::<Option<Vec<_>>>()?;
-    let new_arm_list = match_expr
-        .match_arm_list()?
-        .replace_descendants(match_expr.match_arm_list()?.arms().zip(new_arm_list));
-    Some(make::expr_match(match_expr.expr()?, new_arm_list))
+struct AssignmentsCollector<'a> {
+    sema: &'a hir::Semantics<'a, ide_db::RootDatabase>,
+    common_lhs: ast::Expr,
+    assignments: Vec<(ast::ExprStmt, ast::Expr)>,
 }
 
-fn exprify_if(
-    statement: &ast::IfExpr,
-    sema: &hir::Semantics<ide_db::RootDatabase>,
-    name: &ast::Expr,
-) -> Option<ast::Expr> {
-    let then_branch = exprify_block(&statement.then_branch()?, sema, name)?;
-    let else_branch = match statement.else_branch()? {
-        ast::ElseBranch::Block(ref block) => {
-            ast::ElseBranch::Block(exprify_block(block, sema, name)?)
-        }
-        ast::ElseBranch::IfExpr(expr) => {
-            cov_mark::hit!(test_pull_assignment_up_chained_if);
-            ast::ElseBranch::IfExpr(ast::IfExpr::cast(
-                exprify_if(&expr, sema, name)?.syntax().to_owned(),
-            )?)
+impl<'a> AssignmentsCollector<'a> {
+    fn collect_match(&mut self, match_expr: &ast::MatchExpr) -> Option<()> {
+        for arm in match_expr.match_arm_list()?.arms() {
+            match arm.expr()? {
+                ast::Expr::BlockExpr(block) => self.collect_block(&block)?,
+                _ => return None,
+            }
         }
-    };
-    Some(make::expr_if(statement.condition()?, then_branch, Some(else_branch)))
-}
 
-fn exprify_block(
-    block: &ast::BlockExpr,
-    sema: &hir::Semantics<ide_db::RootDatabase>,
-    name: &ast::Expr,
-) -> Option<ast::BlockExpr> {
-    if block.tail_expr().is_some() {
-        return None;
+        Some(())
     }
+    fn collect_if(&mut self, if_expr: &ast::IfExpr) -> Option<()> {
+        let then_branch = if_expr.then_branch()?;
+        self.collect_block(&then_branch)?;
+
+        match if_expr.else_branch()? {
+            ast::ElseBranch::Block(block) => self.collect_block(&block),
+            ast::ElseBranch::IfExpr(expr) => {
+                cov_mark::hit!(test_pull_assignment_up_chained_if);
+                self.collect_if(&expr)
+            }
+        }
+    }
+    fn collect_block(&mut self, block: &ast::BlockExpr) -> Option<()> {
+        if block.tail_expr().is_some() {
+            return None;
+        }
 
-    let mut stmts: Vec<_> = block.statements().collect();
-    let stmt = stmts.pop()?;
-
-    if let ast::Stmt::ExprStmt(stmt) = stmt {
-        if let ast::Expr::BinExpr(expr) = stmt.expr()? {
-            if expr.op_kind()? == ast::BinOp::Assignment && is_equivalent(sema, &expr.lhs()?, name)
-            {
-                // The last statement in the block is an assignment to the name we want
-                return Some(make::block_expr(stmts, Some(expr.rhs()?)));
+        let last_stmt = block.statements().last()?;
+        if let ast::Stmt::ExprStmt(stmt) = last_stmt {
+            if let ast::Expr::BinExpr(expr) = stmt.expr()? {
+                if expr.op_kind()? == ast::BinOp::Assignment
+                    && is_equivalent(self.sema, &expr.lhs()?, &self.common_lhs)
+                {
+                    self.assignments.push((stmt, expr.rhs()?));
+                    return Some(());
+                }
             }
         }
+
+        None
     }
-    None
 }
 
 fn is_equivalent(
@@ -243,6 +241,38 @@ fn foo() {
     }
 
     #[test]
+    #[ignore]
+    fn test_pull_assignment_up_assignment_expressions() {
+        check_assist(
+            pull_assignment_up,
+            r#"
+fn foo() {
+    let mut a = 1;
+
+    match 1 {
+        1 => { $0a = 2; },
+        2 => a = 3,
+        3 => {
+            a = 4
+        }
+    }
+}"#,
+            r#"
+fn foo() {
+    let mut a = 1;
+
+    a = match 1 {
+        1 => { 2 },
+        2 => 3,
+        3 => {
+            4
+        }
+    };
+}"#,
+        );
+    }
+
+    #[test]
     fn test_pull_assignment_up_not_last_not_applicable() {
         check_assist_not_applicable(
             pull_assignment_up,
@@ -439,4 +469,24 @@ fn foo() {
 "#,
         )
     }
+
+    #[test]
+    fn test_cant_pull_non_assignments() {
+        cov_mark::check!(test_cant_pull_non_assignments);
+        check_assist_not_applicable(
+            pull_assignment_up,
+            r#"
+fn foo() {
+    let mut a = 1;
+    let b = &mut a;
+
+    if true {
+        $0*b + 2;
+    } else {
+        *b + 3;
+    }
+}
+"#,
+        )
+    }
 }
diff --git a/crates/ide_completion/src/context.rs b/crates/ide_completion/src/context.rs
index 62ef40818..787eb2fd3 100644
--- a/crates/ide_completion/src/context.rs
+++ b/crates/ide_completion/src/context.rs
@@ -313,7 +313,8 @@ impl<'a> CompletionContext<'a> {
                         cov_mark::hit!(expected_type_let_with_leading_char);
                         cov_mark::hit!(expected_type_let_without_leading_char);
                         let ty = it.pat()
-                            .and_then(|pat| self.sema.type_of_pat(&pat));
+                            .and_then(|pat| self.sema.type_of_pat(&pat))
+                            .or_else(|| it.initializer().and_then(|it| self.sema.type_of_expr(&it)));
                         let name = if let Some(ast::Pat::IdentPat(ident)) = it.pat() {
                             ident.name().map(NameOrNameRef::Name)
                         } else {
@@ -720,6 +721,26 @@ fn foo() {
     }
 
     #[test]
+    fn expected_type_let_pat() {
+        check_expected_type_and_name(
+            r#"
+fn foo() {
+    let x$0 = 0u32;
+}
+"#,
+            expect![[r#"ty: u32, name: ?"#]],
+        );
+        check_expected_type_and_name(
+            r#"
+fn foo() {
+    let $0 = 0u32;
+}
+"#,
+            expect![[r#"ty: u32, name: ?"#]],
+        );
+    }
+
+    #[test]
     fn expected_type_fn_param_without_leading_char() {
         cov_mark::check!(expected_type_fn_param_without_leading_char);
         check_expected_type_and_name(
diff --git a/crates/ide_db/src/search.rs b/crates/ide_db/src/search.rs
index 8f899ea56..67840602b 100644
--- a/crates/ide_db/src/search.rs
+++ b/crates/ide_db/src/search.rs
@@ -233,6 +233,13 @@ impl Definition {
             };
         }
 
+        if let Definition::SelfType(impl_) = self {
+            return match impl_.source(db).map(|src| src.value.syntax().text_range()) {
+                Some(range) => SearchScope::file_range(FileRange { file_id, range }),
+                None => SearchScope::single_file(file_id),
+            };
+        }
+
         if let Definition::GenericParam(hir::GenericParam::LifetimeParam(param)) = self {
             let range = match param.parent(db) {
                 hir::GenericDef::Function(it) => {
@@ -297,7 +304,7 @@ impl Definition {
     }
 
     pub fn usages<'a>(&'a self, sema: &'a Semantics<RootDatabase>) -> FindUsages<'a> {
-        FindUsages { def: self, sema, scope: None, include_self_kw_refs: false }
+        FindUsages { def: self, sema, scope: None, include_self_kw_refs: None }
     }
 }
 
@@ -305,12 +312,13 @@ pub struct FindUsages<'a> {
     def: &'a Definition,
     sema: &'a Semantics<'a, RootDatabase>,
     scope: Option<SearchScope>,
-    include_self_kw_refs: bool,
+    include_self_kw_refs: Option<hir::Type>,
 }
 
 impl<'a> FindUsages<'a> {
-    pub fn include_self_kw_refs(mut self, include: bool) -> FindUsages<'a> {
-        self.include_self_kw_refs = include;
+    /// Enable searching for `Self` when the definition is a type.
+    pub fn include_self_refs(mut self) -> FindUsages<'a> {
+        self.include_self_kw_refs = def_to_ty(self.sema, self.def);
         self
     }
 
@@ -354,13 +362,18 @@ impl<'a> FindUsages<'a> {
             }
         };
 
-        let name = match self.def.name(sema.db) {
-            Some(it) => it.to_string(),
+        let name = self.def.name(sema.db).or_else(|| {
+            self.include_self_kw_refs.as_ref().and_then(|ty| {
+                ty.as_adt()
+                    .map(|adt| adt.name(self.sema.db))
+                    .or_else(|| ty.as_builtin().map(|builtin| builtin.name()))
+            })
+        });
+        let name = match name {
+            Some(name) => name.to_string(),
             None => return,
         };
-
-        let pat = name.as_str();
-        let search_for_self = self.include_self_kw_refs;
+        let name = name.as_str();
 
         for (file_id, search_range) in search_scope {
             let text = sema.db.file_text(file_id);
@@ -369,51 +382,63 @@ impl<'a> FindUsages<'a> {
 
             let tree = Lazy::new(|| sema.parse(file_id).syntax().clone());
 
-            let mut handle_match = |idx: usize| -> bool {
+            for (idx, _) in text.match_indices(name) {
                 let offset: TextSize = idx.try_into().unwrap();
                 if !search_range.contains_inclusive(offset) {
-                    return false;
+                    continue;
                 }
 
                 if let Some(name) = sema.find_node_at_offset_with_descend(&tree, offset) {
-                    match name {
-                        ast::NameLike::NameRef(name_ref) => {
-                            if self.found_name_ref(&name_ref, sink) {
-                                return true;
-                            }
-                        }
-                        ast::NameLike::Name(name) => {
-                            if self.found_name(&name, sink) {
-                                return true;
-                            }
-                        }
-                        ast::NameLike::Lifetime(lifetime) => {
-                            if self.found_lifetime(&lifetime, sink) {
-                                return true;
-                            }
-                        }
+                    if match name {
+                        ast::NameLike::NameRef(name_ref) => self.found_name_ref(&name_ref, sink),
+                        ast::NameLike::Name(name) => self.found_name(&name, sink),
+                        ast::NameLike::Lifetime(lifetime) => self.found_lifetime(&lifetime, sink),
+                    } {
+                        return;
                     }
                 }
-
-                return false;
-            };
-
-            for (idx, _) in text.match_indices(pat) {
-                if handle_match(idx) {
-                    return;
-                }
             }
-
-            if search_for_self {
+            if let Some(self_ty) = &self.include_self_kw_refs {
                 for (idx, _) in text.match_indices("Self") {
-                    if handle_match(idx) {
-                        return;
+                    let offset: TextSize = idx.try_into().unwrap();
+                    if !search_range.contains_inclusive(offset) {
+                        continue;
+                    }
+
+                    if let Some(ast::NameLike::NameRef(name_ref)) =
+                        sema.find_node_at_offset_with_descend(&tree, offset)
+                    {
+                        if self.found_self_ty_name_ref(&self_ty, &name_ref, sink) {
+                            return;
+                        }
                     }
                 }
             }
         }
     }
 
+    fn found_self_ty_name_ref(
+        &self,
+        self_ty: &hir::Type,
+        name_ref: &ast::NameRef,
+        sink: &mut dyn FnMut(FileId, FileReference) -> bool,
+    ) -> bool {
+        match NameRefClass::classify(self.sema, &name_ref) {
+            Some(NameRefClass::Definition(Definition::SelfType(impl_)))
+                if impl_.self_ty(self.sema.db) == *self_ty =>
+            {
+                let FileRange { file_id, range } = self.sema.original_range(name_ref.syntax());
+                let reference = FileReference {
+                    range,
+                    name: ast::NameLike::NameRef(name_ref.clone()),
+                    access: None,
+                };
+                sink(file_id, reference)
+            }
+            _ => false,
+        }
+    }
+
     fn found_lifetime(
         &self,
         lifetime: &ast::Lifetime,
@@ -429,7 +454,7 @@ impl<'a> FindUsages<'a> {
                 };
                 sink(file_id, reference)
             }
-            _ => false, // not a usage
+            _ => false,
         }
     }
 
@@ -448,42 +473,35 @@ impl<'a> FindUsages<'a> {
                 };
                 sink(file_id, reference)
             }
-            Some(NameRefClass::Definition(Definition::SelfType(impl_))) => {
-                let ty = impl_.self_ty(self.sema.db);
-
-                if let Some(adt) = ty.as_adt() {
-                    if &Definition::ModuleDef(ModuleDef::Adt(adt)) == self.def {
-                        let FileRange { file_id, range } =
-                            self.sema.original_range(name_ref.syntax());
-                        let reference = FileReference {
-                            range,
-                            name: ast::NameLike::NameRef(name_ref.clone()),
-                            access: None,
-                        };
-                        return sink(file_id, reference);
-                    }
+            Some(NameRefClass::Definition(def)) if self.include_self_kw_refs.is_some() => {
+                if self.include_self_kw_refs == def_to_ty(self.sema, &def) {
+                    let FileRange { file_id, range } = self.sema.original_range(name_ref.syntax());
+                    let reference = FileReference {
+                        range,
+                        name: ast::NameLike::NameRef(name_ref.clone()),
+                        access: reference_access(&def, &name_ref),
+                    };
+                    sink(file_id, reference)
+                } else {
+                    false
                 }
-
-                false
             }
             Some(NameRefClass::FieldShorthand { local_ref: local, field_ref: field }) => {
                 let FileRange { file_id, range } = self.sema.original_range(name_ref.syntax());
-                let reference = match self.def {
-                    Definition::Field(_) if &field == self.def => FileReference {
-                        range,
-                        name: ast::NameLike::NameRef(name_ref.clone()),
-                        access: reference_access(&field, &name_ref),
-                    },
-                    Definition::Local(l) if &local == l => FileReference {
-                        range,
-                        name: ast::NameLike::NameRef(name_ref.clone()),
-                        access: reference_access(&Definition::Local(local), &name_ref),
-                    },
-                    _ => return false, // not a usage
+                let access = match self.def {
+                    Definition::Field(_) if &field == self.def => {
+                        reference_access(&field, &name_ref)
+                    }
+                    Definition::Local(l) if &local == l => {
+                        reference_access(&Definition::Local(local), &name_ref)
+                    }
+                    _ => return false,
                 };
+                let reference =
+                    FileReference { range, name: ast::NameLike::NameRef(name_ref.clone()), access };
                 sink(file_id, reference)
             }
-            _ => false, // not a usage
+            _ => false,
         }
     }
 
@@ -513,11 +531,30 @@ impl<'a> FindUsages<'a> {
                     FileReference { range, name: ast::NameLike::Name(name.clone()), access: None };
                 sink(file_id, reference)
             }
-            _ => false, // not a usage
+            _ => false,
         }
     }
 }
 
+fn def_to_ty(sema: &Semantics<RootDatabase>, def: &Definition) -> Option<hir::Type> {
+    match def {
+        Definition::ModuleDef(def) => match def {
+            ModuleDef::Adt(adt) => Some(adt.ty(sema.db)),
+            ModuleDef::TypeAlias(it) => Some(it.ty(sema.db)),
+            ModuleDef::BuiltinType(it) => {
+                let graph = sema.db.crate_graph();
+                let krate = graph.iter().next()?;
+                let root_file = graph[krate].root_file_id;
+                let module = sema.to_module_def(root_file)?;
+                Some(it.ty(sema.db, module))
+            }
+            _ => None,
+        },
+        Definition::SelfType(it) => Some(it.self_ty(sema.db)),
+        _ => None,
+    }
+}
+
 fn reference_access(def: &Definition, name_ref: &ast::NameRef) -> Option<ReferenceAccess> {
     // Only Locals and Fields have accesses for now.
     if !matches!(def, Definition::Local(_) | Definition::Field(_)) {
diff --git a/crates/parser/src/grammar/patterns.rs b/crates/parser/src/grammar/patterns.rs
index 3ab347834..f1d1f9eaa 100644
--- a/crates/parser/src/grammar/patterns.rs
+++ b/crates/parser/src/grammar/patterns.rs
@@ -83,7 +83,7 @@ fn pattern_single_r(p: &mut Parser, recovery_set: TokenSet) {
 }
 
 const PAT_RECOVERY_SET: TokenSet =
-    TokenSet::new(&[T![let], T![if], T![while], T![loop], T![match], T![')'], T![,]]);
+    TokenSet::new(&[T![let], T![if], T![while], T![loop], T![match], T![')'], T![,], T![=]]);
 
 fn atom_pat(p: &mut Parser, recovery_set: TokenSet) -> Option<CompletedMarker> {
     let m = match p.nth(0) {
diff --git a/crates/syntax/src/algo.rs b/crates/syntax/src/algo.rs
index ba263be0d..3f9b84ab9 100644
--- a/crates/syntax/src/algo.rs
+++ b/crates/syntax/src/algo.rs
@@ -1,10 +1,6 @@
 //! FIXME: write short doc here
 
-use std::{
-    fmt,
-    hash::BuildHasherDefault,
-    ops::{self, RangeInclusive},
-};
+use std::{fmt, hash::BuildHasherDefault, ops::RangeInclusive};
 
 use indexmap::IndexMap;
 use itertools::Itertools;
@@ -358,107 +354,11 @@ impl fmt::Debug for SyntaxRewriter<'_> {
 }
 
 impl SyntaxRewriter<'_> {
-    pub fn delete<T: Clone + Into<SyntaxElement>>(&mut self, what: &T) {
-        let what = what.clone().into();
-        let replacement = Replacement::Delete;
-        self.replacements.insert(what, replacement);
-    }
-    pub fn insert_before<T: Clone + Into<SyntaxElement>, U: Clone + Into<SyntaxElement>>(
-        &mut self,
-        before: &T,
-        what: &U,
-    ) {
-        let before = before.clone().into();
-        let pos = match before.prev_sibling_or_token() {
-            Some(sibling) => InsertPos::After(sibling),
-            None => match before.parent() {
-                Some(parent) => InsertPos::FirstChildOf(parent),
-                None => return,
-            },
-        };
-        self.insertions.entry(pos).or_insert_with(Vec::new).push(what.clone().into());
-    }
-    pub fn insert_after<T: Clone + Into<SyntaxElement>, U: Clone + Into<SyntaxElement>>(
-        &mut self,
-        after: &T,
-        what: &U,
-    ) {
-        self.insertions
-            .entry(InsertPos::After(after.clone().into()))
-            .or_insert_with(Vec::new)
-            .push(what.clone().into());
-    }
-    pub fn insert_as_first_child<T: Clone + Into<SyntaxNode>, U: Clone + Into<SyntaxElement>>(
-        &mut self,
-        parent: &T,
-        what: &U,
-    ) {
-        self.insertions
-            .entry(InsertPos::FirstChildOf(parent.clone().into()))
-            .or_insert_with(Vec::new)
-            .push(what.clone().into());
-    }
-    pub fn insert_many_before<
-        T: Clone + Into<SyntaxElement>,
-        U: IntoIterator<Item = SyntaxElement>,
-    >(
-        &mut self,
-        before: &T,
-        what: U,
-    ) {
-        let before = before.clone().into();
-        let pos = match before.prev_sibling_or_token() {
-            Some(sibling) => InsertPos::After(sibling),
-            None => match before.parent() {
-                Some(parent) => InsertPos::FirstChildOf(parent),
-                None => return,
-            },
-        };
-        self.insertions.entry(pos).or_insert_with(Vec::new).extend(what);
-    }
-    pub fn insert_many_after<
-        T: Clone + Into<SyntaxElement>,
-        U: IntoIterator<Item = SyntaxElement>,
-    >(
-        &mut self,
-        after: &T,
-        what: U,
-    ) {
-        self.insertions
-            .entry(InsertPos::After(after.clone().into()))
-            .or_insert_with(Vec::new)
-            .extend(what);
-    }
-    pub fn insert_many_as_first_children<
-        T: Clone + Into<SyntaxNode>,
-        U: IntoIterator<Item = SyntaxElement>,
-    >(
-        &mut self,
-        parent: &T,
-        what: U,
-    ) {
-        self.insertions
-            .entry(InsertPos::FirstChildOf(parent.clone().into()))
-            .or_insert_with(Vec::new)
-            .extend(what)
-    }
     pub fn replace<T: Clone + Into<SyntaxElement>>(&mut self, what: &T, with: &T) {
         let what = what.clone().into();
         let replacement = Replacement::Single(with.clone().into());
         self.replacements.insert(what, replacement);
     }
-    pub fn replace_with_many<T: Clone + Into<SyntaxElement>>(
-        &mut self,
-        what: &T,
-        with: Vec<SyntaxElement>,
-    ) {
-        let what = what.clone().into();
-        let replacement = Replacement::Many(with);
-        self.replacements.insert(what, replacement);
-    }
-    pub fn replace_ast<T: AstNode>(&mut self, what: &T, with: &T) {
-        self.replace(what.syntax(), with.syntax())
-    }
 
     pub fn rewrite(&self, node: &SyntaxNode) -> SyntaxNode {
         let _p = profile::span("rewrite");
@@ -534,10 +434,6 @@ impl SyntaxRewriter<'_> {
         if let Some(replacement) = self.replacement(&element) {
             match replacement {
                 Replacement::Single(element) => acc.push(element_to_green(element)),
-                Replacement::Many(replacements) => {
-                    acc.extend(replacements.into_iter().map(element_to_green))
-                }
-                Replacement::Delete => (),
             };
         } else {
             match element {
@@ -560,25 +456,9 @@ fn element_to_green(element: SyntaxElement) -> NodeOrToken<rowan::GreenNode, row
     }
 }
 
-impl ops::AddAssign for SyntaxRewriter<'_> {
-    fn add_assign(&mut self, rhs: SyntaxRewriter) {
-        self.replacements.extend(rhs.replacements);
-        for (pos, insertions) in rhs.insertions.into_iter() {
-            match self.insertions.entry(pos) {
-                indexmap::map::Entry::Occupied(mut occupied) => {
-                    occupied.get_mut().extend(insertions)
-                }
-                indexmap::map::Entry::Vacant(vacant) => drop(vacant.insert(insertions)),
-            }
-        }
-    }
-}
-
 #[derive(Clone, Debug)]
 enum Replacement {
-    Delete,
     Single(SyntaxElement),
-    Many(Vec<SyntaxElement>),
 }
 
 fn with_children(
diff --git a/crates/syntax/src/ast/edit.rs b/crates/syntax/src/ast/edit.rs
index 8c60927e4..cbc75f922 100644
--- a/crates/syntax/src/ast/edit.rs
+++ b/crates/syntax/src/ast/edit.rs
@@ -665,18 +665,8 @@ pub trait AstNodeEdit: AstNode + Clone + Sized {
 
     #[must_use]
     fn replace_descendant<D: AstNode>(&self, old: D, new: D) -> Self {
-        self.replace_descendants(iter::once((old, new)))
-    }
-
-    #[must_use]
-    fn replace_descendants<D: AstNode>(
-        &self,
-        replacement_map: impl IntoIterator<Item = (D, D)>,
-    ) -> Self {
         let mut rewriter = SyntaxRewriter::default();
-        for (from, to) in replacement_map {
-            rewriter.replace(from.syntax(), to.syntax())
-        }
+        rewriter.replace(old.syntax(), new.syntax());
         rewriter.rewrite_ast(self)
     }
     fn indent_level(&self) -> IndentLevel {
diff --git a/crates/syntax/src/ast/make.rs b/crates/syntax/src/ast/make.rs
index f8b508a90..5a6687397 100644
--- a/crates/syntax/src/ast/make.rs
+++ b/crates/syntax/src/ast/make.rs
@@ -275,6 +275,9 @@ pub fn expr_tuple(elements: impl IntoIterator<Item = ast::Expr>) -> ast::Expr {
     let expr = elements.into_iter().format(", ");
     expr_from_text(&format!("({})", expr))
 }
+pub fn expr_assignment(lhs: ast::Expr, rhs: ast::Expr) -> ast::Expr {
+    expr_from_text(&format!("{} = {}", lhs, rhs))
+}
 fn expr_from_text(text: &str) -> ast::Expr {
     ast_from_text(&format!("const C: () = {};", text))
 }