13 files changed, 451 insertions, 103 deletions

diff --git a/crates/ra_assists/src/add_derive.rs b/crates/ra_assists/src/add_derive.rs
index e91b5eb8d..0c4cf2615 100644
--- a/crates/ra_assists/src/add_derive.rs
+++ b/crates/ra_assists/src/add_derive.rs
@@ -33,8 +33,10 @@ pub(crate) fn add_derive(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist>
 
 // Insert `derive` after doc comments.
 fn derive_insertion_offset(nominal: &ast::NominalDef) -> Option<TextUnit> {
-    let non_ws_child =
-        nominal.syntax().children().find(|it| it.kind() != COMMENT && it.kind() != WHITESPACE)?;
+    let non_ws_child = nominal
+        .syntax()
+        .children_with_tokens()
+        .find(|it| it.kind() != COMMENT && it.kind() != WHITESPACE)?;
     Some(non_ws_child.range().start())
 }
 
diff --git a/crates/ra_assists/src/add_impl.rs b/crates/ra_assists/src/add_impl.rs
index b292f188d..fa1c85890 100644
--- a/crates/ra_assists/src/add_impl.rs
+++ b/crates/ra_assists/src/add_impl.rs
@@ -1,7 +1,7 @@
 use join_to_string::join;
 use hir::db::HirDatabase;
 use ra_syntax::{
-    ast::{self, AstNode, AstToken, NameOwner, TypeParamsOwner},
+    ast::{self, AstNode, NameOwner, TypeParamsOwner},
     TextUnit,
 };
 
@@ -22,8 +22,10 @@ pub(crate) fn add_impl(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
         buf.push_str(" ");
         buf.push_str(name.text().as_str());
         if let Some(type_params) = type_params {
-            let lifetime_params =
-                type_params.lifetime_params().filter_map(|it| it.lifetime()).map(|it| it.text());
+            let lifetime_params = type_params
+                .lifetime_params()
+                .filter_map(|it| it.lifetime_token())
+                .map(|it| it.text());
             let type_params =
                 type_params.type_params().filter_map(|it| it.name()).map(|it| it.text());
             join(lifetime_params.chain(type_params)).surround_with("<", ">").to_buf(&mut buf);
diff --git a/crates/ra_assists/src/add_missing_impl_members.rs b/crates/ra_assists/src/add_missing_impl_members.rs
index e13f54c4f..19a2d05bc 100644
--- a/crates/ra_assists/src/add_missing_impl_members.rs
+++ b/crates/ra_assists/src/add_missing_impl_members.rs
@@ -1,9 +1,11 @@
+use std::fmt::Write;
+
 use crate::{Assist, AssistId, AssistCtx};
 
 use hir::Resolver;
 use hir::db::HirDatabase;
 use ra_syntax::{SmolStr, SyntaxKind, TextRange, TextUnit, TreeArc};
-use ra_syntax::ast::{self, AstNode, FnDef, ImplItem, ImplItemKind, NameOwner};
+use ra_syntax::ast::{self, AstNode, AstToken, FnDef, ImplItem, ImplItemKind, NameOwner};
 use ra_db::FilePosition;
 use ra_fmt::{leading_indent, reindent};
 
@@ -91,8 +93,9 @@ fn add_missing_impl_members_inner(
         };
 
         let changed_range = {
-            let children = impl_item_list.syntax().children();
-            let last_whitespace = children.filter_map(ast::Whitespace::cast).last();
+            let children = impl_item_list.syntax().children_with_tokens();
+            let last_whitespace =
+                children.filter_map(|it| ast::Whitespace::cast(it.as_token()?)).last();
 
             last_whitespace.map(|w| w.syntax().range()).unwrap_or_else(|| {
                 let in_brackets = impl_item_list.syntax().range().end() - TextUnit::of_str("}");
@@ -134,13 +137,13 @@ fn resolve_target_trait_def(
 fn build_func_body(def: &ast::FnDef) -> String {
     let mut buf = String::new();
 
-    for child in def.syntax().children() {
-        match (child.prev_sibling().map(|c| c.kind()), child.kind()) {
+    for child in def.syntax().children_with_tokens() {
+        match (child.prev_sibling_or_token().map(|c| c.kind()), child.kind()) {
             (_, SyntaxKind::SEMI) => buf.push_str(" { unimplemented!() }"),
             (_, SyntaxKind::ATTR) | (_, SyntaxKind::COMMENT) => {}
             (Some(SyntaxKind::ATTR), SyntaxKind::WHITESPACE)
             | (Some(SyntaxKind::COMMENT), SyntaxKind::WHITESPACE) => {}
-            _ => child.text().push_to(&mut buf),
+            _ => write!(buf, "{}", child).unwrap(),
         };
     }
 
diff --git a/crates/ra_assists/src/assist_ctx.rs b/crates/ra_assists/src/assist_ctx.rs
index 4ad21c74b..e80e35738 100644
--- a/crates/ra_assists/src/assist_ctx.rs
+++ b/crates/ra_assists/src/assist_ctx.rs
@@ -2,8 +2,8 @@ use hir::db::HirDatabase;
 use ra_text_edit::TextEditBuilder;
 use ra_db::FileRange;
 use ra_syntax::{
-    SourceFile, TextRange, AstNode, TextUnit, SyntaxNode,
-    algo::{find_leaf_at_offset, find_node_at_offset, find_covering_node, LeafAtOffset},
+    SourceFile, TextRange, AstNode, TextUnit, SyntaxNode, SyntaxElement, SyntaxToken,
+    algo::{find_token_at_offset, find_node_at_offset, find_covering_element, TokenAtOffset},
 };
 use ra_fmt::{leading_indent, reindent};
 
@@ -104,15 +104,19 @@ impl<'a, DB: HirDatabase> AssistCtx<'a, DB> {
         Some(self.assist)
     }
 
-    pub(crate) fn leaf_at_offset(&self) -> LeafAtOffset<&'a SyntaxNode> {
-        find_leaf_at_offset(self.source_file.syntax(), self.frange.range.start())
+    pub(crate) fn token_at_offset(&self) -> TokenAtOffset<SyntaxToken<'a>> {
+        find_token_at_offset(self.source_file.syntax(), self.frange.range.start())
     }
 
     pub(crate) fn node_at_offset<N: AstNode>(&self) -> Option<&'a N> {
         find_node_at_offset(self.source_file.syntax(), self.frange.range.start())
     }
-    pub(crate) fn covering_node(&self) -> &'a SyntaxNode {
-        find_covering_node(self.source_file.syntax(), self.frange.range)
+    pub(crate) fn covering_element(&self) -> SyntaxElement<'a> {
+        find_covering_element(self.source_file.syntax(), self.frange.range)
+    }
+
+    pub(crate) fn covering_node_for_range(&self, range: TextRange) -> SyntaxElement<'a> {
+        find_covering_element(self.source_file.syntax(), range)
     }
 }
 
diff --git a/crates/ra_assists/src/auto_import.rs b/crates/ra_assists/src/auto_import.rs
index 685dbed06..3fdf6b0d9 100644
--- a/crates/ra_assists/src/auto_import.rs
+++ b/crates/ra_assists/src/auto_import.rs
@@ -21,7 +21,7 @@ fn collect_path_segments_raw<'a>(
 ) -> Option<usize> {
     let oldlen = segments.len();
     loop {
-        let mut children = path.syntax().children();
+        let mut children = path.syntax().children_with_tokens();
         let (first, second, third) = (
             children.next().map(|n| (n, n.kind())),
             children.next().map(|n| (n, n.kind())),
@@ -29,11 +29,11 @@ fn collect_path_segments_raw<'a>(
         );
         match (first, second, third) {
             (Some((subpath, PATH)), Some((_, COLONCOLON)), Some((segment, PATH_SEGMENT))) => {
-                path = ast::Path::cast(subpath)?;
-                segments.push(ast::PathSegment::cast(segment)?);
+                path = ast::Path::cast(subpath.as_node()?)?;
+                segments.push(ast::PathSegment::cast(segment.as_node()?)?);
             }
             (Some((segment, PATH_SEGMENT)), _, _) => {
-                segments.push(ast::PathSegment::cast(segment)?);
+                segments.push(ast::PathSegment::cast(segment.as_node()?)?);
                 break;
             }
             (_, _, _) => return None,
@@ -514,8 +514,7 @@ fn apply_auto_import<'a>(
 }
 
 pub(crate) fn auto_import(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
-    let node = ctx.covering_node();
-    let path = node.ancestors().find_map(ast::Path::cast)?;
+    let path: &ast::Path = ctx.node_at_offset()?;
     // We don't want to mess with use statements
     if path.syntax().ancestors().find_map(ast::UseItem::cast).is_some() {
         return None;
@@ -537,7 +536,7 @@ pub(crate) fn auto_import(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist
             );
         }
     } else {
-        let current_file = node.ancestors().find_map(ast::SourceFile::cast)?;
+        let current_file = path.syntax().ancestors().find_map(ast::SourceFile::cast)?;
         ctx.add_action(
             AssistId("auto_import"),
             format!("import {} in the current file", fmt_segments(&segments)),
diff --git a/crates/ra_assists/src/change_visibility.rs b/crates/ra_assists/src/change_visibility.rs
index 50c1be5ae..c63470726 100644
--- a/crates/ra_assists/src/change_visibility.rs
+++ b/crates/ra_assists/src/change_visibility.rs
@@ -15,13 +15,13 @@ pub(crate) fn change_visibility(ctx: AssistCtx<impl HirDatabase>) -> Option<Assi
 }
 
 fn add_vis(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
-    let item_keyword = ctx.leaf_at_offset().find(|leaf| match leaf.kind() {
+    let item_keyword = ctx.token_at_offset().find(|leaf| match leaf.kind() {
         FN_KW | MOD_KW | STRUCT_KW | ENUM_KW | TRAIT_KW => true,
         _ => false,
     });
 
     let (offset, target) = if let Some(keyword) = item_keyword {
-        let parent = keyword.parent()?;
+        let parent = keyword.parent();
         let def_kws = vec![FN_DEF, MODULE, STRUCT_DEF, ENUM_DEF, TRAIT_DEF];
         // Parent is not a definition, can't add visibility
         if !def_kws.iter().any(|&def_kw| def_kw == parent.kind()) {
@@ -33,8 +33,8 @@ fn add_vis(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
         }
         (vis_offset(parent), keyword.range())
     } else {
-        let ident = ctx.leaf_at_offset().find(|leaf| leaf.kind() == IDENT)?;
-        let field = ident.ancestors().find_map(ast::NamedFieldDef::cast)?;
+        let ident = ctx.token_at_offset().find(|leaf| leaf.kind() == IDENT)?;
+        let field = ident.parent().ancestors().find_map(ast::NamedFieldDef::cast)?;
         if field.name()?.syntax().range() != ident.range() && field.visibility().is_some() {
             return None;
         }
@@ -51,7 +51,7 @@ fn add_vis(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
 }
 
 fn vis_offset(node: &SyntaxNode) -> TextUnit {
-    node.children()
+    node.children_with_tokens()
         .skip_while(|it| match it.kind() {
             WHITESPACE | COMMENT | ATTR => true,
             _ => false,
diff --git a/crates/ra_assists/src/flip_binexpr.rs b/crates/ra_assists/src/flip_binexpr.rs
index ec377642e..02d27f66d 100644
--- a/crates/ra_assists/src/flip_binexpr.rs
+++ b/crates/ra_assists/src/flip_binexpr.rs
@@ -8,7 +8,7 @@ pub(crate) fn flip_binexpr(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assis
     let expr = ctx.node_at_offset::<BinExpr>()?;
     let lhs = expr.lhs()?.syntax();
     let rhs = expr.rhs()?.syntax();
-    let op_range = expr.op()?.range();
+    let op_range = expr.op_token()?.range();
     // The assist should be applied only if the cursor is on the operator
     let cursor_in_range = ctx.frange.range.is_subrange(&op_range);
     if !cursor_in_range {
diff --git a/crates/ra_assists/src/flip_comma.rs b/crates/ra_assists/src/flip_comma.rs
index 6b98cac68..a9b108111 100644
--- a/crates/ra_assists/src/flip_comma.rs
+++ b/crates/ra_assists/src/flip_comma.rs
@@ -8,13 +8,13 @@ use ra_syntax::{
 use crate::{AssistCtx, Assist, AssistId};
 
 pub(crate) fn flip_comma(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
-    let comma = ctx.leaf_at_offset().find(|leaf| leaf.kind() == COMMA)?;
-    let prev = non_trivia_sibling(comma, Direction::Prev)?;
-    let next = non_trivia_sibling(comma, Direction::Next)?;
+    let comma = ctx.token_at_offset().find(|leaf| leaf.kind() == COMMA)?;
+    let prev = non_trivia_sibling(comma.into(), Direction::Prev)?;
+    let next = non_trivia_sibling(comma.into(), Direction::Next)?;
     ctx.add_action(AssistId("flip_comma"), "flip comma", |edit| {
         edit.target(comma.range());
-        edit.replace(prev.range(), next.text());
-        edit.replace(next.range(), prev.text());
+        edit.replace(prev.range(), next.to_string());
+        edit.replace(next.range(), prev.to_string());
     });
 
     ctx.build()
diff --git a/crates/ra_assists/src/inline_local_variable.rs b/crates/ra_assists/src/inline_local_variable.rs
index bd3cdb970..950c2910b 100644
--- a/crates/ra_assists/src/inline_local_variable.rs
+++ b/crates/ra_assists/src/inline_local_variable.rs
@@ -1,7 +1,11 @@
-use hir::db::HirDatabase;
-use hir::source_binder::function_from_child_node;
-use ra_syntax::{ast::{self, AstNode}, TextRange};
-use ra_syntax::ast::{PatKind, ExprKind};
+use hir::{
+    db::HirDatabase,
+    source_binder::function_from_child_node,
+};
+use ra_syntax::{
+    ast::{self, AstNode, AstToken, PatKind, ExprKind},
+    TextRange,
+};
 
 use crate::{Assist, AssistCtx, AssistId};
 use crate::assist_ctx::AssistBuilder;
@@ -15,61 +19,77 @@ pub(crate) fn inline_local_varialbe(mut ctx: AssistCtx<impl HirDatabase>) -> Opt
     if bind_pat.is_mutable() {
         return None;
     }
-    let initializer = let_stmt.initializer()?;
-    let wrap_in_parens = match initializer.kind() {
-        ExprKind::LambdaExpr(_)
-        | ExprKind::IfExpr(_)
-        | ExprKind::LoopExpr(_)
-        | ExprKind::ForExpr(_)
-        | ExprKind::WhileExpr(_)
-        | ExprKind::ContinueExpr(_)
-        | ExprKind::BreakExpr(_)
-        | ExprKind::Label(_)
-        | ExprKind::ReturnExpr(_)
-        | ExprKind::MatchExpr(_)
-        | ExprKind::StructLit(_)
-        | ExprKind::CastExpr(_)
-        | ExprKind::PrefixExpr(_)
-        | ExprKind::RangeExpr(_)
-        | ExprKind::BinExpr(_) => true,
-        ExprKind::CallExpr(_)
-        | ExprKind::IndexExpr(_)
-        | ExprKind::MethodCallExpr(_)
-        | ExprKind::FieldExpr(_)
-        | ExprKind::TryExpr(_)
-        | ExprKind::RefExpr(_)
-        | ExprKind::Literal(_)
-        | ExprKind::TupleExpr(_)
-        | ExprKind::ArrayExpr(_)
-        | ExprKind::ParenExpr(_)
-        | ExprKind::PathExpr(_)
-        | ExprKind::BlockExpr(_) => false,
-    };
-
-    let delete_range = if let Some(whitespace) =
-        let_stmt.syntax().next_sibling().and_then(ast::Whitespace::cast)
+    let initializer_expr = let_stmt.initializer();
+    let delete_range = if let Some(whitespace) = let_stmt
+        .syntax()
+        .next_sibling_or_token()
+        .and_then(|it| ast::Whitespace::cast(it.as_token()?))
     {
         TextRange::from_to(let_stmt.syntax().range().start(), whitespace.syntax().range().end())
     } else {
         let_stmt.syntax().range()
     };
 
-    let init_str = if wrap_in_parens {
-        format!("({})", initializer.syntax().text().to_string())
-    } else {
-        initializer.syntax().text().to_string()
-    };
     let function = function_from_child_node(ctx.db, ctx.frange.file_id, bind_pat.syntax())?;
     let scope = function.scopes(ctx.db);
     let refs = scope.find_all_refs(bind_pat);
 
+    let mut wrap_in_parens = vec![true; refs.len()];
+
+    for (i, desc) in refs.iter().enumerate() {
+        let usage_node = ctx
+            .covering_node_for_range(desc.range)
+            .ancestors()
+            .find_map(|node| ast::PathExpr::cast(node))?;
+        let usage_parent_option = usage_node.syntax().parent().and_then(ast::Expr::cast);
+        let usage_parent = match usage_parent_option {
+            Some(u) => u,
+            None => {
+                wrap_in_parens[i] = false;
+                continue;
+            }
+        };
+
+        wrap_in_parens[i] = match (initializer_expr?.kind(), usage_parent.kind()) {
+            (ExprKind::CallExpr(_), _)
+            | (ExprKind::IndexExpr(_), _)
+            | (ExprKind::MethodCallExpr(_), _)
+            | (ExprKind::FieldExpr(_), _)
+            | (ExprKind::TryExpr(_), _)
+            | (ExprKind::RefExpr(_), _)
+            | (ExprKind::Literal(_), _)
+            | (ExprKind::TupleExpr(_), _)
+            | (ExprKind::ArrayExpr(_), _)
+            | (ExprKind::ParenExpr(_), _)
+            | (ExprKind::PathExpr(_), _)
+            | (ExprKind::BlockExpr(_), _)
+            | (_, ExprKind::CallExpr(_))
+            | (_, ExprKind::TupleExpr(_))
+            | (_, ExprKind::ArrayExpr(_))
+            | (_, ExprKind::ParenExpr(_))
+            | (_, ExprKind::ForExpr(_))
+            | (_, ExprKind::WhileExpr(_))
+            | (_, ExprKind::BreakExpr(_))
+            | (_, ExprKind::ReturnExpr(_))
+            | (_, ExprKind::MatchExpr(_)) => false,
+            _ => true,
+        };
+    }
+
+    let init_str = initializer_expr?.syntax().text().to_string();
+    let init_in_paren = format!("({})", &init_str);
+
     ctx.add_action(
         AssistId("inline_local_variable"),
         "inline local variable",
         move |edit: &mut AssistBuilder| {
             edit.delete(delete_range);
-            for desc in refs {
-                edit.replace(desc.range, init_str.clone())
+            for (desc, should_wrap) in refs.iter().zip(wrap_in_parens) {
+                if should_wrap {
+                    edit.replace(desc.range, init_in_paren.clone())
+                } else {
+                    edit.replace(desc.range, init_str.clone())
+                }
             }
             edit.set_cursor(delete_range.start())
         },
@@ -147,7 +167,7 @@ fn foo() {
 
     }
     let b = (1 + 1) * 10;
-    bar((1 + 1));
+    bar(1 + 1);
 }",
         );
     }
@@ -215,7 +235,7 @@ fn foo() {
 
     }
     let b = (bar(1) as u64) * 10;
-    bar((bar(1) as u64));
+    bar(bar(1) as u64);
 }",
         );
     }
@@ -295,4 +315,324 @@ fn foo() {
 }",
         );
     }
+
+    #[test]
+    fn test_call_expr() {
+        check_assist(
+            inline_local_varialbe,
+            "
+fn foo() {
+    let a<|> = bar(10 + 1);
+    let b = a * 10;
+    let c = a as usize;
+}",
+            "
+fn foo() {
+    <|>let b = bar(10 + 1) * 10;
+    let c = bar(10 + 1) as usize;
+}",
+        );
+    }
+
+    #[test]
+    fn test_index_expr() {
+        check_assist(
+            inline_local_varialbe,
+            "
+fn foo() {
+    let x = vec![1, 2, 3];
+    let a<|> = x[0];
+    let b = a * 10;
+    let c = a as usize;
+}",
+            "
+fn foo() {
+    let x = vec![1, 2, 3];
+    <|>let b = x[0] * 10;
+    let c = x[0] as usize;
+}",
+        );
+    }
+
+    #[test]
+    fn test_method_call_expr() {
+        check_assist(
+            inline_local_varialbe,
+            "
+fn foo() {
+    let bar = vec![1];
+    let a<|> = bar.len();
+    let b = a * 10;
+    let c = a as usize;
+}",
+            "
+fn foo() {
+    let bar = vec![1];
+    <|>let b = bar.len() * 10;
+    let c = bar.len() as usize;
+}",
+        );
+    }
+
+    #[test]
+    fn test_field_expr() {
+        check_assist(
+            inline_local_varialbe,
+            "
+struct Bar {
+    foo: usize
+}
+
+fn foo() {
+    let bar = Bar { foo: 1 };
+    let a<|> = bar.foo;
+    let b = a * 10;
+    let c = a as usize;
+}",
+            "
+struct Bar {
+    foo: usize
+}
+
+fn foo() {
+    let bar = Bar { foo: 1 };
+    <|>let b = bar.foo * 10;
+    let c = bar.foo as usize;
+}",
+        );
+    }
+
+    #[test]
+    fn test_try_expr() {
+        check_assist(
+            inline_local_varialbe,
+            "
+fn foo() -> Option<usize> {
+    let bar = Some(1);
+    let a<|> = bar?;
+    let b = a * 10;
+    let c = a as usize;
+    None
+}",
+            "
+fn foo() -> Option<usize> {
+    let bar = Some(1);
+    <|>let b = bar? * 10;
+    let c = bar? as usize;
+    None
+}",
+        );
+    }
+
+    #[test]
+    fn test_ref_expr() {
+        check_assist(
+            inline_local_varialbe,
+            "
+fn foo() {
+    let bar = 10;
+    let a<|> = &bar;
+    let b = a * 10;
+}",
+            "
+fn foo() {
+    let bar = 10;
+    <|>let b = &bar * 10;
+}",
+        );
+    }
+
+    #[test]
+    fn test_tuple_expr() {
+        check_assist(
+            inline_local_varialbe,
+            "
+fn foo() {
+    let a<|> = (10, 20);
+    let b = a[0];
+}",
+            "
+fn foo() {
+    <|>let b = (10, 20)[0];
+}",
+        );
+    }
+
+    #[test]
+    fn test_array_expr() {
+        check_assist(
+            inline_local_varialbe,
+            "
+fn foo() {
+    let a<|> = [1, 2, 3];
+    let b = a.len();
+}",
+            "
+fn foo() {
+    <|>let b = [1, 2, 3].len();
+}",
+        );
+    }
+
+    #[test]
+    fn test_paren() {
+        check_assist(
+            inline_local_varialbe,
+            "
+fn foo() {
+    let a<|> = (10 + 20);
+    let b = a * 10;
+    let c = a as usize;
+}",
+            "
+fn foo() {
+    <|>let b = (10 + 20) * 10;
+    let c = (10 + 20) as usize;
+}",
+        );
+    }
+
+    #[test]
+    fn test_path_expr() {
+        check_assist(
+            inline_local_varialbe,
+            "
+fn foo() {
+    let d = 10;
+    let a<|> = d;
+    let b = a * 10;
+    let c = a as usize;
+}",
+            "
+fn foo() {
+    let d = 10;
+    <|>let b = d * 10;
+    let c = d as usize;
+}",
+        );
+    }
+
+    #[test]
+    fn test_block_expr() {
+        check_assist(
+            inline_local_varialbe,
+            "
+fn foo() {
+    let a<|> = { 10 };
+    let b = a * 10;
+    let c = a as usize;
+}",
+            "
+fn foo() {
+    <|>let b = { 10 } * 10;
+    let c = { 10 } as usize;
+}",
+        );
+    }
+
+    #[test]
+    fn test_used_in_different_expr1() {
+        check_assist(
+            inline_local_varialbe,
+            "
+fn foo() {
+    let a<|> = 10 + 20;
+    let b = a * 10;
+    let c = (a, 20);
+    let d = [a, 10];
+    let e = (a);
+}",
+            "
+fn foo() {
+    <|>let b = (10 + 20) * 10;
+    let c = (10 + 20, 20);
+    let d = [10 + 20, 10];
+    let e = (10 + 20);
+}",
+        );
+    }
+
+    #[test]
+    fn test_used_in_for_expr() {
+        check_assist(
+            inline_local_varialbe,
+            "
+fn foo() {
+    let a<|> = vec![10, 20];
+    for i in a {}
+}",
+            "
+fn foo() {
+    <|>for i in vec![10, 20] {}
+}",
+        );
+    }
+
+    #[test]
+    fn test_used_in_while_expr() {
+        check_assist(
+            inline_local_varialbe,
+            "
+fn foo() {
+    let a<|> = 1 > 0;
+    while a {}
+}",
+            "
+fn foo() {
+    <|>while 1 > 0 {}
+}",
+        );
+    }
+
+    #[test]
+    fn test_used_in_break_expr() {
+        check_assist(
+            inline_local_varialbe,
+            "
+fn foo() {
+    let a<|> = 1 + 1;
+    loop {
+        break a;
+    }
+}",
+            "
+fn foo() {
+    <|>loop {
+        break 1 + 1;
+    }
+}",
+        );
+    }
+
+    #[test]
+    fn test_used_in_return_expr() {
+        check_assist(
+            inline_local_varialbe,
+            "
+fn foo() {
+    let a<|> = 1 > 0;
+    return a;
+}",
+            "
+fn foo() {
+    <|>return 1 > 0;
+}",
+        );
+    }
+
+    #[test]
+    fn test_used_in_match_expr() {
+        check_assist(
+            inline_local_varialbe,
+            "
+fn foo() {
+    let a<|> = 1 > 0;
+    match a {}
+}",
+            "
+fn foo() {
+    <|>match 1 > 0 {}
+}",
+        );
+    }
 }
diff --git a/crates/ra_assists/src/introduce_variable.rs b/crates/ra_assists/src/introduce_variable.rs
index 353bc4105..fb7333c8c 100644
--- a/crates/ra_assists/src/introduce_variable.rs
+++ b/crates/ra_assists/src/introduce_variable.rs
@@ -2,9 +2,8 @@ use test_utils::tested_by;
 use hir::db::HirDatabase;
 use ra_syntax::{
     ast::{self, AstNode},
-    SyntaxKind::{
-        WHITESPACE, MATCH_ARM, LAMBDA_EXPR, PATH_EXPR, BREAK_EXPR, LOOP_EXPR, RETURN_EXPR, COMMENT
-    }, SyntaxNode, TextUnit,
+    SyntaxNode, TextUnit,
+    SyntaxKind::{WHITESPACE, MATCH_ARM, LAMBDA_EXPR, PATH_EXPR, BREAK_EXPR, LOOP_EXPR, RETURN_EXPR, COMMENT},
 };
 
 use crate::{AssistCtx, Assist, AssistId};
@@ -13,14 +12,14 @@ pub(crate) fn introduce_variable(mut ctx: AssistCtx<impl HirDatabase>) -> Option
     if ctx.frange.range.is_empty() {
         return None;
     }
-    let node = ctx.covering_node();
+    let node = ctx.covering_element();
     if node.kind() == COMMENT {
         tested_by!(introduce_var_in_comment_is_not_applicable);
         return None;
     }
     let expr = node.ancestors().find_map(valid_target_expr)?;
     let (anchor_stmt, wrap_in_block) = anchor_stmt(expr)?;
-    let indent = anchor_stmt.prev_sibling()?;
+    let indent = anchor_stmt.prev_sibling_or_token()?.as_token()?;
     if indent.kind() != WHITESPACE {
         return None;
     }
@@ -54,16 +53,15 @@ pub(crate) fn introduce_variable(mut ctx: AssistCtx<impl HirDatabase>) -> Option
             // We want to maintain the indent level,
             // but we do not want to duplicate possible
             // extra newlines in the indent block
-            for chunk in indent.text().chunks() {
-                if chunk.starts_with("\r\n") {
-                    buf.push_str("\r\n");
-                    buf.push_str(chunk.trim_start_matches("\r\n"));
-                } else if chunk.starts_with("\n") {
-                    buf.push_str("\n");
-                    buf.push_str(chunk.trim_start_matches("\n"));
-                } else {
-                    buf.push_str(chunk);
-                }
+            let text = indent.text();
+            if text.starts_with("\r\n") {
+                buf.push_str("\r\n");
+                buf.push_str(text.trim_start_matches("\r\n"));
+            } else if text.starts_with("\n") {
+                buf.push_str("\n");
+                buf.push_str(text.trim_start_matches("\n"));
+            } else {
+                buf.push_str(text);
             }
 
             edit.target(expr.syntax().range());
diff --git a/crates/ra_assists/src/remove_dbg.rs b/crates/ra_assists/src/remove_dbg.rs
index 6ea48d909..ae9958f11 100644
--- a/crates/ra_assists/src/remove_dbg.rs
+++ b/crates/ra_assists/src/remove_dbg.rs
@@ -62,15 +62,15 @@ fn is_valid_macrocall(macro_call: &ast::MacroCall, macro_name: &str) -> Option<b
     let name_ref = path.segment()?.name_ref()?;
 
     // Make sure it is actually a dbg-macro call, dbg followed by !
-    let excl = path.syntax().next_sibling()?;
+    let excl = path.syntax().next_sibling_or_token()?;
 
     if name_ref.text() != macro_name || excl.kind() != EXCL {
         return None;
     }
 
     let node = macro_call.token_tree()?.syntax();
-    let first_child = node.first_child()?;
-    let last_child = node.last_child()?;
+    let first_child = node.first_child_or_token()?;
+    let last_child = node.last_child_or_token()?;
 
     match (first_child.kind(), last_child.kind()) {
         (L_PAREN, R_PAREN) | (L_BRACK, R_BRACK) | (L_CURLY, R_CURLY) => Some(true),
diff --git a/crates/ra_assists/src/replace_if_let_with_match.rs b/crates/ra_assists/src/replace_if_let_with_match.rs
index 230573499..2b451f08d 100644
--- a/crates/ra_assists/src/replace_if_let_with_match.rs
+++ b/crates/ra_assists/src/replace_if_let_with_match.rs
@@ -11,8 +11,8 @@ pub(crate) fn replace_if_let_with_match(mut ctx: AssistCtx<impl HirDatabase>) ->
     let expr = cond.expr()?;
     let then_block = if_expr.then_branch()?;
     let else_block = match if_expr.else_branch()? {
-        ast::ElseBranchFlavor::Block(it) => it,
-        ast::ElseBranchFlavor::IfExpr(_) => return None,
+        ast::ElseBranch::Block(it) => it,
+        ast::ElseBranch::IfExpr(_) => return None,
     };
 
     ctx.add_action(AssistId("replace_if_let_with_match"), "replace with match", |edit| {
diff --git a/crates/ra_assists/src/split_import.rs b/crates/ra_assists/src/split_import.rs
index dd5be4e91..4bf1852db 100644
--- a/crates/ra_assists/src/split_import.rs
+++ b/crates/ra_assists/src/split_import.rs
@@ -8,8 +8,8 @@ use ra_syntax::{
 use crate::{AssistCtx, Assist, AssistId};
 
 pub(crate) fn split_import(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
-    let colon_colon = ctx.leaf_at_offset().find(|leaf| leaf.kind() == COLONCOLON)?;
-    let path = colon_colon.parent().and_then(ast::Path::cast)?;
+    let colon_colon = ctx.token_at_offset().find(|leaf| leaf.kind() == COLONCOLON)?;
+    let path = ast::Path::cast(colon_colon.parent())?;
     let top_path = generate(Some(path), |it| it.parent_path()).last()?;
 
     let use_tree = top_path.syntax().ancestors().find_map(ast::UseTree::cast);