13 files changed, 203 insertions, 98 deletions

diff --git a/crates/ra_editor/src/assists.rs b/crates/ra_editor/src/assists.rs
index 57b78342a..f839f6a7a 100644
--- a/crates/ra_editor/src/assists.rs
+++ b/crates/ra_editor/src/assists.rs
@@ -9,12 +9,15 @@ mod add_impl;
 mod introduce_variable;
 mod change_visibility;
 mod split_import;
+mod replace_if_let_with_match;
 
 use ra_text_edit::{TextEdit, TextEditBuilder};
 use ra_syntax::{
-    Direction, SyntaxNodeRef, TextUnit, TextRange,SourceFileNode, AstNode,
+    Direction, SyntaxNode, TextUnit, TextRange, SourceFile, AstNode,
     algo::{find_leaf_at_offset, find_covering_node, LeafAtOffset},
+    ast::{self, AstToken},
 };
+use itertools::Itertools;
 
 use crate::find_node_at_offset;
 
@@ -25,10 +28,11 @@ pub use self::{
     introduce_variable::introduce_variable,
     change_visibility::change_visibility,
     split_import::split_import,
+    replace_if_let_with_match::replace_if_let_with_match,
 };
 
 /// Return all the assists applicable at the given position.
-pub fn assists(file: &SourceFileNode, range: TextRange) -> Vec<LocalEdit> {
+pub fn assists(file: &SourceFile, range: TextRange) -> Vec<LocalEdit> {
     let ctx = AssistCtx::new(file, range);
     [
         flip_comma,
@@ -37,6 +41,7 @@ pub fn assists(file: &SourceFileNode, range: TextRange) -> Vec<LocalEdit> {
         introduce_variable,
         change_visibility,
         split_import,
+        replace_if_let_with_match,
     ]
     .iter()
     .filter_map(|&assist| ctx.clone().apply(assist))
@@ -50,7 +55,7 @@ pub struct LocalEdit {
     pub cursor_position: Option<TextUnit>,
 }
 
-fn non_trivia_sibling(node: SyntaxNodeRef, direction: Direction) -> Option<SyntaxNodeRef> {
+fn non_trivia_sibling(node: &SyntaxNode, direction: Direction) -> Option<&SyntaxNode> {
     node.siblings(direction)
         .skip(1)
         .find(|node| !node.kind().is_trivia())
@@ -88,7 +93,7 @@ fn non_trivia_sibling(node: SyntaxNodeRef, direction: Direction) -> Option<Synta
 /// easier to just compute the edit eagarly :-)
 #[derive(Debug, Clone)]
 pub struct AssistCtx<'a> {
-    source_file: &'a SourceFileNode,
+    source_file: &'a SourceFile,
     range: TextRange,
     should_compute_edit: bool,
 }
@@ -106,7 +111,7 @@ struct AssistBuilder {
 }
 
 impl<'a> AssistCtx<'a> {
-    pub fn new(source_file: &'a SourceFileNode, range: TextRange) -> AssistCtx {
+    pub fn new(source_file: &'a SourceFile, range: TextRange) -> AssistCtx {
         AssistCtx {
             source_file,
             range,
@@ -145,13 +150,13 @@ impl<'a> AssistCtx<'a> {
         }))
     }
 
-    pub(crate) fn leaf_at_offset(&self) -> LeafAtOffset<SyntaxNodeRef<'a>> {
+    pub(crate) fn leaf_at_offset(&self) -> LeafAtOffset<&'a SyntaxNode> {
         find_leaf_at_offset(self.source_file.syntax(), self.range.start())
     }
-    pub(crate) fn node_at_offset<N: AstNode<'a>>(&self) -> Option<N> {
+    pub(crate) fn node_at_offset<N: AstNode>(&self) -> Option<&'a N> {
         find_node_at_offset(self.source_file.syntax(), self.range.start())
     }
-    pub(crate) fn covering_node(&self) -> SyntaxNodeRef<'a> {
+    pub(crate) fn covering_node(&self) -> &'a SyntaxNode {
         find_covering_node(self.source_file.syntax(), self.range)
     }
 }
@@ -160,6 +165,13 @@ impl AssistBuilder {
     fn replace(&mut self, range: TextRange, replace_with: impl Into<String>) {
         self.edit.replace(range, replace_with.into())
     }
+    fn replace_node_and_indent(&mut self, node: &SyntaxNode, replace_with: impl Into<String>) {
+        let mut replace_with = replace_with.into();
+        if let Some(indent) = calc_indent(node) {
+            replace_with = reindent(&replace_with, indent)
+        }
+        self.replace(node.range(), replace_with)
+    }
     #[allow(unused)]
     fn delete(&mut self, range: TextRange) {
         self.edit.delete(range)
@@ -172,6 +184,17 @@ impl AssistBuilder {
     }
 }
 
+fn calc_indent(node: &SyntaxNode) -> Option<&str> {
+    let prev = node.prev_sibling()?;
+    let ws_text = ast::Whitespace::cast(prev)?.text();
+    ws_text.rfind('\n').map(|pos| &ws_text[pos + 1..])
+}
+
+fn reindent(text: &str, indent: &str) -> String {
+    let indent = format!("\n{}", indent);
+    text.lines().intersperse(&indent).collect()
+}
+
 #[cfg(test)]
 fn check_assist(assist: fn(AssistCtx) -> Option<Assist>, before: &str, after: &str) {
     crate::test_utils::check_action(before, after, |file, off| {
diff --git a/crates/ra_editor/src/assists/add_derive.rs b/crates/ra_editor/src/assists/add_derive.rs
index 1e2cd4f30..6e964d011 100644
--- a/crates/ra_editor/src/assists/add_derive.rs
+++ b/crates/ra_editor/src/assists/add_derive.rs
@@ -28,7 +28,7 @@ pub fn add_derive(ctx: AssistCtx) -> Option<Assist> {
 }
 
 // Insert `derive` after doc comments.
-fn derive_insertion_offset(nominal: ast::NominalDef) -> Option<TextUnit> {
+fn derive_insertion_offset(nominal: &ast::NominalDef) -> Option<TextUnit> {
     let non_ws_child = nominal
         .syntax()
         .children()
diff --git a/crates/ra_editor/src/assists/add_impl.rs b/crates/ra_editor/src/assists/add_impl.rs
index 9353e2717..2eda7cae2 100644
--- a/crates/ra_editor/src/assists/add_impl.rs
+++ b/crates/ra_editor/src/assists/add_impl.rs
@@ -1,6 +1,6 @@
 use join_to_string::join;
 use ra_syntax::{
-    ast::{self, AstNode, NameOwner, TypeParamsOwner},
+    ast::{self, AstNode, AstToken, NameOwner, TypeParamsOwner},
     TextUnit,
 };
 
diff --git a/crates/ra_editor/src/assists/change_visibility.rs b/crates/ra_editor/src/assists/change_visibility.rs
index 6c8466394..89729e2c2 100644
--- a/crates/ra_editor/src/assists/change_visibility.rs
+++ b/crates/ra_editor/src/assists/change_visibility.rs
@@ -46,7 +46,7 @@ fn add_vis(ctx: AssistCtx) -> Option<Assist> {
     })
 }
 
-fn change_vis(ctx: AssistCtx, vis: ast::Visibility) -> Option<Assist> {
+fn change_vis(ctx: AssistCtx, vis: &ast::Visibility) -> Option<Assist> {
     if vis.syntax().text() != "pub" {
         return None;
     }
diff --git a/crates/ra_editor/src/assists/introduce_variable.rs b/crates/ra_editor/src/assists/introduce_variable.rs
index 782861023..523ec7034 100644
--- a/crates/ra_editor/src/assists/introduce_variable.rs
+++ b/crates/ra_editor/src/assists/introduce_variable.rs
@@ -1,7 +1,7 @@
 use ra_syntax::{
     ast::{self, AstNode},
     SyntaxKind::WHITESPACE,
-    SyntaxNodeRef, TextUnit,
+    SyntaxNode, TextUnit,
 };
 
 use crate::assists::{AssistCtx, Assist};
@@ -39,7 +39,7 @@ pub fn introduce_variable<'a>(ctx: AssistCtx) -> Option<Assist> {
 
 /// Statement or last in the block expression, which will follow
 /// the freshly introduced var.
-fn anchor_stmt(expr: ast::Expr) -> Option<SyntaxNodeRef> {
+fn anchor_stmt(expr: &ast::Expr) -> Option<&SyntaxNode> {
     expr.syntax().ancestors().find(|&node| {
         if ast::Stmt::cast(node).is_some() {
             return true;
diff --git a/crates/ra_editor/src/assists/replace_if_let_with_match.rs b/crates/ra_editor/src/assists/replace_if_let_with_match.rs
new file mode 100644
index 000000000..30c371480
--- /dev/null
+++ b/crates/ra_editor/src/assists/replace_if_let_with_match.rs
@@ -0,0 +1,92 @@
+use ra_syntax::{
+    AstNode, SyntaxKind::{L_CURLY, R_CURLY, WHITESPACE},
+    ast,
+};
+
+use crate::assists::{AssistCtx, Assist};
+
+pub fn replace_if_let_with_match(ctx: AssistCtx) -> Option<Assist> {
+    let if_expr: &ast::IfExpr = ctx.node_at_offset()?;
+    let cond = if_expr.condition()?;
+    let pat = cond.pat()?;
+    let expr = cond.expr()?;
+    let then_block = if_expr.then_branch()?;
+    let else_block = if_expr.else_branch()?;
+
+    ctx.build("replace with match", |edit| {
+        let match_expr = build_match_expr(expr, pat, then_block, else_block);
+        edit.replace_node_and_indent(if_expr.syntax(), match_expr);
+        edit.set_cursor(if_expr.syntax().range().start())
+    })
+}
+
+fn build_match_expr(
+    expr: &ast::Expr,
+    pat1: &ast::Pat,
+    arm1: &ast::Block,
+    arm2: &ast::Block,
+) -> String {
+    let mut buf = String::new();
+    buf.push_str(&format!("match {} {{\n", expr.syntax().text()));
+    buf.push_str(&format!(
+        "    {} => {}\n",
+        pat1.syntax().text(),
+        format_arm(arm1)
+    ));
+    buf.push_str(&format!("    _ => {}\n", format_arm(arm2)));
+    buf.push_str("}");
+    buf
+}
+
+fn format_arm(block: &ast::Block) -> String {
+    match extract_expression(block) {
+        None => block.syntax().text().to_string(),
+        Some(e) => format!("{},", e.syntax().text()),
+    }
+}
+
+fn extract_expression(block: &ast::Block) -> Option<&ast::Expr> {
+    let expr = block.expr()?;
+    let non_trivial_children = block.syntax().children().filter(|it| {
+        !(it == &expr.syntax()
+            || it.kind() == L_CURLY
+            || it.kind() == R_CURLY
+            || it.kind() == WHITESPACE)
+    });
+    if non_trivial_children.count() > 0 {
+        return None;
+    }
+    Some(expr)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::assists::check_assist;
+
+    #[test]
+    fn test_replace_if_let_with_match_unwraps_simple_expressions() {
+        check_assist(
+            replace_if_let_with_match,
+            "
+impl VariantData {
+    pub fn is_struct(&self) -> bool {
+        if <|>let VariantData::Struct(..) = *self {
+            true
+        } else {
+            false
+        }
+    }
+}           ",
+            "
+impl VariantData {
+    pub fn is_struct(&self) -> bool {
+        <|>match *self {
+            VariantData::Struct(..) => true,
+            _ => false,
+        }
+    }
+}           ",
+        )
+    }
+}
diff --git a/crates/ra_editor/src/diagnostics.rs b/crates/ra_editor/src/diagnostics.rs
index 199b0e502..2b695dfdf 100644
--- a/crates/ra_editor/src/diagnostics.rs
+++ b/crates/ra_editor/src/diagnostics.rs
@@ -1,25 +1,15 @@
 use itertools::Itertools;
 
 use ra_syntax::{
+    Location, SourceFile, SyntaxKind, TextRange, SyntaxNode,
     ast::{self, AstNode},
-    Location,
-    SourceFileNode,
-    SyntaxKind,
-    TextRange,
-};
-use ra_syntax::SyntaxNodeRef;
-use ra_text_edit::{
-    TextEdit,
-    TextEditBuilder,
-};
 
-use crate::{
-    Diagnostic,
-    LocalEdit,
-    Severity,
 };
+use ra_text_edit::{TextEdit, TextEditBuilder};
+
+use crate::{Diagnostic, LocalEdit, Severity};
 
-pub fn diagnostics(file: &SourceFileNode) -> Vec<Diagnostic> {
+pub fn diagnostics(file: &SourceFile) -> Vec<Diagnostic> {
     fn location_to_range(location: Location) -> TextRange {
         match location {
             Location::Offset(offset) => TextRange::offset_len(offset, 1.into()),
@@ -48,7 +38,7 @@ pub fn diagnostics(file: &SourceFileNode) -> Vec<Diagnostic> {
 
 fn check_unnecessary_braces_in_use_statement(
     acc: &mut Vec<Diagnostic>,
-    node: SyntaxNodeRef,
+    node: &SyntaxNode,
 ) -> Option<()> {
     let use_tree_list = ast::UseTreeList::cast(node)?;
     if let Some((single_use_tree,)) = use_tree_list.use_trees().collect_tuple() {
@@ -79,7 +69,7 @@ fn check_unnecessary_braces_in_use_statement(
 }
 
 fn text_edit_for_remove_unnecessary_braces_with_self_in_use_statement(
-    single_use_tree: ast::UseTree,
+    single_use_tree: &ast::UseTree,
 ) -> Option<TextEdit> {
     let use_tree_list_node = single_use_tree.syntax().parent()?;
     if single_use_tree
@@ -102,7 +92,7 @@ fn text_edit_for_remove_unnecessary_braces_with_self_in_use_statement(
 
 fn check_struct_shorthand_initialization(
     acc: &mut Vec<Diagnostic>,
-    node: SyntaxNodeRef,
+    node: &SyntaxNode,
 ) -> Option<()> {
     let struct_lit = ast::StructLit::cast(node)?;
     let named_field_list = struct_lit.named_field_list()?;
@@ -138,10 +128,10 @@ mod tests {
 
     use super::*;
 
-    type DiagnosticChecker = fn(&mut Vec<Diagnostic>, SyntaxNodeRef) -> Option<()>;
+    type DiagnosticChecker = fn(&mut Vec<Diagnostic>, &SyntaxNode) -> Option<()>;
 
     fn check_not_applicable(code: &str, func: DiagnosticChecker) {
-        let file = SourceFileNode::parse(code);
+        let file = SourceFile::parse(code);
         let mut diagnostics = Vec::new();
         for node in file.syntax().descendants() {
             func(&mut diagnostics, node);
@@ -150,7 +140,7 @@ mod tests {
     }
 
     fn check_apply(before: &str, after: &str, func: DiagnosticChecker) {
-        let file = SourceFileNode::parse(before);
+        let file = SourceFile::parse(before);
         let mut diagnostics = Vec::new();
         for node in file.syntax().descendants() {
             func(&mut diagnostics, node);
diff --git a/crates/ra_editor/src/extend_selection.rs b/crates/ra_editor/src/extend_selection.rs
index 7a423852b..08cae5a51 100644
--- a/crates/ra_editor/src/extend_selection.rs
+++ b/crates/ra_editor/src/extend_selection.rs
@@ -1,11 +1,10 @@
 use ra_syntax::{
+    Direction, SyntaxNode, TextRange, TextUnit,
     algo::{find_covering_node, find_leaf_at_offset, LeafAtOffset},
-    Direction,
     SyntaxKind::*,
-    SyntaxNodeRef, TextRange, TextUnit,
 };
 
-pub fn extend_selection(root: SyntaxNodeRef, range: TextRange) -> Option<TextRange> {
+pub fn extend_selection(root: &SyntaxNode, range: TextRange) -> Option<TextRange> {
     let string_kinds = [COMMENT, STRING, RAW_STRING, BYTE_STRING, RAW_BYTE_STRING];
     if range.is_empty() {
         let offset = range.start();
@@ -40,7 +39,7 @@ pub fn extend_selection(root: SyntaxNodeRef, range: TextRange) -> Option<TextRan
 }
 
 fn extend_single_word_in_comment_or_string(
-    leaf: SyntaxNodeRef,
+    leaf: &SyntaxNode,
     offset: TextUnit,
 ) -> Option<TextRange> {
     let text: &str = leaf.leaf_text()?;
@@ -66,7 +65,7 @@ fn extend_single_word_in_comment_or_string(
     }
 }
 
-fn extend_ws(root: SyntaxNodeRef, ws: SyntaxNodeRef, offset: TextUnit) -> TextRange {
+fn extend_ws(root: &SyntaxNode, ws: &SyntaxNode, offset: TextUnit) -> TextRange {
     let ws_text = ws.leaf_text().unwrap();
     let suffix = TextRange::from_to(offset, ws.range().end()) - ws.range().start();
     let prefix = TextRange::from_to(ws.range().start(), offset) - ws.range().start();
@@ -89,9 +88,9 @@ fn extend_ws(root: SyntaxNodeRef, ws: SyntaxNodeRef, offset: TextUnit) -> TextRa
     ws.range()
 }
 
-fn pick_best<'a>(l: SyntaxNodeRef<'a>, r: SyntaxNodeRef<'a>) -> SyntaxNodeRef<'a> {
+fn pick_best<'a>(l: &'a SyntaxNode, r: &'a SyntaxNode) -> &'a SyntaxNode {
     return if priority(r) > priority(l) { r } else { l };
-    fn priority(n: SyntaxNodeRef) -> usize {
+    fn priority(n: &SyntaxNode) -> usize {
         match n.kind() {
             WHITESPACE => 0,
             IDENT | SELF_KW | SUPER_KW | CRATE_KW | LIFETIME => 2,
@@ -100,7 +99,7 @@ fn pick_best<'a>(l: SyntaxNodeRef<'a>, r: SyntaxNodeRef<'a>) -> SyntaxNodeRef<'a
     }
 }
 
-fn extend_comments(node: SyntaxNodeRef) -> Option<TextRange> {
+fn extend_comments(node: &SyntaxNode) -> Option<TextRange> {
     let prev = adj_comments(node, Direction::Prev);
     let next = adj_comments(node, Direction::Next);
     if prev != next {
@@ -110,7 +109,7 @@ fn extend_comments(node: SyntaxNodeRef) -> Option<TextRange> {
     }
 }
 
-fn adj_comments(node: SyntaxNodeRef, dir: Direction) -> SyntaxNodeRef {
+fn adj_comments(node: &SyntaxNode, dir: Direction) -> &SyntaxNode {
     let mut res = node;
     for node in node.siblings(dir) {
         match node.kind() {
@@ -124,13 +123,14 @@ fn adj_comments(node: SyntaxNodeRef, dir: Direction) -> SyntaxNodeRef {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use ra_syntax::SourceFileNode;
+    use ra_syntax::{SourceFile, AstNode};
     use test_utils::extract_offset;
 
+    use super::*;
+
     fn do_check(before: &str, afters: &[&str]) {
         let (cursor, before) = extract_offset(before);
-        let file = SourceFileNode::parse(&before);
+        let file = SourceFile::parse(&before);
         let mut range = TextRange::offset_len(cursor, 0.into());
         for &after in afters {
             range = extend_selection(file.syntax(), range).unwrap();
diff --git a/crates/ra_editor/src/folding_ranges.rs b/crates/ra_editor/src/folding_ranges.rs
index da542ecf0..6f3106889 100644
--- a/crates/ra_editor/src/folding_ranges.rs
+++ b/crates/ra_editor/src/folding_ranges.rs
@@ -1,9 +1,8 @@
 use rustc_hash::FxHashSet;
 
 use ra_syntax::{
-    ast, AstNode, Direction, SourceFileNode,
+    ast, AstNode, Direction, SourceFile, SyntaxNode, TextRange,
     SyntaxKind::{self, *},
-    SyntaxNodeRef, TextRange,
 };
 
 #[derive(Debug, PartialEq, Eq)]
@@ -19,7 +18,7 @@ pub struct Fold {
     pub kind: FoldKind,
 }
 
-pub fn folding_ranges(file: &SourceFileNode) -> Vec<Fold> {
+pub fn folding_ranges(file: &SourceFile) -> Vec<Fold> {
     let mut res = vec![];
     let mut visited_comments = FxHashSet::default();
     let mut visited_imports = FxHashSet::default();
@@ -69,7 +68,7 @@ fn fold_kind(kind: SyntaxKind) -> Option<FoldKind> {
     }
 }
 
-fn has_newline(node: SyntaxNodeRef) -> bool {
+fn has_newline(node: &SyntaxNode) -> bool {
     for descendant in node.descendants() {
         if let Some(ws) = ast::Whitespace::cast(descendant) {
             if ws.has_newlines() {
@@ -86,8 +85,8 @@ fn has_newline(node: SyntaxNodeRef) -> bool {
 }
 
 fn contiguous_range_for_group<'a>(
-    first: SyntaxNodeRef<'a>,
-    visited: &mut FxHashSet<SyntaxNodeRef<'a>>,
+    first: &'a SyntaxNode,
+    visited: &mut FxHashSet<&'a SyntaxNode>,
 ) -> Option<TextRange> {
     visited.insert(first);
 
@@ -124,8 +123,8 @@ fn contiguous_range_for_group<'a>(
 }
 
 fn contiguous_range_for_comment<'a>(
-    first: SyntaxNodeRef<'a>,
-    visited: &mut FxHashSet<SyntaxNodeRef<'a>>,
+    first: &'a SyntaxNode,
+    visited: &mut FxHashSet<&'a SyntaxNode>,
 ) -> Option<TextRange> {
     visited.insert(first);
 
@@ -174,7 +173,7 @@ mod tests {
 
     fn do_check(text: &str, fold_kinds: &[FoldKind]) {
         let (ranges, text) = extract_ranges(text, "fold");
-        let file = SourceFileNode::parse(&text);
+        let file = SourceFile::parse(&text);
         let folds = folding_ranges(&file);
 
         assert_eq!(
diff --git a/crates/ra_editor/src/lib.rs b/crates/ra_editor/src/lib.rs
index a3c85ed5d..6731260a3 100644
--- a/crates/ra_editor/src/lib.rs
+++ b/crates/ra_editor/src/lib.rs
@@ -21,11 +21,10 @@ pub use self::{
 };
 use ra_text_edit::TextEditBuilder;
 use ra_syntax::{
-    algo::find_leaf_at_offset,
-    ast::{self, AstNode},
-    SourceFileNode,
+    SourceFile, SyntaxNode, TextRange, TextUnit, Direction,
     SyntaxKind::{self, *},
-    SyntaxNodeRef, TextRange, TextUnit, Direction,
+    ast::{self, AstNode},
+    algo::find_leaf_at_offset,
 };
 use rustc_hash::FxHashSet;
 
@@ -49,7 +48,7 @@ pub struct Diagnostic {
     pub fix: Option<LocalEdit>,
 }
 
-pub fn matching_brace(file: &SourceFileNode, offset: TextUnit) -> Option<TextUnit> {
+pub fn matching_brace(file: &SourceFile, offset: TextUnit) -> Option<TextUnit> {
     const BRACES: &[SyntaxKind] = &[
         L_CURLY, R_CURLY, L_BRACK, R_BRACK, L_PAREN, R_PAREN, L_ANGLE, R_ANGLE,
     ];
@@ -67,7 +66,7 @@ pub fn matching_brace(file: &SourceFileNode, offset: TextUnit) -> Option<TextUni
     Some(matching_node.range().start())
 }
 
-pub fn highlight(root: SyntaxNodeRef) -> Vec<HighlightedRange> {
+pub fn highlight(root: &SyntaxNode) -> Vec<HighlightedRange> {
     // Visited nodes to handle highlighting priorities
     let mut highlighted = FxHashSet::default();
     let mut res = Vec::new();
@@ -117,26 +116,25 @@ pub fn highlight(root: SyntaxNodeRef) -> Vec<HighlightedRange> {
     res
 }
 
-pub fn syntax_tree(file: &SourceFileNode) -> String {
+pub fn syntax_tree(file: &SourceFile) -> String {
     ::ra_syntax::utils::dump_tree(file.syntax())
 }
 
-pub fn find_node_at_offset<'a, N: AstNode<'a>>(
-    syntax: SyntaxNodeRef<'a>,
-    offset: TextUnit,
-) -> Option<N> {
+pub fn find_node_at_offset<N: AstNode>(syntax: &SyntaxNode, offset: TextUnit) -> Option<&N> {
     find_leaf_at_offset(syntax, offset).find_map(|leaf| leaf.ancestors().find_map(N::cast))
 }
 
 #[cfg(test)]
 mod tests {
+    use ra_syntax::AstNode;
+
     use crate::test_utils::{add_cursor, assert_eq_dbg, assert_eq_text, extract_offset};
 
     use super::*;
 
     #[test]
     fn test_highlighting() {
-        let file = SourceFileNode::parse(
+        let file = SourceFile::parse(
             r#"
 // comment
 fn main() {}
@@ -159,7 +157,7 @@ fn main() {}
     fn test_matching_brace() {
         fn do_check(before: &str, after: &str) {
             let (pos, before) = extract_offset(before);
-            let file = SourceFileNode::parse(&before);
+            let file = SourceFile::parse(&before);
             let new_pos = match matching_brace(&file, pos) {
                 None => pos,
                 Some(pos) => pos,
diff --git a/crates/ra_editor/src/structure.rs b/crates/ra_editor/src/structure.rs
index 32d59e335..8bd57555f 100644
--- a/crates/ra_editor/src/structure.rs
+++ b/crates/ra_editor/src/structure.rs
@@ -3,7 +3,7 @@ use crate::TextRange;
 use ra_syntax::{
     algo::visit::{visitor, Visitor},
     ast::{self, NameOwner},
-    AstNode, SourceFileNode, SyntaxKind, SyntaxNodeRef, WalkEvent,
+    AstNode, SourceFile, SyntaxKind, SyntaxNode, WalkEvent,
 };
 
 #[derive(Debug, Clone)]
@@ -15,7 +15,7 @@ pub struct StructureNode {
     pub kind: SyntaxKind,
 }
 
-pub fn file_structure(file: &SourceFileNode) -> Vec<StructureNode> {
+pub fn file_structure(file: &SourceFile) -> Vec<StructureNode> {
     let mut res = Vec::new();
     let mut stack = Vec::new();
 
@@ -38,8 +38,8 @@ pub fn file_structure(file: &SourceFileNode) -> Vec<StructureNode> {
     res
 }
 
-fn structure_node(node: SyntaxNodeRef) -> Option<StructureNode> {
-    fn decl<'a, N: NameOwner<'a>>(node: N) -> Option<StructureNode> {
+fn structure_node(node: &SyntaxNode) -> Option<StructureNode> {
+    fn decl<N: NameOwner>(node: &N) -> Option<StructureNode> {
         let name = node.name()?;
         Some(StructureNode {
             parent: None,
@@ -60,7 +60,7 @@ fn structure_node(node: SyntaxNodeRef) -> Option<StructureNode> {
         .visit(decl::<ast::TypeDef>)
         .visit(decl::<ast::ConstDef>)
         .visit(decl::<ast::StaticDef>)
-        .visit(|im: ast::ImplBlock| {
+        .visit(|im: &ast::ImplBlock| {
             let target_type = im.target_type()?;
             let target_trait = im.target_trait();
             let label = match target_trait {
@@ -91,7 +91,7 @@ mod tests {
 
     #[test]
     fn test_file_structure() {
-        let file = SourceFileNode::parse(
+        let file = SourceFile::parse(
             r#"
 struct Foo {
     x: i32
diff --git a/crates/ra_editor/src/test_utils.rs b/crates/ra_editor/src/test_utils.rs
index f0a4f250a..dc2470aa3 100644
--- a/crates/ra_editor/src/test_utils.rs
+++ b/crates/ra_editor/src/test_utils.rs
@@ -1,32 +1,35 @@
-use ra_syntax::{SourceFileNode, TextRange, TextUnit};
+use ra_syntax::{SourceFile, TextRange, TextUnit};
 
 use crate::LocalEdit;
 pub use test_utils::*;
 
-pub fn check_action<F: Fn(&SourceFileNode, TextUnit) -> Option<LocalEdit>>(
+pub fn check_action<F: Fn(&SourceFile, TextUnit) -> Option<LocalEdit>>(
     before: &str,
     after: &str,
     f: F,
 ) {
     let (before_cursor_pos, before) = extract_offset(before);
-    let file = SourceFileNode::parse(&before);
+    let file = SourceFile::parse(&before);
     let result = f(&file, before_cursor_pos).expect("code action is not applicable");
     let actual = result.edit.apply(&before);
     let actual_cursor_pos = match result.cursor_position {
-        None => result.edit.apply_to_offset(before_cursor_pos).unwrap(),
+        None => result
+            .edit
+            .apply_to_offset(before_cursor_pos)
+            .expect("cursor position is affected by the edit"),
         Some(off) => off,
     };
     let actual = add_cursor(&actual, actual_cursor_pos);
     assert_eq_text!(after, &actual);
 }
 
-pub fn check_action_range<F: Fn(&SourceFileNode, TextRange) -> Option<LocalEdit>>(
+pub fn check_action_range<F: Fn(&SourceFile, TextRange) -> Option<LocalEdit>>(
     before: &str,
     after: &str,
     f: F,
 ) {
     let (range, before) = extract_range(before);
-    let file = SourceFileNode::parse(&before);
+    let file = SourceFile::parse(&before);
     let result = f(&file, range).expect("code action is not applicable");
     let actual = result.edit.apply(&before);
     let actual_cursor_pos = match result.cursor_position {
diff --git a/crates/ra_editor/src/typing.rs b/crates/ra_editor/src/typing.rs
index 12500854c..5b260d2ac 100644
--- a/crates/ra_editor/src/typing.rs
+++ b/crates/ra_editor/src/typing.rs
@@ -5,15 +5,15 @@ use ra_syntax::{
     algo::{find_covering_node, find_leaf_at_offset, LeafAtOffset},
     ast,
     text_utils::intersect,
-    AstNode, Direction, SourceFileNode, SyntaxKind,
+    AstNode, Direction, SourceFile, SyntaxKind,
     SyntaxKind::*,
-    SyntaxNodeRef, TextRange, TextUnit,
+    SyntaxNode, TextRange, TextUnit,
 };
 use ra_text_edit::text_utils::contains_offset_nonstrict;
 
 use crate::{find_node_at_offset, LocalEdit, TextEditBuilder};
 
-pub fn join_lines(file: &SourceFileNode, range: TextRange) -> LocalEdit {
+pub fn join_lines(file: &SourceFile, range: TextRange) -> LocalEdit {
     let range = if range.is_empty() {
         let syntax = file.syntax();
         let text = syntax.text().slice(range.start()..);
@@ -59,7 +59,7 @@ pub fn join_lines(file: &SourceFileNode, range: TextRange) -> LocalEdit {
     }
 }
 
-pub fn on_enter(file: &SourceFileNode, offset: TextUnit) -> Option<LocalEdit> {
+pub fn on_enter(file: &SourceFile, offset: TextUnit) -> Option<LocalEdit> {
     let comment = find_leaf_at_offset(file.syntax(), offset)
         .left_biased()
         .and_then(ast::Comment::cast)?;
@@ -85,7 +85,7 @@ pub fn on_enter(file: &SourceFileNode, offset: TextUnit) -> Option<LocalEdit> {
     })
 }
 
-fn node_indent<'a>(file: &'a SourceFileNode, node: SyntaxNodeRef) -> Option<&'a str> {
+fn node_indent<'a>(file: &'a SourceFile, node: &SyntaxNode) -> Option<&'a str> {
     let ws = match find_leaf_at_offset(file.syntax(), node.range().start()) {
         LeafAtOffset::Between(l, r) => {
             assert!(r == node);
@@ -105,8 +105,8 @@ fn node_indent<'a>(file: &'a SourceFileNode, node: SyntaxNodeRef) -> Option<&'a
     Some(&text[pos..])
 }
 
-pub fn on_eq_typed(file: &SourceFileNode, offset: TextUnit) -> Option<LocalEdit> {
-    let let_stmt: ast::LetStmt = find_node_at_offset(file.syntax(), offset)?;
+pub fn on_eq_typed(file: &SourceFile, offset: TextUnit) -> Option<LocalEdit> {
+    let let_stmt: &ast::LetStmt = find_node_at_offset(file.syntax(), offset)?;
     if let_stmt.has_semi() {
         return None;
     }
@@ -136,7 +136,7 @@ pub fn on_eq_typed(file: &SourceFileNode, offset: TextUnit) -> Option<LocalEdit>
     })
 }
 
-pub fn on_dot_typed(file: &SourceFileNode, offset: TextUnit) -> Option<LocalEdit> {
+pub fn on_dot_typed(file: &SourceFile, offset: TextUnit) -> Option<LocalEdit> {
     let before_dot_offset = offset - TextUnit::of_char('.');
 
     let whitespace = find_leaf_at_offset(file.syntax(), before_dot_offset).left_biased()?;
@@ -151,7 +151,7 @@ pub fn on_dot_typed(file: &SourceFileNode, offset: TextUnit) -> Option<LocalEdit
         .skip(1)
         .next()?;
 
-    ast::MethodCallExprNode::cast(method_call)?;
+    ast::MethodCallExpr::cast(method_call)?;
 
     // find how much the _method call is indented
     let method_chain_indent = method_call
@@ -188,7 +188,7 @@ fn last_line_indent_in_whitespace(ws: &str) -> &str {
 
 fn remove_newline(
     edit: &mut TextEditBuilder,
-    node: SyntaxNodeRef,
+    node: &SyntaxNode,
     node_text: &str,
     offset: TextUnit,
 ) {
@@ -266,7 +266,7 @@ fn is_trailing_comma(left: SyntaxKind, right: SyntaxKind) -> bool {
     }
 }
 
-fn join_single_expr_block(edit: &mut TextEditBuilder, node: SyntaxNodeRef) -> Option<()> {
+fn join_single_expr_block(edit: &mut TextEditBuilder, node: &SyntaxNode) -> Option<()> {
     let block = ast::Block::cast(node.parent()?)?;
     let block_expr = ast::BlockExpr::cast(block.syntax().parent()?)?;
     let expr = single_expr(block)?;
@@ -277,7 +277,7 @@ fn join_single_expr_block(edit: &mut TextEditBuilder, node: SyntaxNodeRef) -> Op
     Some(())
 }
 
-fn single_expr(block: ast::Block) -> Option<ast::Expr> {
+fn single_expr(block: &ast::Block) -> Option<&ast::Expr> {
     let mut res = None;
     for child in block.syntax().children() {
         if let Some(expr) = ast::Expr::cast(child) {
@@ -297,7 +297,7 @@ fn single_expr(block: ast::Block) -> Option<ast::Expr> {
     res
 }
 
-fn join_single_use_tree(edit: &mut TextEditBuilder, node: SyntaxNodeRef) -> Option<()> {
+fn join_single_use_tree(edit: &mut TextEditBuilder, node: &SyntaxNode) -> Option<()> {
     let use_tree_list = ast::UseTreeList::cast(node.parent()?)?;
     let (tree,) = use_tree_list.use_trees().collect_tuple()?;
     edit.replace(
@@ -307,7 +307,7 @@ fn join_single_use_tree(edit: &mut TextEditBuilder, node: SyntaxNodeRef) -> Opti
     Some(())
 }
 
-fn compute_ws(left: SyntaxNodeRef, right: SyntaxNodeRef) -> &'static str {
+fn compute_ws(left: &SyntaxNode, right: &SyntaxNode) -> &'static str {
     match left.kind() {
         L_PAREN | L_BRACK => return "",
         L_CURLY => {
@@ -547,7 +547,7 @@ fn foo() {
 
     fn check_join_lines_sel(before: &str, after: &str) {
         let (sel, before) = extract_range(before);
-        let file = SourceFileNode::parse(&before);
+        let file = SourceFile::parse(&before);
         let result = join_lines(&file, sel);
         let actual = result.edit.apply(&before);
         assert_eq_text!(after, &actual);
@@ -626,7 +626,7 @@ pub fn handle_find_matching_brace() {
     fn test_on_eq_typed() {
         fn do_check(before: &str, after: &str) {
             let (offset, before) = extract_offset(before);
-            let file = SourceFileNode::parse(&before);
+            let file = SourceFile::parse(&before);
             let result = on_eq_typed(&file, offset).unwrap();
             let actual = result.edit.apply(&before);
             assert_eq_text!(after, &actual);
@@ -670,7 +670,7 @@ fn foo() {
     fn test_on_dot_typed() {
         fn do_check(before: &str, after: &str) {
             let (offset, before) = extract_offset(before);
-            let file = SourceFileNode::parse(&before);
+            let file = SourceFile::parse(&before);
             if let Some(result) = on_eq_typed(&file, offset) {
                 let actual = result.edit.apply(&before);
                 assert_eq_text!(after, &actual);
@@ -779,7 +779,7 @@ fn foo() {
     fn test_on_enter() {
         fn apply_on_enter(before: &str) -> Option<String> {
             let (offset, before) = extract_offset(before);
-            let file = SourceFileNode::parse(&before);
+            let file = SourceFile::parse(&before);
             let result = on_enter(&file, offset)?;
             let actual = result.edit.apply(&before);
             let actual = add_cursor(&actual, result.cursor_position.unwrap());