Merge #449

449: switch to new rowan API r=matklad a=matklad

closes https://github.com/rust-analyzer/rust-analyzer/issues/448

Co-authored-by: Aleksey Kladov <[email protected]>

61 files changed, 2504 insertions, 3762 deletions

diff --git a/Cargo.lock b/Cargo.lock
index dbadfc64e..6ef51fed0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -221,7 +221,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
  "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.15.23 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.15.24 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
@@ -284,7 +284,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
  "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.15.23 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.15.24 (registry+https://github.com/rust-lang/crates.io-index)",
  "synstructure 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
@@ -295,7 +295,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
 name = "flexi_logger"
-version = "0.10.3"
+version = "0.10.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "chrono 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -501,7 +501,7 @@ dependencies = [
  "num-traits 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
  "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.15.23 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.15.24 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
@@ -585,7 +585,7 @@ dependencies = [
  "pest_meta 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
  "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.15.23 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.15.24 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
@@ -706,7 +706,7 @@ version = "0.1.0"
 dependencies = [
  "arrayvec 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
  "ena 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "flexi_logger 0.10.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "flexi_logger 0.10.4 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "parking_lot 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "ra_arena 0.1.0",
@@ -728,7 +728,7 @@ dependencies = [
  "drop_bomb 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
  "failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
- "flexi_logger 0.10.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "flexi_logger 0.10.4 (registry+https://github.com/rust-lang/crates.io-index)",
  "gen_lsp_server 0.1.0",
  "im 12.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "languageserver-types 0.53.1 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -764,7 +764,7 @@ dependencies = [
  "itertools 0.8.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "parking_lot 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "ra_text_edit 0.1.0",
- "rowan 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)",
+ "rowan 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "test_utils 0.1.0",
  "text_unit 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -969,7 +969,7 @@ dependencies = [
 
 [[package]]
 name = "rowan"
-version = "0.1.4"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "parking_lot 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1075,7 +1075,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
  "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.15.23 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.15.24 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
@@ -1140,7 +1140,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
 name = "syn"
-version = "0.15.23"
+version = "0.15.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1155,7 +1155,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
  "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
- "syn 0.15.23 (registry+https://github.com/rust-lang/crates.io-index)",
+ "syn 0.15.24 (registry+https://github.com/rust-lang/crates.io-index)",
  "unicode-xid 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
@@ -1510,7 +1510,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 "checksum failure 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "795bd83d3abeb9220f257e597aa0080a508b27533824adf336529648f6abf7e2"
 "checksum failure_derive 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "ea1063915fd7ef4309e222a5a07cf9c319fb9c7836b1f89b85458672dbb127e1"
 "checksum fake-simd 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "e88a8acf291dafb59c2d96e8f59828f3838bb1a70398823ade51a84de6a6deed"
-"checksum flexi_logger 0.10.3 (registry+https://github.com/rust-lang/crates.io-index)" = "4dda06444ccc8b0a6da19d939989b4a4e83f328710ada449eedaed48c8b903cd"
+"checksum flexi_logger 0.10.4 (registry+https://github.com/rust-lang/crates.io-index)" = "7d3681306880a7ce87740ceb3d1ce98ca92ae636ff30a629494488cbbcf85ff8"
 "checksum fnv 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)" = "2fad85553e09a6f881f739c29f0b00b0f01357c743266d478b68951ce23285f3"
 "checksum fst 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "db72126ca7dff566cdbbdd54af44668c544897d9d3862b198141f176f1238bdf"
 "checksum fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "2e9763c69ebaae630ba35f74888db465e49e259ba1bc0eda7d06f4a067615d82"
@@ -1571,7 +1571,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 "checksum relative-path 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "0e7790c7f1cc73d831d28dc5a7deb316a006e7848e6a7f467cdb10a0a9e0fb1c"
 "checksum remove_dir_all 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3488ba1b9a2084d38645c4c08276a1752dcbf2c7130d74f1569681ad5d2799c5"
 "checksum ron 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "c48677d8a9247a4e0d1f3f9cb4b0a8e29167fdc3c04f383a5e669cd7a960ae0f"
-"checksum rowan 0.1.4 (registry+https://github.com/rust-lang/crates.io-index)" = "c218b4430ab922850b71b14fa9bca224425097f935f6155c0b6a4b1f398a54f0"
+"checksum rowan 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ae9ae7dba5e703f423ceb8646d636c73e6d858a2f8c834808b4565e42ccda9e2"
 "checksum rustc-demangle 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "adacaae16d02b6ec37fdc7acfcddf365978de76d1983d3ee22afc260e1ca9619"
 "checksum rustc-hash 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7540fc8b0c49f096ee9c961cda096467dce8084bec6bdca2fc83895fd9b28cb8"
 "checksum rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
@@ -1593,7 +1593,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 "checksum stable_deref_trait 1.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "dba1a27d3efae4351c8051072d619e3ade2820635c3958d826bfea39d59b54c8"
 "checksum strsim 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bb4f380125926a99e52bc279241539c018323fab05ad6368b56f93d9369ff550"
 "checksum superslice 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b50b13d42370e0f5fc62eafdd5c2d20065eaf5458dab215ff3e20e63eea96b30"
-"checksum syn 0.15.23 (registry+https://github.com/rust-lang/crates.io-index)" = "9545a6a093a3f0bd59adb472700acc08cad3776f860f16a897dfce8c88721cbc"
+"checksum syn 0.15.24 (registry+https://github.com/rust-lang/crates.io-index)" = "734ecc29cd36e8123850d9bf21dfd62ef8300aaa8f879aabaa899721808be37c"
 "checksum synstructure 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)" = "73687139bf99285483c96ac0add482c3776528beac1d97d444f6e91f203a2015"
 "checksum tempfile 3.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "7e91405c14320e5c79b3d148e1c86f40749a36e490642202a31689cb1a3452b2"
 "checksum tera 0.11.20 (registry+https://github.com/rust-lang/crates.io-index)" = "4b505279e19d8f7d24b1a9dc58327c9c36174b1a2c7ebdeac70792d017cb64f3"
diff --git a/crates/ra_analysis/src/completion/complete_fn_param.rs b/crates/ra_analysis/src/completion/complete_fn_param.rs
index bb5fdfda0..c1739e47e 100644
--- a/crates/ra_analysis/src/completion/complete_fn_param.rs
+++ b/crates/ra_analysis/src/completion/complete_fn_param.rs
@@ -39,9 +39,9 @@ pub(super) fn complete_fn_param(acc: &mut Completions, ctx: &CompletionContext)
                 .add_to(acc)
         });
 
-    fn process<'a, N: ast::FnDefOwner<'a>>(
-        node: N,
-        params: &mut FxHashMap<String, (u32, ast::Param<'a>)>,
+    fn process<'a, N: ast::FnDefOwner>(
+        node: &'a N,
+        params: &mut FxHashMap<String, (u32, &'a ast::Param)>,
     ) {
         node.functions()
             .filter_map(|it| it.param_list())
diff --git a/crates/ra_analysis/src/completion/complete_keyword.rs b/crates/ra_analysis/src/completion/complete_keyword.rs
index 28194c908..d350f06ce 100644
--- a/crates/ra_analysis/src/completion/complete_keyword.rs
+++ b/crates/ra_analysis/src/completion/complete_keyword.rs
@@ -2,7 +2,7 @@ use ra_syntax::{
     algo::visit::{visitor, Visitor},
     AstNode,
     ast::{self, LoopBodyOwner},
-    SyntaxKind::*, SyntaxNodeRef,
+    SyntaxKind::*, SyntaxNode,
 };
 
 use crate::completion::{CompletionContext, CompletionItem, Completions, CompletionKind, CompletionItemKind};
@@ -76,7 +76,7 @@ pub(super) fn complete_expr_keyword(acc: &mut Completions, ctx: &CompletionConte
     acc.add_all(complete_return(fn_def, ctx.can_be_stmt));
 }
 
-fn is_in_loop_body(leaf: SyntaxNodeRef) -> bool {
+fn is_in_loop_body(leaf: &SyntaxNode) -> bool {
     for node in leaf.ancestors() {
         if node.kind() == FN_DEF || node.kind() == LAMBDA_EXPR {
             break;
@@ -95,7 +95,7 @@ fn is_in_loop_body(leaf: SyntaxNodeRef) -> bool {
     false
 }
 
-fn complete_return(fn_def: ast::FnDef, can_be_stmt: bool) -> Option<CompletionItem> {
+fn complete_return(fn_def: &ast::FnDef, can_be_stmt: bool) -> Option<CompletionItem> {
     let snip = match (can_be_stmt, fn_def.ret_type().is_some()) {
         (true, true) => "return $0;",
         (true, false) => "return;",
diff --git a/crates/ra_analysis/src/completion/completion_context.rs b/crates/ra_analysis/src/completion/completion_context.rs
index 4584f355d..988c21c58 100644
--- a/crates/ra_analysis/src/completion/completion_context.rs
+++ b/crates/ra_analysis/src/completion/completion_context.rs
@@ -1,13 +1,9 @@
 use ra_editor::find_node_at_offset;
 use ra_text_edit::AtomTextEdit;
 use ra_syntax::{
-    algo::{find_leaf_at_offset, find_covering_node},
+    AstNode, SyntaxNode, SourceFile, TextUnit, TextRange,
     ast,
-    AstNode,
-    SyntaxNodeRef,
-    SourceFileNode,
-    TextUnit,
-    TextRange,
+    algo::{find_leaf_at_offset, find_covering_node},
     SyntaxKind::*,
 };
 use hir::source_binder;
@@ -20,11 +16,11 @@ use crate::{db, FilePosition, Cancelable};
 pub(super) struct CompletionContext<'a> {
     pub(super) db: &'a db::RootDatabase,
     pub(super) offset: TextUnit,
-    pub(super) leaf: SyntaxNodeRef<'a>,
+    pub(super) leaf: &'a SyntaxNode,
     pub(super) module: Option<hir::Module>,
     pub(super) function: Option<hir::Function>,
-    pub(super) function_syntax: Option<ast::FnDef<'a>>,
-    pub(super) use_item_syntax: Option<ast::UseItem<'a>>,
+    pub(super) function_syntax: Option<&'a ast::FnDef>,
+    pub(super) use_item_syntax: Option<&'a ast::UseItem>,
     pub(super) is_param: bool,
     /// A single-indent path, like `foo`.
     pub(super) is_trivial_path: bool,
@@ -36,7 +32,7 @@ pub(super) struct CompletionContext<'a> {
     /// Something is typed at the "top" level, in module or impl/trait.
     pub(super) is_new_item: bool,
     /// The receiver if this is a field or method access, i.e. writing something.<|>
-    pub(super) dot_receiver: Option<ast::Expr<'a>>,
+    pub(super) dot_receiver: Option<&'a ast::Expr>,
     /// If this is a method call in particular, i.e. the () are already there.
     pub(super) is_method_call: bool,
 }
@@ -44,7 +40,7 @@ pub(super) struct CompletionContext<'a> {
 impl<'a> CompletionContext<'a> {
     pub(super) fn new(
         db: &'a db::RootDatabase,
-        original_file: &'a SourceFileNode,
+        original_file: &'a SourceFile,
         position: FilePosition,
     ) -> Cancelable<Option<CompletionContext<'a>>> {
         let module = source_binder::module_from_position(db, position)?;
@@ -71,7 +67,7 @@ impl<'a> CompletionContext<'a> {
         Ok(Some(ctx))
     }
 
-    fn fill(&mut self, original_file: &'a SourceFileNode, offset: TextUnit) {
+    fn fill(&mut self, original_file: &'a SourceFile, offset: TextUnit) {
         // Insert a fake ident to get a valid parse tree. We will use this file
         // to determine context, though the original_file will be used for
         // actual completion.
@@ -100,7 +96,7 @@ impl<'a> CompletionContext<'a> {
             }
         }
     }
-    fn classify_name_ref(&mut self, original_file: &'a SourceFileNode, name_ref: ast::NameRef) {
+    fn classify_name_ref(&mut self, original_file: &'a SourceFile, name_ref: &ast::NameRef) {
         let name_range = name_ref.syntax().range();
         let top_node = name_ref
             .syntax()
@@ -197,15 +193,12 @@ impl<'a> CompletionContext<'a> {
     }
 }
 
-fn find_node_with_range<'a, N: AstNode<'a>>(
-    syntax: SyntaxNodeRef<'a>,
-    range: TextRange,
-) -> Option<N> {
+fn find_node_with_range<N: AstNode>(syntax: &SyntaxNode, range: TextRange) -> Option<&N> {
     let node = find_covering_node(syntax, range);
     node.ancestors().find_map(N::cast)
 }
 
-fn is_node<'a, N: AstNode<'a>>(node: SyntaxNodeRef<'a>) -> bool {
+fn is_node<N: AstNode>(node: &SyntaxNode) -> bool {
     match node.ancestors().filter_map(N::cast).next() {
         None => false,
         Some(n) => n.syntax().range() == node.range(),
diff --git a/crates/ra_analysis/src/extend_selection.rs b/crates/ra_analysis/src/extend_selection.rs
index f1b77f981..3b130f966 100644
--- a/crates/ra_analysis/src/extend_selection.rs
+++ b/crates/ra_analysis/src/extend_selection.rs
@@ -1,6 +1,6 @@
 use ra_db::SyntaxDatabase;
 use ra_syntax::{
-    SyntaxNodeRef, AstNode, SourceFileNode,
+    SyntaxNode, AstNode, SourceFile,
     ast, algo::find_covering_node,
 };
 
@@ -19,18 +19,18 @@ pub(crate) fn extend_selection(db: &RootDatabase, frange: FileRange) -> TextRang
 
 fn extend_selection_in_macro(
     _db: &RootDatabase,
-    source_file: &SourceFileNode,
+    source_file: &SourceFile,
     frange: FileRange,
 ) -> Option<TextRange> {
     let macro_call = find_macro_call(source_file.syntax(), frange.range)?;
     let (off, exp) = hir::MacroDef::ast_expand(macro_call)?;
     let dst_range = exp.map_range_forward(frange.range - off)?;
-    let dst_range = ra_editor::extend_selection(exp.syntax().borrowed(), dst_range)?;
+    let dst_range = ra_editor::extend_selection(&exp.syntax(), dst_range)?;
     let src_range = exp.map_range_back(dst_range)? + off;
     Some(src_range)
 }
 
-fn find_macro_call(node: SyntaxNodeRef, range: TextRange) -> Option<ast::MacroCall> {
+fn find_macro_call(node: &SyntaxNode, range: TextRange) -> Option<&ast::MacroCall> {
     find_covering_node(node, range)
         .ancestors()
         .find_map(ast::MacroCall::cast)
diff --git a/crates/ra_analysis/src/goto_defenition.rs b/crates/ra_analysis/src/goto_defenition.rs
index aa0616e3b..0bcf13ebd 100644
--- a/crates/ra_analysis/src/goto_defenition.rs
+++ b/crates/ra_analysis/src/goto_defenition.rs
@@ -23,7 +23,7 @@ pub(crate) fn goto_defenition(
 pub(crate) fn reference_defenition(
     db: &RootDatabase,
     file_id: FileId,
-    name_ref: ast::NameRef,
+    name_ref: &ast::NameRef,
 ) -> Cancelable<Vec<NavigationTarget>> {
     if let Some(fn_descr) =
         hir::source_binder::function_from_child_node(db, file_id, name_ref.syntax())?
@@ -53,7 +53,7 @@ pub(crate) fn reference_defenition(
 fn name_defenition(
     db: &RootDatabase,
     file_id: FileId,
-    name: ast::Name,
+    name: &ast::Name,
 ) -> Cancelable<Option<Vec<NavigationTarget>>> {
     if let Some(module) = name.syntax().parent().and_then(ast::Module::cast) {
         if module.has_semi() {
diff --git a/crates/ra_analysis/src/hover.rs b/crates/ra_analysis/src/hover.rs
index 06632df4f..5607c3ef3 100644
--- a/crates/ra_analysis/src/hover.rs
+++ b/crates/ra_analysis/src/hover.rs
@@ -1,7 +1,7 @@
 use ra_db::{Cancelable, SyntaxDatabase};
 use ra_editor::find_node_at_offset;
 use ra_syntax::{
-    AstNode, SyntaxNode,
+    AstNode, SyntaxNode, TreePtr,
     ast::{self, NameOwner},
     algo::{find_covering_node, find_leaf_at_offset, visit::{visitor, Visitor}},
 };
@@ -88,20 +88,19 @@ fn doc_text_for(db: &RootDatabase, nav: NavigationTarget) -> Cancelable<Option<S
 }
 
 impl NavigationTarget {
-    fn node(&self, db: &RootDatabase) -> Option<SyntaxNode> {
+    fn node(&self, db: &RootDatabase) -> Option<TreePtr<SyntaxNode>> {
         let source_file = db.source_file(self.file_id);
         let source_file = source_file.syntax();
         let node = source_file
             .descendants()
             .find(|node| node.kind() == self.kind && node.range() == self.range)?
-            .owned();
+            .to_owned();
         Some(node)
     }
 
     fn docs(&self, db: &RootDatabase) -> Option<String> {
         let node = self.node(db)?;
-        let node = node.borrowed();
-        fn doc_comments<'a, N: ast::DocCommentsOwner<'a>>(node: N) -> Option<String> {
+        fn doc_comments<N: ast::DocCommentsOwner>(node: &N) -> Option<String> {
             let comments = node.doc_comment_text();
             if comments.is_empty() {
                 None
@@ -119,7 +118,7 @@ impl NavigationTarget {
             .visit(doc_comments::<ast::TypeDef>)
             .visit(doc_comments::<ast::ConstDef>)
             .visit(doc_comments::<ast::StaticDef>)
-            .accept(node)?
+            .accept(&node)?
     }
 
     /// Get a description of this node.
@@ -128,50 +127,49 @@ impl NavigationTarget {
     fn description(&self, db: &RootDatabase) -> Option<String> {
         // TODO: After type inference is done, add type information to improve the output
         let node = self.node(db)?;
-        let node = node.borrowed();
         // TODO: Refactor to be have less repetition
         visitor()
-            .visit(|node: ast::FnDef| {
+            .visit(|node: &ast::FnDef| {
                 let mut string = "fn ".to_string();
                 node.name()?.syntax().text().push_to(&mut string);
                 Some(string)
             })
-            .visit(|node: ast::StructDef| {
+            .visit(|node: &ast::StructDef| {
                 let mut string = "struct ".to_string();
                 node.name()?.syntax().text().push_to(&mut string);
                 Some(string)
             })
-            .visit(|node: ast::EnumDef| {
+            .visit(|node: &ast::EnumDef| {
                 let mut string = "enum ".to_string();
                 node.name()?.syntax().text().push_to(&mut string);
                 Some(string)
             })
-            .visit(|node: ast::TraitDef| {
+            .visit(|node: &ast::TraitDef| {
                 let mut string = "trait ".to_string();
                 node.name()?.syntax().text().push_to(&mut string);
                 Some(string)
             })
-            .visit(|node: ast::Module| {
+            .visit(|node: &ast::Module| {
                 let mut string = "mod ".to_string();
                 node.name()?.syntax().text().push_to(&mut string);
                 Some(string)
             })
-            .visit(|node: ast::TypeDef| {
+            .visit(|node: &ast::TypeDef| {
                 let mut string = "type ".to_string();
                 node.name()?.syntax().text().push_to(&mut string);
                 Some(string)
             })
-            .visit(|node: ast::ConstDef| {
+            .visit(|node: &ast::ConstDef| {
                 let mut string = "const ".to_string();
                 node.name()?.syntax().text().push_to(&mut string);
                 Some(string)
             })
-            .visit(|node: ast::StaticDef| {
+            .visit(|node: &ast::StaticDef| {
                 let mut string = "static ".to_string();
                 node.name()?.syntax().text().push_to(&mut string);
                 Some(string)
             })
-            .accept(node)?
+            .accept(&node)?
     }
 }
 
diff --git a/crates/ra_analysis/src/imp.rs b/crates/ra_analysis/src/imp.rs
index 07a966290..8ac430e41 100644
--- a/crates/ra_analysis/src/imp.rs
+++ b/crates/ra_analysis/src/imp.rs
@@ -8,10 +8,9 @@ use hir::{
 use ra_db::{FilesDatabase, SourceRoot, SourceRootId, SyntaxDatabase};
 use ra_editor::{self, find_node_at_offset, assists, LocalEdit, Severity};
 use ra_syntax::{
-    ast::{self, ArgListOwner, Expr, NameOwner},
-    AstNode, SourceFileNode,
+    SyntaxNode, TextRange, TextUnit, AstNode, SourceFile,
+    ast::{self, ArgListOwner, NameOwner},
     SyntaxKind::*,
-    SyntaxNodeRef, TextRange, TextUnit,
 };
 
 use crate::{
@@ -113,7 +112,6 @@ impl db::RootDatabase {
             None => return Ok(Vec::new()),
             Some(it) => it,
         };
-        let ast_module = ast_module.borrowed();
         let name = ast_module.name().unwrap();
         Ok(vec![NavigationTarget {
             file_id,
@@ -163,9 +161,9 @@ impl db::RootDatabase {
 
         fn find_binding<'a>(
             db: &db::RootDatabase,
-            source_file: &'a SourceFileNode,
+            source_file: &'a SourceFile,
             position: FilePosition,
-        ) -> Cancelable<Option<(ast::BindPat<'a>, hir::Function)>> {
+        ) -> Cancelable<Option<(&'a ast::BindPat, hir::Function)>> {
             let syntax = source_file.syntax();
             if let Some(binding) = find_node_at_offset::<ast::BindPat>(syntax, position.offset) {
                 let descr = ctry!(source_binder::function_from_child_node(
@@ -281,7 +279,7 @@ impl db::RootDatabase {
             if symbol.ptr.kind() == FN_DEF {
                 let fn_file = self.source_file(symbol.file_id);
                 let fn_def = symbol.ptr.resolve(&fn_file);
-                let fn_def = ast::FnDef::cast(fn_def.borrowed()).unwrap();
+                let fn_def = ast::FnDef::cast(&fn_def).unwrap();
                 let descr = ctry!(source_binder::function_from_source(
                     self,
                     symbol.file_id,
@@ -352,7 +350,7 @@ impl db::RootDatabase {
             .collect::<Vec<_>>();
         Ok(res)
     }
-    pub(crate) fn index_resolve(&self, name_ref: ast::NameRef) -> Cancelable<Vec<FileSymbol>> {
+    pub(crate) fn index_resolve(&self, name_ref: &ast::NameRef) -> Cancelable<Vec<FileSymbol>> {
         let name = name_ref.text();
         let mut query = Query::new(name.to_string());
         query.exact();
@@ -379,12 +377,12 @@ impl SourceChange {
 }
 
 enum FnCallNode<'a> {
-    CallExpr(ast::CallExpr<'a>),
-    MethodCallExpr(ast::MethodCallExpr<'a>),
+    CallExpr(&'a ast::CallExpr),
+    MethodCallExpr(&'a ast::MethodCallExpr),
 }
 
 impl<'a> FnCallNode<'a> {
-    pub fn with_node(syntax: SyntaxNodeRef, offset: TextUnit) -> Option<FnCallNode> {
+    pub fn with_node(syntax: &'a SyntaxNode, offset: TextUnit) -> Option<FnCallNode<'a>> {
         if let Some(expr) = find_node_at_offset::<ast::CallExpr>(syntax, offset) {
             return Some(FnCallNode::CallExpr(expr));
         }
@@ -394,10 +392,10 @@ impl<'a> FnCallNode<'a> {
         None
     }
 
-    pub fn name_ref(&self) -> Option<ast::NameRef> {
+    pub fn name_ref(&self) -> Option<&'a ast::NameRef> {
         match *self {
-            FnCallNode::CallExpr(call_expr) => Some(match call_expr.expr()? {
-                Expr::PathExpr(path_expr) => path_expr.path()?.segment()?.name_ref()?,
+            FnCallNode::CallExpr(call_expr) => Some(match call_expr.expr()?.kind() {
+                ast::ExprKind::PathExpr(path_expr) => path_expr.path()?.segment()?.name_ref()?,
                 _ => return None,
             }),
 
@@ -409,7 +407,7 @@ impl<'a> FnCallNode<'a> {
         }
     }
 
-    pub fn arg_list(&self) -> Option<ast::ArgList> {
+    pub fn arg_list(&self) -> Option<&'a ast::ArgList> {
         match *self {
             FnCallNode::CallExpr(expr) => expr.arg_list(),
             FnCallNode::MethodCallExpr(expr) => expr.arg_list(),
diff --git a/crates/ra_analysis/src/lib.rs b/crates/ra_analysis/src/lib.rs
index c8f846c56..ec400ffe2 100644
--- a/crates/ra_analysis/src/lib.rs
+++ b/crates/ra_analysis/src/lib.rs
@@ -26,7 +26,7 @@ mod syntax_highlighting;
 
 use std::{fmt, sync::Arc};
 
-use ra_syntax::{SmolStr, SourceFileNode, SyntaxKind, TextRange, TextUnit};
+use ra_syntax::{SmolStr, SourceFile, TreePtr, SyntaxKind, TextRange, TextUnit};
 use ra_text_edit::TextEdit;
 use rayon::prelude::*;
 use relative_path::RelativePathBuf;
@@ -308,7 +308,7 @@ impl Analysis {
         self.db.file_text(file_id)
     }
     /// Gets the syntax tree of the file.
-    pub fn file_syntax(&self, file_id: FileId) -> SourceFileNode {
+    pub fn file_syntax(&self, file_id: FileId) -> TreePtr<SourceFile> {
         self.db.source_file(file_id).clone()
     }
     /// Gets the file's `LineIndex`: data structure to convert between absolute
@@ -322,7 +322,7 @@ impl Analysis {
     }
     /// Returns position of the mathcing brace (all types of braces are
     /// supported).
-    pub fn matching_brace(&self, file: &SourceFileNode, offset: TextUnit) -> Option<TextUnit> {
+    pub fn matching_brace(&self, file: &SourceFile, offset: TextUnit) -> Option<TextUnit> {
         ra_editor::matching_brace(file, offset)
     }
     /// Returns a syntax tree represented as `String`, for debug purposes.
@@ -469,7 +469,7 @@ impl LibraryData {
         files: Vec<(FileId, RelativePathBuf, Arc<String>)>,
     ) -> LibraryData {
         let symbol_index = SymbolIndex::for_files(files.par_iter().map(|(file_id, _, text)| {
-            let file = SourceFileNode::parse(text);
+            let file = SourceFile::parse(text);
             (*file_id, file)
         }));
         let mut root_change = RootChange::default();
diff --git a/crates/ra_analysis/src/runnables.rs b/crates/ra_analysis/src/runnables.rs
index 216209098..98b1d2d55 100644
--- a/crates/ra_analysis/src/runnables.rs
+++ b/crates/ra_analysis/src/runnables.rs
@@ -1,7 +1,7 @@
 use itertools::Itertools;
 use ra_syntax::{
+    TextRange, SyntaxNode,
     ast::{self, AstNode, NameOwner, ModuleItemOwner},
-    TextRange, SyntaxNodeRef,
 };
 use ra_db::{Cancelable, SyntaxDatabase};
 
@@ -30,7 +30,7 @@ pub(crate) fn runnables(db: &RootDatabase, file_id: FileId) -> Cancelable<Vec<Ru
     Ok(res)
 }
 
-fn runnable(db: &RootDatabase, file_id: FileId, item: SyntaxNodeRef) -> Option<Runnable> {
+fn runnable(db: &RootDatabase, file_id: FileId, item: &SyntaxNode) -> Option<Runnable> {
     if let Some(fn_def) = ast::FnDef::cast(item) {
         runnable_fn(fn_def)
     } else if let Some(m) = ast::Module::cast(item) {
@@ -40,7 +40,7 @@ fn runnable(db: &RootDatabase, file_id: FileId, item: SyntaxNodeRef) -> Option<R
     }
 }
 
-fn runnable_fn(fn_def: ast::FnDef) -> Option<Runnable> {
+fn runnable_fn(fn_def: &ast::FnDef) -> Option<Runnable> {
     let name = fn_def.name()?.text();
     let kind = if name == "main" {
         RunnableKind::Bin
@@ -57,12 +57,12 @@ fn runnable_fn(fn_def: ast::FnDef) -> Option<Runnable> {
     })
 }
 
-fn runnable_mod(db: &RootDatabase, file_id: FileId, module: ast::Module) -> Option<Runnable> {
+fn runnable_mod(db: &RootDatabase, file_id: FileId, module: &ast::Module) -> Option<Runnable> {
     let has_test_function = module
         .item_list()?
         .items()
-        .filter_map(|it| match it {
-            ast::ModuleItem::FnDef(it) => Some(it),
+        .filter_map(|it| match it.kind() {
+            ast::ModuleItemKind::FnDef(it) => Some(it),
             _ => None,
         })
         .any(|f| f.has_atom_attr("test"));
diff --git a/crates/ra_analysis/src/symbol_index.rs b/crates/ra_analysis/src/symbol_index.rs
index e2b1c88fe..ed1796756 100644
--- a/crates/ra_analysis/src/symbol_index.rs
+++ b/crates/ra_analysis/src/symbol_index.rs
@@ -27,7 +27,7 @@ use std::{
 
 use fst::{self, Streamer};
 use ra_syntax::{
-    SyntaxNodeRef, SourceFileNode, SmolStr,
+    SyntaxNode, SourceFile, SmolStr, TreePtr, AstNode,
     algo::{visit::{visitor, Visitor}, find_covering_node},
     SyntaxKind::{self, *},
     ast::{self, NameOwner},
@@ -141,7 +141,7 @@ impl SymbolIndex {
     }
 
     pub(crate) fn for_files(
-        files: impl ParallelIterator<Item = (FileId, SourceFileNode)>,
+        files: impl ParallelIterator<Item = (FileId, TreePtr<SourceFile>)>,
     ) -> SymbolIndex {
         let symbols = files
             .flat_map(|(file_id, file)| {
@@ -203,8 +203,8 @@ pub(crate) struct FileSymbol {
     pub(crate) ptr: LocalSyntaxPtr,
 }
 
-fn to_symbol(node: SyntaxNodeRef) -> Option<(SmolStr, LocalSyntaxPtr)> {
-    fn decl<'a, N: NameOwner<'a>>(node: N) -> Option<(SmolStr, LocalSyntaxPtr)> {
+fn to_symbol(node: &SyntaxNode) -> Option<(SmolStr, LocalSyntaxPtr)> {
+    fn decl<N: NameOwner>(node: &N) -> Option<(SmolStr, LocalSyntaxPtr)> {
         let name = node.name()?.text();
         let ptr = LocalSyntaxPtr::new(node.syntax());
         Some((name, ptr))
diff --git a/crates/ra_analysis/src/syntax_highlighting.rs b/crates/ra_analysis/src/syntax_highlighting.rs
index 35e153ca0..d2dc6cfbb 100644
--- a/crates/ra_analysis/src/syntax_highlighting.rs
+++ b/crates/ra_analysis/src/syntax_highlighting.rs
@@ -16,7 +16,7 @@ pub(crate) fn highlight(db: &RootDatabase, file_id: FileId) -> Cancelable<Vec<Hi
         .filter_map(ast::MacroCall::cast)
     {
         if let Some((off, exp)) = hir::MacroDef::ast_expand(macro_call) {
-            let mapped_ranges = ra_editor::highlight(exp.syntax().borrowed())
+            let mapped_ranges = ra_editor::highlight(&exp.syntax())
                 .into_iter()
                 .filter_map(|r| {
                     let mapped_range = exp.map_range_back(r.range)?;
diff --git a/crates/ra_cli/src/main.rs b/crates/ra_cli/src/main.rs
index a3b856aa9..0d12f3a88 100644
--- a/crates/ra_cli/src/main.rs
+++ b/crates/ra_cli/src/main.rs
@@ -3,7 +3,7 @@ use std::{fs, io::Read, path::Path, time::Instant};
 use clap::{App, Arg, SubCommand};
 use join_to_string::join;
 use ra_editor::{extend_selection, file_structure, syntax_tree};
-use ra_syntax::{SourceFileNode, TextRange};
+use ra_syntax::{SourceFile, TextRange, TreePtr, AstNode};
 use tools::collect_tests;
 
 type Result<T> = ::std::result::Result<T, failure::Error>;
@@ -71,9 +71,9 @@ fn main() -> Result<()> {
     Ok(())
 }
 
-fn file() -> Result<SourceFileNode> {
+fn file() -> Result<TreePtr<SourceFile>> {
     let text = read_stdin()?;
-    Ok(SourceFileNode::parse(&text))
+    Ok(SourceFile::parse(&text))
 }
 
 fn read_stdin() -> Result<String> {
@@ -92,12 +92,12 @@ fn render_test(file: &Path, line: usize) -> Result<(String, String)> {
         None => failure::bail!("No test found at line {} at {}", line, file.display()),
         Some((_start_line, test)) => test,
     };
-    let file = SourceFileNode::parse(&test.text);
+    let file = SourceFile::parse(&test.text);
     let tree = syntax_tree(&file);
     Ok((test.text, tree))
 }
 
-fn selections(file: &SourceFileNode, start: u32, end: u32) -> String {
+fn selections(file: &SourceFile, start: u32, end: u32) -> String {
     let mut ranges = Vec::new();
     let mut cur = Some(TextRange::from_to((start - 1).into(), (end - 1).into()));
     while let Some(r) = cur {
diff --git a/crates/ra_db/src/lib.rs b/crates/ra_db/src/lib.rs
index 7181f2950..3c41ee56d 100644
--- a/crates/ra_db/src/lib.rs
+++ b/crates/ra_db/src/lib.rs
@@ -8,7 +8,7 @@ pub mod mock;
 use std::sync::Arc;
 
 use ra_editor::LineIndex;
-use ra_syntax::{TextUnit, TextRange, SourceFileNode};
+use ra_syntax::{TextUnit, TextRange, SourceFile, TreePtr};
 
 pub use crate::{
     cancelation::{Canceled, Cancelable},
@@ -47,7 +47,7 @@ pub trait BaseDatabase: salsa::Database {
 
 salsa::query_group! {
     pub trait SyntaxDatabase: crate::input::FilesDatabase + BaseDatabase {
-        fn source_file(file_id: FileId) -> SourceFileNode {
+        fn source_file(file_id: FileId) -> TreePtr<SourceFile> {
             type SourceFileQuery;
         }
         fn file_lines(file_id: FileId) -> Arc<LineIndex> {
@@ -56,9 +56,9 @@ salsa::query_group! {
     }
 }
 
-fn source_file(db: &impl SyntaxDatabase, file_id: FileId) -> SourceFileNode {
+fn source_file(db: &impl SyntaxDatabase, file_id: FileId) -> TreePtr<SourceFile> {
     let text = db.file_text(file_id);
-    SourceFileNode::parse(&*text)
+    SourceFile::parse(&*text)
 }
 fn file_lines(db: &impl SyntaxDatabase, file_id: FileId) -> Arc<LineIndex> {
     let text = db.file_text(file_id);
diff --git a/crates/ra_db/src/syntax_ptr.rs b/crates/ra_db/src/syntax_ptr.rs
index 5bfcedf2b..be64d417c 100644
--- a/crates/ra_db/src/syntax_ptr.rs
+++ b/crates/ra_db/src/syntax_ptr.rs
@@ -1,4 +1,4 @@
-use ra_syntax::{SourceFileNode, SyntaxKind, SyntaxNode, SyntaxNodeRef, TextRange};
+use ra_syntax::{AstNode, SourceFile, SyntaxKind, SyntaxNode, TextRange, TreePtr};
 
 /// A pointer to a syntax node inside a file.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -8,18 +8,18 @@ pub struct LocalSyntaxPtr {
 }
 
 impl LocalSyntaxPtr {
-    pub fn new(node: SyntaxNodeRef) -> LocalSyntaxPtr {
+    pub fn new(node: &SyntaxNode) -> LocalSyntaxPtr {
         LocalSyntaxPtr {
             range: node.range(),
             kind: node.kind(),
         }
     }
 
-    pub fn resolve(self, file: &SourceFileNode) -> SyntaxNode {
+    pub fn resolve(self, file: &SourceFile) -> TreePtr<SyntaxNode> {
         let mut curr = file.syntax();
         loop {
             if curr.range() == self.range && curr.kind() == self.kind {
-                return curr.owned();
+                return curr.to_owned();
             }
             curr = curr
                 .children()
@@ -40,7 +40,7 @@ impl LocalSyntaxPtr {
 #[test]
 fn test_local_syntax_ptr() {
     use ra_syntax::{ast, AstNode};
-    let file = SourceFileNode::parse("struct Foo { f: u32, }");
+    let file = SourceFile::parse("struct Foo { f: u32, }");
     let field = file
         .syntax()
         .descendants()
@@ -48,5 +48,5 @@ fn test_local_syntax_ptr() {
         .unwrap();
     let ptr = LocalSyntaxPtr::new(field.syntax());
     let field_syntax = ptr.resolve(&file);
-    assert_eq!(field.syntax(), field_syntax);
+    assert_eq!(field.syntax(), &*field_syntax);
 }
diff --git a/crates/ra_editor/src/assists.rs b/crates/ra_editor/src/assists.rs
index 57b78342a..a320caabf 100644
--- a/crates/ra_editor/src/assists.rs
+++ b/crates/ra_editor/src/assists.rs
@@ -12,7 +12,7 @@ mod split_import;
 
 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},
 };
 
@@ -28,7 +28,7 @@ pub use self::{
 };
 
 /// 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,
@@ -50,7 +50,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 +88,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 +106,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 +145,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)
     }
 }
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/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/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..bf40c92c0 100644
--- a/crates/ra_editor/src/test_utils.rs
+++ b/crates/ra_editor/src/test_utils.rs
@@ -1,15 +1,15 @@
-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 {
@@ -20,13 +20,13 @@ pub fn check_action<F: Fn(&SourceFileNode, TextUnit) -> Option<LocalEdit>>(
     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());
diff --git a/crates/ra_hir/src/adt.rs b/crates/ra_hir/src/adt.rs
index c6463235c..b700be267 100644
--- a/crates/ra_hir/src/adt.rs
+++ b/crates/ra_hir/src/adt.rs
@@ -42,7 +42,7 @@ pub struct StructData {
 }
 
 impl StructData {
-    pub(crate) fn new(struct_def: ast::StructDef) -> StructData {
+    pub(crate) fn new(struct_def: &ast::StructDef) -> StructData {
         let name = struct_def.name().map(|n| n.as_name());
         let variant_data = VariantData::new(struct_def.flavor());
         let variant_data = Arc::new(variant_data);
@@ -87,7 +87,7 @@ pub struct EnumData {
 }
 
 impl EnumData {
-    pub(crate) fn new(enum_def: ast::EnumDef) -> Self {
+    pub(crate) fn new(enum_def: &ast::EnumDef) -> Self {
         let name = enum_def.name().map(|n| n.as_name());
         let variants = if let Some(evl) = enum_def.variant_list() {
             evl.variants()
diff --git a/crates/ra_hir/src/code_model_api.rs b/crates/ra_hir/src/code_model_api.rs
index 09b532f74..43cddb504 100644
--- a/crates/ra_hir/src/code_model_api.rs
+++ b/crates/ra_hir/src/code_model_api.rs
@@ -1,6 +1,6 @@
 use relative_path::RelativePathBuf;
 use ra_db::{CrateId, Cancelable, FileId};
-use ra_syntax::{ast, SyntaxNode};
+use ra_syntax::{ast, TreePtr, SyntaxNode};
 
 use crate::{Name, db::HirDatabase, DefId, Path, PerNs, nameres::ModuleScope};
 
@@ -36,8 +36,8 @@ pub struct Module {
 }
 
 pub enum ModuleSource {
-    SourceFile(ast::SourceFileNode),
-    Module(ast::ModuleNode),
+    SourceFile(TreePtr<ast::SourceFile>),
+    Module(TreePtr<ast::Module>),
 }
 
 #[derive(Clone, Debug, Hash, PartialEq, Eq)]
@@ -66,7 +66,7 @@ impl Module {
     pub fn declaration_source(
         &self,
         db: &impl HirDatabase,
-    ) -> Cancelable<Option<(FileId, ast::ModuleNode)>> {
+    ) -> Cancelable<Option<(FileId, TreePtr<ast::Module>)>> {
         self.declaration_source_impl(db)
     }
 
@@ -104,7 +104,10 @@ impl Module {
     pub fn resolve_path(&self, db: &impl HirDatabase, path: &Path) -> Cancelable<PerNs<DefId>> {
         self.resolve_path_impl(db, path)
     }
-    pub fn problems(&self, db: &impl HirDatabase) -> Cancelable<Vec<(SyntaxNode, Problem)>> {
+    pub fn problems(
+        &self,
+        db: &impl HirDatabase,
+    ) -> Cancelable<Vec<(TreePtr<SyntaxNode>, Problem)>> {
         self.problems_impl(db)
     }
 }
diff --git a/crates/ra_hir/src/code_model_impl/module.rs b/crates/ra_hir/src/code_model_impl/module.rs
index eb35779f1..0d22c9dbe 100644
--- a/crates/ra_hir/src/code_model_impl/module.rs
+++ b/crates/ra_hir/src/code_model_impl/module.rs
@@ -1,5 +1,5 @@
 use ra_db::{Cancelable, SourceRootId, FileId};
-use ra_syntax::{ast, SyntaxNode, AstNode};
+use ra_syntax::{ast, SyntaxNode, AstNode, TreePtr};
 
 use crate::{
     Module, ModuleSource, Problem,
@@ -43,12 +43,11 @@ impl Module {
         let loc = self.def_id.loc(db);
         let file_id = loc.source_item_id.file_id.as_original_file();
         let syntax_node = db.file_item(loc.source_item_id);
-        let syntax_node = syntax_node.borrowed();
-        let module_source = if let Some(source_file) = ast::SourceFile::cast(syntax_node) {
-            ModuleSource::SourceFile(source_file.owned())
+        let module_source = if let Some(source_file) = ast::SourceFile::cast(&syntax_node) {
+            ModuleSource::SourceFile(source_file.to_owned())
         } else {
-            let module = ast::Module::cast(syntax_node).unwrap();
-            ModuleSource::Module(module.owned())
+            let module = ast::Module::cast(&syntax_node).unwrap();
+            ModuleSource::Module(module.to_owned())
         };
         Ok((file_id, module_source))
     }
@@ -56,7 +55,7 @@ impl Module {
     pub fn declaration_source_impl(
         &self,
         db: &impl HirDatabase,
-    ) -> Cancelable<Option<(FileId, ast::ModuleNode)>> {
+    ) -> Cancelable<Option<(FileId, TreePtr<ast::Module>)>> {
         let loc = self.def_id.loc(db);
         let module_tree = db.module_tree(loc.source_root_id)?;
         let link = ctry!(loc.module_id.parent_link(&module_tree));
@@ -146,7 +145,10 @@ impl Module {
         }
         Ok(curr_per_ns)
     }
-    pub fn problems_impl(&self, db: &impl HirDatabase) -> Cancelable<Vec<(SyntaxNode, Problem)>> {
+    pub fn problems_impl(
+        &self,
+        db: &impl HirDatabase,
+    ) -> Cancelable<Vec<(TreePtr<SyntaxNode>, Problem)>> {
         let loc = self.def_id.loc(db);
         let module_tree = db.module_tree(loc.source_root_id)?;
         Ok(loc.module_id.problems(&module_tree, db))
diff --git a/crates/ra_hir/src/db.rs b/crates/ra_hir/src/db.rs
index 04249400b..03e65387d 100644
--- a/crates/ra_hir/src/db.rs
+++ b/crates/ra_hir/src/db.rs
@@ -1,6 +1,6 @@
 use std::sync::Arc;
 
-use ra_syntax::{SyntaxNode, SourceFileNode};
+use ra_syntax::{SyntaxNode, TreePtr, SourceFile};
 use ra_db::{SourceRootId, LocationIntener, SyntaxDatabase, Cancelable};
 
 use crate::{
@@ -22,7 +22,7 @@ pub trait HirDatabase: SyntaxDatabase
     + AsRef<LocationIntener<DefLoc, DefId>>
     + AsRef<LocationIntener<MacroCallLoc, MacroCallId>>
 {
-    fn hir_source_file(file_id: HirFileId) -> SourceFileNode {
+    fn hir_source_file(file_id: HirFileId) -> TreePtr<SourceFile> {
         type HirSourceFileQuery;
         use fn HirFileId::hir_source_file;
     }
@@ -66,7 +66,7 @@ pub trait HirDatabase: SyntaxDatabase
         use fn query_definitions::file_items;
     }
 
-    fn file_item(source_item_id: SourceItemId) -> SyntaxNode {
+    fn file_item(source_item_id: SourceItemId) -> TreePtr<SyntaxNode> {
         type FileItemQuery;
         use fn query_definitions::file_item;
     }
diff --git a/crates/ra_hir/src/expr.rs b/crates/ra_hir/src/expr.rs
index b0063cad2..4c54449ef 100644
--- a/crates/ra_hir/src/expr.rs
+++ b/crates/ra_hir/src/expr.rs
@@ -77,7 +77,7 @@ impl BodySyntaxMapping {
     pub fn syntax_expr(&self, ptr: LocalSyntaxPtr) -> Option<ExprId> {
         self.expr_syntax_mapping.get(&ptr).cloned()
     }
-    pub fn node_expr(&self, node: ast::Expr) -> Option<ExprId> {
+    pub fn node_expr(&self, node: &ast::Expr) -> Option<ExprId> {
         self.expr_syntax_mapping
             .get(&LocalSyntaxPtr::new(node.syntax()))
             .cloned()
@@ -88,7 +88,7 @@ impl BodySyntaxMapping {
     pub fn syntax_pat(&self, ptr: LocalSyntaxPtr) -> Option<PatId> {
         self.pat_syntax_mapping.get(&ptr).cloned()
     }
-    pub fn node_pat(&self, node: ast::Pat) -> Option<PatId> {
+    pub fn node_pat(&self, node: &ast::Pat) -> Option<PatId> {
         self.pat_syntax_mapping
             .get(&LocalSyntaxPtr::new(node.syntax()))
             .cloned()
@@ -373,10 +373,10 @@ impl ExprCollector {
         self.exprs.alloc(block)
     }
 
-    fn collect_expr(&mut self, expr: ast::Expr) -> ExprId {
+    fn collect_expr(&mut self, expr: &ast::Expr) -> ExprId {
         let syntax_ptr = LocalSyntaxPtr::new(expr.syntax());
-        match expr {
-            ast::Expr::IfExpr(e) => {
+        match expr.kind() {
+            ast::ExprKind::IfExpr(e) => {
                 if let Some(pat) = e.condition().and_then(|c| c.pat()) {
                     // if let -- desugar to match
                     let pat = self.collect_pat(pat);
@@ -419,12 +419,12 @@ impl ExprCollector {
                     )
                 }
             }
-            ast::Expr::BlockExpr(e) => self.collect_block_opt(e.block()),
-            ast::Expr::LoopExpr(e) => {
+            ast::ExprKind::BlockExpr(e) => self.collect_block_opt(e.block()),
+            ast::ExprKind::LoopExpr(e) => {
                 let body = self.collect_block_opt(e.loop_body());
                 self.alloc_expr(Expr::Loop { body }, syntax_ptr)
             }
-            ast::Expr::WhileExpr(e) => {
+            ast::ExprKind::WhileExpr(e) => {
                 let condition = if let Some(condition) = e.condition() {
                     if condition.pat().is_none() {
                         self.collect_expr_opt(condition.expr())
@@ -438,7 +438,7 @@ impl ExprCollector {
                 let body = self.collect_block_opt(e.loop_body());
                 self.alloc_expr(Expr::While { condition, body }, syntax_ptr)
             }
-            ast::Expr::ForExpr(e) => {
+            ast::ExprKind::ForExpr(e) => {
                 let iterable = self.collect_expr_opt(e.iterable());
                 let pat = self.collect_pat_opt(e.pat());
                 let body = self.collect_block_opt(e.loop_body());
@@ -451,7 +451,7 @@ impl ExprCollector {
                     syntax_ptr,
                 )
             }
-            ast::Expr::CallExpr(e) => {
+            ast::ExprKind::CallExpr(e) => {
                 let callee = self.collect_expr_opt(e.expr());
                 let args = if let Some(arg_list) = e.arg_list() {
                     arg_list.args().map(|e| self.collect_expr(e)).collect()
@@ -460,7 +460,7 @@ impl ExprCollector {
                 };
                 self.alloc_expr(Expr::Call { callee, args }, syntax_ptr)
             }
-            ast::Expr::MethodCallExpr(e) => {
+            ast::ExprKind::MethodCallExpr(e) => {
                 let receiver = self.collect_expr_opt(e.expr());
                 let args = if let Some(arg_list) = e.arg_list() {
                     arg_list.args().map(|e| self.collect_expr(e)).collect()
@@ -480,7 +480,7 @@ impl ExprCollector {
                     syntax_ptr,
                 )
             }
-            ast::Expr::MatchExpr(e) => {
+            ast::ExprKind::MatchExpr(e) => {
                 let expr = self.collect_expr_opt(e.expr());
                 let arms = if let Some(match_arm_list) = e.match_arm_list() {
                     match_arm_list
@@ -495,7 +495,7 @@ impl ExprCollector {
                 };
                 self.alloc_expr(Expr::Match { expr, arms }, syntax_ptr)
             }
-            ast::Expr::PathExpr(e) => {
+            ast::ExprKind::PathExpr(e) => {
                 let path = e
                     .path()
                     .and_then(Path::from_ast)
@@ -503,25 +503,25 @@ impl ExprCollector {
                     .unwrap_or(Expr::Missing);
                 self.alloc_expr(path, syntax_ptr)
             }
-            ast::Expr::ContinueExpr(_e) => {
+            ast::ExprKind::ContinueExpr(_e) => {
                 // TODO: labels
                 self.alloc_expr(Expr::Continue, syntax_ptr)
             }
-            ast::Expr::BreakExpr(e) => {
+            ast::ExprKind::BreakExpr(e) => {
                 let expr = e.expr().map(|e| self.collect_expr(e));
                 self.alloc_expr(Expr::Break { expr }, syntax_ptr)
             }
-            ast::Expr::ParenExpr(e) => {
+            ast::ExprKind::ParenExpr(e) => {
                 let inner = self.collect_expr_opt(e.expr());
                 // make the paren expr point to the inner expression as well
                 self.expr_syntax_mapping.insert(syntax_ptr, inner);
                 inner
             }
-            ast::Expr::ReturnExpr(e) => {
+            ast::ExprKind::ReturnExpr(e) => {
                 let expr = e.expr().map(|e| self.collect_expr(e));
                 self.alloc_expr(Expr::Return { expr }, syntax_ptr)
             }
-            ast::Expr::StructLit(e) => {
+            ast::ExprKind::StructLit(e) => {
                 let path = e.path().and_then(Path::from_ast);
                 let fields = if let Some(nfl) = e.named_field_list() {
                     nfl.fields()
@@ -558,7 +558,7 @@ impl ExprCollector {
                     syntax_ptr,
                 )
             }
-            ast::Expr::FieldExpr(e) => {
+            ast::ExprKind::FieldExpr(e) => {
                 let expr = self.collect_expr_opt(e.expr());
                 let name = e
                     .name_ref()
@@ -566,26 +566,26 @@ impl ExprCollector {
                     .unwrap_or_else(Name::missing);
                 self.alloc_expr(Expr::Field { expr, name }, syntax_ptr)
             }
-            ast::Expr::TryExpr(e) => {
+            ast::ExprKind::TryExpr(e) => {
                 let expr = self.collect_expr_opt(e.expr());
                 self.alloc_expr(Expr::Try { expr }, syntax_ptr)
             }
-            ast::Expr::CastExpr(e) => {
+            ast::ExprKind::CastExpr(e) => {
                 let expr = self.collect_expr_opt(e.expr());
                 let type_ref = TypeRef::from_ast_opt(e.type_ref());
                 self.alloc_expr(Expr::Cast { expr, type_ref }, syntax_ptr)
             }
-            ast::Expr::RefExpr(e) => {
+            ast::ExprKind::RefExpr(e) => {
                 let expr = self.collect_expr_opt(e.expr());
                 let mutability = Mutability::from_mutable(e.is_mut());
                 self.alloc_expr(Expr::Ref { expr, mutability }, syntax_ptr)
             }
-            ast::Expr::PrefixExpr(e) => {
+            ast::ExprKind::PrefixExpr(e) => {
                 let expr = self.collect_expr_opt(e.expr());
                 let op = e.op();
                 self.alloc_expr(Expr::UnaryOp { expr, op }, syntax_ptr)
             }
-            ast::Expr::LambdaExpr(e) => {
+            ast::ExprKind::LambdaExpr(e) => {
                 let mut args = Vec::new();
                 let mut arg_types = Vec::new();
                 if let Some(pl) = e.param_list() {
@@ -606,7 +606,7 @@ impl ExprCollector {
                     syntax_ptr,
                 )
             }
-            ast::Expr::BinExpr(e) => {
+            ast::ExprKind::BinExpr(e) => {
                 let lhs = self.collect_expr_opt(e.lhs());
                 let rhs = self.collect_expr_opt(e.rhs());
                 let op = e.op();
@@ -614,16 +614,16 @@ impl ExprCollector {
             }
 
             // TODO implement HIR for these:
-            ast::Expr::Label(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
-            ast::Expr::IndexExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
-            ast::Expr::TupleExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
-            ast::Expr::ArrayExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
-            ast::Expr::RangeExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
-            ast::Expr::Literal(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
+            ast::ExprKind::Label(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
+            ast::ExprKind::IndexExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
+            ast::ExprKind::TupleExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
+            ast::ExprKind::ArrayExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
+            ast::ExprKind::RangeExpr(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
+            ast::ExprKind::Literal(_e) => self.alloc_expr(Expr::Missing, syntax_ptr),
         }
     }
 
-    fn collect_expr_opt(&mut self, expr: Option<ast::Expr>) -> ExprId {
+    fn collect_expr_opt(&mut self, expr: Option<&ast::Expr>) -> ExprId {
         if let Some(expr) = expr {
             self.collect_expr(expr)
         } else {
@@ -631,11 +631,11 @@ impl ExprCollector {
         }
     }
 
-    fn collect_block(&mut self, block: ast::Block) -> ExprId {
+    fn collect_block(&mut self, block: &ast::Block) -> ExprId {
         let statements = block
             .statements()
-            .map(|s| match s {
-                ast::Stmt::LetStmt(stmt) => {
+            .map(|s| match s.kind() {
+                ast::StmtKind::LetStmt(stmt) => {
                     let pat = self.collect_pat_opt(stmt.pat());
                     let type_ref = stmt.type_ref().map(TypeRef::from_ast);
                     let initializer = stmt.initializer().map(|e| self.collect_expr(e));
@@ -645,7 +645,9 @@ impl ExprCollector {
                         initializer,
                     }
                 }
-                ast::Stmt::ExprStmt(stmt) => Statement::Expr(self.collect_expr_opt(stmt.expr())),
+                ast::StmtKind::ExprStmt(stmt) => {
+                    Statement::Expr(self.collect_expr_opt(stmt.expr()))
+                }
             })
             .collect();
         let tail = block.expr().map(|e| self.collect_expr(e));
@@ -655,7 +657,7 @@ impl ExprCollector {
         )
     }
 
-    fn collect_block_opt(&mut self, block: Option<ast::Block>) -> ExprId {
+    fn collect_block_opt(&mut self, block: Option<&ast::Block>) -> ExprId {
         if let Some(block) = block {
             self.collect_block(block)
         } else {
@@ -663,17 +665,17 @@ impl ExprCollector {
         }
     }
 
-    fn collect_pat(&mut self, pat: ast::Pat) -> PatId {
+    fn collect_pat(&mut self, pat: &ast::Pat) -> PatId {
         let syntax_ptr = LocalSyntaxPtr::new(pat.syntax());
-        match pat {
-            ast::Pat::BindPat(bp) => {
+        match pat.kind() {
+            ast::PatKind::BindPat(bp) => {
                 let name = bp
                     .name()
                     .map(|nr| nr.as_name())
                     .unwrap_or_else(Name::missing);
                 self.alloc_pat(Pat::Bind { name }, syntax_ptr)
             }
-            ast::Pat::TupleStructPat(p) => {
+            ast::PatKind::TupleStructPat(p) => {
                 let path = p.path().and_then(Path::from_ast);
                 let args = p.args().map(|p| self.collect_pat(p)).collect();
                 self.alloc_pat(Pat::TupleStruct { path, args }, syntax_ptr)
@@ -685,7 +687,7 @@ impl ExprCollector {
         }
     }
 
-    fn collect_pat_opt(&mut self, pat: Option<ast::Pat>) -> PatId {
+    fn collect_pat_opt(&mut self, pat: Option<&ast::Pat>) -> PatId {
         if let Some(pat) = pat {
             self.collect_pat(pat)
         } else {
@@ -710,7 +712,7 @@ impl ExprCollector {
     }
 }
 
-pub(crate) fn collect_fn_body_syntax(node: ast::FnDef) -> BodySyntaxMapping {
+pub(crate) fn collect_fn_body_syntax(node: &ast::FnDef) -> BodySyntaxMapping {
     let mut collector = ExprCollector::new();
 
     let args = if let Some(param_list) = node.param_list() {
@@ -758,9 +760,7 @@ pub(crate) fn body_syntax_mapping(
     let body_syntax_mapping = match def {
         Def::Function(f) => {
             let node = f.syntax(db);
-            let node = node.borrowed();
-
-            collect_fn_body_syntax(node)
+            collect_fn_body_syntax(&node)
         }
         // TODO: consts, etc.
         _ => panic!("Trying to get body for item type without body"),
diff --git a/crates/ra_hir/src/function.rs b/crates/ra_hir/src/function.rs
index 4627be071..81b790c5f 100644
--- a/crates/ra_hir/src/function.rs
+++ b/crates/ra_hir/src/function.rs
@@ -7,7 +7,7 @@ use std::{
 
 use ra_db::Cancelable;
 use ra_syntax::{
-    TextRange, TextUnit,
+    TextRange, TextUnit, TreePtr,
     ast::{self, AstNode, DocCommentsOwner, NameOwner},
 };
 
@@ -29,11 +29,11 @@ impl Function {
         self.def_id
     }
 
-    pub fn syntax(&self, db: &impl HirDatabase) -> ast::FnDefNode {
+    pub fn syntax(&self, db: &impl HirDatabase) -> TreePtr<ast::FnDef> {
         let def_loc = self.def_id.loc(db);
         assert!(def_loc.kind == DefKind::Function);
         let syntax = db.file_item(def_loc.source_item_id);
-        ast::FnDef::cast(syntax.borrowed()).unwrap().owned()
+        ast::FnDef::cast(&syntax).unwrap().to_owned()
     }
 
     pub fn body(&self, db: &impl HirDatabase) -> Cancelable<Arc<Body>> {
@@ -59,7 +59,7 @@ impl Function {
 
     pub fn signature_info(&self, db: &impl HirDatabase) -> Option<FnSignatureInfo> {
         let syntax = self.syntax(db);
-        FnSignatureInfo::new(syntax.borrowed())
+        FnSignatureInfo::new(&syntax)
     }
 
     pub fn infer(&self, db: &impl HirDatabase) -> Cancelable<Arc<InferenceResult>> {
@@ -99,8 +99,7 @@ impl FnSignature {
 
 pub(crate) fn fn_signature(db: &impl HirDatabase, def_id: DefId) -> Arc<FnSignature> {
     let func = Function::new(def_id);
-    let syntax = func.syntax(db);
-    let node = syntax.borrowed();
+    let node = func.syntax(db);
     let mut args = Vec::new();
     if let Some(param_list) = node.param_list() {
         if let Some(self_param) = param_list.self_param() {
@@ -144,7 +143,7 @@ pub struct FnSignatureInfo {
 }
 
 impl FnSignatureInfo {
-    fn new(node: ast::FnDef) -> Option<Self> {
+    fn new(node: &ast::FnDef) -> Option<Self> {
         let name = node.name()?.text().to_string();
 
         let mut doc = None;
@@ -207,7 +206,7 @@ impl FnSignatureInfo {
         })
     }
 
-    fn extract_doc_comments(node: ast::FnDef) -> Option<(TextRange, String)> {
+    fn extract_doc_comments(node: &ast::FnDef) -> Option<(TextRange, String)> {
         if node.doc_comments().count() == 0 {
             return None;
         }
@@ -227,7 +226,7 @@ impl FnSignatureInfo {
         Some((range, comment_text))
     }
 
-    fn param_list(node: ast::FnDef) -> Vec<String> {
+    fn param_list(node: &ast::FnDef) -> Vec<String> {
         let mut res = vec![];
         if let Some(param_list) = node.param_list() {
             if let Some(self_param) = param_list.self_param() {
diff --git a/crates/ra_hir/src/function/scope.rs b/crates/ra_hir/src/function/scope.rs
index 0a12f0b35..699784f71 100644
--- a/crates/ra_hir/src/function/scope.rs
+++ b/crates/ra_hir/src/function/scope.rs
@@ -3,7 +3,7 @@ use std::sync::Arc;
 use rustc_hash::{FxHashMap, FxHashSet};
 
 use ra_syntax::{
-    AstNode, SyntaxNodeRef, TextUnit, TextRange,
+    AstNode, SyntaxNode, TextUnit, TextRange,
     algo::generate,
     ast,
 };
@@ -127,7 +127,7 @@ impl ScopeEntryWithSyntax {
 }
 
 impl ScopesWithSyntaxMapping {
-    pub fn scope_chain<'a>(&'a self, node: SyntaxNodeRef) -> impl Iterator<Item = ScopeId> + 'a {
+    pub fn scope_chain<'a>(&'a self, node: &SyntaxNode) -> impl Iterator<Item = ScopeId> + 'a {
         generate(self.scope_for(node), move |&scope| {
             self.scopes.scopes[scope].parent
         })
@@ -178,7 +178,7 @@ impl ScopesWithSyntaxMapping {
             .unwrap_or(original_scope)
     }
 
-    pub fn resolve_local_name(&self, name_ref: ast::NameRef) -> Option<ScopeEntryWithSyntax> {
+    pub fn resolve_local_name(&self, name_ref: &ast::NameRef) -> Option<ScopeEntryWithSyntax> {
         let mut shadowed = FxHashSet::default();
         let name = name_ref.as_name();
         let ret = self
@@ -195,7 +195,7 @@ impl ScopesWithSyntaxMapping {
         })
     }
 
-    pub fn find_all_refs(&self, pat: ast::BindPat) -> Vec<ReferenceDescriptor> {
+    pub fn find_all_refs(&self, pat: &ast::BindPat) -> Vec<ReferenceDescriptor> {
         let fn_def = pat.syntax().ancestors().find_map(ast::FnDef::cast).unwrap();
         let name_ptr = LocalSyntaxPtr::new(pat.syntax());
         fn_def
@@ -213,7 +213,7 @@ impl ScopesWithSyntaxMapping {
             .collect()
     }
 
-    fn scope_for(&self, node: SyntaxNodeRef) -> Option<ScopeId> {
+    fn scope_for(&self, node: &SyntaxNode) -> Option<ScopeId> {
         node.ancestors()
             .map(LocalSyntaxPtr::new)
             .filter_map(|ptr| self.syntax_mapping.syntax_expr(ptr))
@@ -309,7 +309,7 @@ pub struct ReferenceDescriptor {
 #[cfg(test)]
 mod tests {
     use ra_editor::find_node_at_offset;
-    use ra_syntax::SourceFileNode;
+    use ra_syntax::SourceFile;
     use test_utils::{extract_offset, assert_eq_text};
 
     use crate::expr;
@@ -326,9 +326,9 @@ mod tests {
             buf.push_str(&code[off..]);
             buf
         };
-        let file = SourceFileNode::parse(&code);
-        let marker: ast::PathExpr = find_node_at_offset(file.syntax(), off).unwrap();
-        let fn_def: ast::FnDef = find_node_at_offset(file.syntax(), off).unwrap();
+        let file = SourceFile::parse(&code);
+        let marker: &ast::PathExpr = find_node_at_offset(file.syntax(), off).unwrap();
+        let fn_def: &ast::FnDef = find_node_at_offset(file.syntax(), off).unwrap();
         let body_hir = expr::collect_fn_body_syntax(fn_def);
         let scopes = FnScopes::new(Arc::clone(body_hir.body()));
         let scopes = ScopesWithSyntaxMapping {
@@ -422,9 +422,9 @@ mod tests {
 
     fn do_check_local_name(code: &str, expected_offset: u32) {
         let (off, code) = extract_offset(code);
-        let file = SourceFileNode::parse(&code);
-        let fn_def: ast::FnDef = find_node_at_offset(file.syntax(), off).unwrap();
-        let name_ref: ast::NameRef = find_node_at_offset(file.syntax(), off).unwrap();
+        let file = SourceFile::parse(&code);
+        let fn_def: &ast::FnDef = find_node_at_offset(file.syntax(), off).unwrap();
+        let name_ref: &ast::NameRef = find_node_at_offset(file.syntax(), off).unwrap();
 
         let body_hir = expr::collect_fn_body_syntax(fn_def);
         let scopes = FnScopes::new(Arc::clone(body_hir.body()));
diff --git a/crates/ra_hir/src/ids.rs b/crates/ra_hir/src/ids.rs
index c7391ee05..730a3e542 100644
--- a/crates/ra_hir/src/ids.rs
+++ b/crates/ra_hir/src/ids.rs
@@ -1,5 +1,5 @@
 use ra_db::{SourceRootId, LocationIntener, Cancelable, FileId};
-use ra_syntax::{SourceFileNode, SyntaxKind, SyntaxNode, SyntaxNodeRef, SourceFile, AstNode, ast};
+use ra_syntax::{TreePtr, SyntaxKind, SyntaxNode, SourceFile, AstNode, ast};
 use ra_arena::{Arena, RawId, impl_arena_id};
 
 use crate::{HirDatabase, PerNs, ModuleId, Def, Function, Struct, Enum, ImplBlock, Crate};
@@ -55,7 +55,10 @@ impl HirFileId {
         }
     }
 
-    pub(crate) fn hir_source_file(db: &impl HirDatabase, file_id: HirFileId) -> SourceFileNode {
+    pub(crate) fn hir_source_file(
+        db: &impl HirDatabase,
+        file_id: HirFileId,
+    ) -> TreePtr<SourceFile> {
         match file_id.0 {
             HirFileIdRepr::File(file_id) => db.source_file(file_id),
             HirFileIdRepr::Macro(m) => {
@@ -63,7 +66,7 @@ impl HirFileId {
                     return exp.file();
                 }
                 // returning an empty string looks fishy...
-                SourceFileNode::parse("")
+                SourceFile::parse("")
             }
         }
     }
@@ -233,11 +236,11 @@ pub struct SourceItemId {
 #[derive(Debug, PartialEq, Eq)]
 pub struct SourceFileItems {
     file_id: HirFileId,
-    arena: Arena<SourceFileItemId, SyntaxNode>,
+    arena: Arena<SourceFileItemId, TreePtr<SyntaxNode>>,
 }
 
 impl SourceFileItems {
-    pub(crate) fn new(file_id: HirFileId, source_file: SourceFile) -> SourceFileItems {
+    pub(crate) fn new(file_id: HirFileId, source_file: &SourceFile) -> SourceFileItems {
         let mut res = SourceFileItems {
             file_id,
             arena: Arena::default(),
@@ -246,20 +249,20 @@ impl SourceFileItems {
         res
     }
 
-    fn init(&mut self, source_file: SourceFile) {
+    fn init(&mut self, source_file: &SourceFile) {
         source_file.syntax().descendants().for_each(|it| {
             if let Some(module_item) = ast::ModuleItem::cast(it) {
-                self.alloc(module_item.syntax().owned());
+                self.alloc(module_item.syntax().to_owned());
             } else if let Some(macro_call) = ast::MacroCall::cast(it) {
-                self.alloc(macro_call.syntax().owned());
+                self.alloc(macro_call.syntax().to_owned());
             }
         });
     }
 
-    fn alloc(&mut self, item: SyntaxNode) -> SourceFileItemId {
+    fn alloc(&mut self, item: TreePtr<SyntaxNode>) -> SourceFileItemId {
         self.arena.alloc(item)
     }
-    pub(crate) fn id_of(&self, file_id: HirFileId, item: SyntaxNodeRef) -> SourceFileItemId {
+    pub(crate) fn id_of(&self, file_id: HirFileId, item: &SyntaxNode) -> SourceFileItemId {
         assert_eq!(
             self.file_id, file_id,
             "SourceFileItems: wrong file, expected {:?}, got {:?}",
@@ -267,8 +270,8 @@ impl SourceFileItems {
         );
         self.id_of_unchecked(item)
     }
-    pub(crate) fn id_of_unchecked(&self, item: SyntaxNodeRef) -> SourceFileItemId {
-        if let Some((id, _)) = self.arena.iter().find(|(_id, i)| i.borrowed() == item) {
+    pub(crate) fn id_of_unchecked(&self, item: &SyntaxNode) -> SourceFileItemId {
+        if let Some((id, _)) = self.arena.iter().find(|(_id, i)| *i == item) {
             return id;
         }
         // This should not happen. Let's try to give a sensible diagnostics.
diff --git a/crates/ra_hir/src/impl_block.rs b/crates/ra_hir/src/impl_block.rs
index 7ce8d17e6..bb0ad84e4 100644
--- a/crates/ra_hir/src/impl_block.rs
+++ b/crates/ra_hir/src/impl_block.rs
@@ -62,7 +62,7 @@ impl ImplData {
         db: &impl AsRef<LocationIntener<DefLoc, DefId>>,
         file_items: &SourceFileItems,
         module: &Module,
-        node: ast::ImplBlock,
+        node: &ast::ImplBlock,
     ) -> Self {
         let target_trait = node.target_type().map(TypeRef::from_ast);
         let target_type = TypeRef::from_ast_opt(node.target_type());
@@ -71,10 +71,10 @@ impl ImplData {
             item_list
                 .impl_items()
                 .map(|item_node| {
-                    let kind = match item_node {
-                        ast::ImplItem::FnDef(..) => DefKind::Function,
-                        ast::ImplItem::ConstDef(..) => DefKind::Item,
-                        ast::ImplItem::TypeDef(..) => DefKind::Item,
+                    let kind = match item_node.kind() {
+                        ast::ImplItemKind::FnDef(..) => DefKind::Function,
+                        ast::ImplItemKind::ConstDef(..) => DefKind::Item,
+                        ast::ImplItemKind::TypeDef(..) => DefKind::Item,
                     };
                     let item_id = file_items.id_of_unchecked(item_node.syntax());
                     let source_item_id = SourceItemId {
@@ -87,10 +87,10 @@ impl ImplData {
                         ..module_loc
                     };
                     let def_id = def_loc.id(db);
-                    match item_node {
-                        ast::ImplItem::FnDef(..) => ImplItem::Method(Function::new(def_id)),
-                        ast::ImplItem::ConstDef(..) => ImplItem::Const(def_id),
-                        ast::ImplItem::TypeDef(..) => ImplItem::Type(def_id),
+                    match item_node.kind() {
+                        ast::ImplItemKind::FnDef(..) => ImplItem::Method(Function::new(def_id)),
+                        ast::ImplItemKind::ConstDef(..) => ImplItem::Const(def_id),
+                        ast::ImplItemKind::TypeDef(..) => ImplItem::Type(def_id),
                     }
                 })
                 .collect()
@@ -152,8 +152,8 @@ impl ModuleImplBlocks {
     fn collect(&mut self, db: &impl HirDatabase, module: Module) -> Cancelable<()> {
         let (file_id, module_source) = module.defenition_source(db)?;
         let node = match &module_source {
-            ModuleSource::SourceFile(node) => node.borrowed().syntax(),
-            ModuleSource::Module(node) => node.borrowed().syntax(),
+            ModuleSource::SourceFile(node) => node.syntax(),
+            ModuleSource::Module(node) => node.syntax(),
         };
 
         let source_file_items = db.file_items(file_id.into());
diff --git a/crates/ra_hir/src/macros.rs b/crates/ra_hir/src/macros.rs
index 1b378c977..eb1c86091 100644
--- a/crates/ra_hir/src/macros.rs
+++ b/crates/ra_hir/src/macros.rs
@@ -11,7 +11,7 @@ use std::sync::Arc;
 
 use ra_db::LocalSyntaxPtr;
 use ra_syntax::{
-    TextRange, TextUnit, SourceFileNode, AstNode, SyntaxNode,
+    TextRange, TextUnit, SourceFile, AstNode, SyntaxNode, TreePtr,
     ast::{self, NameOwner},
 };
 
@@ -28,14 +28,14 @@ pub enum MacroDef {
 impl MacroDef {
     /// Expands macro call, returning the expansion and offset to be used to
     /// convert ranges between expansion and original source.
-    pub fn ast_expand(macro_call: ast::MacroCall) -> Option<(TextUnit, MacroExpansion)> {
+    pub fn ast_expand(macro_call: &ast::MacroCall) -> Option<(TextUnit, MacroExpansion)> {
         let (def, input) = MacroDef::from_call(macro_call)?;
         let exp = def.expand(input)?;
         let off = macro_call.token_tree()?.syntax().range().start();
         Some((off, exp))
     }
 
-    fn from_call(macro_call: ast::MacroCall) -> Option<(MacroDef, MacroInput)> {
+    fn from_call(macro_call: &ast::MacroCall) -> Option<(MacroDef, MacroInput)> {
         let def = {
             let path = macro_call.path()?;
             let name_ref = path.segment()?.name_ref()?;
@@ -77,7 +77,7 @@ impl MacroDef {
                 }}",
             input.text
         );
-        let file = SourceFileNode::parse(&text);
+        let file = SourceFile::parse(&text);
         let match_expr = file.syntax().descendants().find_map(ast::MatchExpr::cast)?;
         let match_arg = match_expr.expr()?;
         let ptr = LocalSyntaxPtr::new(match_arg.syntax());
@@ -92,7 +92,7 @@ impl MacroDef {
     }
     fn expand_vec(self, input: MacroInput) -> Option<MacroExpansion> {
         let text = format!(r"fn dummy() {{ {}; }}", input.text);
-        let file = SourceFileNode::parse(&text);
+        let file = SourceFile::parse(&text);
         let array_expr = file.syntax().descendants().find_map(ast::ArrayExpr::cast)?;
         let ptr = LocalSyntaxPtr::new(array_expr.syntax());
         let src_range = TextRange::offset_len(0.into(), TextUnit::of_str(&input.text));
@@ -116,7 +116,7 @@ impl MacroDef {
         }
         let src_range = TextRange::offset_len((pos as u32).into(), TextUnit::of_str(&trait_name));
         let text = format!(r"trait {} {{ }}", trait_name);
-        let file = SourceFileNode::parse(&text);
+        let file = SourceFile::parse(&text);
         let trait_def = file.syntax().descendants().find_map(ast::TraitDef::cast)?;
         let name = trait_def.name()?;
         let ptr = LocalSyntaxPtr::new(trait_def.syntax());
@@ -152,11 +152,11 @@ pub struct MacroExpansion {
 impl MacroExpansion {
     // FIXME: does not really make sense, macro expansion is not neccessary a
     // whole file. See `MacroExpansion::ptr` as well.
-    pub(crate) fn file(&self) -> SourceFileNode {
-        SourceFileNode::parse(&self.text)
+    pub(crate) fn file(&self) -> TreePtr<SourceFile> {
+        SourceFile::parse(&self.text)
     }
 
-    pub fn syntax(&self) -> SyntaxNode {
+    pub fn syntax(&self) -> TreePtr<SyntaxNode> {
         self.ptr.resolve(&self.file())
     }
     /// Maps range in the source code to the range in the expanded code.
@@ -191,8 +191,7 @@ pub(crate) fn expand_macro_invocation(
 ) -> Option<Arc<MacroExpansion>> {
     let loc = invoc.loc(db);
     let syntax = db.file_item(loc.source_item_id);
-    let syntax = syntax.borrowed();
-    let macro_call = ast::MacroCall::cast(syntax).unwrap();
+    let macro_call = ast::MacroCall::cast(&syntax).unwrap();
 
     let (def, input) = MacroDef::from_call(macro_call)?;
     def.expand(input).map(Arc::new)
diff --git a/crates/ra_hir/src/module_tree.rs b/crates/ra_hir/src/module_tree.rs
index c7a442319..91aab5c74 100644
--- a/crates/ra_hir/src/module_tree.rs
+++ b/crates/ra_hir/src/module_tree.rs
@@ -5,9 +5,9 @@ use arrayvec::ArrayVec;
 use relative_path::RelativePathBuf;
 use ra_db::{FileId, SourceRootId, Cancelable, SourceRoot};
 use ra_syntax::{
+    SyntaxNode, TreePtr,
     algo::generate,
     ast::{self, AstNode, NameOwner},
-    SyntaxNode,
 };
 use ra_arena::{Arena, RawId, impl_arena_id};
 
@@ -19,12 +19,11 @@ impl ModuleSource {
         source_item_id: SourceItemId,
     ) -> ModuleSource {
         let module_syntax = db.file_item(source_item_id);
-        let module_syntax = module_syntax.borrowed();
-        if let Some(source_file) = ast::SourceFile::cast(module_syntax) {
-            ModuleSource::SourceFile(source_file.owned())
-        } else if let Some(module) = ast::Module::cast(module_syntax) {
+        if let Some(source_file) = ast::SourceFile::cast(&module_syntax) {
+            ModuleSource::SourceFile(source_file.to_owned())
+        } else if let Some(module) = ast::Module::cast(&module_syntax) {
             assert!(module.item_list().is_some(), "expected inline module");
-            ModuleSource::Module(module.owned())
+            ModuleSource::Module(module.to_owned())
         } else {
             panic!("expected file or inline module")
         }
@@ -49,19 +48,18 @@ impl Submodule {
         let module_source = ModuleSource::from_source_item_id(db, source);
         let submodules = match module_source {
             ModuleSource::SourceFile(source_file) => {
-                collect_submodules(file_id, &file_items, source_file.borrowed())
+                collect_submodules(file_id, &file_items, &*source_file)
             }
             ModuleSource::Module(module) => {
-                let module = module.borrowed();
                 collect_submodules(file_id, &file_items, module.item_list().unwrap())
             }
         };
         return Ok(Arc::new(submodules));
 
-        fn collect_submodules<'a>(
+        fn collect_submodules(
             file_id: HirFileId,
             file_items: &SourceFileItems,
-            root: impl ast::ModuleItemOwner<'a>,
+            root: &impl ast::ModuleItemOwner,
         ) -> Vec<Submodule> {
             modules(root)
                 .map(|(name, m)| Submodule {
@@ -120,8 +118,8 @@ impl ModuleTree {
         source_root: SourceRootId,
     ) -> Cancelable<Arc<ModuleTree>> {
         db.check_canceled()?;
-        let res = create_module_tree(db, source_root)?;
-        Ok(Arc::new(res))
+        let res = create_module_tree(db, source_root);
+        Ok(Arc::new(res?))
     }
 
     pub(crate) fn modules<'a>(&'a self) -> impl Iterator<Item = ModuleId> + 'a {
@@ -172,14 +170,14 @@ impl ModuleId {
         self,
         tree: &ModuleTree,
         db: &impl HirDatabase,
-    ) -> Vec<(SyntaxNode, Problem)> {
+    ) -> Vec<(TreePtr<SyntaxNode>, Problem)> {
         tree.mods[self]
             .children
             .iter()
             .filter_map(|&link| {
                 let p = tree.links[link].problem.clone()?;
                 let s = link.source(tree, db);
-                let s = s.borrowed().name().unwrap().syntax().owned();
+                let s = s.name().unwrap().syntax().to_owned();
                 Some((s, p))
             })
             .collect()
@@ -193,11 +191,9 @@ impl LinkId {
     pub(crate) fn name(self, tree: &ModuleTree) -> &Name {
         &tree.links[self].name
     }
-    pub(crate) fn source(self, tree: &ModuleTree, db: &impl HirDatabase) -> ast::ModuleNode {
+    pub(crate) fn source(self, tree: &ModuleTree, db: &impl HirDatabase) -> TreePtr<ast::Module> {
         let syntax_node = db.file_item(tree.links[self].source);
-        ast::ModuleNode::cast(syntax_node.borrowed())
-            .unwrap()
-            .owned()
+        ast::Module::cast(&syntax_node).unwrap().to_owned()
     }
 }
 
@@ -213,12 +209,10 @@ impl ModuleTree {
     }
 }
 
-fn modules<'a>(
-    root: impl ast::ModuleItemOwner<'a>,
-) -> impl Iterator<Item = (Name, ast::Module<'a>)> {
+fn modules(root: &impl ast::ModuleItemOwner) -> impl Iterator<Item = (Name, &ast::Module)> {
     root.items()
-        .filter_map(|item| match item {
-            ast::ModuleItem::Module(m) => Some(m),
+        .filter_map(|item| match item.kind() {
+            ast::ModuleItemKind::Module(m) => Some(m),
             _ => None,
         })
         .filter_map(|module| {
diff --git a/crates/ra_hir/src/name.rs b/crates/ra_hir/src/name.rs
index 599285346..dee1c9c5c 100644
--- a/crates/ra_hir/src/name.rs
+++ b/crates/ra_hir/src/name.rs
@@ -74,13 +74,13 @@ pub(crate) trait AsName {
     fn as_name(&self) -> Name;
 }
 
-impl AsName for ast::NameRef<'_> {
+impl AsName for ast::NameRef {
     fn as_name(&self) -> Name {
         Name::new(self.text())
     }
 }
 
-impl AsName for ast::Name<'_> {
+impl AsName for ast::Name {
     fn as_name(&self) -> Name {
         Name::new(self.text())
     }
diff --git a/crates/ra_hir/src/nameres.rs b/crates/ra_hir/src/nameres.rs
index 9a412bc82..749fd604e 100644
--- a/crates/ra_hir/src/nameres.rs
+++ b/crates/ra_hir/src/nameres.rs
@@ -103,7 +103,7 @@ impl NamedImport {
             item_id: Some(self.file_item_id),
         };
         let syntax = db.file_item(source_item_id);
-        let offset = syntax.borrowed().range().start();
+        let offset = syntax.range().start();
         self.relative_range + offset
     }
 }
@@ -215,45 +215,45 @@ impl InputModuleItems {
         &mut self,
         file_id: HirFileId,
         file_items: &SourceFileItems,
-        item: ast::ModuleItem,
+        item: &ast::ModuleItem,
     ) -> Option<()> {
-        match item {
-            ast::ModuleItem::StructDef(it) => {
+        match item.kind() {
+            ast::ModuleItemKind::StructDef(it) => {
                 self.items.push(ModuleItem::new(file_id, file_items, it)?)
             }
-            ast::ModuleItem::EnumDef(it) => {
+            ast::ModuleItemKind::EnumDef(it) => {
                 self.items.push(ModuleItem::new(file_id, file_items, it)?)
             }
-            ast::ModuleItem::FnDef(it) => {
+            ast::ModuleItemKind::FnDef(it) => {
                 self.items.push(ModuleItem::new(file_id, file_items, it)?)
             }
-            ast::ModuleItem::TraitDef(it) => {
+            ast::ModuleItemKind::TraitDef(it) => {
                 self.items.push(ModuleItem::new(file_id, file_items, it)?)
             }
-            ast::ModuleItem::TypeDef(it) => {
+            ast::ModuleItemKind::TypeDef(it) => {
                 self.items.push(ModuleItem::new(file_id, file_items, it)?)
             }
-            ast::ModuleItem::ImplBlock(_) => {
+            ast::ModuleItemKind::ImplBlock(_) => {
                 // impls don't define items
             }
-            ast::ModuleItem::UseItem(it) => self.add_use_item(file_items, it),
-            ast::ModuleItem::ExternCrateItem(_) => {
+            ast::ModuleItemKind::UseItem(it) => self.add_use_item(file_items, it),
+            ast::ModuleItemKind::ExternCrateItem(_) => {
                 // TODO
             }
-            ast::ModuleItem::ConstDef(it) => {
+            ast::ModuleItemKind::ConstDef(it) => {
                 self.items.push(ModuleItem::new(file_id, file_items, it)?)
             }
-            ast::ModuleItem::StaticDef(it) => {
+            ast::ModuleItemKind::StaticDef(it) => {
                 self.items.push(ModuleItem::new(file_id, file_items, it)?)
             }
-            ast::ModuleItem::Module(it) => {
+            ast::ModuleItemKind::Module(it) => {
                 self.items.push(ModuleItem::new(file_id, file_items, it)?)
             }
         }
         Some(())
     }
 
-    fn add_use_item(&mut self, file_items: &SourceFileItems, item: ast::UseItem) {
+    fn add_use_item(&mut self, file_items: &SourceFileItems, item: &ast::UseItem) {
         let file_item_id = file_items.id_of_unchecked(item.syntax());
         let start_offset = item.syntax().range().start();
         Path::expand_use_item(item, |path, range| {
@@ -270,10 +270,10 @@ impl InputModuleItems {
 }
 
 impl ModuleItem {
-    fn new<'a>(
+    fn new(
         file_id: HirFileId,
         file_items: &SourceFileItems,
-        item: impl ast::NameOwner<'a>,
+        item: &impl ast::NameOwner,
     ) -> Option<ModuleItem> {
         let name = item.name()?.as_name();
         let kind = item.syntax().kind();
diff --git a/crates/ra_hir/src/path.rs b/crates/ra_hir/src/path.rs
index dcf4cf8b6..6f0b0da97 100644
--- a/crates/ra_hir/src/path.rs
+++ b/crates/ra_hir/src/path.rs
@@ -18,14 +18,14 @@ pub enum PathKind {
 
 impl Path {
     /// Calls `cb` with all paths, represented by this use item.
-    pub fn expand_use_item(item: ast::UseItem, mut cb: impl FnMut(Path, Option<TextRange>)) {
+    pub fn expand_use_item(item: &ast::UseItem, mut cb: impl FnMut(Path, Option<TextRange>)) {
         if let Some(tree) = item.use_tree() {
             expand_use_tree(None, tree, &mut cb);
         }
     }
 
     /// Converts an `ast::Path` to `Path`. Works with use trees.
-    pub fn from_ast(mut path: ast::Path) -> Option<Path> {
+    pub fn from_ast(mut path: &ast::Path) -> Option<Path> {
         let mut kind = PathKind::Plain;
         let mut segments = Vec::new();
         loop {
@@ -53,7 +53,7 @@ impl Path {
         segments.reverse();
         return Some(Path { kind, segments });
 
-        fn qualifier(path: ast::Path) -> Option<ast::Path> {
+        fn qualifier(path: &ast::Path) -> Option<&ast::Path> {
             if let Some(q) = path.qualifier() {
                 return Some(q);
             }
@@ -66,7 +66,7 @@ impl Path {
     }
 
     /// Converts an `ast::NameRef` into a single-identifier `Path`.
-    pub fn from_name_ref(name_ref: ast::NameRef) -> Path {
+    pub fn from_name_ref(name_ref: &ast::NameRef) -> Path {
         name_ref.as_name().into()
     }
 
@@ -100,7 +100,7 @@ impl From<Name> for Path {
 
 fn expand_use_tree(
     prefix: Option<Path>,
-    tree: ast::UseTree,
+    tree: &ast::UseTree,
     cb: &mut impl FnMut(Path, Option<TextRange>),
 ) {
     if let Some(use_tree_list) = tree.use_tree_list() {
@@ -146,7 +146,7 @@ fn expand_use_tree(
     }
 }
 
-fn convert_path(prefix: Option<Path>, path: ast::Path) -> Option<Path> {
+fn convert_path(prefix: Option<Path>, path: &ast::Path) -> Option<Path> {
     let prefix = if let Some(qual) = path.qualifier() {
         Some(convert_path(prefix, qual)?)
     } else {
diff --git a/crates/ra_hir/src/query_definitions.rs b/crates/ra_hir/src/query_definitions.rs
index 8f2c40669..380ea5410 100644
--- a/crates/ra_hir/src/query_definitions.rs
+++ b/crates/ra_hir/src/query_definitions.rs
@@ -5,7 +5,7 @@ use std::{
 
 use rustc_hash::FxHashMap;
 use ra_syntax::{
-    AstNode, SyntaxNode,
+    AstNode, SyntaxNode, TreePtr,
     ast::{self, ModuleItemOwner}
 };
 use ra_db::{SourceRootId, Cancelable,};
@@ -31,30 +31,34 @@ pub(super) fn struct_data(db: &impl HirDatabase, def_id: DefId) -> Cancelable<Ar
     assert!(def_loc.kind == DefKind::Struct);
     let syntax = db.file_item(def_loc.source_item_id);
     let struct_def =
-        ast::StructDef::cast(syntax.borrowed()).expect("struct def should point to StructDef node");
-    Ok(Arc::new(StructData::new(struct_def.borrowed())))
+        ast::StructDef::cast(&syntax).expect("struct def should point to StructDef node");
+    Ok(Arc::new(StructData::new(struct_def)))
 }
 
 pub(super) fn enum_data(db: &impl HirDatabase, def_id: DefId) -> Cancelable<Arc<EnumData>> {
     let def_loc = def_id.loc(db);
     assert!(def_loc.kind == DefKind::Enum);
     let syntax = db.file_item(def_loc.source_item_id);
-    let enum_def =
-        ast::EnumDef::cast(syntax.borrowed()).expect("enum def should point to EnumDef node");
-    Ok(Arc::new(EnumData::new(enum_def.borrowed())))
+    let enum_def = ast::EnumDef::cast(&syntax).expect("enum def should point to EnumDef node");
+    Ok(Arc::new(EnumData::new(enum_def)))
 }
 
 pub(super) fn file_items(db: &impl HirDatabase, file_id: HirFileId) -> Arc<SourceFileItems> {
     let source_file = db.hir_source_file(file_id);
-    let source_file = source_file.borrowed();
-    let res = SourceFileItems::new(file_id, source_file);
+    let res = SourceFileItems::new(file_id, &source_file);
     Arc::new(res)
 }
 
-pub(super) fn file_item(db: &impl HirDatabase, source_item_id: SourceItemId) -> SyntaxNode {
+pub(super) fn file_item(
+    db: &impl HirDatabase,
+    source_item_id: SourceItemId,
+) -> TreePtr<SyntaxNode> {
     match source_item_id.item_id {
-        Some(id) => db.file_items(source_item_id.file_id)[id].clone(),
-        None => db.hir_source_file(source_item_id.file_id).syntax().owned(),
+        Some(id) => db.file_items(source_item_id.file_id)[id].to_owned(),
+        None => db
+            .hir_source_file(source_item_id.file_id)
+            .syntax()
+            .to_owned(),
     }
 }
 
@@ -88,7 +92,7 @@ pub(super) fn input_module_items(
                     let file_id = HirFileId::from(id);
                     let file_items = db.file_items(file_id);
                     //FIXME: expand recursively
-                    for item in db.hir_source_file(file_id).borrowed().items() {
+                    for item in db.hir_source_file(file_id).items() {
                         acc.add_item(file_id, &file_items, item);
                     }
                 }
@@ -98,9 +102,9 @@ pub(super) fn input_module_items(
 
     let mut res = InputModuleItems::default();
     match source {
-        ModuleSource::SourceFile(it) => fill(&mut res, &mut it.borrowed().items_with_macros()),
+        ModuleSource::SourceFile(it) => fill(&mut res, &mut it.items_with_macros()),
         ModuleSource::Module(it) => {
-            if let Some(item_list) = it.borrowed().item_list() {
+            if let Some(item_list) = it.item_list() {
                 fill(&mut res, &mut item_list.items_with_macros())
             }
         }
diff --git a/crates/ra_hir/src/source_binder.rs b/crates/ra_hir/src/source_binder.rs
index 4c14650c0..82675c0e4 100644
--- a/crates/ra_hir/src/source_binder.rs
+++ b/crates/ra_hir/src/source_binder.rs
@@ -8,7 +8,7 @@
 use ra_db::{FileId, FilePosition, Cancelable};
 use ra_editor::find_node_at_offset;
 use ra_syntax::{
-    SmolStr, TextRange, SyntaxNodeRef,
+    SmolStr, TextRange, SyntaxNode,
     ast::{self, AstNode, NameOwner},
 };
 
@@ -30,7 +30,7 @@ pub fn module_from_file_id(db: &impl HirDatabase, file_id: FileId) -> Cancelable
 pub fn module_from_declaration(
     db: &impl HirDatabase,
     file_id: FileId,
-    decl: ast::Module,
+    decl: &ast::Module,
 ) -> Cancelable<Option<Module>> {
     let parent_module = module_from_file_id(db, file_id)?;
     let child_name = decl.name();
@@ -60,7 +60,7 @@ pub fn module_from_position(
 fn module_from_inline(
     db: &impl HirDatabase,
     file_id: FileId,
-    module: ast::Module,
+    module: &ast::Module,
 ) -> Cancelable<Option<Module>> {
     assert!(!module.has_semi());
     let file_id = file_id.into();
@@ -77,7 +77,7 @@ fn module_from_inline(
 pub fn module_from_child_node(
     db: &impl HirDatabase,
     file_id: FileId,
-    child: SyntaxNodeRef,
+    child: &SyntaxNode,
 ) -> Cancelable<Option<Module>> {
     if let Some(m) = child
         .ancestors()
@@ -112,7 +112,7 @@ pub fn function_from_position(
 pub fn function_from_source(
     db: &impl HirDatabase,
     file_id: FileId,
-    fn_def: ast::FnDef,
+    fn_def: &ast::FnDef,
 ) -> Cancelable<Option<Function>> {
     let module = ctry!(module_from_child_node(db, file_id, fn_def.syntax())?);
     let res = function_from_module(db, &module, fn_def);
@@ -122,7 +122,7 @@ pub fn function_from_source(
 pub fn function_from_module(
     db: &impl HirDatabase,
     module: &Module,
-    fn_def: ast::FnDef,
+    fn_def: &ast::FnDef,
 ) -> Function {
     let loc = module.def_id.loc(db);
     let file_id = loc.source_item_id.file_id;
@@ -144,7 +144,7 @@ pub fn function_from_module(
 pub fn function_from_child_node(
     db: &impl HirDatabase,
     file_id: FileId,
-    node: SyntaxNodeRef,
+    node: &SyntaxNode,
 ) -> Cancelable<Option<Function>> {
     let fn_def = ctry!(node.ancestors().find_map(ast::FnDef::cast));
     function_from_source(db, file_id, fn_def)
@@ -170,8 +170,7 @@ pub fn macro_symbols(
         if let Some(exp) = db.expand_macro_invocation(macro_call_id) {
             let loc = macro_call_id.loc(db);
             let syntax = db.file_item(loc.source_item_id);
-            let syntax = syntax.borrowed();
-            let macro_call = ast::MacroCall::cast(syntax).unwrap();
+            let macro_call = ast::MacroCall::cast(&syntax).unwrap();
             let off = macro_call.token_tree().unwrap().syntax().range().start();
             let file = exp.file();
             for trait_def in file.syntax().descendants().filter_map(ast::TraitDef::cast) {
diff --git a/crates/ra_hir/src/type_ref.rs b/crates/ra_hir/src/type_ref.rs
index 859f330c2..c9db4e0a5 100644
--- a/crates/ra_hir/src/type_ref.rs
+++ b/crates/ra_hir/src/type_ref.rs
@@ -56,9 +56,9 @@ pub enum TypeRef {
 
 impl TypeRef {
     /// Converts an `ast::TypeRef` to a `hir::TypeRef`.
-    pub(crate) fn from_ast(node: ast::TypeRef) -> Self {
-        use ra_syntax::ast::TypeRef::*;
-        match node {
+    pub(crate) fn from_ast(node: &ast::TypeRef) -> Self {
+        use ra_syntax::ast::TypeRefKind::*;
+        match node.kind() {
             ParenType(inner) => TypeRef::from_ast_opt(inner.type_ref()),
             TupleType(inner) => TypeRef::Tuple(inner.fields().map(TypeRef::from_ast).collect()),
             NeverType(..) => TypeRef::Never,
@@ -100,7 +100,7 @@ impl TypeRef {
         }
     }
 
-    pub(crate) fn from_ast_opt(node: Option<ast::TypeRef>) -> Self {
+    pub(crate) fn from_ast_opt(node: Option<&ast::TypeRef>) -> Self {
         if let Some(node) = node {
             TypeRef::from_ast(node)
         } else {
diff --git a/crates/ra_lsp_server/src/main_loop/handlers.rs b/crates/ra_lsp_server/src/main_loop/handlers.rs
index 51f134e8a..99f15354f 100644
--- a/crates/ra_lsp_server/src/main_loop/handlers.rs
+++ b/crates/ra_lsp_server/src/main_loop/handlers.rs
@@ -11,7 +11,7 @@ use languageserver_types::{
 use ra_analysis::{
     FileId, FilePosition, FileRange, FoldKind, Query, RunnableKind, Severity, SourceChange,
 };
-use ra_syntax::{text_utils::intersect, TextUnit};
+use ra_syntax::{text_utils::intersect, TextUnit, AstNode};
 use ra_text_edit::text_utils::contains_offset_nonstrict;
 use rustc_hash::FxHashMap;
 use serde_json::to_value;
diff --git a/crates/ra_syntax/Cargo.toml b/crates/ra_syntax/Cargo.toml
index fd6966d4a..eea0e251a 100644
--- a/crates/ra_syntax/Cargo.toml
+++ b/crates/ra_syntax/Cargo.toml
@@ -13,7 +13,7 @@ unicode-xid = "0.1.0"
 itertools = "0.8.0"
 drop_bomb = "0.1.4"
 parking_lot = "0.7.0"
-rowan = "0.1.2"
+rowan = "0.2.0"
 text_unit = "0.1.5"
 ra_text_edit = { path = "../ra_text_edit" }
 
diff --git a/crates/ra_syntax/src/algo.rs b/crates/ra_syntax/src/algo.rs
index 4b3548ea9..13f50d2ef 100644
--- a/crates/ra_syntax/src/algo.rs
+++ b/crates/ra_syntax/src/algo.rs
@@ -1,19 +1,23 @@
 pub mod visit;
 
-use crate::{SyntaxNode, SyntaxNodeRef, TextRange, TextUnit};
+use rowan::TransparentNewType;
+
+use crate::{SyntaxNode, TextRange, TextUnit};
 
 pub use rowan::LeafAtOffset;
 
-pub fn find_leaf_at_offset(node: SyntaxNodeRef, offset: TextUnit) -> LeafAtOffset<SyntaxNodeRef> {
+pub fn find_leaf_at_offset(node: &SyntaxNode, offset: TextUnit) -> LeafAtOffset<&SyntaxNode> {
     match node.0.leaf_at_offset(offset) {
         LeafAtOffset::None => LeafAtOffset::None,
-        LeafAtOffset::Single(n) => LeafAtOffset::Single(SyntaxNode(n)),
-        LeafAtOffset::Between(l, r) => LeafAtOffset::Between(SyntaxNode(l), SyntaxNode(r)),
+        LeafAtOffset::Single(n) => LeafAtOffset::Single(SyntaxNode::from_repr(n)),
+        LeafAtOffset::Between(l, r) => {
+            LeafAtOffset::Between(SyntaxNode::from_repr(l), SyntaxNode::from_repr(r))
+        }
     }
 }
 
-pub fn find_covering_node(root: SyntaxNodeRef, range: TextRange) -> SyntaxNodeRef {
-    SyntaxNode(root.0.covering_node(range))
+pub fn find_covering_node(root: &SyntaxNode, range: TextRange) -> &SyntaxNode {
+    SyntaxNode::from_repr(root.0.covering_node(range))
 }
 
 pub fn generate<T>(seed: Option<T>, step: impl Fn(&T) -> Option<T>) -> impl Iterator<Item = T> {
diff --git a/crates/ra_syntax/src/algo/visit.rs b/crates/ra_syntax/src/algo/visit.rs
index c021f464c..38f21594c 100644
--- a/crates/ra_syntax/src/algo/visit.rs
+++ b/crates/ra_syntax/src/algo/visit.rs
@@ -1,4 +1,4 @@
-use crate::{AstNode, SyntaxNodeRef};
+use crate::{AstNode, SyntaxNode};
 
 use std::marker::PhantomData;
 
@@ -15,11 +15,11 @@ pub fn visitor_ctx<'a, T, C>(ctx: C) -> impl VisitorCtx<'a, Output = T, Ctx = C>
 
 pub trait Visitor<'a>: Sized {
     type Output;
-    fn accept(self, node: SyntaxNodeRef<'a>) -> Option<Self::Output>;
+    fn accept(self, node: &'a SyntaxNode) -> Option<Self::Output>;
     fn visit<N, F>(self, f: F) -> Vis<Self, N, F>
     where
-        N: AstNode<'a>,
-        F: FnOnce(N) -> Self::Output,
+        N: AstNode + 'a,
+        F: FnOnce(&'a N) -> Self::Output,
     {
         Vis {
             inner: self,
@@ -32,11 +32,11 @@ pub trait Visitor<'a>: Sized {
 pub trait VisitorCtx<'a>: Sized {
     type Output;
     type Ctx;
-    fn accept(self, node: SyntaxNodeRef<'a>) -> Result<Self::Output, Self::Ctx>;
+    fn accept(self, node: &'a SyntaxNode) -> Result<Self::Output, Self::Ctx>;
     fn visit<N, F>(self, f: F) -> VisCtx<Self, N, F>
     where
-        N: AstNode<'a>,
-        F: FnOnce(N, Self::Ctx) -> Self::Output,
+        N: AstNode + 'a,
+        F: FnOnce(&'a N, Self::Ctx) -> Self::Output,
     {
         VisCtx {
             inner: self,
@@ -54,7 +54,7 @@ struct EmptyVisitor<T> {
 impl<'a, T> Visitor<'a> for EmptyVisitor<T> {
     type Output = T;
 
-    fn accept(self, _node: SyntaxNodeRef<'a>) -> Option<T> {
+    fn accept(self, _node: &'a SyntaxNode) -> Option<T> {
         None
     }
 }
@@ -69,7 +69,7 @@ impl<'a, T, C> VisitorCtx<'a> for EmptyVisitorCtx<T, C> {
     type Output = T;
     type Ctx = C;
 
-    fn accept(self, _node: SyntaxNodeRef<'a>) -> Result<T, C> {
+    fn accept(self, _node: &'a SyntaxNode) -> Result<T, C> {
         Err(self.ctx)
     }
 }
@@ -84,12 +84,12 @@ pub struct Vis<V, N, F> {
 impl<'a, V, N, F> Visitor<'a> for Vis<V, N, F>
 where
     V: Visitor<'a>,
-    N: AstNode<'a>,
-    F: FnOnce(N) -> <V as Visitor<'a>>::Output,
+    N: AstNode + 'a,
+    F: FnOnce(&'a N) -> <V as Visitor<'a>>::Output,
 {
     type Output = <V as Visitor<'a>>::Output;
 
-    fn accept(self, node: SyntaxNodeRef<'a>) -> Option<Self::Output> {
+    fn accept(self, node: &'a SyntaxNode) -> Option<Self::Output> {
         let Vis { inner, f, .. } = self;
         inner.accept(node).or_else(|| N::cast(node).map(f))
     }
@@ -105,13 +105,13 @@ pub struct VisCtx<V, N, F> {
 impl<'a, V, N, F> VisitorCtx<'a> for VisCtx<V, N, F>
 where
     V: VisitorCtx<'a>,
-    N: AstNode<'a>,
-    F: FnOnce(N, <V as VisitorCtx<'a>>::Ctx) -> <V as VisitorCtx<'a>>::Output,
+    N: AstNode + 'a,
+    F: FnOnce(&'a N, <V as VisitorCtx<'a>>::Ctx) -> <V as VisitorCtx<'a>>::Output,
 {
     type Output = <V as VisitorCtx<'a>>::Output;
     type Ctx = <V as VisitorCtx<'a>>::Ctx;
 
-    fn accept(self, node: SyntaxNodeRef<'a>) -> Result<Self::Output, Self::Ctx> {
+    fn accept(self, node: &'a SyntaxNode) -> Result<Self::Output, Self::Ctx> {
         let VisCtx { inner, f, .. } = self;
         inner.accept(node).or_else(|ctx| match N::cast(node) {
             None => Err(ctx),
diff --git a/crates/ra_syntax/src/ast.rs b/crates/ra_syntax/src/ast.rs
index 9ab59738f..0e303ee98 100644
--- a/crates/ra_syntax/src/ast.rs
+++ b/crates/ra_syntax/src/ast.rs
@@ -1,119 +1,115 @@
 mod generated;
 
 use std::marker::PhantomData;
-use std::string::String as RustString;
 
 use itertools::Itertools;
 
 pub use self::generated::*;
 use crate::{
-    yellow::{RefRoot, SyntaxNodeChildren},
+    yellow::{SyntaxNode, SyntaxNodeChildren, TreePtr, RaTypes},
     SmolStr,
     SyntaxKind::*,
-    SyntaxNodeRef,
 };
 
 /// The main trait to go from untyped `SyntaxNode`  to a typed ast. The
 /// conversion itself has zero runtime cost: ast and syntax nodes have exactly
 /// the same representation: a pointer to the tree root and a pointer to the
 /// node itself.
-pub trait AstNode<'a>: Clone + Copy + 'a {
-    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self>
+pub trait AstNode: rowan::TransparentNewType<Repr = rowan::SyntaxNode<RaTypes>> {
+    fn cast(syntax: &SyntaxNode) -> Option<&Self>
     where
         Self: Sized;
-    fn syntax(self) -> SyntaxNodeRef<'a>;
+    fn syntax(&self) -> &SyntaxNode;
+    fn to_owned(&self) -> TreePtr<Self>;
 }
 
-pub trait NameOwner<'a>: AstNode<'a> {
-    fn name(self) -> Option<Name<'a>> {
+pub trait NameOwner: AstNode {
+    fn name(&self) -> Option<&Name> {
         child_opt(self)
     }
 }
 
-pub trait VisibilityOwner<'a>: AstNode<'a> {
-    fn visibility(self) -> Option<Visibility<'a>> {
+pub trait VisibilityOwner: AstNode {
+    fn visibility(&self) -> Option<&Visibility> {
         child_opt(self)
     }
 }
 
-pub trait LoopBodyOwner<'a>: AstNode<'a> {
-    fn loop_body(self) -> Option<Block<'a>> {
+pub trait LoopBodyOwner: AstNode {
+    fn loop_body(&self) -> Option<&Block> {
         child_opt(self)
     }
 }
 
-pub trait ArgListOwner<'a>: AstNode<'a> {
-    fn arg_list(self) -> Option<ArgList<'a>> {
+pub trait ArgListOwner: AstNode {
+    fn arg_list(&self) -> Option<&ArgList> {
         child_opt(self)
     }
 }
 
-pub trait FnDefOwner<'a>: AstNode<'a> {
-    fn functions(self) -> AstChildren<'a, FnDef<'a>> {
+pub trait FnDefOwner: AstNode {
+    fn functions(&self) -> AstChildren<FnDef> {
         children(self)
     }
 }
 
-// ModuleItem
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ItemOrMacro<'a> {
-    Item(ModuleItem<'a>),
-    Macro(MacroCall<'a>),
+    Item(&'a ModuleItem),
+    Macro(&'a MacroCall),
 }
 
-impl<'a> AstNode<'a> for ItemOrMacro<'a> {
-    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
-        let res = if let Some(item) = ModuleItem::cast(syntax) {
-            ItemOrMacro::Item(item)
-        } else if let Some(macro_call) = MacroCall::cast(syntax) {
-            ItemOrMacro::Macro(macro_call)
-        } else {
-            return None;
-        };
-        Some(res)
+pub trait ModuleItemOwner: AstNode {
+    fn items(&self) -> AstChildren<ModuleItem> {
+        children(self)
     }
-    fn syntax(self) -> SyntaxNodeRef<'a> {
-        match self {
-            ItemOrMacro::Item(it) => it.syntax(),
-            ItemOrMacro::Macro(it) => it.syntax(),
-        }
+    fn items_with_macros(&self) -> ItemOrMacroIter {
+        ItemOrMacroIter(self.syntax().children())
     }
 }
 
-pub trait ModuleItemOwner<'a>: AstNode<'a> {
-    fn items(self) -> AstChildren<'a, ModuleItem<'a>> {
-        children(self)
-    }
+#[derive(Debug)]
+pub struct ItemOrMacroIter<'a>(SyntaxNodeChildren<'a>);
 
-    fn items_with_macros(self) -> AstChildren<'a, ItemOrMacro<'a>> {
-        children(self)
+impl<'a> Iterator for ItemOrMacroIter<'a> {
+    type Item = ItemOrMacro<'a>;
+    fn next(&mut self) -> Option<ItemOrMacro<'a>> {
+        loop {
+            let n = self.0.next()?;
+            if let Some(item) = ModuleItem::cast(n) {
+                return Some(ItemOrMacro::Item(item));
+            }
+            if let Some(call) = MacroCall::cast(n) {
+                return Some(ItemOrMacro::Macro(call));
+            }
+        }
     }
 }
 
-pub trait TypeParamsOwner<'a>: AstNode<'a> {
-    fn type_param_list(self) -> Option<TypeParamList<'a>> {
+pub trait TypeParamsOwner: AstNode {
+    fn type_param_list(&self) -> Option<&TypeParamList> {
         child_opt(self)
     }
 
-    fn where_clause(self) -> Option<WhereClause<'a>> {
+    fn where_clause(&self) -> Option<&WhereClause> {
         child_opt(self)
     }
 }
 
-pub trait AttrsOwner<'a>: AstNode<'a> {
-    fn attrs(self) -> AstChildren<'a, Attr<'a>> {
+pub trait AttrsOwner: AstNode {
+    fn attrs(&self) -> AstChildren<Attr> {
         children(self)
     }
 }
 
-pub trait DocCommentsOwner<'a>: AstNode<'a> {
-    fn doc_comments(self) -> AstChildren<'a, Comment<'a>> {
+pub trait DocCommentsOwner: AstNode {
+    fn doc_comments(&self) -> AstChildren<Comment> {
         children(self)
     }
 
     /// Returns the textual content of a doc comment block as a single string.
     /// That is, strips leading `///` and joins lines
-    fn doc_comment_text(self) -> RustString {
+    fn doc_comment_text(&self) -> std::string::String {
         self.doc_comments()
             .filter(|comment| comment.is_doc_comment())
             .map(|comment| {
@@ -130,13 +126,13 @@ pub trait DocCommentsOwner<'a>: AstNode<'a> {
     }
 }
 
-impl<'a> FnDef<'a> {
+impl FnDef {
     pub fn has_atom_attr(&self, atom: &str) -> bool {
         self.attrs().filter_map(|x| x.as_atom()).any(|x| x == atom)
     }
 }
 
-impl<'a> Attr<'a> {
+impl Attr {
     pub fn as_atom(&self) -> Option<SmolStr> {
         let tt = self.value()?;
         let (_bra, attr, _ket) = tt.syntax().children().collect_tuple()?;
@@ -147,7 +143,7 @@ impl<'a> Attr<'a> {
         }
     }
 
-    pub fn as_call(&self) -> Option<(SmolStr, TokenTree<'a>)> {
+    pub fn as_call(&self) -> Option<(SmolStr, &TokenTree)> {
         let tt = self.value()?;
         let (_bra, attr, args, _ket) = tt.syntax().children().collect_tuple()?;
         let args = TokenTree::cast(args)?;
@@ -159,37 +155,37 @@ impl<'a> Attr<'a> {
     }
 }
 
-impl<'a> Lifetime<'a> {
+impl Lifetime {
     pub fn text(&self) -> SmolStr {
         self.syntax().leaf_text().unwrap().clone()
     }
 }
 
-impl<'a> Char<'a> {
+impl Char {
     pub fn text(&self) -> &SmolStr {
         &self.syntax().leaf_text().unwrap()
     }
 }
 
-impl<'a> Byte<'a> {
+impl Byte {
     pub fn text(&self) -> &SmolStr {
         &self.syntax().leaf_text().unwrap()
     }
 }
 
-impl<'a> ByteString<'a> {
+impl ByteString {
     pub fn text(&self) -> &SmolStr {
         &self.syntax().leaf_text().unwrap()
     }
 }
 
-impl<'a> String<'a> {
+impl String {
     pub fn text(&self) -> &SmolStr {
         &self.syntax().leaf_text().unwrap()
     }
 }
 
-impl<'a> Comment<'a> {
+impl Comment {
     pub fn text(&self) -> &SmolStr {
         self.syntax().leaf_text().unwrap()
     }
@@ -251,7 +247,7 @@ impl CommentFlavor {
     }
 }
 
-impl<'a> Whitespace<'a> {
+impl Whitespace {
     pub fn text(&self) -> &SmolStr {
         &self.syntax().leaf_text().unwrap()
     }
@@ -265,36 +261,36 @@ impl<'a> Whitespace<'a> {
     }
 }
 
-impl<'a> Name<'a> {
+impl Name {
     pub fn text(&self) -> SmolStr {
         let ident = self.syntax().first_child().unwrap();
         ident.leaf_text().unwrap().clone()
     }
 }
 
-impl<'a> NameRef<'a> {
+impl NameRef {
     pub fn text(&self) -> SmolStr {
         let ident = self.syntax().first_child().unwrap();
         ident.leaf_text().unwrap().clone()
     }
 }
 
-impl<'a> ImplBlock<'a> {
-    pub fn target_type(self) -> Option<TypeRef<'a>> {
+impl ImplBlock {
+    pub fn target_type(&self) -> Option<&TypeRef> {
         match self.target() {
             (Some(t), None) | (_, Some(t)) => Some(t),
             _ => None,
         }
     }
 
-    pub fn target_trait(self) -> Option<TypeRef<'a>> {
+    pub fn target_trait(&self) -> Option<&TypeRef> {
         match self.target() {
             (Some(t), Some(_)) => Some(t),
             _ => None,
         }
     }
 
-    fn target(self) -> (Option<TypeRef<'a>>, Option<TypeRef<'a>>) {
+    fn target(&self) -> (Option<&TypeRef>, Option<&TypeRef>) {
         let mut types = children(self);
         let first = types.next();
         let second = types.next();
@@ -302,8 +298,8 @@ impl<'a> ImplBlock<'a> {
     }
 }
 
-impl<'a> Module<'a> {
-    pub fn has_semi(self) -> bool {
+impl Module {
+    pub fn has_semi(&self) -> bool {
         match self.syntax().last_child() {
             None => false,
             Some(node) => node.kind() == SEMI,
@@ -311,8 +307,8 @@ impl<'a> Module<'a> {
     }
 }
 
-impl<'a> LetStmt<'a> {
-    pub fn has_semi(self) -> bool {
+impl LetStmt {
+    pub fn has_semi(&self) -> bool {
         match self.syntax().last_child() {
             None => false,
             Some(node) => node.kind() == SEMI,
@@ -320,35 +316,35 @@ impl<'a> LetStmt<'a> {
     }
 }
 
-impl<'a> IfExpr<'a> {
-    pub fn then_branch(self) -> Option<Block<'a>> {
+impl IfExpr {
+    pub fn then_branch(&self) -> Option<&Block> {
         self.blocks().nth(0)
     }
-    pub fn else_branch(self) -> Option<Block<'a>> {
+    pub fn else_branch(&self) -> Option<&Block> {
         self.blocks().nth(1)
     }
-    fn blocks(self) -> AstChildren<'a, Block<'a>> {
+    fn blocks(&self) -> AstChildren<Block> {
         children(self)
     }
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum PathSegmentKind<'a> {
-    Name(NameRef<'a>),
+    Name(&'a NameRef),
     SelfKw,
     SuperKw,
     CrateKw,
 }
 
-impl<'a> PathSegment<'a> {
-    pub fn parent_path(self) -> Path<'a> {
+impl PathSegment {
+    pub fn parent_path(&self) -> &Path {
         self.syntax()
             .parent()
             .and_then(Path::cast)
             .expect("segments are always nested in paths")
     }
 
-    pub fn kind(self) -> Option<PathSegmentKind<'a>> {
+    pub fn kind(&self) -> Option<PathSegmentKind> {
         let res = if let Some(name_ref) = self.name_ref() {
             PathSegmentKind::Name(name_ref)
         } else {
@@ -363,20 +359,20 @@ impl<'a> PathSegment<'a> {
     }
 }
 
-impl<'a> Path<'a> {
-    pub fn parent_path(self) -> Option<Path<'a>> {
+impl Path {
+    pub fn parent_path(&self) -> Option<&Path> {
         self.syntax().parent().and_then(Path::cast)
     }
 }
 
-impl<'a> UseTree<'a> {
-    pub fn has_star(self) -> bool {
+impl UseTree {
+    pub fn has_star(&self) -> bool {
         self.syntax().children().any(|it| it.kind() == STAR)
     }
 }
 
-impl<'a> UseTreeList<'a> {
-    pub fn parent_use_tree(self) -> UseTree<'a> {
+impl UseTreeList {
+    pub fn parent_use_tree(&self) -> &UseTree {
         self.syntax()
             .parent()
             .and_then(UseTree::cast)
@@ -384,22 +380,22 @@ impl<'a> UseTreeList<'a> {
     }
 }
 
-fn child_opt<'a, P: AstNode<'a>, C: AstNode<'a>>(parent: P) -> Option<C> {
+fn child_opt<P: AstNode, C: AstNode>(parent: &P) -> Option<&C> {
     children(parent).next()
 }
 
-fn children<'a, P: AstNode<'a>, C: AstNode<'a>>(parent: P) -> AstChildren<'a, C> {
+fn children<P: AstNode, C: AstNode>(parent: &P) -> AstChildren<C> {
     AstChildren::new(parent.syntax())
 }
 
 #[derive(Debug)]
 pub struct AstChildren<'a, N> {
-    inner: SyntaxNodeChildren<RefRoot<'a>>,
+    inner: SyntaxNodeChildren<'a>,
     ph: PhantomData<N>,
 }
 
 impl<'a, N> AstChildren<'a, N> {
-    fn new(parent: SyntaxNodeRef<'a>) -> Self {
+    fn new(parent: &'a SyntaxNode) -> Self {
         AstChildren {
             inner: parent.children(),
             ph: PhantomData,
@@ -407,9 +403,9 @@ impl<'a, N> AstChildren<'a, N> {
     }
 }
 
-impl<'a, N: AstNode<'a>> Iterator for AstChildren<'a, N> {
-    type Item = N;
-    fn next(&mut self) -> Option<N> {
+impl<'a, N: AstNode + 'a> Iterator for AstChildren<'a, N> {
+    type Item = &'a N;
+    fn next(&mut self) -> Option<&'a N> {
         loop {
             if let Some(n) = N::cast(self.inner.next()?) {
                 return Some(n);
@@ -420,13 +416,13 @@ impl<'a, N: AstNode<'a>> Iterator for AstChildren<'a, N> {
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum StructFlavor<'a> {
-    Tuple(PosFieldList<'a>),
-    Named(NamedFieldDefList<'a>),
+    Tuple(&'a PosFieldList),
+    Named(&'a NamedFieldDefList),
     Unit,
 }
 
-impl<'a> StructFlavor<'a> {
-    fn from_node<N: AstNode<'a>>(node: N) -> StructFlavor<'a> {
+impl StructFlavor<'_> {
+    fn from_node<N: AstNode>(node: &N) -> StructFlavor {
         if let Some(nfdl) = child_opt::<_, NamedFieldDefList>(node) {
             StructFlavor::Named(nfdl)
         } else if let Some(pfl) = child_opt::<_, PosFieldList>(node) {
@@ -437,31 +433,31 @@ impl<'a> StructFlavor<'a> {
     }
 }
 
-impl<'a> StructDef<'a> {
-    pub fn flavor(self) -> StructFlavor<'a> {
+impl StructDef {
+    pub fn flavor(&self) -> StructFlavor {
         StructFlavor::from_node(self)
     }
 }
 
-impl<'a> EnumVariant<'a> {
-    pub fn flavor(self) -> StructFlavor<'a> {
+impl EnumVariant {
+    pub fn flavor(&self) -> StructFlavor {
         StructFlavor::from_node(self)
     }
 }
 
-impl<'a> PointerType<'a> {
+impl PointerType {
     pub fn is_mut(&self) -> bool {
         self.syntax().children().any(|n| n.kind() == MUT_KW)
     }
 }
 
-impl<'a> ReferenceType<'a> {
+impl ReferenceType {
     pub fn is_mut(&self) -> bool {
         self.syntax().children().any(|n| n.kind() == MUT_KW)
     }
 }
 
-impl<'a> RefExpr<'a> {
+impl RefExpr {
     pub fn is_mut(&self) -> bool {
         self.syntax().children().any(|n| n.kind() == MUT_KW)
     }
@@ -477,7 +473,7 @@ pub enum PrefixOp {
     Neg,
 }
 
-impl<'a> PrefixExpr<'a> {
+impl PrefixExpr {
     pub fn op(&self) -> Option<PrefixOp> {
         match self.syntax().first_child()?.kind() {
             STAR => Some(PrefixOp::Deref),
@@ -552,7 +548,7 @@ pub enum BinOp {
     BitXorAssign,
 }
 
-impl<'a> BinExpr<'a> {
+impl BinExpr {
     pub fn op(&self) -> Option<BinOp> {
         self.syntax()
             .children()
@@ -592,15 +588,15 @@ impl<'a> BinExpr<'a> {
             .next()
     }
 
-    pub fn lhs(self) -> Option<Expr<'a>> {
+    pub fn lhs(&self) -> Option<&Expr> {
         children(self).nth(0)
     }
 
-    pub fn rhs(self) -> Option<Expr<'a>> {
+    pub fn rhs(&self) -> Option<&Expr> {
         children(self).nth(1)
     }
 
-    pub fn sub_exprs(self) -> (Option<Expr<'a>>, Option<Expr<'a>>) {
+    pub fn sub_exprs(&self) -> (Option<&Expr>, Option<&Expr>) {
         let mut children = children(self);
         let first = children.next();
         let second = children.next();
@@ -618,7 +614,7 @@ pub enum SelfParamFlavor {
     MutRef,
 }
 
-impl<'a> SelfParam<'a> {
+impl SelfParam {
     pub fn flavor(&self) -> SelfParamFlavor {
         let borrowed = self.syntax().children().any(|n| n.kind() == AMP);
         if borrowed {
@@ -641,7 +637,7 @@ impl<'a> SelfParam<'a> {
 
 #[test]
 fn test_doc_comment_of_items() {
-    let file = SourceFileNode::parse(
+    let file = SourceFile::parse(
         r#"
         //! doc
         // non-doc
diff --git a/crates/ra_syntax/src/ast/generated.rs b/crates/ra_syntax/src/ast/generated.rs
index 24f72393a..5e96ab142 100644
--- a/crates/ra_syntax/src/ast/generated.rs
+++ b/crates/ra_syntax/src/ast/generated.rs
@@ -9,4648 +9,3387 @@
 
 #![cfg_attr(rustfmt, rustfmt_skip)]
 
-use std::hash::{Hash, Hasher};
+use rowan::TransparentNewType;
 
 use crate::{
-    ast,
-    SyntaxNode, SyntaxNodeRef, AstNode,
-    yellow::{TreeRoot, RaTypes, OwnedRoot, RefRoot},
-    SyntaxKind::*,
+    SyntaxNode, SyntaxKind::*,
+    yellow::{RaTypes, TreePtr},
+    ast::{self, AstNode},
 };
 
 // ArgList
-#[derive(Debug, Clone, Copy,)]
-pub struct ArgListNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    pub(crate) syntax: SyntaxNode<R>,
+#[derive(Debug, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+pub struct ArgList {
+    pub(crate) syntax: SyntaxNode,
 }
-pub type ArgList<'a> = ArgListNode<RefRoot<'a>>;
-
-impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ArgListNode<R1>> for ArgListNode<R2> {
-    fn eq(&self, other: &ArgListNode<R1>) -> bool { self.syntax == other.syntax }
-}
-impl<R: TreeRoot<RaTypes>> Eq for ArgListNode<R> {}
-impl<R: TreeRoot<RaTypes>> Hash for ArgListNode<R> {
-    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+unsafe impl TransparentNewType for ArgList {
+    type Repr = rowan::SyntaxNode<RaTypes>;
 }
 
-impl<'a> AstNode<'a> for ArgList<'a> {
-    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+impl AstNode for ArgList {
+    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
         match syntax.kind() {
-            ARG_LIST => Some(ArgList { syntax }),
+            ARG_LIST => Some(ArgList::from_repr(syntax.into_repr())),
             _ => None,
         }
     }
-    fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
-}
-
-impl<R: TreeRoot<RaTypes>> ArgListNode<R> {
-    pub fn borrowed(&self) -> ArgList {
-        ArgListNode { syntax: self.syntax.borrowed() }
-    }
-    pub fn owned(&self) -> ArgListNode {
-        ArgListNode { syntax: self.syntax.owned() }
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
+    fn to_owned(&self) -> TreePtr<ArgList> { TreePtr::cast(self.syntax.to_owned()) }
 }
 
 
-impl<'a> ArgList<'a> {
-    pub fn args(self) -> impl Iterator<Item = Expr<'a>> + 'a {
+impl ArgList {
+    pub fn args(&self) -> impl Iterator<Item = &Expr> {
         super::children(self)
     }
 }
 
 // ArrayExpr
-#[derive(Debug, Clone, Copy,)]
-pub struct ArrayExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    pub(crate) syntax: SyntaxNode<R>,
+#[derive(Debug, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+pub struct ArrayExpr {
+    pub(crate) syntax: SyntaxNode,
 }
-pub type ArrayExpr<'a> = ArrayExprNode<RefRoot<'a>>;
-
-impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ArrayExprNode<R1>> for ArrayExprNode<R2> {
-    fn eq(&self, other: &ArrayExprNode<R1>) -> bool { self.syntax == other.syntax }
-}
-impl<R: TreeRoot<RaTypes>> Eq for ArrayExprNode<R> {}
-impl<R: TreeRoot<RaTypes>> Hash for ArrayExprNode<R> {
-    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+unsafe impl TransparentNewType for ArrayExpr {
+    type Repr = rowan::SyntaxNode<RaTypes>;
 }
 
-impl<'a> AstNode<'a> for ArrayExpr<'a> {
-    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+impl AstNode for ArrayExpr {
+    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
         match syntax.kind() {
-            ARRAY_EXPR => Some(ArrayExpr { syntax }),
+            ARRAY_EXPR => Some(ArrayExpr::from_repr(syntax.into_repr())),
             _ => None,
         }
     }
-    fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
-}
-
-impl<R: TreeRoot<RaTypes>> ArrayExprNode<R> {
-    pub fn borrowed(&self) -> ArrayExpr {
-        ArrayExprNode { syntax: self.syntax.borrowed() }
-    }
-    pub fn owned(&self) -> ArrayExprNode {
-        ArrayExprNode { syntax: self.syntax.owned() }
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
+    fn to_owned(&self) -> TreePtr<ArrayExpr> { TreePtr::cast(self.syntax.to_owned()) }
 }
 
 
-impl<'a> ArrayExpr<'a> {}
+impl ArrayExpr {}
 
 // ArrayType
-#[derive(Debug, Clone, Copy,)]
-pub struct ArrayTypeNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    pub(crate) syntax: SyntaxNode<R>,
-}
-pub type ArrayType<'a> = ArrayTypeNode<RefRoot<'a>>;
-
-impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ArrayTypeNode<R1>> for ArrayTypeNode<R2> {
-    fn eq(&self, other: &ArrayTypeNode<R1>) -> bool { self.syntax == other.syntax }
+#[derive(Debug, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+pub struct ArrayType {
+    pub(crate) syntax: SyntaxNode,
 }
-impl<R: TreeRoot<RaTypes>> Eq for ArrayTypeNode<R> {}
-impl<R: TreeRoot<RaTypes>> Hash for ArrayTypeNode<R> {
-    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+unsafe impl TransparentNewType for ArrayType {
+    type Repr = rowan::SyntaxNode<RaTypes>;
 }
 
-impl<'a> AstNode<'a> for ArrayType<'a> {
-    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+impl AstNode for ArrayType {
+    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
         match syntax.kind() {
-            ARRAY_TYPE => Some(ArrayType { syntax }),
+            ARRAY_TYPE => Some(ArrayType::from_repr(syntax.into_repr())),
             _ => None,
         }
     }
-    fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
+    fn to_owned(&self) -> TreePtr<ArrayType> { TreePtr::cast(self.syntax.to_owned()) }
 }
 
-impl<R: TreeRoot<RaTypes>> ArrayTypeNode<R> {
-    pub fn borrowed(&self) -> ArrayType {
-        ArrayTypeNode { syntax: self.syntax.borrowed() }
-    }
-    pub fn owned(&self) -> ArrayTypeNode {
-        ArrayTypeNode { syntax: self.syntax.owned() }
-    }
-}
 
-
-impl<'a> ArrayType<'a> {
-    pub fn type_ref(self) -> Option<TypeRef<'a>> {
+impl ArrayType {
+    pub fn type_ref(&self) -> Option<&TypeRef> {
         super::child_opt(self)
     }
 
-    pub fn expr(self) -> Option<Expr<'a>> {
+    pub fn expr(&self) -> Option<&Expr> {
         super::child_opt(self)
     }
 }
 
 // Attr
-#[derive(Debug, Clone, Copy,)]
-pub struct AttrNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    pub(crate) syntax: SyntaxNode<R>,
-}
-pub type Attr<'a> = AttrNode<RefRoot<'a>>;
-
-impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<AttrNode<R1>> for AttrNode<R2> {
-    fn eq(&self, other: &AttrNode<R1>) -> bool { self.syntax == other.syntax }
+#[derive(Debug, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+pub struct Attr {
+    pub(crate) syntax: SyntaxNode,
 }
-impl<R: TreeRoot<RaTypes>> Eq for AttrNode<R> {}
-impl<R: TreeRoot<RaTypes>> Hash for AttrNode<R> {
-    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+unsafe impl TransparentNewType for Attr {
+    type Repr = rowan::SyntaxNode<RaTypes>;
 }
 
-impl<'a> AstNode<'a> for Attr<'a> {
-    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+impl AstNode for Attr {
+    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
         match syntax.kind() {
-            ATTR => Some(Attr { syntax }),
+            ATTR => Some(Attr::from_repr(syntax.into_repr())),
             _ => None,
         }
     }
-    fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
-}
-
-impl<R: TreeRoot<RaTypes>> AttrNode<R> {
-    pub fn borrowed(&self) -> Attr {
-        AttrNode { syntax: self.syntax.borrowed() }
-    }
-    pub fn owned(&self) -> AttrNode {
-        AttrNode { syntax: self.syntax.owned() }
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
+    fn to_owned(&self) -> TreePtr<Attr> { TreePtr::cast(self.syntax.to_owned()) }
 }
 
 
-impl<'a> Attr<'a> {
-    pub fn value(self) -> Option<TokenTree<'a>> {
+impl Attr {
+    pub fn value(&self) -> Option<&TokenTree> {
         super::child_opt(self)
     }
 }
 
 // BinExpr
-#[derive(Debug, Clone, Copy,)]
-pub struct BinExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    pub(crate) syntax: SyntaxNode<R>,
-}
-pub type BinExpr<'a> = BinExprNode<RefRoot<'a>>;
-
-impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<BinExprNode<R1>> for BinExprNode<R2> {
-    fn eq(&self, other: &BinExprNode<R1>) -> bool { self.syntax == other.syntax }
+#[derive(Debug, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+pub struct BinExpr {
+    pub(crate) syntax: SyntaxNode,
 }
-impl<R: TreeRoot<RaTypes>> Eq for BinExprNode<R> {}
-impl<R: TreeRoot<RaTypes>> Hash for BinExprNode<R> {
-    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+unsafe impl TransparentNewType for BinExpr {
+    type Repr = rowan::SyntaxNode<RaTypes>;
 }
 
-impl<'a> AstNode<'a> for BinExpr<'a> {
-    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+impl AstNode for BinExpr {
+    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
         match syntax.kind() {
-            BIN_EXPR => Some(BinExpr { syntax }),
+            BIN_EXPR => Some(BinExpr::from_repr(syntax.into_repr())),
             _ => None,
         }
     }
-    fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
-}
-
-impl<R: TreeRoot<RaTypes>> BinExprNode<R> {
-    pub fn borrowed(&self) -> BinExpr {
-        BinExprNode { syntax: self.syntax.borrowed() }
-    }
-    pub fn owned(&self) -> BinExprNode {
-        BinExprNode { syntax: self.syntax.owned() }
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
+    fn to_owned(&self) -> TreePtr<BinExpr> { TreePtr::cast(self.syntax.to_owned()) }
 }
 
 
-impl<'a> BinExpr<'a> {}
+impl BinExpr {}
 
 // BindPat
-#[derive(Debug, Clone, Copy,)]
-pub struct BindPatNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    pub(crate) syntax: SyntaxNode<R>,
+#[derive(Debug, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+pub struct BindPat {
+    pub(crate) syntax: SyntaxNode,
 }
-pub type BindPat<'a> = BindPatNode<RefRoot<'a>>;
-
-impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<BindPatNode<R1>> for BindPatNode<R2> {
-    fn eq(&self, other: &BindPatNode<R1>) -> bool { self.syntax == other.syntax }
-}
-impl<R: TreeRoot<RaTypes>> Eq for BindPatNode<R> {}
-impl<R: TreeRoot<RaTypes>> Hash for BindPatNode<R> {
-    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+unsafe impl TransparentNewType for BindPat {
+    type Repr = rowan::SyntaxNode<RaTypes>;
 }
 
-impl<'a> AstNode<'a> for BindPat<'a> {
-    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+impl AstNode for BindPat {
+    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
         match syntax.kind() {
-            BIND_PAT => Some(BindPat { syntax }),
+            BIND_PAT => Some(BindPat::from_repr(syntax.into_repr())),
             _ => None,
         }
     }
-    fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
-}
-
-impl<R: TreeRoot<RaTypes>> BindPatNode<R> {
-    pub fn borrowed(&self) -> BindPat {
-        BindPatNode { syntax: self.syntax.borrowed() }
-    }
-    pub fn owned(&self) -> BindPatNode {
-        BindPatNode { syntax: self.syntax.owned() }
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
+    fn to_owned(&self) -> TreePtr<BindPat> { TreePtr::cast(self.syntax.to_owned()) }
 }
 
 
-impl<'a> ast::NameOwner<'a> for BindPat<'a> {}
-impl<'a> BindPat<'a> {}
+impl ast::NameOwner for BindPat {}
+impl BindPat {}
 
 // Block
-#[derive(Debug, Clone, Copy,)]
-pub struct BlockNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    pub(crate) syntax: SyntaxNode<R>,
-}
-pub type Block<'a> = BlockNode<RefRoot<'a>>;
-
-impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<BlockNode<R1>> for BlockNode<R2> {
-    fn eq(&self, other: &BlockNode<R1>) -> bool { self.syntax == other.syntax }
+#[derive(Debug, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+pub struct Block {
+    pub(crate) syntax: SyntaxNode,
 }
-impl<R: TreeRoot<RaTypes>> Eq for BlockNode<R> {}
-impl<R: TreeRoot<RaTypes>> Hash for BlockNode<R> {
-    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+unsafe impl TransparentNewType for Block {
+    type Repr = rowan::SyntaxNode<RaTypes>;
 }
 
-impl<'a> AstNode<'a> for Block<'a> {
-    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+impl AstNode for Block {
+    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
         match syntax.kind() {
-            BLOCK => Some(Block { syntax }),
+            BLOCK => Some(Block::from_repr(syntax.into_repr())),
             _ => None,
         }
     }
-    fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
+    fn to_owned(&self) -> TreePtr<Block> { TreePtr::cast(self.syntax.to_owned()) }
 }
 
-impl<R: TreeRoot<RaTypes>> BlockNode<R> {
-    pub fn borrowed(&self) -> Block {
-        BlockNode { syntax: self.syntax.borrowed() }
-    }
-    pub fn owned(&self) -> BlockNode {
-        BlockNode { syntax: self.syntax.owned() }
-    }
-}
 
-
-impl<'a> Block<'a> {
-    pub fn statements(self) -> impl Iterator<Item = Stmt<'a>> + 'a {
+impl Block {
+    pub fn statements(&self) -> impl Iterator<Item = &Stmt> {
         super::children(self)
     }
 
-    pub fn expr(self) -> Option<Expr<'a>> {
+    pub fn expr(&self) -> Option<&Expr> {
         super::child_opt(self)
     }
 }
 
 // BlockExpr
-#[derive(Debug, Clone, Copy,)]
-pub struct BlockExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    pub(crate) syntax: SyntaxNode<R>,
+#[derive(Debug, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+pub struct BlockExpr {
+    pub(crate) syntax: SyntaxNode,
 }
-pub type BlockExpr<'a> = BlockExprNode<RefRoot<'a>>;
-
-impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<BlockExprNode<R1>> for BlockExprNode<R2> {
-    fn eq(&self, other: &BlockExprNode<R1>) -> bool { self.syntax == other.syntax }
-}
-impl<R: TreeRoot<RaTypes>> Eq for BlockExprNode<R> {}
-impl<R: TreeRoot<RaTypes>> Hash for BlockExprNode<R> {
-    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+unsafe impl TransparentNewType for BlockExpr {
+    type Repr = rowan::SyntaxNode<RaTypes>;
 }
 
-impl<'a> AstNode<'a> for BlockExpr<'a> {
-    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+impl AstNode for BlockExpr {
+    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
         match syntax.kind() {
-            BLOCK_EXPR => Some(BlockExpr { syntax }),
+            BLOCK_EXPR => Some(BlockExpr::from_repr(syntax.into_repr())),
             _ => None,
         }
     }
-    fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
-}
-
-impl<R: TreeRoot<RaTypes>> BlockExprNode<R> {
-    pub fn borrowed(&self) -> BlockExpr {
-        BlockExprNode { syntax: self.syntax.borrowed() }
-    }
-    pub fn owned(&self) -> BlockExprNode {
-        BlockExprNode { syntax: self.syntax.owned() }
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
+    fn to_owned(&self) -> TreePtr<BlockExpr> { TreePtr::cast(self.syntax.to_owned()) }
 }
 
 
-impl<'a> BlockExpr<'a> {
-    pub fn block(self) -> Option<Block<'a>> {
+impl BlockExpr {
+    pub fn block(&self) -> Option<&Block> {
         super::child_opt(self)
     }
 }
 
 // BreakExpr
-#[derive(Debug, Clone, Copy,)]
-pub struct BreakExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    pub(crate) syntax: SyntaxNode<R>,
+#[derive(Debug, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+pub struct BreakExpr {
+    pub(crate) syntax: SyntaxNode,
 }
-pub type BreakExpr<'a> = BreakExprNode<RefRoot<'a>>;
-
-impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<BreakExprNode<R1>> for BreakExprNode<R2> {
-    fn eq(&self, other: &BreakExprNode<R1>) -> bool { self.syntax == other.syntax }
-}
-impl<R: TreeRoot<RaTypes>> Eq for BreakExprNode<R> {}
-impl<R: TreeRoot<RaTypes>> Hash for BreakExprNode<R> {
-    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+unsafe impl TransparentNewType for BreakExpr {
+    type Repr = rowan::SyntaxNode<RaTypes>;
 }
 
-impl<'a> AstNode<'a> for BreakExpr<'a> {
-    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+impl AstNode for BreakExpr {
+    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
         match syntax.kind() {
-            BREAK_EXPR => Some(BreakExpr { syntax }),
+            BREAK_EXPR => Some(BreakExpr::from_repr(syntax.into_repr())),
             _ => None,
         }
     }
-    fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
-}
-
-impl<R: TreeRoot<RaTypes>> BreakExprNode<R> {
-    pub fn borrowed(&self) -> BreakExpr {
-        BreakExprNode { syntax: self.syntax.borrowed() }
-    }
-    pub fn owned(&self) -> BreakExprNode {
-        BreakExprNode { syntax: self.syntax.owned() }
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
+    fn to_owned(&self) -> TreePtr<BreakExpr> { TreePtr::cast(self.syntax.to_owned()) }
 }
 
 
-impl<'a> BreakExpr<'a> {
-    pub fn expr(self) -> Option<Expr<'a>> {
+impl BreakExpr {
+    pub fn expr(&self) -> Option<&Expr> {
         super::child_opt(self)
     }
 }
 
 // Byte
-#[derive(Debug, Clone, Copy,)]
-pub struct ByteNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    pub(crate) syntax: SyntaxNode<R>,
+#[derive(Debug, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+pub struct Byte {
+    pub(crate) syntax: SyntaxNode,
 }
-pub type Byte<'a> = ByteNode<RefRoot<'a>>;
-
-impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ByteNode<R1>> for ByteNode<R2> {
-    fn eq(&self, other: &ByteNode<R1>) -> bool { self.syntax == other.syntax }
-}
-impl<R: TreeRoot<RaTypes>> Eq for ByteNode<R> {}
-impl<R: TreeRoot<RaTypes>> Hash for ByteNode<R> {
-    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+unsafe impl TransparentNewType for Byte {
+    type Repr = rowan::SyntaxNode<RaTypes>;
 }
 
-impl<'a> AstNode<'a> for Byte<'a> {
-    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+impl AstNode for Byte {
+    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
         match syntax.kind() {
-            BYTE => Some(Byte { syntax }),
+            BYTE => Some(Byte::from_repr(syntax.into_repr())),
             _ => None,
         }
     }
-    fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
-}
-
-impl<R: TreeRoot<RaTypes>> ByteNode<R> {
-    pub fn borrowed(&self) -> Byte {
-        ByteNode { syntax: self.syntax.borrowed() }
-    }
-    pub fn owned(&self) -> ByteNode {
-        ByteNode { syntax: self.syntax.owned() }
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
+    fn to_owned(&self) -> TreePtr<Byte> { TreePtr::cast(self.syntax.to_owned()) }
 }
 
 
-impl<'a> Byte<'a> {}
+impl Byte {}
 
 // ByteString
-#[derive(Debug, Clone, Copy,)]
-pub struct ByteStringNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    pub(crate) syntax: SyntaxNode<R>,
-}
-pub type ByteString<'a> = ByteStringNode<RefRoot<'a>>;
-
-impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<ByteStringNode<R1>> for ByteStringNode<R2> {
-    fn eq(&self, other: &ByteStringNode<R1>) -> bool { self.syntax == other.syntax }
+#[derive(Debug, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+pub struct ByteString {
+    pub(crate) syntax: SyntaxNode,
 }
-impl<R: TreeRoot<RaTypes>> Eq for ByteStringNode<R> {}
-impl<R: TreeRoot<RaTypes>> Hash for ByteStringNode<R> {
-    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+unsafe impl TransparentNewType for ByteString {
+    type Repr = rowan::SyntaxNode<RaTypes>;
 }
 
-impl<'a> AstNode<'a> for ByteString<'a> {
-    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+impl AstNode for ByteString {
+    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
         match syntax.kind() {
-            BYTE_STRING => Some(ByteString { syntax }),
+            BYTE_STRING => Some(ByteString::from_repr(syntax.into_repr())),
             _ => None,
         }
     }
-    fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
-}
-
-impl<R: TreeRoot<RaTypes>> ByteStringNode<R> {
-    pub fn borrowed(&self) -> ByteString {
-        ByteStringNode { syntax: self.syntax.borrowed() }
-    }
-    pub fn owned(&self) -> ByteStringNode {
-        ByteStringNode { syntax: self.syntax.owned() }
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
+    fn to_owned(&self) -> TreePtr<ByteString> { TreePtr::cast(self.syntax.to_owned()) }
 }
 
 
-impl<'a> ByteString<'a> {}
+impl ByteString {}
 
 // CallExpr
-#[derive(Debug, Clone, Copy,)]
-pub struct CallExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    pub(crate) syntax: SyntaxNode<R>,
-}
-pub type CallExpr<'a> = CallExprNode<RefRoot<'a>>;
-
-impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<CallExprNode<R1>> for CallExprNode<R2> {
-    fn eq(&self, other: &CallExprNode<R1>) -> bool { self.syntax == other.syntax }
+#[derive(Debug, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+pub struct CallExpr {
+    pub(crate) syntax: SyntaxNode,
 }
-impl<R: TreeRoot<RaTypes>> Eq for CallExprNode<R> {}
-impl<R: TreeRoot<RaTypes>> Hash for CallExprNode<R> {
-    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+unsafe impl TransparentNewType for CallExpr {
+    type Repr = rowan::SyntaxNode<RaTypes>;
 }
 
-impl<'a> AstNode<'a> for CallExpr<'a> {
-    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+impl AstNode for CallExpr {
+    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
         match syntax.kind() {
-            CALL_EXPR => Some(CallExpr { syntax }),
+            CALL_EXPR => Some(CallExpr::from_repr(syntax.into_repr())),
             _ => None,
         }
     }
-    fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
-}
-
-impl<R: TreeRoot<RaTypes>> CallExprNode<R> {
-    pub fn borrowed(&self) -> CallExpr {
-        CallExprNode { syntax: self.syntax.borrowed() }
-    }
-    pub fn owned(&self) -> CallExprNode {
-        CallExprNode { syntax: self.syntax.owned() }
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
+    fn to_owned(&self) -> TreePtr<CallExpr> { TreePtr::cast(self.syntax.to_owned()) }
 }
 
 
-impl<'a> ast::ArgListOwner<'a> for CallExpr<'a> {}
-impl<'a> CallExpr<'a> {
-    pub fn expr(self) -> Option<Expr<'a>> {
+impl ast::ArgListOwner for CallExpr {}
+impl CallExpr {
+    pub fn expr(&self) -> Option<&Expr> {
         super::child_opt(self)
     }
 }
 
 // CastExpr
-#[derive(Debug, Clone, Copy,)]
-pub struct CastExprNode<R: TreeRoot<RaTypes> = OwnedRoot> {
-    pub(crate) syntax: SyntaxNode<R>,
+#[derive(Debug, PartialEq, Eq, Hash)]
+#[repr(transparent)]
+pub struct CastExpr {
+    pub(crate) syntax: SyntaxNode,
 }
-pub type CastExpr<'a> = CastExprNode<RefRoot<'a>>;
-
-impl<R1: TreeRoot<RaTypes>, R2: TreeRoot<RaTypes>> PartialEq<CastExprNode<R1>> for CastExprNode<R2> {
-    fn eq(&self, other: &CastExprNode<R1>) -> bool { self.syntax == other.syntax }
-}
-impl<R: TreeRoot<RaTypes>> Eq for CastExprNode<R> {}
-impl<R: TreeRoot<RaTypes>> Hash for CastExprNode<R> {
-    fn hash<H: Hasher>(&self, state: &mut H) { self.syntax.hash(state) }
+unsafe impl TransparentNewType for CastExpr {
+    type Repr = rowan::SyntaxNode<RaTypes>;
 }
 
-impl<'a> AstNode<'a> for CastExpr<'a> {
-    fn cast(syntax: SyntaxNodeRef<'a>) -> Option<Self> {
+impl AstNode for CastExpr {
+    fn cast(syntax: &SyntaxNode) -> Option<&Self> {
         match syntax.kind() {
-            CAST_EXPR => Some(CastExpr { syntax }),
+            CAST_EXPR => Some(CastExpr::from_repr(syntax.into_repr())),
             _ => None,
         }
     }
-    fn syntax(self) -> SyntaxNodeRef<'a> { self.syntax }
-}
-
-impl<R: TreeRoot<RaTypes>> CastExprNode<R> {
-    pub fn borrowed(&self) -> CastExpr {
-        CastExprNode { syntax: self.syntax.borrowed() }
-    }
-    pub fn owned(&self) -> CastExprNode {
-        CastExprNode { syntax: self.syntax.owned() }
-    }
+    fn syntax(&self) -> &SyntaxNode { &self.syntax }
+    fn to_owned(&self) -> TreePtr<CastExpr> { TreePtr::cast(self.syntax.to_owned()) }
 }
 
 
-impl<'a> CastExpr<'a> {
-    pub fn expr(self) -> Option<Expr<'a>> {
+impl CastExpr {
+    pub fn expr(&self) -> Option<&Expr> {
         super::child_opt(self)
     }
 
-    pub fn type_ref(self) -> Option<TypeRef<'a>> {
+    pub fn type_ref(&self) -> Option<&TypeRef> {
         super::child_opt(self)
     }
 }